WPrefs.app/Appearance.c

   1 /* Apperance.c- color/texture for titlebar etc.
   2  *
   3  *  WPrefs - Window Maker Preferences Program
   4  *
   5  *  Copyright (c) 1999 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
  26 #include <unistd.h>
  27 #include <errno.h>
  28
  29 #include "TexturePanel.h"
  30
  31 typedef struct _Panel {
  32     WMFrame *frame;
  33     char *sectionName;
  34
  35     CallbackRec callbacks;
  36
  37     WMWindow *win;
  38
  39     WMButton *prevB;
  40
  41     WMPopUpButton *secP;
  42
  43     /* texture list */
  44     WMLabel *texL;
  45     WMList *texLs;
  46
  47     WMButton *newB;
  48     WMButton *editB;
  49     WMButton *ripB;
  50     WMButton *delB;
  51
  52
  53     proplist_t ftitleTex;
  54     proplist_t utitleTex;
  55     proplist_t ptitleTex;
  56     proplist_t iconTex;
  57     proplist_t menuTex;
  58     proplist_t mtitleTex;
  59     proplist_t backTex;
  60
  61     int textureIndex[8];
  62
  63     WMFont *smallFont;
  64     WMFont *normalFont;
  65     WMFont *boldFont;
  66
  67     TexturePanel *texturePanel;
  68
  69     WMPixmap *onLed;
  70     WMPixmap *offLed;
  71
  72     /* for preview shit */
  73     Pixmap preview;
  74     Pixmap ftitle;
  75     Pixmap utitle;
  76     Pixmap otitle;
  77     Pixmap icon;
  78     Pixmap back;
  79     Pixmap mtitle;
  80     Pixmap mitem;
  81
  82     char *fprefix;
  83 } _Panel;
  84
  85
  86 typedef struct {
  87     char *title;
  88     char *texture;
  89     proplist_t prop;
  90     Pixmap preview;
  91
  92     char *path;
  93
  94     char selectedFor;
  95     unsigned current:1;
  96 } TextureListItem;
  97
  98
  99 static void showData(_Panel *panel);
 100
 101
 102 #define ICON_FILE       "appearance"
 103
 104 #define TNEW_FILE       "tnew"
 105 #define TDEL_FILE       "tdel"
 106 #define TEDIT_FILE      "tedit"
 107 #define TEXTR_FILE      "textr"
 108
 109
 110
 111 /* XPM */
 112 static char * blueled_xpm[] = {
 113 "8 8 17 1",
 114 "       c None",
 115 ".      c #020204",
 116 "+      c #16B6FC",
 117 "@      c #176AFC",
 118 "#      c #163AFC",
 119 "$      c #72D2FC",
 120 "%      c #224CF4",
 121 "&      c #76D6FC",
 122 "*      c #16AAFC",
 123 "=      c #CEE9FC",
 124 "-      c #229EFC",
 125 ";      c #164CFC",
 126 ">      c #FAFEFC",
 127 ",      c #2482FC",
 128 "'      c #1652FC",
 129 ")      c #1E76FC",
 130 "!      c #1A60FC",
 131 "  ....  ",
 132 " .=>-@. ",
 133 ".=>$@@'.",
 134 ".=$@!;;.",
 135 ".!@*+!#.",
 136 ".#'*+*,.",
 137 " .@)@,. ",
 138 "  ....  "};
 139
 140
 141 /* XPM */
 142 static char *blueled2_xpm[] = {
 143 /* width height num_colors chars_per_pixel */
 144 "     8     8       17            1",
 145 /* colors */
 146 ". c None",
 147 "# c #090909",
 148 "a c #4b63a4",
 149 "b c #011578",
 150 "c c #264194",
 151 "d c #04338c",
 152 "e c #989dac",
 153 "f c #011a7c",
 154 "g c #465c9c",
 155 "h c #03278a",
 156 "i c #6175ac",
 157 "j c #011e74",
 158 "k c #043a90",
 159 "l c #042f94",
 160 "m c #0933a4",
 161 "n c #022184",
 162 "o c #012998",
 163 /* pixels */
 164 "..####..",
 165 ".#aimn#.",
 166 "#aechnf#",
 167 "#gchnjf#",
 168 "#jndknb#",
 169 "#bjdddl#",
 170 ".#nono#.",
 171 "..####.."
 172 };
 173
 174
 175
 176 #define FTITLE  (1<<0)
 177 #define UTITLE  (1<<1)
 178 #define OTITLE  (1<<2)
 179 #define MTITLE  (1<<3)
 180 #define MITEM   (1<<4)
 181 #define ICON    (1<<5)
 182 #define BACK    (1<<6)
 183 #define EVERYTHING      0xff
 184
 185
 186
 187
 188 #define TEXPREV_WIDTH   40
 189 #define TEXPREV_HEIGHT  24
 190
 191
 192
 193
 194
 195 static void
 196 str2rcolor(RContext *rc, char *name, RColor *color)
 197 {
 198     XColor xcolor;
 199
 200     XParseColor(rc->dpy, rc->cmap, name, &xcolor);
 201
 202     color->alpha = 255;
 203     color->red = xcolor.red >> 8;
 204     color->green = xcolor.green >> 8;
 205     color->blue = xcolor.blue >> 8;
 206 }
 207
 208
 209
 210 static void
 211 dumpRImage(char *path, RImage *image)
 212 {
 213     FILE *f;
 214
 215     f = fopen(path, "w");
 216     if (!f) {
 217         wsyserror(path);
 218         return;
 219     }
 220     fprintf(f, "%02x%02x%1x", image->width, image->height,
 221             image->data[3]!=NULL ? 4 : 3);
 222
 223     fwrite(image->data[0], 1, image->width * image->height, f);
 224     fwrite(image->data[1], 1, image->width * image->height, f);
 225     fwrite(image->data[2], 1, image->width * image->height, f);
 226     if (image->data[3])
 227         fwrite(image->data[3], 1, image->width * image->height, f);
 228
 229     if (fclose(f) < 0) {
 230         wsyserror(path);
 231     }
 232 }
 233
 234
 235
 236 static Pixmap
 237 renderTexture(WMScreen *scr, proplist_t texture, int width, int height,
 238               char *path, Bool bordered)
 239 {
 240     char *type;
 241     RImage *image;
 242     Pixmap pixmap;
 243     RContext *rc = WMScreenRContext(scr);
 244     char *str;
 245     RColor rcolor;
 246
 247
 248     type = PLGetString(PLGetArrayElement(texture, 0));
 249
 250     image = RCreateImage(width, height, False);
 251
 252     if (strcasecmp(type, "solid")==0) {
 253
 254         str = PLGetString(PLGetArrayElement(texture, 1));
 255
 256         str2rcolor(rc, str, &rcolor);
 257
 258         RClearImage(image, &rcolor);
 259     } else if (strcasecmp(&type[1], "gradient")==0) {
 260         int style;
 261         RColor rcolor2;
 262
 263         switch (toupper(type[0])) {
 264          case 'V':
 265             style = RVerticalGradient;
 266             break;
 267          case 'H':
 268             style = RHorizontalGradient;
 269             break;
 270          case 'D':
 271             style = RDiagonalGradient;
 272             break;
 273         }
 274
 275         str = PLGetString(PLGetArrayElement(texture, 1));
 276         str2rcolor(rc, str, &rcolor);
 277         str = PLGetString(PLGetArrayElement(texture, 2));
 278         str2rcolor(rc, str, &rcolor2);
 279
 280         image = RRenderGradient(width, height, &rcolor, &rcolor2, style);
 281     } else if (strcasecmp(&type[2], "gradient")==0) {
 282         int style;
 283         RColor **colors;
 284         int i, j;
 285
 286         switch (toupper(type[1])) {
 287          case 'V':
 288             style = RVerticalGradient;
 289             break;
 290          case 'H':
 291             style = RHorizontalGradient;
 292             break;
 293          case 'D':
 294             style = RDiagonalGradient;
 295             break;
 296         }
 297
 298         j = PLGetNumberOfElements(texture);
 299
 300         if (j > 0) {
 301             colors = wmalloc(j * sizeof(RColor*));
 302
 303             for (i = 2; i < j; i++) {
 304                 str = PLGetString(PLGetArrayElement(texture, i));
 305                 colors[i-2] = wmalloc(sizeof(RColor));
 306                 str2rcolor(rc, str, colors[i-2]);
 307             }
 308             colors[i-2] = NULL;
 309
 310             image = RRenderMultiGradient(width, height, colors, style);
 311
 312             for (i = 0; colors[i]!=NULL; i++)
 313                 free(colors[i]);
 314             free(colors);
 315         }
 316     } else if (strcasecmp(&type[1], "pixmap")==0) {
 317         int style;
 318         RImage *timage;
 319         int w, h;
 320         char *path;
 321
 322         str = PLGetString(PLGetArrayElement(texture, 1));
 323
 324         path = wfindfileinarray(GetObjectForKey("PixmapPath"), str);
 325         timage = RLoadImage(rc, path, 0);
 326         free(path);
 327         if (timage) {
 328             w = timage->width;
 329             h = timage->height;
 330
 331             if (w - TEXPREV_WIDTH > h - TEXPREV_HEIGHT) {
 332                 h = (w * TEXPREV_HEIGHT)/TEXPREV_WIDTH;
 333             } else {
 334                 w = (h * TEXPREV_WIDTH)/TEXPREV_HEIGHT;
 335             }
 336
 337             image = RScaleImage(timage, w, h);
 338             RDestroyImage(timage);
 339         }
 340     }
 341
 342     if (path) {
 343         dumpRImage(path, image);
 344     }
 345
 346     RConvertImage(rc, image, &pixmap);
 347     RDestroyImage(image);
 348
 349     return pixmap;
 350 }
 351
 352
 353 #if 0
 354 static void
 355 updatePreviewBox(_Panel *panel, int elements)
 356 {
 357     WMScreen *scr = WMWidgetScreen(panel->win);
 358     Display *dpy = WMScreenDisplay(scr);
 359  /*   RContext *rc = WMScreenRContext(scr);*/
 360     int refresh = 0;
 361     char *tmp;
 362
 363     if (!panel->preview) {
 364         panel->preview = XCreatePixmap(dpy, WMWidgetXID(panel->win),
 365                                        220-4, 185-4, WMScreenDepth(scr));
 366
 367         refresh = -1;
 368     }
 369
 370     if (elements & FTITLE) {
 371         if (panel->ftitle)
 372             XFreePixmap(dpy, panel->ftitle);
 373
 374         panel->ftitle = renderTexture(scr, tmp, 180, 20, NULL, True);
 375         free(tmp);
 376     }
 377
 378     /* have to repaint everything to make things simple, eliminating
 379      * clipping stuff */
 380     if (refresh) {
 381
 382     }
 383
 384     if (refresh<0) {
 385         WMPixmap *pix;
 386         pix = WMCreatePixmapFromXPixmaps(scr, panel->preview, None,
 387                                          220-4, 185-4, WMScreenDepth(scr));
 388
 389         WMSetLabelImage(panel->prevL, pix);
 390         WMReleasePixmap(pix);
 391     }
 392 }
 393
 394
 395
 396 static char*
 397 getStrArrayForKey(char *key)
 398 {
 399     proplist_t v;
 400
 401     v = GetObjectForKey(key);
 402     if (!v)
 403         return NULL;
 404
 405     return PLGetDescription(v);
 406 }
 407 #endif
 408
 409
 410
 411 static void
 412 cancelNewTexture(void *data)
 413 {
 414     _Panel *panel = (_Panel*)data;
 415
 416     HideTexturePanel(panel->texturePanel);
 417 }
 418
 419
 420 static char*
 421 makeFileName(char *prefix, char *name)
 422 {
 423     char *fname, *str;
 424     int i;
 425
 426     str = wstrappend(prefix, name);
 427     fname = wstrdup(str);
 428
 429     i = 1;
 430     while (access(fname, F_OK)==0) {
 431         char buf[16];
 432
 433         free(fname);
 434         sprintf(buf, "%i", i++);
 435         fname = wstrappend(str, buf);
 436     }
 437     free(str);
 438
 439     return fname;
 440 }
 441
 442
 443 static void
 444 okNewTexture(void *data)
 445 {
 446     _Panel *panel = (_Panel*)data;
 447     WMListItem *item;
 448     char *name;
 449     char *str;
 450     proplist_t prop;
 451     TextureListItem *titem;
 452     WMScreen *scr = WMWidgetScreen(panel->win);
 453
 454     titem = wmalloc(sizeof(TextureListItem));
 455     memset(titem, 0, sizeof(TextureListItem));
 456
 457     HideTexturePanel(panel->texturePanel);
 458
 459     name = GetTexturePanelTextureName(panel->texturePanel);
 460
 461     prop = GetTexturePanelTexture(panel->texturePanel);
 462
 463     str = PLGetDescription(prop);
 464
 465     titem->title = name;
 466     titem->prop = prop;
 467     titem->texture = str;
 468     titem->selectedFor = 0;
 469
 470     titem->path = makeFileName(panel->fprefix, name);
 471     titem->preview = renderTexture(scr, prop, TEXPREV_WIDTH, TEXPREV_HEIGHT,
 472                                    titem->path, False);
 473
 474     item = WMAddListItem(panel->texLs, "");
 475     item->clientData = titem;
 476
 477     WMSetListPosition(panel->texLs, WMGetListNumberOfRows(panel->texLs));
 478 }
 479
 480
 481
 482 static void
 483 okEditTexture(void *data)
 484 {
 485     _Panel *panel = (_Panel*)data;
 486     WMListItem *item;
 487     char *name;
 488     char *str;
 489     proplist_t prop;
 490     TextureListItem *titem;
 491
 492     item = WMGetListItem(panel->texLs, WMGetListSelectedItemRow(panel->texLs));
 493     titem = (TextureListItem*)item->clientData;
 494
 495     HideTexturePanel(panel->texturePanel);
 496
 497     name = GetTexturePanelTextureName(panel->texturePanel);
 498
 499     prop = GetTexturePanelTexture(panel->texturePanel);
 500
 501     str = PLGetDescription(prop);
 502
 503     free(titem->title);
 504     titem->title = name;
 505
 506     PLRelease(titem->prop);
 507     titem->prop = prop;
 508
 509     free(titem->texture);
 510     titem->texture = str;
 511
 512     XFreePixmap(WMScreenDisplay(WMWidgetScreen(panel->texLs)), titem->preview);
 513     titem->preview = renderTexture(WMWidgetScreen(panel->texLs), titem->prop,
 514                                    TEXPREV_WIDTH, TEXPREV_HEIGHT,
 515                                    titem->path, False);
 516
 517     WMRedisplayWidget(panel->texLs);
 518 }
 519
 520
 521
 522 static void
 523 editTexture(WMWidget *w, void *data)
 524 {
 525     _Panel *panel = (_Panel*)data;
 526     WMListItem *item;
 527     TextureListItem *titem;
 528
 529     item = WMGetListItem(panel->texLs, WMGetListSelectedItemRow(panel->texLs));
 530     titem = (TextureListItem*)item->clientData;
 531
 532     SetTexturePanelTexture(panel->texturePanel, titem->title, titem->prop);
 533
 534     SetTexturePanelCancelAction(panel->texturePanel, cancelNewTexture, panel);
 535     SetTexturePanelOkAction(panel->texturePanel, okEditTexture, panel);
 536
 537     SetTexturePanelPixmapPath(panel->texturePanel,
 538                               GetObjectForKey("PixmapPath"));
 539     ShowTexturePanel(panel->texturePanel);
 540 }
 541
 542
 543
 544 static void
 545 newTexture(WMWidget *w, void *data)
 546 {
 547     _Panel *panel = (_Panel*)data;
 548
 549     SetTexturePanelTexture(panel->texturePanel, "New Texture", NULL);
 550
 551     SetTexturePanelCancelAction(panel->texturePanel, cancelNewTexture, panel);
 552
 553     SetTexturePanelOkAction(panel->texturePanel, okNewTexture, panel);
 554
 555     SetTexturePanelPixmapPath(panel->texturePanel,
 556                               GetObjectForKey("PixmapPath"));
 557     ShowTexturePanel(panel->texturePanel);
 558 }
 559
 560
 561
 562 static void
 563 deleteTexture(WMWidget *w, void *data)
 564 {
 565     _Panel *panel = (_Panel*)data;
 566     WMListItem *item;
 567     TextureListItem *titem;
 568     int row;
 569     int section;
 570
 571     section = WMGetPopUpButtonSelectedItem(panel->secP);
 572     row = WMGetListSelectedItemRow(panel->texLs);
 573     item = WMGetListItem(panel->texLs, row);
 574     titem = (TextureListItem*)item->clientData;
 575
 576     if (titem->selectedFor & (1 << section)) {
 577         TextureListItem *titem2;
 578
 579         panel->textureIndex[section] = section;
 580         item = WMGetListItem(panel->texLs, section);
 581         titem2 = (TextureListItem*)item->clientData;
 582         titem2->selectedFor |= 1 << section;
 583     }
 584
 585     free(titem->title);
 586     free(titem->texture);
 587     PLRelease(titem->prop);
 588     if (titem->path) {
 589         if (remove(titem->path) < 0 && errno != ENOENT) {
 590             wsyserror("could not remove file %s", titem->path);
 591         }
 592         free(titem->path);
 593     }
 594
 595     free(titem);
 596
 597     WMRemoveListItem(panel->texLs, row);
 598     WMSetButtonEnabled(panel->delB, False);
 599 }
 600
 601
 602 static void
 603 changePage(WMWidget *w, void *data)
 604 {
 605     _Panel *panel = (_Panel*)data;
 606     int section;
 607
 608     section = WMGetPopUpButtonSelectedItem(panel->secP);
 609
 610     WMSelectListItem(panel->texLs, panel->textureIndex[section]);
 611
 612     WMSetListPosition(panel->texLs, panel->textureIndex[section]
 613                       - WMGetListNumberOfRows(panel->texLs)/2);
 614 }
 615
 616
 617
 618 static void
 619 textureClick(WMWidget *w, void *data)
 620 {
 621     _Panel *panel = (_Panel*)data;
 622     int i;
 623     WMListItem *item;
 624     TextureListItem *titem;
 625
 626     i = WMGetListSelectedItemRow(panel->texLs);
 627
 628     item = WMGetListItem(panel->texLs, i);
 629
 630     titem = (TextureListItem*)item->clientData;
 631
 632     if (titem->current) {
 633         WMSetButtonEnabled(panel->delB, False);
 634     } else {
 635         WMSetButtonEnabled(panel->delB, True);
 636     }
 637 }
 638
 639
 640
 641 static void
 642 textureDoubleClick(WMWidget *w, void *data)
 643 {
 644     _Panel *panel = (_Panel*)data;
 645     int i, section;
 646     WMListItem *item;
 647     TextureListItem *titem;
 648
 649     /* unselect old texture */
 650     section = WMGetPopUpButtonSelectedItem(panel->secP);
 651
 652     item = WMGetListItem(panel->texLs, panel->textureIndex[section]);
 653     titem = (TextureListItem*)item->clientData;
 654     titem->selectedFor &= ~(1 << section);
 655
 656     /* select new texture */
 657     i = WMGetListSelectedItemRow(panel->texLs);
 658
 659     item = WMGetListItem(panel->texLs, i);
 660
 661     titem = (TextureListItem*)item->clientData;
 662
 663     titem->selectedFor |= 1<<section;
 664
 665     panel->textureIndex[section] = i;
 666
 667     WMRedisplayWidget(panel->texLs);
 668 }
 669
 670
 671
 672
 673 static void
 674 paintListItem(WMList *lPtr, int index, Drawable d, char *text, int state,
 675               WMRect *rect)
 676 {
 677     _Panel *panel = (_Panel*)WMGetHangedData(lPtr);
 678     WMScreen *scr = WMWidgetScreen(lPtr);
 679     int width, height, x, y;
 680     Display *dpy = WMScreenDisplay(scr);
 681     WMColor *white = WMWhiteColor(scr);
 682     WMListItem *item;
 683     WMColor *black = WMBlackColor(scr);
 684     TextureListItem *titem;
 685
 686     width = rect->size.width;
 687     height = rect->size.height;
 688     x = rect->pos.x;
 689     y = rect->pos.y;
 690
 691     if (state & WLDSSelected)
 692         XFillRectangle(dpy, d, WMColorGC(white), x, y, width, height);
 693     else
 694         XClearArea(dpy, d, x, y, width, height, False);
 695
 696     item = WMGetListItem(lPtr, index);
 697     titem = (TextureListItem*)item->clientData;
 698
 699     if (titem->preview)
 700     XCopyArea(dpy, titem->preview, d, WMColorGC(black), 0, 0, TEXPREV_WIDTH,
 701               TEXPREV_HEIGHT, x + 5, y + 5);
 702
 703     if ((1 << WMGetPopUpButtonSelectedItem(panel->secP)) & titem->selectedFor)
 704         WMDrawPixmap(panel->onLed, d, x + TEXPREV_WIDTH + 10, y + 6);
 705     else if (titem->selectedFor)
 706         WMDrawPixmap(panel->offLed, d, x + TEXPREV_WIDTH + 10, y + 6);
 707
 708     WMDrawString(scr, d, WMColorGC(black), panel->boldFont,
 709                  x + TEXPREV_WIDTH + 22, y + 2, titem->title,
 710                  strlen(titem->title));
 711
 712     WMDrawString(scr, d, WMColorGC(black), panel->smallFont,
 713                  x + TEXPREV_WIDTH + 14, y + 18, titem->texture,
 714                  strlen(titem->texture));
 715
 716
 717     WMReleaseColor(white);
 718     WMReleaseColor(black);
 719 }
 720
 721
 722
 723 static Pixmap
 724 loadRImage(WMScreen *scr, char *path)
 725 {
 726     FILE *f;
 727     RImage *image;
 728     int w, h, d;
 729     int i;
 730     Pixmap pixmap;
 731
 732     f = fopen(path, "r");
 733     if (!f)
 734         return None;
 735
 736     fscanf(f, "%02x%02x%1x", &w, &h, &d);
 737
 738     image = RCreateImage(w, h, d == 4);
 739     for (i = 0; i < d; i++) {
 740         fread(image->data[i], 1, w*h, f);
 741     }
 742     fclose(f);
 743
 744     RConvertImage(WMScreenRContext(scr), image, &pixmap);
 745     RDestroyImage(image);
 746
 747     return pixmap;
 748 }
 749
 750
 751 static void
 752 fillTextureList(WMList *lPtr)
 753 {
 754     proplist_t textureList;
 755     proplist_t texture;
 756     WMUserDefaults *udb = WMGetStandardUserDefaults();
 757     int i;
 758     TextureListItem *titem;
 759     WMScreen *scr  = WMWidgetScreen(lPtr);
 760
 761     textureList = WMGetUDObjectForKey(udb, "TextureList");
 762     if (!textureList)
 763         return;
 764
 765     for (i = 0; i < PLGetNumberOfElements(textureList); i++) {
 766         WMListItem *item;
 767
 768         texture = PLGetArrayElement(textureList, i);
 769
 770         titem = wmalloc(sizeof(TextureListItem));
 771         memset(titem, 0, sizeof(TextureListItem));
 772
 773         titem->title = wstrdup(PLGetString(PLGetArrayElement(texture, 0)));
 774         titem->prop = PLRetain(PLGetArrayElement(texture, 1));
 775         titem->texture = PLGetDescription(titem->prop);
 776         titem->selectedFor = 0;
 777         titem->path = wstrdup(PLGetString(PLGetArrayElement(texture, 2)));
 778
 779         titem->preview = loadRImage(scr, titem->path);
 780         if (!titem->preview) {
 781             titem->preview = renderTexture(scr, titem->prop, TEXPREV_WIDTH,
 782                                            TEXPREV_HEIGHT, NULL, False);
 783         }
 784         item = WMAddListItem(lPtr, "");
 785         item->clientData = titem;
 786     }
 787 }
 788
 789
 790 static void
 791 createPanel(Panel *p)
 792 {
 793     _Panel *panel = (_Panel*)p;
 794     WMColor *color;
 795     WMFont *font;
 796     WMScreen *scr = WMWidgetScreen(panel->win);
 797
 798     char *tmp;
 799     Bool ok = True;
 800
 801     panel->fprefix = wstrappend(wusergnusteppath(), "/.AppInfo");
 802
 803     if (access(panel->fprefix, F_OK)!=0) {
 804         if (mkdir(panel->fprefix, 0755) < 0) {
 805             wsyserror(panel->fprefix);
 806             ok = False;
 807         }
 808     }
 809     if (ok) {
 810         tmp = wstrappend(panel->fprefix, "/WPrefs/");
 811         free(panel->fprefix);
 812         panel->fprefix = tmp;
 813         if (access(panel->fprefix, F_OK)!=0) {
 814             if (mkdir(panel->fprefix, 0755) < 0) {
 815                 wsyserror(panel->fprefix);
 816             }
 817         }
 818     }
 819
 820     panel->smallFont = WMSystemFontOfSize(scr, 10);
 821     panel->normalFont = WMSystemFontOfSize(scr, 12);
 822     panel->boldFont = WMBoldSystemFontOfSize(scr, 12);
 823
 824     panel->onLed = WMCreatePixmapFromXPMData(scr, blueled_xpm);
 825     panel->offLed = WMCreatePixmapFromXPMData(scr, blueled2_xpm);
 826
 827     panel->frame = WMCreateFrame(panel->win);
 828     WMResizeWidget(panel->frame, FRAME_WIDTH, FRAME_HEIGHT);
 829     WMMoveWidget(panel->frame, FRAME_LEFT, FRAME_TOP);
 830
 831     /* preview box */
 832     panel->prevB = WMCreateCommandButton(panel->frame);
 833     WMResizeWidget(panel->prevB, 260, 165);
 834     WMMoveWidget(panel->prevB, 15, 10);
 835     WMSetButtonImagePosition(panel->prevB, WIPImageOnly);
 836
 837     panel->secP = WMCreatePopUpButton(panel->frame);
 838     WMResizeWidget(panel->secP, 260, 20);
 839     WMMoveWidget(panel->secP, 15, 180);
 840     WMSetPopUpButtonSelectedItem(panel->secP, 0);
 841     WMAddPopUpButtonItem(panel->secP, _("Titlebar of Focused Window"));
 842     WMAddPopUpButtonItem(panel->secP, _("Titlebar of Unfocused Windows"));
 843     WMAddPopUpButtonItem(panel->secP, _("Titlebar of Focused Window's Owner"));
 844     WMAddPopUpButtonItem(panel->secP, _("Titlebar of Menus"));
 845     WMAddPopUpButtonItem(panel->secP, _("Menu Items"));
 846     WMAddPopUpButtonItem(panel->secP, _("Icon Background"));
 847 /*    WMAddPopUpButtonItem(panel->secP, _("Workspace Backgrounds"));
 848  */
 849     WMSetPopUpButtonAction(panel->secP, changePage, panel);
 850
 851     /* texture list */
 852     font = WMBoldSystemFontOfSize(scr, 12);
 853
 854     panel->texL = WMCreateLabel(panel->frame);
 855     WMResizeWidget(panel->texL, 225, 18);
 856     WMMoveWidget(panel->texL, 285, 10);
 857     WMSetLabelFont(panel->texL, font);
 858     WMSetLabelText(panel->texL, _("Textures"));
 859     WMSetLabelRelief(panel->texL, WRSunken);
 860     WMSetLabelTextAlignment(panel->texL, WACenter);
 861     color = WMDarkGrayColor(scr);
 862     WMSetWidgetBackgroundColor(panel->texL, color);
 863     WMReleaseColor(color);
 864     color = WMWhiteColor(scr);
 865     WMSetLabelTextColor(panel->texL, color);
 866     WMReleaseColor(color);
 867
 868     WMReleaseFont(font);
 869
 870     panel->texLs = WMCreateList(panel->frame);
 871     WMResizeWidget(panel->texLs, 225, 144);
 872     WMMoveWidget(panel->texLs, 285, 30);
 873     WMSetListUserDrawItemHeight(panel->texLs, 35);
 874     WMSetListUserDrawProc(panel->texLs, paintListItem);
 875     WMHangData(panel->texLs, panel);
 876     WMSetListAction(panel->texLs, textureClick, panel);
 877     WMSetListDoubleAction(panel->texLs, textureDoubleClick, panel);
 878
 879     /* command buttons */
 880
 881     font = WMSystemFontOfSize(scr, 10);
 882
 883
 884     panel->newB = WMCreateCommandButton(panel->frame);
 885     WMResizeWidget(panel->newB, 56, 48);
 886     WMMoveWidget(panel->newB, 285, 180);
 887     WMSetButtonFont(panel->newB, font);
 888     WMSetButtonImagePosition(panel->newB, WIPAbove);
 889     WMSetButtonText(panel->newB, _("New"));
 890     WMSetButtonAction(panel->newB, newTexture, panel);
 891     SetButtonAlphaImage(scr, panel->newB, TNEW_FILE);
 892
 893     panel->ripB = WMCreateCommandButton(panel->frame);
 894     WMResizeWidget(panel->ripB, 56, 48);
 895     WMMoveWidget(panel->ripB, 341, 180);
 896     WMSetButtonFont(panel->ripB, font);
 897     WMSetButtonImagePosition(panel->ripB, WIPAbove);
 898     WMSetButtonText(panel->ripB, _("Extract..."));
 899     SetButtonAlphaImage(scr, panel->ripB, TEXTR_FILE);
 900
 901     WMSetButtonEnabled(panel->ripB, False);
 902
 903     panel->editB = WMCreateCommandButton(panel->frame);
 904     WMResizeWidget(panel->editB, 56, 48);
 905     WMMoveWidget(panel->editB, 397, 180);
 906     WMSetButtonFont(panel->editB, font);
 907     WMSetButtonImagePosition(panel->editB, WIPAbove);
 908     WMSetButtonText(panel->editB, _("Edit"));
 909     SetButtonAlphaImage(scr, panel->editB, TEDIT_FILE);
 910     WMSetButtonAction(panel->editB, editTexture, panel);
 911
 912     panel->delB = WMCreateCommandButton(panel->frame);
 913     WMResizeWidget(panel->delB, 56, 48);
 914     WMMoveWidget(panel->delB, 453, 180);
 915     WMSetButtonFont(panel->delB, font);
 916     WMSetButtonImagePosition(panel->delB, WIPAbove);
 917     WMSetButtonText(panel->delB, _("Delete"));
 918     SetButtonAlphaImage(scr, panel->delB, TDEL_FILE);
 919     WMSetButtonEnabled(panel->delB, False);
 920     WMSetButtonAction(panel->delB, deleteTexture, panel);
 921
 922     WMReleaseFont(font);
 923
 924     /**/
 925
 926     WMRealizeWidget(panel->frame);
 927     WMMapSubwidgets(panel->frame);
 928
 929     WMSetPopUpButtonSelectedItem(panel->secP, 0);
 930
 931     showData(panel);
 932
 933     fillTextureList(panel->texLs);
 934
 935     panel->texturePanel = CreateTexturePanel(panel->win);
 936 }
 937
 938
 939
 940 static proplist_t
 941 setupTextureFor(WMList *list, char *key, char *defValue, char *title,
 942                 int index)
 943 {
 944     WMListItem *item;
 945     TextureListItem *titem;
 946
 947     titem = wmalloc(sizeof(TextureListItem));
 948     memset(titem, 0, sizeof(TextureListItem));
 949
 950     titem->title = wstrdup(title);
 951     titem->prop = GetObjectForKey(key);
 952     if (!titem->prop) {
 953         titem->prop = PLGetProplistWithDescription(defValue);
 954     } else {
 955         PLRetain(titem->prop);
 956     }
 957     titem->texture = PLGetDescription((proplist_t)titem->prop);
 958     titem->current = 1;
 959     titem->selectedFor = 1<<index;
 960
 961     titem->preview = renderTexture(WMWidgetScreen(list), titem->prop,
 962                                    TEXPREV_WIDTH, TEXPREV_HEIGHT, NULL, False);
 963
 964     item = WMAddListItem(list, "");
 965     item->clientData = titem;
 966
 967     return titem->prop;
 968 }
 969
 970
 971
 972 static void
 973 showData(_Panel *panel)
 974 {
 975     int i = 0;
 976
 977     panel->ftitleTex = setupTextureFor(panel->texLs, "FTitleBack",
 978                                        "(solid, black)", "[Focused]", i);
 979     panel->textureIndex[i] = i++;
 980
 981     panel->utitleTex = setupTextureFor(panel->texLs, "UTitleBack",
 982                                        "(solid, gray)", "[Unfocused]", i);
 983     panel->textureIndex[i] = i++;
 984
 985     panel->ptitleTex = setupTextureFor(panel->texLs, "PTitleBack",
 986                                        "(solid, \"#616161\")",
 987                                        "[Owner of Focused]", i);
 988     panel->textureIndex[i] = i++;
 989
 990     panel->mtitleTex = setupTextureFor(panel->texLs, "MenuTitleBack",
 991                                        "(solid, black)", "[Menu Title]", i);
 992     panel->textureIndex[i] = i++;
 993
 994     panel->menuTex = setupTextureFor(panel->texLs, "MenuTextBack",
 995                                      "(solid, gray)", "[Menu Item]", i);
 996     panel->textureIndex[i] = i++;
 997
 998     panel->iconTex = setupTextureFor(panel->texLs, "IconBack",
 999                                      "(solid, gray)", "[Icon]", i);
1000     panel->textureIndex[i] = i++;
1001 /*
1002     panel->backTex = setupTextureFor(panel->texLs, "WorkspaceBack",
1003                                      "(solid, black)", "[Workspace]", i);
1004     panel->textureIndex[i] = i++;
1005  */
1006 }
1007
1008
1009
1010 static void
1011 storeData(_Panel *panel)
1012 {
1013     proplist_t textureList;
1014     proplist_t texture;
1015     int i;
1016     TextureListItem *titem;
1017     WMListItem *item;
1018     WMUserDefaults *udb = WMGetStandardUserDefaults();
1019
1020     textureList = PLMakeArrayFromElements(NULL, NULL);
1021
1022     /* store list of textures */
1023     for (i = 6; i < WMGetListNumberOfRows(panel->texLs); i++) {
1024         item = WMGetListItem(panel->texLs, i);
1025         titem = (TextureListItem*)item->clientData;
1026
1027         texture = PLMakeArrayFromElements(PLMakeString(titem->title),
1028                                           PLRetain(titem->prop),
1029                                           PLMakeString(titem->path),
1030                                           NULL);
1031
1032         PLAppendArrayElement(textureList, texture);
1033     }
1034
1035     WMSetUDObjectForKey(udb, textureList, "TextureList");
1036     PLRelease(textureList);
1037
1038     item = WMGetListItem(panel->texLs, panel->textureIndex[0]);
1039     titem = (TextureListItem*)item->clientData;
1040     SetObjectForKey(titem->prop, "FTitleBack");
1041
1042     item = WMGetListItem(panel->texLs, panel->textureIndex[1]);
1043     titem = (TextureListItem*)item->clientData;
1044     SetObjectForKey(titem->prop, "UTitleBack");
1045
1046     item = WMGetListItem(panel->texLs, panel->textureIndex[2]);
1047     titem = (TextureListItem*)item->clientData;
1048     SetObjectForKey(titem->prop, "PTitleBack");
1049
1050     item = WMGetListItem(panel->texLs, panel->textureIndex[3]);
1051     titem = (TextureListItem*)item->clientData;
1052     SetObjectForKey(titem->prop, "MenuTextBack");
1053
1054     item = WMGetListItem(panel->texLs, panel->textureIndex[4]);
1055     titem = (TextureListItem*)item->clientData;
1056     SetObjectForKey(titem->prop, "MenuItemBack");
1057
1058     item = WMGetListItem(panel->texLs, panel->textureIndex[5]);
1059     titem = (TextureListItem*)item->clientData;
1060     SetObjectForKey(titem->prop, "IconBack");
1061
1062 }
1063
1064
1065
1066 Panel*
1067 InitAppearance(WMScreen *scr, WMWindow *win)
1068 {
1069     _Panel *panel;
1070
1071     panel = wmalloc(sizeof(_Panel));
1072     memset(panel, 0, sizeof(_Panel));
1073
1074     panel->sectionName = _("Appearance Preferences");
1075
1076     panel->win = win;
1077
1078     panel->callbacks.createWidgets = createPanel;
1079     panel->callbacks.updateDomain = storeData;
1080
1081     AddSection(panel, ICON_FILE);
1082
1083     return panel;
1084 }