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 #include <ctype.h>
  29 #include <time.h>
  30 #include <sys/stat.h>
  31 #include <sys/types.h>
  32 #include <fcntl.h>
  33 #include <unistd.h>
  34
  35
  36
  37
  38 #include "TexturePanel.h"
  39
  40 typedef struct _Panel {
  41     WMFrame *frame;
  42     char *sectionName;
  43
  44     CallbackRec callbacks;
  45
  46     WMWindow *win;
  47
  48     WMLabel *prevL;
  49
  50     WMPopUpButton *secP;
  51
  52     /* texture list */
  53     WMLabel *texL;
  54     WMList *texLs;
  55     WMLabel *texsL;
  56
  57     WMButton *newB;
  58     WMButton *editB;
  59     WMButton *ripB;
  60     WMButton *delB;
  61
  62     int textureIndex[8];
  63
  64     WMFont *smallFont;
  65     WMFont *normalFont;
  66     WMFont *boldFont;
  67
  68     TexturePanel *texturePanel;
  69
  70     WMPixmap *onLed;
  71     WMPixmap *offLed;
  72     WMPixmap *hand;
  73
  74     int oldsection;
  75
  76     Pixmap preview;
  77
  78     char *fprefix;
  79 } _Panel;
  80
  81
  82 typedef struct {
  83     char *title;
  84     char *texture;
  85     proplist_t prop;
  86     Pixmap preview;
  87
  88     char *path;
  89
  90     char selectedFor;
  91     unsigned current:1;
  92     unsigned ispixmap:1;
  93 } TextureListItem;
  94
  95
  96 static void showData(_Panel *panel);
  97
  98
  99 static void OpenExtractPanelFor(_Panel *panel, char *path);
 100
 101 #define ICON_FILE       "appearance"
 102
 103 #define TNEW_FILE       "tnew"
 104 #define TDEL_FILE       "tdel"
 105 #define TEDIT_FILE      "tedit"
 106 #define TEXTR_FILE      "textr"
 107
 108
 109
 110 /* XPM */
 111 static char * blueled_xpm[] = {
 112 "8 8 17 1",
 113 "       c None",
 114 ".      c #020204",
 115 "+      c #16B6FC",
 116 "@      c #176AFC",
 117 "#      c #163AFC",
 118 "$      c #72D2FC",
 119 "%      c #224CF4",
 120 "&      c #76D6FC",
 121 "*      c #16AAFC",
 122 "=      c #CEE9FC",
 123 "-      c #229EFC",
 124 ";      c #164CFC",
 125 ">      c #FAFEFC",
 126 ",      c #2482FC",
 127 "'      c #1652FC",
 128 ")      c #1E76FC",
 129 "!      c #1A60FC",
 130 "  ....  ",
 131 " .=>-@. ",
 132 ".=>$@@'.",
 133 ".=$@!;;.",
 134 ".!@*+!#.",
 135 ".#'*+*,.",
 136 " .@)@,. ",
 137 "  ....  "};
 138
 139
 140 /* XPM */
 141 static char *blueled2_xpm[] = {
 142 /* width height num_colors chars_per_pixel */
 143 "     8     8       17            1",
 144 /* colors */
 145 ". c None",
 146 "# c #090909",
 147 "a c #4b63a4",
 148 "b c #011578",
 149 "c c #264194",
 150 "d c #04338c",
 151 "e c #989dac",
 152 "f c #011a7c",
 153 "g c #465c9c",
 154 "h c #03278a",
 155 "i c #6175ac",
 156 "j c #011e74",
 157 "k c #043a90",
 158 "l c #042f94",
 159 "m c #0933a4",
 160 "n c #022184",
 161 "o c #012998",
 162 /* pixels */
 163 "..####..",
 164 ".#aimn#.",
 165 "#aechnf#",
 166 "#gchnjf#",
 167 "#jndknb#",
 168 "#bjdddl#",
 169 ".#nono#.",
 170 "..####.."
 171 };
 172
 173 /* XPM */
 174 static char * hand_xpm[] = {
 175 "22 21 17 1",
 176 "       c None",
 177 ".      c #030305",
 178 "+      c #101010",
 179 "@      c #535355",
 180 "#      c #7F7F7E",
 181 "$      c #969697",
 182 "%      c #B5B5B6",
 183 "&      c #C5C5C6",
 184 "*      c #D2D2D0",
 185 "=      c #DCDCDC",
 186 "-      c #E5E5E4",
 187 ";      c #ECECEC",
 188 ">      c #767674",
 189 ",      c #F2F2F4",
 190 "'      c #676767",
 191 ")      c #FDFDFB",
 192 "!      c #323234",
 193 "                      ",
 194 "       .....          ",
 195 "     ..#%&&$.         ",
 196 "    .))),%..........  ",
 197 "   .)-)),&)))))))))$. ",
 198 "  .-&))))))))),,,,;;. ",
 199 " .=)))))))));-=***&$. ",
 200 " .=)))))))),..+.....  ",
 201 " +=)))))))))-&#.      ",
 202 " +=)))))))))-%>.      ",
 203 " +&)))))))))-%'.      ",
 204 " +$,,))))));...       ",
 205 " .#%%*;,)),*$>+       ",
 206 "  .'>$%&&&&$#@.       ",
 207 "   .!'>#$##>'.        ",
 208 "     ..+++++.         ",
 209 "                      ",
 210 "     ##@@@##          ",
 211 "   @@@@@@@@@@@        ",
 212 "     >>@@@##          ",
 213 "                      "};
 214
 215
 216
 217
 218 #define FTITLE  (1<<0)
 219 #define UTITLE  (1<<1)
 220 #define OTITLE  (1<<2)
 221 #define RESIZEBAR (1<<3)
 222 #define MTITLE  (1<<4)
 223 #define MITEM   (1<<5)
 224 #define ICON    (1<<6)
 225 #define BACK    (1<<7)
 226 #define EVERYTHING      0xff
 227
 228
 229 #define RESIZEBAR_BEVEL -1
 230 #define MENU_BEVEL      -2
 231
 232 #define TEXPREV_WIDTH   40
 233 #define TEXPREV_HEIGHT  24
 234
 235
 236
 237
 238
 239 static void
 240 str2rcolor(RContext *rc, char *name, RColor *color)
 241 {
 242     XColor xcolor;
 243
 244     XParseColor(rc->dpy, rc->cmap, name, &xcolor);
 245
 246     color->alpha = 255;
 247     color->red = xcolor.red >> 8;
 248     color->green = xcolor.green >> 8;
 249     color->blue = xcolor.blue >> 8;
 250 }
 251
 252
 253
 254 static void
 255 dumpRImage(char *path, RImage *image)
 256 {
 257     FILE *f;
 258
 259     f = fopen(path, "w");
 260     if (!f) {
 261         wsyserror(path);
 262         return;
 263     }
 264     fprintf(f, "%02x%02x%1x", image->width, image->height,
 265             image->data[3]!=NULL ? 4 : 3);
 266
 267     fwrite(image->data[0], 1, image->width * image->height, f);
 268     fwrite(image->data[1], 1, image->width * image->height, f);
 269     fwrite(image->data[2], 1, image->width * image->height, f);
 270     if (image->data[3])
 271         fwrite(image->data[3], 1, image->width * image->height, f);
 272
 273     if (fclose(f) < 0) {
 274         wsyserror(path);
 275     }
 276 }
 277
 278
 279
 280 static int
 281 isPixmap(proplist_t prop)
 282 {
 283     proplist_t p;
 284     char *s;
 285
 286     p = PLGetArrayElement(prop, 0);
 287     s = PLGetString(p);
 288     if (strcasecmp(&s[1], "pixmap")==0)
 289         return 1;
 290     else
 291         return 0;
 292 }
 293
 294
 295 static void
 296 drawResizebarBevel(RImage *img)
 297 {
 298     RColor light;
 299     RColor dark;
 300     RColor black;
 301     int width = img->width;
 302     int height = img->height;
 303     int cwidth = 28;
 304
 305     black.alpha = 255;
 306     black.red = black.green = black.blue = 0;
 307
 308     light.alpha = 0;
 309     light.red = light.green = light.blue = 80;
 310
 311     dark.alpha = 0;
 312     dark.red = dark.green = dark.blue = 40;
 313
 314     ROperateLine(img, RSubtractOperation, 0, 0, width-1, 0, &dark);
 315     ROperateLine(img, RAddOperation, 0, 1, width-1, 1, &light);
 316
 317     ROperateLine(img, RSubtractOperation, cwidth, 2, cwidth, height-1, &dark);
 318     ROperateLine(img, RAddOperation, cwidth+1, 2, cwidth+1, height-1, &light);
 319
 320     ROperateLine(img, RSubtractOperation, width-cwidth-2, 2, width-cwidth-2,
 321                  height-1, &dark);
 322     ROperateLine(img, RAddOperation, width-cwidth-1, 2, width-cwidth-1,
 323                  height-1, &light);
 324
 325     RDrawLine(img, 0, height-1, width-1, height-1, &black);
 326     RDrawLine(img, 0, 0, 0, height-1, &black);
 327     RDrawLine(img, width-1, 0, width-1, height-1, &black);
 328 }
 329
 330
 331 static void
 332 drawMenuBevel(RImage *img)
 333 {
 334     RColor light, dark, mid;
 335     int i;
 336     int iheight = img->height / 3;
 337
 338     light.alpha = 0;
 339     light.red = light.green = light.blue = 80;
 340
 341     dark.alpha = 255;
 342     dark.red = dark.green = dark.blue = 0;
 343
 344     mid.alpha = 0;
 345     mid.red = mid.green = mid.blue = 40;
 346
 347     for (i = 1; i < 3; i++) {
 348         ROperateLine(img, RSubtractOperation, 0, i*iheight-2,
 349                      img->width-1, i*iheight-2, &mid);
 350
 351         RDrawLine(img, 0, i*iheight-1,
 352                   img->width-1, i*iheight-1, &dark);
 353
 354         ROperateLine(img, RAddOperation, 0, i*iheight,
 355                      img->width-1, i*iheight, &light);
 356     }
 357 }
 358
 359
 360 static Pixmap
 361 renderTexture(WMScreen *scr, proplist_t texture, int width, int height,
 362               char *path, int border)
 363 {
 364     char *type;
 365     RImage *image;
 366     Pixmap pixmap;
 367     RContext *rc = WMScreenRContext(scr);
 368     char *str;
 369     RColor rcolor;
 370
 371
 372     type = PLGetString(PLGetArrayElement(texture, 0));
 373
 374     image = RCreateImage(width, height, False);
 375
 376     if (strcasecmp(type, "solid")==0) {
 377
 378         str = PLGetString(PLGetArrayElement(texture, 1));
 379
 380         str2rcolor(rc, str, &rcolor);
 381
 382         RClearImage(image, &rcolor);
 383     } else if (strcasecmp(&type[1], "gradient")==0) {
 384         int style;
 385         RColor rcolor2;
 386
 387         switch (toupper(type[0])) {
 388          case 'V':
 389             style = RVerticalGradient;
 390             break;
 391          case 'H':
 392             style = RHorizontalGradient;
 393             break;
 394          default:
 395          case 'D':
 396             style = RDiagonalGradient;
 397             break;
 398         }
 399
 400         str = PLGetString(PLGetArrayElement(texture, 1));
 401         str2rcolor(rc, str, &rcolor);
 402         str = PLGetString(PLGetArrayElement(texture, 2));
 403         str2rcolor(rc, str, &rcolor2);
 404
 405         image = RRenderGradient(width, height, &rcolor, &rcolor2, style);
 406     } else if (strcasecmp(&type[2], "gradient")==0 && toupper(type[0])=='T') {
 407         int style;
 408         RColor rcolor2;
 409         int i;
 410         RImage *grad, *timage;
 411         char *path;
 412
 413         switch (toupper(type[1])) {
 414          case 'V':
 415             style = RVerticalGradient;
 416             break;
 417          case 'H':
 418             style = RHorizontalGradient;
 419             break;
 420          default:
 421          case 'D':
 422             style = RDiagonalGradient;
 423             break;
 424         }
 425
 426         str = PLGetString(PLGetArrayElement(texture, 3));
 427         str2rcolor(rc, str, &rcolor);
 428         str = PLGetString(PLGetArrayElement(texture, 4));
 429         str2rcolor(rc, str, &rcolor2);
 430
 431         str = PLGetString(PLGetArrayElement(texture, 1));
 432
 433         path = wfindfileinarray(GetObjectForKey("PixmapPath"), str);
 434         timage = RLoadImage(rc, path, 0);
 435
 436         if (!timage) {
 437             wwarning("could not load file '%s': %s", path,
 438                      RMessageForError(RErrorCode));
 439         } else {
 440             grad = RRenderGradient(width, height, &rcolor, &rcolor2, style);
 441
 442             image = RMakeTiledImage(timage, width, height);
 443             RDestroyImage(timage);
 444
 445             i = atoi(PLGetString(PLGetArrayElement(texture, 2)));
 446
 447             RCombineImagesWithOpaqueness(image, grad, i);
 448             RDestroyImage(grad);
 449         }
 450     } else if (strcasecmp(&type[2], "gradient")==0 && toupper(type[0])=='M') {
 451         int style;
 452         RColor **colors;
 453         int i, j;
 454
 455         switch (toupper(type[1])) {
 456          case 'V':
 457             style = RVerticalGradient;
 458             break;
 459          case 'H':
 460             style = RHorizontalGradient;
 461             break;
 462          default:
 463          case 'D':
 464             style = RDiagonalGradient;
 465             break;
 466         }
 467
 468         j = PLGetNumberOfElements(texture);
 469
 470         if (j > 0) {
 471             colors = wmalloc(j * sizeof(RColor*));
 472
 473             for (i = 2; i < j; i++) {
 474                 str = PLGetString(PLGetArrayElement(texture, i));
 475                 colors[i-2] = wmalloc(sizeof(RColor));
 476                 str2rcolor(rc, str, colors[i-2]);
 477             }
 478             colors[i-2] = NULL;
 479
 480             image = RRenderMultiGradient(width, height, colors, style);
 481
 482             for (i = 0; colors[i]!=NULL; i++)
 483                 free(colors[i]);
 484             free(colors);
 485         }
 486     } else if (strcasecmp(&type[1], "pixmap")==0) {
 487         RImage *timage;
 488         char *path;
 489         RColor color;
 490
 491         str = PLGetString(PLGetArrayElement(texture, 1));
 492
 493         path = wfindfileinarray(GetObjectForKey("PixmapPath"), str);
 494         timage = RLoadImage(rc, path, 0);
 495
 496         if (!timage) {
 497             wwarning("could not load file '%s': %s", path,
 498                      RMessageForError(RErrorCode));
 499         } else {
 500             str = PLGetString(PLGetArrayElement(texture, 2));
 501             str2rcolor(rc, str, &color);
 502
 503             switch (toupper(type[0])) {
 504              case 'T':
 505                 image = RMakeTiledImage(timage, width, height);
 506                 RDestroyImage(timage);
 507                 timage = image;
 508                 break;
 509              case 'C':
 510                 image = RMakeCenteredImage(timage, width, height, &color);
 511                 RDestroyImage(timage);
 512                 timage = image;
 513                 break;
 514              case 'S':
 515              case 'M':
 516                 image = RScaleImage(timage, width, height);
 517                 RDestroyImage(timage);
 518                 timage = image;
 519                 break;
 520             }
 521
 522         }
 523         free(path);
 524     }
 525
 526     if (!image)
 527         return None;
 528
 529     if (path) {
 530         dumpRImage(path, image);
 531     }
 532
 533     if (border < 0) {
 534         if (border == RESIZEBAR_BEVEL) {
 535             drawResizebarBevel(image);
 536         } else if (border == MENU_BEVEL) {
 537             drawMenuBevel(image);
 538         }
 539     } else if (border) {
 540         RBevelImage(image, border);
 541     }
 542
 543     RConvertImage(rc, image, &pixmap);
 544     RDestroyImage(image);
 545
 546     return pixmap;
 547 }
 548
 549
 550 static Pixmap
 551 renderMenu(_Panel *panel, proplist_t texture, int width, int iheight)
 552 {
 553     WMScreen *scr = WMWidgetScreen(panel->win);
 554     Display *dpy = WMScreenDisplay(scr);
 555     Pixmap pix, tmp;
 556     char *str;
 557     GC gc = XCreateGC(dpy, WMWidgetXID(panel->win), 0, NULL);
 558
 559
 560     str = GetStringForKey("MenuStyle");
 561     if (!str || strcasecmp(str, "normal")==0) {
 562         int i;
 563
 564         tmp = renderTexture(scr, texture, width, iheight, NULL, RBEV_RAISED2);
 565
 566         pix = XCreatePixmap(dpy, tmp, width, iheight*3,
 567                             WMScreenDepth(scr));
 568         for (i = 0; i < 3; i++) {
 569             XCopyArea(dpy, tmp, pix, gc, 0, 0, width, iheight,
 570                       0, iheight*i);
 571         }
 572         XFreePixmap(dpy, tmp);
 573     } else if (strcasecmp(str, "flat")==0) {
 574         pix = renderTexture(scr, texture, width, iheight*3, NULL, RBEV_RAISED2);
 575     } else {
 576         pix = renderTexture(scr, texture, width, iheight*3, NULL, MENU_BEVEL);
 577     }
 578
 579     XFreeGC(dpy, gc);
 580
 581     return pix;
 582 }
 583
 584
 585 static void
 586 updatePreviewBox(_Panel *panel, int elements)
 587 {
 588     WMScreen *scr = WMWidgetScreen(panel->win);
 589     Display *dpy = WMScreenDisplay(scr);
 590  /*   RContext *rc = WMScreenRContext(scr);*/
 591     int refresh = 0;
 592     Pixmap pix;
 593     GC gc;
 594     WMListItem *item;
 595     TextureListItem *titem;
 596
 597     gc = XCreateGC(dpy, WMWidgetXID(panel->win), 0, NULL);
 598
 599
 600     if (!panel->preview) {
 601         WMColor *color;
 602
 603         panel->preview = XCreatePixmap(dpy, WMWidgetXID(panel->win),
 604                                        260-4, 165-4, WMScreenDepth(scr));
 605
 606         color = WMGrayColor(scr);
 607         XFillRectangle(dpy, panel->preview, WMColorGC(color),
 608                        0, 0, 260-4, 165-4);
 609         WMReleaseColor(color);
 610
 611         refresh = -1;
 612     }
 613
 614     if (elements & FTITLE) {
 615         item = WMGetListItem(panel->texLs, panel->textureIndex[0]);
 616         titem = (TextureListItem*)item->clientData;
 617
 618         pix = renderTexture(scr, titem->prop, 210, 20, NULL, RBEV_RAISED2);
 619
 620         XCopyArea(dpy, pix, panel->preview, gc, 0, 0, 210, 20, 30, 5);
 621
 622         XFreePixmap(dpy, pix);
 623     }
 624     if (elements & UTITLE) {
 625         item = WMGetListItem(panel->texLs, panel->textureIndex[1]);
 626         titem = (TextureListItem*)item->clientData;
 627
 628         pix = renderTexture(scr, titem->prop, 210, 20, NULL, RBEV_RAISED2);
 629
 630         XCopyArea(dpy, pix, panel->preview, gc, 0, 0, 210, 20, 30, 30);
 631
 632         XFreePixmap(dpy, pix);
 633     }
 634     if (elements & OTITLE) {
 635         item = WMGetListItem(panel->texLs, panel->textureIndex[2]);
 636         titem = (TextureListItem*)item->clientData;
 637
 638         pix = renderTexture(scr, titem->prop, 210, 20, NULL, RBEV_RAISED2);
 639
 640         XCopyArea(dpy, pix, panel->preview, gc, 0, 0, 210, 20, 30, 55);
 641
 642         XFreePixmap(dpy, pix);
 643     }
 644     if (elements & RESIZEBAR) {
 645         item = WMGetListItem(panel->texLs, panel->textureIndex[3]);
 646         titem = (TextureListItem*)item->clientData;
 647
 648         pix = renderTexture(scr, titem->prop, 210, 9, NULL, RESIZEBAR_BEVEL);
 649
 650         XCopyArea(dpy, pix, panel->preview, gc, 0, 0, 210, 20, 30, 80);
 651
 652         XFreePixmap(dpy, pix);
 653     }
 654     if (elements & MTITLE) {
 655         item = WMGetListItem(panel->texLs, panel->textureIndex[4]);
 656         titem = (TextureListItem*)item->clientData;
 657
 658         pix = renderTexture(scr, titem->prop, 100, 20, NULL, RBEV_RAISED2);
 659
 660         XCopyArea(dpy, pix, panel->preview, gc, 0, 0, 100, 20, 30, 95);
 661
 662         XFreePixmap(dpy, pix);
 663     }
 664     if (elements & MITEM) {
 665         item = WMGetListItem(panel->texLs, panel->textureIndex[5]);
 666         titem = (TextureListItem*)item->clientData;
 667
 668         pix = renderMenu(panel, titem->prop, 100, 18);
 669
 670         XCopyArea(dpy, pix, panel->preview, gc, 0, 0, 100, 18*3, 30, 115);
 671
 672         XFreePixmap(dpy, pix);
 673     }
 674     if (elements & (MITEM|MTITLE)) {
 675         XDrawLine(dpy, panel->preview, gc, 29, 95, 29, 115+36+20);
 676         XDrawLine(dpy, panel->preview, gc, 29, 94, 129, 94);
 677     }
 678
 679     if (elements & ICON) {
 680         item = WMGetListItem(panel->texLs, panel->textureIndex[6]);
 681         titem = (TextureListItem*)item->clientData;
 682
 683         pix = renderTexture(scr, titem->prop, 64, 64, NULL,
 684                             titem->ispixmap ? 0 : RBEV_RAISED3);
 685
 686         XCopyArea(dpy, pix, panel->preview, gc, 0, 0, 64, 64, 170, 95);
 687
 688         XFreePixmap(dpy, pix);
 689     }
 690
 691
 692     if (refresh < 0) {
 693         WMPixmap *p;
 694         p = WMCreatePixmapFromXPixmaps(scr, panel->preview, None,
 695                                        260-4, 165-4, WMScreenDepth(scr));
 696
 697         WMSetLabelImage(panel->prevL, p);
 698         WMReleasePixmap(p);
 699     } else {
 700         WMRedisplayWidget(panel->prevL);
 701     }
 702
 703     XFreeGC(dpy, gc);
 704 }
 705
 706
 707
 708
 709 static void
 710 cancelNewTexture(void *data)
 711 {
 712     _Panel *panel = (_Panel*)data;
 713
 714     HideTexturePanel(panel->texturePanel);
 715 }
 716
 717
 718
 719
 720 static char*
 721 makeFileName(char *prefix)
 722 {
 723     char *fname;
 724
 725     fname = wstrdup(prefix);
 726
 727     while (access(fname, F_OK)==0) {
 728         char buf[30];
 729
 730         free(fname);
 731         sprintf(buf, "%08lx.cache", time(NULL));
 732         fname = wstrappend(prefix, buf);
 733     }
 734
 735     return fname;
 736 }
 737
 738
 739
 740
 741 static void
 742 okNewTexture(void *data)
 743 {
 744     _Panel *panel = (_Panel*)data;
 745     WMListItem *item;
 746     char *name;
 747     char *str;
 748     proplist_t prop;
 749     TextureListItem *titem;
 750     WMScreen *scr = WMWidgetScreen(panel->win);
 751
 752     titem = wmalloc(sizeof(TextureListItem));
 753     memset(titem, 0, sizeof(TextureListItem));
 754
 755     HideTexturePanel(panel->texturePanel);
 756
 757     name = GetTexturePanelTextureName(panel->texturePanel);
 758
 759     prop = GetTexturePanelTexture(panel->texturePanel);
 760
 761     str = PLGetDescription(prop);
 762
 763     titem->title = name;
 764     titem->prop = prop;
 765     titem->texture = str;
 766     titem->selectedFor = 0;
 767
 768     titem->ispixmap = isPixmap(prop);
 769
 770     titem->path = makeFileName(panel->fprefix);
 771     titem->preview = renderTexture(scr, prop, TEXPREV_WIDTH, TEXPREV_HEIGHT,
 772                                    titem->path, 0);
 773
 774     item = WMAddListItem(panel->texLs, "");
 775     item->clientData = titem;
 776
 777     WMSetListPosition(panel->texLs, WMGetListNumberOfRows(panel->texLs));
 778 }
 779
 780
 781 static void
 782 okEditTexture(void *data)
 783 {
 784     _Panel *panel = (_Panel*)data;
 785     WMListItem *item;
 786     char *name;
 787     char *str;
 788     proplist_t prop;
 789     TextureListItem *titem;
 790
 791     item = WMGetListItem(panel->texLs, WMGetListSelectedItemRow(panel->texLs));
 792     titem = (TextureListItem*)item->clientData;
 793
 794     HideTexturePanel(panel->texturePanel);
 795
 796     if (titem->current) {
 797         name = GetTexturePanelTextureName(panel->texturePanel);
 798
 799         free(titem->title);
 800         titem->title = name;
 801     }
 802
 803     prop = GetTexturePanelTexture(panel->texturePanel);
 804
 805     str = PLGetDescription(prop);
 806
 807     PLRelease(titem->prop);
 808     titem->prop = prop;
 809
 810     titem->ispixmap = isPixmap(prop);
 811
 812     free(titem->texture);
 813     titem->texture = str;
 814
 815     XFreePixmap(WMScreenDisplay(WMWidgetScreen(panel->texLs)), titem->preview);
 816     titem->preview = renderTexture(WMWidgetScreen(panel->texLs), titem->prop,
 817                                    TEXPREV_WIDTH, TEXPREV_HEIGHT,
 818                                    titem->path, 0);
 819
 820     WMRedisplayWidget(panel->texLs);
 821
 822     if (titem->selectedFor)
 823         updatePreviewBox(panel, titem->selectedFor);
 824 }
 825
 826
 827
 828 static void
 829 editTexture(WMWidget *w, void *data)
 830 {
 831     _Panel *panel = (_Panel*)data;
 832     WMListItem *item;
 833     TextureListItem *titem;
 834
 835     item = WMGetListItem(panel->texLs, WMGetListSelectedItemRow(panel->texLs));
 836     titem = (TextureListItem*)item->clientData;
 837
 838     SetTexturePanelPixmapPath(panel->texturePanel,
 839                               GetObjectForKey("PixmapPath"));
 840
 841     SetTexturePanelTexture(panel->texturePanel, titem->title, titem->prop);
 842
 843     SetTexturePanelCancelAction(panel->texturePanel, cancelNewTexture, panel);
 844     SetTexturePanelOkAction(panel->texturePanel, okEditTexture, panel);
 845
 846     ShowTexturePanel(panel->texturePanel);
 847 }
 848
 849
 850
 851 static void
 852 newTexture(WMWidget *w, void *data)
 853 {
 854     _Panel *panel = (_Panel*)data;
 855
 856     SetTexturePanelPixmapPath(panel->texturePanel,
 857                               GetObjectForKey("PixmapPath"));
 858
 859     SetTexturePanelTexture(panel->texturePanel, "New Texture", NULL);
 860
 861     SetTexturePanelCancelAction(panel->texturePanel, cancelNewTexture, panel);
 862
 863     SetTexturePanelOkAction(panel->texturePanel, okNewTexture, panel);
 864
 865     ShowTexturePanel(panel->texturePanel);
 866 }
 867
 868
 869
 870 static void
 871 deleteTexture(WMWidget *w, void *data)
 872 {
 873     _Panel *panel = (_Panel*)data;
 874     WMListItem *item;
 875     TextureListItem *titem;
 876     int row;
 877     int section;
 878
 879     section = WMGetPopUpButtonSelectedItem(panel->secP);
 880     row = WMGetListSelectedItemRow(panel->texLs);
 881     item = WMGetListItem(panel->texLs, row);
 882     titem = (TextureListItem*)item->clientData;
 883
 884     if (titem->selectedFor & (1 << section)) {
 885         TextureListItem *titem2;
 886
 887         panel->textureIndex[section] = section;
 888         item = WMGetListItem(panel->texLs, section);
 889         titem2 = (TextureListItem*)item->clientData;
 890         titem2->selectedFor |= 1 << section;
 891     }
 892
 893     free(titem->title);
 894     free(titem->texture);
 895     PLRelease(titem->prop);
 896     if (titem->path) {
 897         if (remove(titem->path) < 0 && errno != ENOENT) {
 898             wsyserror("could not remove file %s", titem->path);
 899         }
 900         free(titem->path);
 901     }
 902
 903     free(titem);
 904
 905     WMRemoveListItem(panel->texLs, row);
 906     WMSetButtonEnabled(panel->delB, False);
 907 }
 908
 909
 910
 911
 912 static void
 913 extractTexture(WMWidget *w, void *data)
 914 {
 915     _Panel *panel = (_Panel*)data;
 916     char *path;
 917     WMOpenPanel *opanel;
 918     WMScreen *scr = WMWidgetScreen(w);
 919
 920     opanel = WMGetOpenPanel(scr);
 921     WMSetFilePanelCanChooseDirectories(opanel, False);
 922     WMSetFilePanelCanChooseFiles(opanel, True);
 923
 924     if (WMRunModalFilePanelForDirectory(opanel, panel->win, wgethomedir(),
 925                                         _("Select File"), NULL)) {
 926         path = WMGetFilePanelFileName(opanel);
 927
 928         OpenExtractPanelFor(panel, path);
 929
 930         free(path);
 931     }
 932 }
 933
 934
 935 static void
 936 changePage(WMWidget *w, void *data)
 937 {
 938     _Panel *panel = (_Panel*)data;
 939     int section;
 940     WMListItem *item;
 941     TextureListItem *titem;
 942     char *str;
 943     WMScreen *scr = WMWidgetScreen(w);
 944     RContext *rc = WMScreenRContext(scr);
 945     static WMPoint positions[] = {
 946         {5, 5},
 947         {5, 30},
 948         {5, 55},
 949         {5, 80},
 950         {5, 95},
 951         {5, 130},
 952         {145, 110}
 953     };
 954
 955     section = WMGetPopUpButtonSelectedItem(panel->secP);
 956
 957     WMSelectListItem(panel->texLs, panel->textureIndex[section]);
 958
 959     WMSetListPosition(panel->texLs, panel->textureIndex[section]
 960                       - WMGetListNumberOfRows(panel->texLs)/2);
 961
 962     item = WMGetListItem(panel->texLs, panel->textureIndex[section]);
 963
 964     titem = (TextureListItem*)item->clientData;
 965
 966     str = wmalloc(strlen(titem->title) + strlen(titem->texture) + 4);
 967     sprintf(str, "%s: %s", titem->title, titem->texture);
 968     WMSetLabelText(panel->texsL, str);
 969     free(str);
 970
 971     {
 972         WMColor *color;
 973
 974         color = WMGrayColor(scr);
 975         XFillRectangle(rc->dpy, panel->preview, WMColorGC(color),
 976                        positions[panel->oldsection].x,
 977                        positions[panel->oldsection].y, 22, 22);
 978         WMReleaseColor(color);
 979     }
 980     panel->oldsection = section;
 981     WMDrawPixmap(panel->hand, panel->preview, positions[section].x,
 982                  positions[section].y);
 983
 984     WMRedisplayWidget(panel->prevL);
 985 }
 986
 987
 988
 989 static void
 990 previewClick(XEvent *event, void *clientData)
 991 {
 992     _Panel *panel = (_Panel*)clientData;
 993     int i;
 994     static WMRect parts[] = {
 995         {{30, 5},{210, 20}},
 996         {{30,30},{210,20}},
 997         {{30,55},{210,20}},
 998         {{30,80},{210,9}},
 999         {{30,95},{100,20}},
1000         {{30,115},{100,60}},
1001         {{170,90},{64,64}}
1002     };
1003
1004     for (i = 0; i < 7; i++) {
1005         if (event->xbutton.x >= parts[i].pos.x
1006             && event->xbutton.y >= parts[i].pos.y
1007             && event->xbutton.x < parts[i].pos.x + parts[i].size.width
1008             && event->xbutton.y < parts[i].pos.y + parts[i].size.height) {
1009
1010             WMSetPopUpButtonSelectedItem(panel->secP, i);
1011             changePage(panel->secP, panel);
1012             return;
1013         }
1014     }
1015 }
1016
1017
1018 static void
1019 textureClick(WMWidget *w, void *data)
1020 {
1021     _Panel *panel = (_Panel*)data;
1022     int i;
1023     WMListItem *item;
1024     TextureListItem *titem;
1025
1026     i = WMGetListSelectedItemRow(panel->texLs);
1027
1028     item = WMGetListItem(panel->texLs, i);
1029
1030     titem = (TextureListItem*)item->clientData;
1031
1032     if (titem->current) {
1033         WMSetButtonEnabled(panel->delB, False);
1034     } else {
1035         WMSetButtonEnabled(panel->delB, True);
1036     }
1037 }
1038
1039
1040
1041 static void
1042 textureDoubleClick(WMWidget *w, void *data)
1043 {
1044     _Panel *panel = (_Panel*)data;
1045     int i, section;
1046     WMListItem *item;
1047     TextureListItem *titem;
1048     char *str;
1049
1050     /* unselect old texture */
1051     section = WMGetPopUpButtonSelectedItem(panel->secP);
1052
1053     item = WMGetListItem(panel->texLs, panel->textureIndex[section]);
1054     titem = (TextureListItem*)item->clientData;
1055     titem->selectedFor &= ~(1 << section);
1056
1057     /* select new texture */
1058     i = WMGetListSelectedItemRow(panel->texLs);
1059
1060     item = WMGetListItem(panel->texLs, i);
1061
1062     titem = (TextureListItem*)item->clientData;
1063
1064     titem->selectedFor |= 1<<section;
1065
1066     panel->textureIndex[section] = i;
1067
1068     WMRedisplayWidget(panel->texLs);
1069
1070     str = wmalloc(strlen(titem->title) + strlen(titem->texture) + 4);
1071     sprintf(str, "%s: %s", titem->title, titem->texture);
1072     WMSetLabelText(panel->texsL, str);
1073     free(str);
1074
1075     updatePreviewBox(panel, 1<<section);
1076 }
1077
1078
1079
1080
1081 static void
1082 paintListItem(WMList *lPtr, int index, Drawable d, char *text, int state,
1083               WMRect *rect)
1084 {
1085     _Panel *panel = (_Panel*)WMGetHangedData(lPtr);
1086     WMScreen *scr = WMWidgetScreen(lPtr);
1087     int width, height, x, y;
1088     Display *dpy = WMScreenDisplay(scr);
1089     WMColor *white = WMWhiteColor(scr);
1090     WMListItem *item;
1091     WMColor *black = WMBlackColor(scr);
1092     TextureListItem *titem;
1093
1094     width = rect->size.width;
1095     height = rect->size.height;
1096     x = rect->pos.x;
1097     y = rect->pos.y;
1098
1099     if (state & WLDSSelected)
1100         XFillRectangle(dpy, d, WMColorGC(white), x, y, width, height);
1101     else
1102         XClearArea(dpy, d, x, y, width, height, False);
1103
1104     item = WMGetListItem(lPtr, index);
1105     titem = (TextureListItem*)item->clientData;
1106
1107     if (titem->preview)
1108     XCopyArea(dpy, titem->preview, d, WMColorGC(black), 0, 0, TEXPREV_WIDTH,
1109               TEXPREV_HEIGHT, x + 5, y + 5);
1110
1111     if ((1 << WMGetPopUpButtonSelectedItem(panel->secP)) & titem->selectedFor)
1112         WMDrawPixmap(panel->onLed, d, x + TEXPREV_WIDTH + 10, y + 6);
1113     else if (titem->selectedFor)
1114         WMDrawPixmap(panel->offLed, d, x + TEXPREV_WIDTH + 10, y + 6);
1115
1116     WMDrawString(scr, d, WMColorGC(black), panel->boldFont,
1117                  x + TEXPREV_WIDTH + 22, y + 2, titem->title,
1118                  strlen(titem->title));
1119
1120     WMDrawString(scr, d, WMColorGC(black), panel->smallFont,
1121                  x + TEXPREV_WIDTH + 14, y + 18, titem->texture,
1122                  strlen(titem->texture));
1123
1124
1125     WMReleaseColor(white);
1126     WMReleaseColor(black);
1127 }
1128
1129
1130
1131 static Pixmap
1132 loadRImage(WMScreen *scr, char *path)
1133 {
1134     FILE *f;
1135     RImage *image;
1136     int w, h, d;
1137     int i;
1138     Pixmap pixmap;
1139
1140     f = fopen(path, "r");
1141     if (!f)
1142         return None;
1143
1144     fscanf(f, "%02x%02x%1x", &w, &h, &d);
1145
1146     image = RCreateImage(w, h, d == 4);
1147     for (i = 0; i < d; i++) {
1148         fread(image->data[i], 1, w*h, f);
1149     }
1150     fclose(f);
1151
1152     RConvertImage(WMScreenRContext(scr), image, &pixmap);
1153     RDestroyImage(image);
1154
1155     return pixmap;
1156 }
1157
1158
1159
1160 static void
1161 fillTextureList(WMList *lPtr)
1162 {
1163     proplist_t textureList;
1164     proplist_t texture;
1165     WMUserDefaults *udb = WMGetStandardUserDefaults();
1166     int i;
1167     TextureListItem *titem;
1168     WMScreen *scr  = WMWidgetScreen(lPtr);
1169
1170     textureList = WMGetUDObjectForKey(udb, "TextureList");
1171     if (!textureList)
1172         return;
1173
1174     for (i = 0; i < PLGetNumberOfElements(textureList); i++) {
1175         WMListItem *item;
1176
1177         texture = PLGetArrayElement(textureList, i);
1178
1179         titem = wmalloc(sizeof(TextureListItem));
1180         memset(titem, 0, sizeof(TextureListItem));
1181
1182         titem->title = wstrdup(PLGetString(PLGetArrayElement(texture, 0)));
1183         titem->prop = PLRetain(PLGetArrayElement(texture, 1));
1184         titem->texture = PLGetDescription(titem->prop);
1185         titem->selectedFor = 0;
1186         titem->path = wstrdup(PLGetString(PLGetArrayElement(texture, 2)));
1187
1188         titem->preview = loadRImage(scr, titem->path);
1189         if (!titem->preview) {
1190             titem->preview = renderTexture(scr, titem->prop, TEXPREV_WIDTH,
1191                                            TEXPREV_HEIGHT, NULL, 0);
1192         }
1193         item = WMAddListItem(lPtr, "");
1194         item->clientData = titem;
1195     }
1196 }
1197
1198
1199 static void
1200 createPanel(Panel *p)
1201 {
1202     _Panel *panel = (_Panel*)p;
1203     WMColor *color;
1204     WMFont *font;
1205     WMScreen *scr = WMWidgetScreen(panel->win);
1206
1207     char *tmp;
1208     Bool ok = True;
1209
1210     panel->fprefix = wstrappend(wusergnusteppath(), "/.AppInfo");
1211
1212     if (access(panel->fprefix, F_OK)!=0) {
1213         if (mkdir(panel->fprefix, 0755) < 0) {
1214             wsyserror(panel->fprefix);
1215             ok = False;
1216         }
1217     }
1218     if (ok) {
1219         tmp = wstrappend(panel->fprefix, "/WPrefs/");
1220         free(panel->fprefix);
1221         panel->fprefix = tmp;
1222         if (access(panel->fprefix, F_OK)!=0) {
1223             if (mkdir(panel->fprefix, 0755) < 0) {
1224                 wsyserror(panel->fprefix);
1225             }
1226         }
1227     }
1228
1229     panel->smallFont = WMSystemFontOfSize(scr, 10);
1230     panel->normalFont = WMSystemFontOfSize(scr, 12);
1231     panel->boldFont = WMBoldSystemFontOfSize(scr, 12);
1232
1233     panel->onLed = WMCreatePixmapFromXPMData(scr, blueled_xpm);
1234     panel->offLed = WMCreatePixmapFromXPMData(scr, blueled2_xpm);
1235     panel->hand = WMCreatePixmapFromXPMData(scr, hand_xpm);
1236
1237     panel->frame = WMCreateFrame(panel->win);
1238     WMResizeWidget(panel->frame, FRAME_WIDTH, FRAME_HEIGHT);
1239     WMMoveWidget(panel->frame, FRAME_LEFT, FRAME_TOP);
1240
1241     /* preview box */
1242     panel->prevL = WMCreateLabel(panel->frame);
1243     WMResizeWidget(panel->prevL, 260, 165);
1244     WMMoveWidget(panel->prevL, 15, 10);
1245     WMSetLabelRelief(panel->prevL, WRSunken);
1246     WMSetLabelImagePosition(panel->prevL, WIPImageOnly);
1247
1248     WMCreateEventHandler(WMWidgetView(panel->prevL), ButtonPressMask,
1249                          previewClick, panel);
1250
1251
1252     panel->secP = WMCreatePopUpButton(panel->frame);
1253     WMResizeWidget(panel->secP, 260, 20);
1254     WMMoveWidget(panel->secP, 15, 180);
1255     WMSetPopUpButtonSelectedItem(panel->secP, 0);
1256     WMAddPopUpButtonItem(panel->secP, _("Titlebar of Focused Window"));
1257     WMAddPopUpButtonItem(panel->secP, _("Titlebar of Unfocused Windows"));
1258     WMAddPopUpButtonItem(panel->secP, _("Titlebar of Focused Window's Owner"));
1259     WMAddPopUpButtonItem(panel->secP, _("Window Resizebar"));
1260     WMAddPopUpButtonItem(panel->secP, _("Titlebar of Menus"));
1261     WMAddPopUpButtonItem(panel->secP, _("Menu Items"));
1262     WMAddPopUpButtonItem(panel->secP, _("Icon Background"));
1263 /*    WMAddPopUpButtonItem(panel->secP, _("Workspace Backgrounds"));
1264  */
1265     WMSetPopUpButtonAction(panel->secP, changePage, panel);
1266
1267
1268     panel->texsL = WMCreateLabel(panel->frame);
1269     WMResizeWidget(panel->texsL, 260, 20);
1270     WMMoveWidget(panel->texsL, 15, 205);
1271     WMSetLabelWraps(panel->texsL, False);
1272
1273     /* texture list */
1274     font = WMBoldSystemFontOfSize(scr, 12);
1275
1276     panel->texL = WMCreateLabel(panel->frame);
1277     WMResizeWidget(panel->texL, 225, 18);
1278     WMMoveWidget(panel->texL, 285, 10);
1279     WMSetLabelFont(panel->texL, font);
1280     WMSetLabelText(panel->texL, _("Textures"));
1281     WMSetLabelRelief(panel->texL, WRSunken);
1282     WMSetLabelTextAlignment(panel->texL, WACenter);
1283     color = WMDarkGrayColor(scr);
1284     WMSetWidgetBackgroundColor(panel->texL, color);
1285     WMReleaseColor(color);
1286     color = WMWhiteColor(scr);
1287     WMSetLabelTextColor(panel->texL, color);
1288     WMReleaseColor(color);
1289
1290     WMReleaseFont(font);
1291
1292     panel->texLs = WMCreateList(panel->frame);
1293     WMResizeWidget(panel->texLs, 225, 144);
1294     WMMoveWidget(panel->texLs, 285, 30);
1295     WMSetListUserDrawItemHeight(panel->texLs, 35);
1296     WMSetListUserDrawProc(panel->texLs, paintListItem);
1297     WMHangData(panel->texLs, panel);
1298     WMSetListAction(panel->texLs, textureClick, panel);
1299     WMSetListDoubleAction(panel->texLs, textureDoubleClick, panel);
1300
1301     /* command buttons */
1302
1303     font = WMSystemFontOfSize(scr, 10);
1304
1305
1306     panel->newB = WMCreateCommandButton(panel->frame);
1307     WMResizeWidget(panel->newB, 56, 48);
1308     WMMoveWidget(panel->newB, 285, 180);
1309     WMSetButtonFont(panel->newB, font);
1310     WMSetButtonImagePosition(panel->newB, WIPAbove);
1311     WMSetButtonText(panel->newB, _("New"));
1312     WMSetButtonAction(panel->newB, newTexture, panel);
1313     SetButtonAlphaImage(scr, panel->newB, TNEW_FILE);
1314
1315     panel->ripB = WMCreateCommandButton(panel->frame);
1316     WMResizeWidget(panel->ripB, 56, 48);
1317     WMMoveWidget(panel->ripB, 341, 180);
1318     WMSetButtonFont(panel->ripB, font);
1319     WMSetButtonImagePosition(panel->ripB, WIPAbove);
1320     WMSetButtonText(panel->ripB, _("Extract..."));
1321     WMSetButtonAction(panel->ripB, extractTexture, panel);
1322     SetButtonAlphaImage(scr, panel->ripB, TEXTR_FILE);
1323
1324     WMSetButtonEnabled(panel->ripB, False);
1325
1326     panel->editB = WMCreateCommandButton(panel->frame);
1327     WMResizeWidget(panel->editB, 56, 48);
1328     WMMoveWidget(panel->editB, 397, 180);
1329     WMSetButtonFont(panel->editB, font);
1330     WMSetButtonImagePosition(panel->editB, WIPAbove);
1331     WMSetButtonText(panel->editB, _("Edit"));
1332     SetButtonAlphaImage(scr, panel->editB, TEDIT_FILE);
1333     WMSetButtonAction(panel->editB, editTexture, panel);
1334
1335     panel->delB = WMCreateCommandButton(panel->frame);
1336     WMResizeWidget(panel->delB, 56, 48);
1337     WMMoveWidget(panel->delB, 453, 180);
1338     WMSetButtonFont(panel->delB, font);
1339     WMSetButtonImagePosition(panel->delB, WIPAbove);
1340     WMSetButtonText(panel->delB, _("Delete"));
1341     SetButtonAlphaImage(scr, panel->delB, TDEL_FILE);
1342     WMSetButtonEnabled(panel->delB, False);
1343     WMSetButtonAction(panel->delB, deleteTexture, panel);
1344
1345     WMReleaseFont(font);
1346
1347     /**/
1348
1349     WMRealizeWidget(panel->frame);
1350     WMMapSubwidgets(panel->frame);
1351
1352     WMSetPopUpButtonSelectedItem(panel->secP, 0);
1353
1354     showData(panel);
1355
1356     changePage(panel->secP, panel);
1357
1358     fillTextureList(panel->texLs);
1359
1360     panel->texturePanel = CreateTexturePanel(panel->win);
1361 }
1362
1363
1364
1365 static void
1366 setupTextureFor(WMList *list, char *key, char *defValue, char *title,
1367                 int index)
1368 {
1369     WMListItem *item;
1370     TextureListItem *titem;
1371
1372     titem = wmalloc(sizeof(TextureListItem));
1373     memset(titem, 0, sizeof(TextureListItem));
1374
1375     titem->title = wstrdup(title);
1376     titem->prop = GetObjectForKey(key);
1377     if (!titem->prop) {
1378         titem->prop = PLGetProplistWithDescription(defValue);
1379     } else {
1380         PLRetain(titem->prop);
1381     }
1382     titem->texture = PLGetDescription((proplist_t)titem->prop);
1383     titem->current = 1;
1384     titem->selectedFor = 1<<index;
1385
1386     titem->ispixmap = isPixmap(titem->prop);
1387
1388     titem->preview = renderTexture(WMWidgetScreen(list), titem->prop,
1389                                    TEXPREV_WIDTH, TEXPREV_HEIGHT, NULL, 0);
1390
1391     item = WMAddListItem(list, "");
1392     item->clientData = titem;
1393 }
1394
1395
1396
1397 static void
1398 showData(_Panel *panel)
1399 {
1400     int i = 0;
1401
1402     setupTextureFor(panel->texLs, "FTitleBack", "(solid, black)",
1403                     "[Focused]", i);
1404     panel->textureIndex[i] = i++;
1405
1406     setupTextureFor(panel->texLs, "UTitleBack", "(solid, gray)",
1407                     "[Unfocused]", i);
1408     panel->textureIndex[i] = i++;
1409
1410     setupTextureFor(panel->texLs, "PTitleBack", "(solid, \"#616161\")",
1411                     "[Owner of Focused]", i);
1412     panel->textureIndex[i] = i++;
1413
1414     setupTextureFor(panel->texLs, "ResizebarBack", "(solid, gray)",
1415                     "[Resizebar]", i);
1416     panel->textureIndex[i] = i++;
1417
1418     setupTextureFor(panel->texLs, "MenuTitleBack", "(solid, black)",
1419                     "[Menu Title]", i);
1420     panel->textureIndex[i] = i++;
1421
1422     setupTextureFor(panel->texLs, "MenuTextBack", "(solid, gray)",
1423                     "[Menu Item]", i);
1424     panel->textureIndex[i] = i++;
1425
1426     setupTextureFor(panel->texLs, "IconBack", "(solid, gray)", "[Icon]", i);
1427     panel->textureIndex[i] = i++;
1428 /*
1429     setupTextureFor(panel->texLs, "WorkspaceBack", "(solid, black)",
1430                     "[Workspace]", i);
1431     panel->textureIndex[i] = i++;
1432  */
1433
1434     updatePreviewBox(panel, EVERYTHING);
1435 }
1436
1437
1438
1439 static void
1440 storeData(_Panel *panel)
1441 {
1442     TextureListItem *titem;
1443     WMListItem *item;
1444
1445     item = WMGetListItem(panel->texLs, panel->textureIndex[0]);
1446     titem = (TextureListItem*)item->clientData;
1447     SetObjectForKey(titem->prop, "FTitleBack");
1448
1449     item = WMGetListItem(panel->texLs, panel->textureIndex[1]);
1450     titem = (TextureListItem*)item->clientData;
1451     SetObjectForKey(titem->prop, "UTitleBack");
1452
1453     item = WMGetListItem(panel->texLs, panel->textureIndex[2]);
1454     titem = (TextureListItem*)item->clientData;
1455     SetObjectForKey(titem->prop, "PTitleBack");
1456
1457     item = WMGetListItem(panel->texLs, panel->textureIndex[3]);
1458     titem = (TextureListItem*)item->clientData;
1459     SetObjectForKey(titem->prop, "ResizebarBack");
1460
1461     item = WMGetListItem(panel->texLs, panel->textureIndex[4]);
1462     titem = (TextureListItem*)item->clientData;
1463     SetObjectForKey(titem->prop, "MenuTitleBack");
1464
1465     item = WMGetListItem(panel->texLs, panel->textureIndex[5]);
1466     titem = (TextureListItem*)item->clientData;
1467     SetObjectForKey(titem->prop, "MenuTextBack");
1468
1469     item = WMGetListItem(panel->texLs, panel->textureIndex[6]);
1470     titem = (TextureListItem*)item->clientData;
1471     SetObjectForKey(titem->prop, "IconBack");
1472 }
1473
1474
1475 static void
1476 prepareForClose(_Panel *panel)
1477 {
1478     proplist_t textureList;
1479     proplist_t texture;
1480     int i;
1481     TextureListItem *titem;
1482     WMListItem *item;
1483     WMUserDefaults *udb = WMGetStandardUserDefaults();
1484
1485     textureList = PLMakeArrayFromElements(NULL, NULL);
1486
1487     /* store list of textures */
1488     for (i = 7; i < WMGetListNumberOfRows(panel->texLs); i++) {
1489         item = WMGetListItem(panel->texLs, i);
1490         titem = (TextureListItem*)item->clientData;
1491
1492         texture = PLMakeArrayFromElements(PLMakeString(titem->title),
1493                                           PLRetain(titem->prop),
1494                                           PLMakeString(titem->path),
1495                                           NULL);
1496
1497         PLAppendArrayElement(textureList, texture);
1498     }
1499
1500     WMSetUDObjectForKey(udb, textureList, "TextureList");
1501     PLRelease(textureList);
1502
1503     WMSynchronizeUserDefaults(udb);
1504 }
1505
1506
1507
1508 Panel*
1509 InitAppearance(WMScreen *scr, WMWindow *win)
1510 {
1511     _Panel *panel;
1512
1513     panel = wmalloc(sizeof(_Panel));
1514     memset(panel, 0, sizeof(_Panel));
1515
1516     panel->sectionName = _("Appearance Preferences");
1517
1518     panel->win = win;
1519
1520     panel->callbacks.createWidgets = createPanel;
1521     panel->callbacks.updateDomain = storeData;
1522     panel->callbacks.prepareForClose = prepareForClose;
1523
1524     AddSection(panel, ICON_FILE);
1525
1526     return panel;
1527 }
1528
1529
1530
1531 /****************************************************************************/
1532
1533
1534
1535 typedef struct ExtractPanel {
1536     WMWindow *win;
1537
1538     WMLabel *label;
1539     WMList *list;
1540
1541     WMButton *closeB;
1542     WMButton *extrB;
1543 } ExtractPanel;
1544
1545
1546
1547 static void
1548 OpenExtractPanelFor(_Panel *panel, char *path)
1549 {
1550     ExtractPanel *epanel;
1551     WMColor *color;
1552     WMFont *font;
1553     WMScreen *scr = WMWidgetScreen(panel->win);
1554
1555     epanel = wmalloc(sizeof(ExtractPanel));
1556     epanel->win = WMCreatePanelWithStyleForWindow(panel->win, "extract",
1557                                                   WMTitledWindowMask
1558                                                   |WMClosableWindowMask);
1559     WMResizeWidget(epanel->win, 245, 250);
1560     WMSetWindowTitle(epanel->win, _("Extract Texture"));
1561
1562     epanel->label = WMCreateLabel(epanel->win);
1563     WMResizeWidget(epanel->label, 225, 18);
1564     WMMoveWidget(epanel->label, 10, 10);
1565     WMSetLabelTextAlignment(epanel->label, WACenter);
1566     WMSetLabelRelief(epanel->label, WRSunken);
1567
1568     color = WMDarkGrayColor(scr);
1569     WMSetWidgetBackgroundColor(epanel->label, color);
1570     WMReleaseColor(color);
1571
1572     color = WMWhiteColor(scr);
1573     WMSetLabelTextColor(epanel->label, color);
1574     WMReleaseColor(color);
1575
1576     font = WMBoldSystemFontOfSize(scr, 12);
1577     WMSetLabelFont(epanel->label, font);
1578     WMReleaseFont(font);
1579
1580     WMSetLabelText(epanel->label, _("Textures"));
1581
1582     epanel->list = WMCreateList(epanel->win);
1583     WMResizeWidget(epanel->list, 225, 165);
1584     WMMoveWidget(epanel->list, 10, 30);
1585
1586
1587
1588     epanel->closeB = WMCreateCommandButton(epanel->win);
1589     WMResizeWidget(epanel->closeB, 74, 24);
1590     WMMoveWidget(epanel->closeB, 165, 215);
1591     WMSetButtonText(epanel->closeB, _("Close"));
1592
1593     epanel->extrB = WMCreateCommandButton(epanel->win);
1594     WMResizeWidget(epanel->extrB, 74, 24);
1595     WMMoveWidget(epanel->extrB, 80, 215);
1596     WMSetButtonText(epanel->extrB, _("Extract"));
1597
1598     WMMapSubwidgets(epanel->win);
1599
1600
1601     /* take textures from file */
1602
1603
1604
1605     WMRealizeWidget(epanel->win);
1606
1607     WMMapWidget(epanel->win);
1608 }
1609
1610
1611
1612