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