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