WPrefs.app/Appearance.c

   1 /* Apperance.c- color/texture for titlebar etc.
   2  *
   3  *  WPrefs - Window Maker Preferences Program
   4  *
   5  *  Copyright (c) 1999-2003 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 along
  18  *  with this program; if not, write to the Free Software Foundation, Inc.,
  19  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "WPrefs.h"
  23
  24 #include <unistd.h>
  25 #include <errno.h>
  26 #include <ctype.h>
  27 #include <time.h>
  28 #include <sys/stat.h>
  29 #include <sys/types.h>
  30 #include <fcntl.h>
  31
  32 #include "TexturePanel.h"
  33
  34 typedef struct _Panel {
  35         WMBox *box;
  36         char *sectionName;
  37
  38         char *description;
  39
  40         CallbackRec callbacks;
  41
  42         WMWidget *parent;
  43
  44         WMLabel *prevL;
  45
  46         WMTabView *tabv;
  47
  48         /* texture list */
  49         WMFrame *texF;
  50         WMList *texLs;
  51
  52         WMPopUpButton *secP;
  53
  54         WMButton *newB;
  55         WMButton *editB;
  56         WMButton *ripB;
  57         WMButton *delB;
  58
  59         /* text color */
  60         WMFrame *colF;
  61
  62         WMPopUpButton *colP;
  63         WMColor *colors[14];
  64
  65         WMColorWell *colW;
  66
  67         WMColorWell *sampW[24];
  68
  69         /* options */
  70         WMFrame *optF;
  71
  72         WMFrame *mstyF;
  73         WMButton *mstyB[3];
  74
  75         WMFrame *taliF;
  76         WMButton *taliB[3];
  77
  78         /* root bg */
  79         WMFrame *bgF;
  80
  81         WMLabel *bgprevL;
  82         WMButton *selbgB;
  83
  84         WMPopUpButton *modeB[3];
  85
  86         /* */
  87
  88         int textureIndex[8];
  89
  90         WMFont *smallFont;
  91         WMFont *normalFont;
  92         WMFont *boldFont;
  93
  94         TexturePanel *texturePanel;
  95
  96         WMPixmap *onLed;
  97         WMPixmap *offLed;
  98         WMPixmap *hand;
  99
 100         int oldsection;
 101         int oldcsection;
 102
 103         char oldTabItem;
 104
 105         int menuStyle;
 106
 107         int titleAlignment;
 108
 109         Pixmap preview;
 110         Pixmap previewNoText;
 111
 112         char *fprefix;
 113 } _Panel;
 114
 115 typedef struct {
 116         char *title;
 117         char *texture;
 118         WMPropList *prop;
 119         Pixmap preview;
 120
 121         char *path;
 122
 123         char selectedFor;
 124         unsigned current:1;
 125         unsigned ispixmap:1;
 126 } TextureListItem;
 127
 128 static void updateColorPreviewBox(_Panel * panel, int elements);
 129
 130 static void showData(_Panel * panel);
 131
 132 static void changePage(WMWidget * w, void *data);
 133
 134 static void changeColorPage(WMWidget * w, void *data);
 135
 136 static void OpenExtractPanelFor(_Panel * panel, char *path);
 137
 138 static void changedTabItem(struct WMTabViewDelegate *self, WMTabView * tabView, WMTabViewItem * item);
 139
 140 static WMTabViewDelegate tabviewDelegate = {
 141         NULL,
 142         NULL,                   /* didChangeNumberOfItems */
 143         changedTabItem,         /* didSelectItem */
 144         NULL,                   /* shouldSelectItem */
 145         NULL                    /* willSelectItem */
 146 };
 147
 148 #define ICON_FILE       "appearance"
 149
 150 #define TNEW_FILE       "tnew"
 151 #define TDEL_FILE       "tdel"
 152 #define TEDIT_FILE      "tedit"
 153 #define TEXTR_FILE      "textr"
 154
 155 #define MSTYLE1_FILE    "msty1"
 156 #define MSTYLE2_FILE    "msty2"
 157 #define MSTYLE3_FILE    "msty3"
 158
 159 /* XPM */
 160 static char *blueled_xpm[] = {
 161         "8 8 17 1",
 162         "       c None",
 163         ".      c #020204",
 164         "+      c #16B6FC",
 165         "@      c #176AFC",
 166         "#      c #163AFC",
 167         "$      c #72D2FC",
 168         "%      c #224CF4",
 169         "&      c #76D6FC",
 170         "*      c #16AAFC",
 171         "=      c #CEE9FC",
 172         "-      c #229EFC",
 173         ";      c #164CFC",
 174         ">      c #FAFEFC",
 175         ",      c #2482FC",
 176         "'      c #1652FC",
 177         ")      c #1E76FC",
 178         "!      c #1A60FC",
 179         "  ....  ",
 180         " .=>-@. ",
 181         ".=>$@@'.",
 182         ".=$@!;;.",
 183         ".!@*+!#.",
 184         ".#'*+*,.",
 185         " .@)@,. ",
 186         "  ....  "
 187 };
 188
 189 /* XPM */
 190 static char *blueled2_xpm[] = {
 191         /* width height num_colors chars_per_pixel */
 192         "     8     8       17            1",
 193         /* colors */
 194         ". c None",
 195         "# c #090909",
 196         "a c #4b63a4",
 197         "b c #011578",
 198         "c c #264194",
 199         "d c #04338c",
 200         "e c #989dac",
 201         "f c #011a7c",
 202         "g c #465c9c",
 203         "h c #03278a",
 204         "i c #6175ac",
 205         "j c #011e74",
 206         "k c #043a90",
 207         "l c #042f94",
 208         "m c #0933a4",
 209         "n c #022184",
 210         "o c #012998",
 211         /* pixels */
 212         "..####..",
 213         ".#aimn#.",
 214         "#aechnf#",
 215         "#gchnjf#",
 216         "#jndknb#",
 217         "#bjdddl#",
 218         ".#nono#.",
 219         "..####.."
 220 };
 221
 222 /* XPM */
 223 static char *hand_xpm[] = {
 224         "22 21 19 1",
 225         "       c None",
 226         ".      c #030305",
 227         "+      c #7F7F7E",
 228         "@      c #B5B5B6",
 229         "#      c #C5C5C6",
 230         "$      c #969697",
 231         "%      c #FDFDFB",
 232         "&      c #F2F2F4",
 233         "*      c #E5E5E4",
 234         "=      c #ECECEC",
 235         "-      c #DCDCDC",
 236         ";      c #D2D2D0",
 237         ">      c #101010",
 238         ",      c #767674",
 239         "'      c #676767",
 240         ")      c #535355",
 241         "!      c #323234",
 242         "~      c #3E3C56",
 243         "{      c #333147",
 244         "                      ",
 245         "       .....          ",
 246         "     ..+@##$.         ",
 247         "    .%%%&@..........  ",
 248         "   .%*%%&#%%%%%%%%%$. ",
 249         "  .*#%%%%%%%%%&&&&==. ",
 250         " .-%%%%%%%%%=*-;;;#$. ",
 251         " .-%%%%%%%%&..>.....  ",
 252         " >-%%%%%%%%%*#+.      ",
 253         " >-%%%%%%%%%*@,.      ",
 254         " >#%%%%%%%%%*@'.      ",
 255         " >$&&%%%%%%=...       ",
 256         " .+@@;=&%%&;$,>       ",
 257         "  .',$@####$+).       ",
 258         "   .!',+$++,'.        ",
 259         "     ..>>>>>.         ",
 260         "                      ",
 261         "     ~~{{{~~          ",
 262         "   {{{{{{{{{{{        ",
 263         "     ~~{{{~~          ",
 264         "                      "
 265 };
 266
 267 static char *sampleColors[] = {
 268         "black",
 269         "#292929",
 270         "#525252",
 271         "#848484",
 272         "#adadad",
 273         "#d6d6d6",
 274         "white",
 275         "#d6d68c",
 276         "#d6a57b",
 277         "#8cd68c",
 278         "#8cd6ce",
 279         "#d68c8c",
 280         "#8c9cd6",
 281         "#bd86d6",
 282         "#d68cbd",
 283         "#d64a4a",
 284         "#4a5ad6",
 285         "#4ad6ce",
 286         "#4ad65a",
 287         "#ced64a",
 288         "#d6844a",
 289         "#8ad631",
 290         "#ce29c6",
 291         "#ce2973",
 292         "black"
 293 };
 294
 295 static char *textureOptions[] = {
 296         "FTitleBack", "(solid, black)", "[Focused]",
 297         "UTitleBack", "(solid, gray)", "[Unfocused]",
 298         "PTitleBack", "(solid, \"#616161\")", "[Owner of Focused]",
 299         "ResizebarBack", "(solid, gray)", "[Resizebar]",
 300         "MenuTitleBack", "(solid, black)", "[Menu Title]",
 301         "MenuTextBack", "(solid, gray)", "[Menu Item]",
 302         "IconBack", "(solid, gray)", "[Icon]"
 303 };
 304
 305 #define RESIZEBAR_BEVEL -1
 306 #define MENU_BEVEL      -2
 307
 308 #define TEXPREV_WIDTH   40
 309 #define TEXPREV_HEIGHT  24
 310
 311 #define MSTYLE_NORMAL   0
 312 #define MSTYLE_SINGLE   1
 313 #define MSTYLE_FLAT     2
 314
 315 #define FTITLE_COL      (1<<0)
 316 #define UTITLE_COL      (1<<1)
 317 #define OTITLE_COL      (1<<2)
 318 #define MTITLE_COL      (1<<3)
 319 #define MITEM_COL       (1<<4)
 320 #define MDISAB_COL      (1<<5)
 321 #define MHIGH_COL       (1<<6)
 322 #define MHIGHT_COL      (1<<7)
 323 #define ICONT_COL       (1<<8)
 324 #define ICONB_COL       (1<<9)
 325 #define CLIP_COL        (1<<10)
 326 #define CCLIP_COL       (1<<11)
 327
 328 static char *colorOptions[] = {
 329         "FTitleColor", "white",
 330         "UTitleColor", "black",
 331         "PTitleColor", "white",
 332         "MenuTitleColor", "white",
 333         "MenuTextColor", "black",
 334         "MenuDisabledColor", "#616161",
 335         "HighlightColor", "white",
 336         "HighlightTextColor", "black",
 337         "IconTitleColor", "white",
 338         "IconTitleBack", "black",
 339         "ClipTitleColor", "black",
 340         "CClipTitleColor", "#454045"
 341 };
 342
 343 static WMRect previewPositions[] = {
 344 #define PFOCUSED        0
 345         {{30, 10}, {190, 20}},
 346 #define PUNFOCUSED      1
 347         {{30, 40}, {190, 20}},
 348 #define POWNER          2
 349         {{30, 70}, {190, 20}},
 350 #define PRESIZEBAR      3
 351         {{30, 100}, {190, 9}},
 352 #define PMTITLE         4
 353         {{30, 120}, {90, 20}},
 354 #define PMITEM          5
 355         {{30, 140}, {90, 20 * 4}},
 356 #define PICON           6
 357         {{155, 130}, {64, 64}}
 358 };
 359
 360 #define EVERYTHING      0xff
 361
 362 static WMRect previewColorPositions[] = {
 363         {{30, 10}, {190, 20}},
 364         {{30, 40}, {190, 20}},
 365         {{30, 70}, {190, 20}},
 366         {{30, 120}, {90, 20}},
 367         {{30, 140}, {90, 20}},
 368         {{30, 160}, {90, 20}},
 369         {{30, 180}, {90, 20}},
 370         {{30, 200}, {90, 20}},
 371         {{155, 130}, {64, 64}},
 372         {{155, 130}, {64, 64}},
 373         {{155, 130}, {64, 64}},
 374         {{155, 130}, {64, 64}}
 375 };
 376
 377 static void str2rcolor(RContext * rc, char *name, RColor * color)
 378 {
 379         XColor xcolor;
 380
 381         XParseColor(rc->dpy, rc->cmap, name, &xcolor);
 382
 383         color->alpha = 255;
 384         color->red = xcolor.red >> 8;
 385         color->green = xcolor.green >> 8;
 386         color->blue = xcolor.blue >> 8;
 387 }
 388
 389 static void dumpRImage(char *path, RImage * image)
 390 {
 391         FILE *f;
 392         int channels = (image->format == RRGBAFormat ? 4 : 3);
 393
 394         f = fopen(path, "wb");
 395         if (!f) {
 396                 werror("%s", path);
 397                 return;
 398         }
 399         fprintf(f, "%02x%02x%1x", image->width, image->height, channels);
 400
 401         fwrite(image->data, 1, image->width * image->height * channels, f);
 402
 403         fsync(fileno(f));
 404         if (fclose(f) < 0) {
 405                 werror("%s", path);
 406         }
 407 }
 408
 409 static int isPixmap(WMPropList * prop)
 410 {
 411         WMPropList *p;
 412         char *s;
 413
 414         p = WMGetFromPLArray(prop, 0);
 415         s = WMGetFromPLString(p);
 416         if (strcasecmp(&s[1], "pixmap") == 0)
 417                 return 1;
 418         else
 419                 return 0;
 420 }
 421
 422 /**********************************************************************/
 423
 424 static void drawResizebarBevel(RImage * img)
 425 {
 426         RColor light;
 427         RColor dark;
 428         RColor black;
 429         int width = img->width;
 430         int height = img->height;
 431         int cwidth = 28;
 432
 433         black.alpha = 255;
 434         black.red = black.green = black.blue = 0;
 435
 436         light.alpha = 0;
 437         light.red = light.green = light.blue = 80;
 438
 439         dark.alpha = 0;
 440         dark.red = dark.green = dark.blue = 40;
 441
 442         ROperateLine(img, RSubtractOperation, 0, 0, width - 1, 0, &dark);
 443         ROperateLine(img, RAddOperation, 0, 1, width - 1, 1, &light);
 444
 445         ROperateLine(img, RSubtractOperation, cwidth, 2, cwidth, height - 1, &dark);
 446         ROperateLine(img, RAddOperation, cwidth + 1, 2, cwidth + 1, height - 1, &light);
 447
 448         ROperateLine(img, RSubtractOperation, width - cwidth - 2, 2, width - cwidth - 2, height - 1, &dark);
 449         ROperateLine(img, RAddOperation, width - cwidth - 1, 2, width - cwidth - 1, height - 1, &light);
 450
 451         RDrawLine(img, 0, height - 1, width - 1, height - 1, &black);
 452         RDrawLine(img, 0, 0, 0, height - 1, &black);
 453         RDrawLine(img, width - 1, 0, width - 1, height - 1, &black);
 454 }
 455
 456 static void drawMenuBevel(RImage * img)
 457 {
 458         RColor light, dark, mid;
 459         int i;
 460         int iheight = img->height / 4;
 461
 462         light.alpha = 0;
 463         light.red = light.green = light.blue = 80;
 464
 465         dark.alpha = 255;
 466         dark.red = dark.green = dark.blue = 0;
 467
 468         mid.alpha = 0;
 469         mid.red = mid.green = mid.blue = 40;
 470
 471         for (i = 1; i < 4; i++) {
 472                 ROperateLine(img, RSubtractOperation, 0, i * iheight - 2, img->width - 1, i * iheight - 2, &mid);
 473
 474                 RDrawLine(img, 0, i * iheight - 1, img->width - 1, i * iheight - 1, &dark);
 475
 476                 ROperateLine(img, RAddOperation, 1, i * iheight, img->width - 2, i * iheight, &light);
 477         }
 478 }
 479
 480 static Pixmap renderTexture(WMScreen * scr, WMPropList * texture, int width, int height, char *path, int border)
 481 {
 482         char *type;
 483         RImage *image = NULL;
 484         Pixmap pixmap;
 485         RContext *rc = WMScreenRContext(scr);
 486         char *str;
 487         RColor rcolor;
 488
 489         type = WMGetFromPLString(WMGetFromPLArray(texture, 0));
 490
 491         if (strcasecmp(type, "solid") == 0) {
 492
 493                 str = WMGetFromPLString(WMGetFromPLArray(texture, 1));
 494
 495                 str2rcolor(rc, str, &rcolor);
 496
 497                 image = RCreateImage(width, height, False);
 498                 RClearImage(image, &rcolor);
 499         } else if (strcasecmp(type, "igradient") == 0) {
 500                 int t1, t2;
 501                 RColor c1[2], c2[2];
 502
 503                 str = WMGetFromPLString(WMGetFromPLArray(texture, 1));
 504                 str2rcolor(rc, str, &c1[0]);
 505                 str = WMGetFromPLString(WMGetFromPLArray(texture, 2));
 506                 str2rcolor(rc, str, &c1[1]);
 507                 str = WMGetFromPLString(WMGetFromPLArray(texture, 3));
 508                 t1 = atoi(str);
 509
 510                 str = WMGetFromPLString(WMGetFromPLArray(texture, 4));
 511                 str2rcolor(rc, str, &c2[0]);
 512                 str = WMGetFromPLString(WMGetFromPLArray(texture, 5));
 513                 str2rcolor(rc, str, &c2[1]);
 514                 str = WMGetFromPLString(WMGetFromPLArray(texture, 6));
 515                 t2 = atoi(str);
 516
 517                 image = RRenderInterwovenGradient(width, height, c1, t1, c2, t2);
 518         } else if (strcasecmp(&type[1], "gradient") == 0) {
 519                 int style;
 520                 RColor rcolor2;
 521
 522                 switch (toupper(type[0])) {
 523                 case 'V':
 524                         style = RVerticalGradient;
 525                         break;
 526                 case 'H':
 527                         style = RHorizontalGradient;
 528                         break;
 529                 default:
 530                 case 'D':
 531                         style = RDiagonalGradient;
 532                         break;
 533                 }
 534
 535                 str = WMGetFromPLString(WMGetFromPLArray(texture, 1));
 536                 str2rcolor(rc, str, &rcolor);
 537                 str = WMGetFromPLString(WMGetFromPLArray(texture, 2));
 538                 str2rcolor(rc, str, &rcolor2);
 539
 540                 image = RRenderGradient(width, height, &rcolor, &rcolor2, style);
 541         } else if (strcasecmp(&type[2], "gradient") == 0 && toupper(type[0]) == 'T') {
 542                 int style;
 543                 RColor rcolor2;
 544                 int i;
 545                 RImage *grad, *timage = NULL;
 546                 char *path;
 547
 548                 switch (toupper(type[1])) {
 549                 case 'V':
 550                         style = RVerticalGradient;
 551                         break;
 552                 case 'H':
 553                         style = RHorizontalGradient;
 554                         break;
 555                 default:
 556                 case 'D':
 557                         style = RDiagonalGradient;
 558                         break;
 559                 }
 560
 561                 str = WMGetFromPLString(WMGetFromPLArray(texture, 3));
 562                 str2rcolor(rc, str, &rcolor);
 563                 str = WMGetFromPLString(WMGetFromPLArray(texture, 4));
 564                 str2rcolor(rc, str, &rcolor2);
 565
 566                 str = WMGetFromPLString(WMGetFromPLArray(texture, 1));
 567
 568                 if ((path = wfindfileinarray(GetObjectForKey("PixmapPath"), str)) != NULL)
 569                         timage = RLoadImage(rc, path, 0);
 570
 571                 if (!path || !timage) {
 572                         wwarning("could not load file '%s': %s", path, RMessageForError(RErrorCode));
 573                 } else {
 574                         grad = RRenderGradient(width, height, &rcolor, &rcolor2, style);
 575
 576                         image = RMakeTiledImage(timage, width, height);
 577                         RReleaseImage(timage);
 578
 579                         i = atoi(WMGetFromPLString(WMGetFromPLArray(texture, 2)));
 580
 581                         RCombineImagesWithOpaqueness(image, grad, i);
 582                         RReleaseImage(grad);
 583                 }
 584         } else if (strcasecmp(&type[2], "gradient") == 0 && toupper(type[0]) == 'M') {
 585                 int style;
 586                 RColor **colors;
 587                 int i, j;
 588
 589                 switch (toupper(type[1])) {
 590                 case 'V':
 591                         style = RVerticalGradient;
 592                         break;
 593                 case 'H':
 594                         style = RHorizontalGradient;
 595                         break;
 596                 default:
 597                 case 'D':
 598                         style = RDiagonalGradient;
 599                         break;
 600                 }
 601
 602                 j = WMGetPropListItemCount(texture);
 603
 604                 if (j > 0) {
 605                         colors = wmalloc(j * sizeof(RColor *));
 606
 607                         for (i = 2; i < j; i++) {
 608                                 str = WMGetFromPLString(WMGetFromPLArray(texture, i));
 609                                 colors[i - 2] = wmalloc(sizeof(RColor));
 610                                 str2rcolor(rc, str, colors[i - 2]);
 611                         }
 612                         colors[i - 2] = NULL;
 613
 614                         image = RRenderMultiGradient(width, height, colors, style);
 615
 616                         for (i = 0; colors[i] != NULL; i++)
 617                                 wfree(colors[i]);
 618                         wfree(colors);
 619                 }
 620         } else if (strcasecmp(&type[1], "pixmap") == 0) {
 621                 RImage *timage = NULL;
 622                 char *path;
 623                 RColor color;
 624
 625                 str = WMGetFromPLString(WMGetFromPLArray(texture, 1));
 626
 627                 if ((path = wfindfileinarray(GetObjectForKey("PixmapPath"), str)) != NULL)
 628                         timage = RLoadImage(rc, path, 0);
 629
 630                 if (!path || !timage) {
 631                         wwarning("could not load file '%s': %s", path ? path : str, RMessageForError(RErrorCode));
 632                 } else {
 633                         str = WMGetFromPLString(WMGetFromPLArray(texture, 2));
 634                         str2rcolor(rc, str, &color);
 635
 636                         switch (toupper(type[0])) {
 637                         case 'T':
 638                                 image = RMakeTiledImage(timage, width, height);
 639                                 RReleaseImage(timage);
 640                                 timage = image;
 641                                 break;
 642                         case 'C':
 643                                 image = RMakeCenteredImage(timage, width, height, &color);
 644                                 RReleaseImage(timage);
 645                                 timage = image;
 646                                 break;
 647                         case 'S':
 648                         case 'M':
 649                                 image = RScaleImage(timage, width, height);
 650                                 RReleaseImage(timage);
 651                                 timage = image;
 652                                 break;
 653                         }
 654
 655                 }
 656                 wfree(path);
 657         }
 658
 659         if (!image)
 660                 return None;
 661
 662         if (path) {
 663                 dumpRImage(path, image);
 664         }
 665
 666         if (border < 0) {
 667                 if (border == RESIZEBAR_BEVEL) {
 668                         drawResizebarBevel(image);
 669                 } else if (border == MENU_BEVEL) {
 670                         drawMenuBevel(image);
 671                         RBevelImage(image, RBEV_RAISED2);
 672                 }
 673         } else if (border) {
 674                 RBevelImage(image, border);
 675         }
 676
 677         RConvertImage(rc, image, &pixmap);
 678         RReleaseImage(image);
 679
 680         return pixmap;
 681 }
 682
 683 static Pixmap renderMenu(_Panel * panel, WMPropList * texture, int width, int iheight)
 684 {
 685         WMScreen *scr = WMWidgetScreen(panel->parent);
 686         Display *dpy = WMScreenDisplay(scr);
 687         Pixmap pix, tmp;
 688         GC gc = XCreateGC(dpy, WMWidgetXID(panel->parent), 0, NULL);
 689         int i;
 690
 691         switch (panel->menuStyle) {
 692         case MSTYLE_NORMAL:
 693                 tmp = renderTexture(scr, texture, width, iheight, NULL, RBEV_RAISED2);
 694
 695                 pix = XCreatePixmap(dpy, tmp, width, iheight * 4, WMScreenDepth(scr));
 696                 for (i = 0; i < 4; i++) {
 697                         XCopyArea(dpy, tmp, pix, gc, 0, 0, width, iheight, 0, iheight * i);
 698                 }
 699                 XFreePixmap(dpy, tmp);
 700                 break;
 701         case MSTYLE_SINGLE:
 702                 pix = renderTexture(scr, texture, width, iheight * 4, NULL, MENU_BEVEL);
 703                 break;
 704         case MSTYLE_FLAT:
 705                 pix = renderTexture(scr, texture, width, iheight * 4, NULL, RBEV_RAISED2);
 706                 break;
 707         default:
 708                 pix = None;
 709         }
 710         XFreeGC(dpy, gc);
 711
 712         return pix;
 713 }
 714
 715 static void renderPreview(_Panel * panel, GC gc, int part, int relief)
 716 {
 717         WMListItem *item;
 718         TextureListItem *titem;
 719         Pixmap pix;
 720         WMScreen *scr = WMWidgetScreen(panel->box);
 721
 722         item = WMGetListItem(panel->texLs, panel->textureIndex[part]);
 723         titem = (TextureListItem *) item->clientData;
 724
 725         pix = renderTexture(scr, titem->prop,
 726                             previewPositions[part].size.width, previewPositions[part].size.height, NULL, relief);
 727
 728         XCopyArea(WMScreenDisplay(scr), pix, panel->preview, gc, 0, 0,
 729                   previewPositions[part].size.width,
 730                   previewPositions[part].size.height, previewPositions[part].pos.x, previewPositions[part].pos.y);
 731
 732         XCopyArea(WMScreenDisplay(scr), pix, panel->previewNoText, gc, 0, 0,
 733                   previewPositions[part].size.width,
 734                   previewPositions[part].size.height, previewPositions[part].pos.x, previewPositions[part].pos.y);
 735
 736         XFreePixmap(WMScreenDisplay(scr), pix);
 737 }
 738
 739 static void updatePreviewBox(_Panel * panel, int elements)
 740 {
 741         WMScreen *scr = WMWidgetScreen(panel->parent);
 742         Display *dpy = WMScreenDisplay(scr);
 743         Pixmap pix;
 744         GC gc;
 745         int colorUpdate = 0;
 746         WMColor *black = WMBlackColor(scr);
 747
 748         gc = XCreateGC(dpy, WMWidgetXID(panel->parent), 0, NULL);
 749
 750         if (panel->preview == None) {
 751                 WMColor *color;
 752                 WMPixmap *p;
 753
 754                 panel->previewNoText = XCreatePixmap(dpy, WMWidgetXID(panel->parent),
 755                                                      240 - 4, 215 - 4, WMScreenDepth(scr));
 756
 757                 p = WMCreatePixmap(scr, 240 - 4, 215 - 4, WMScreenDepth(scr), False);
 758                 panel->preview = WMGetPixmapXID(p);
 759                 WMSetLabelImage(panel->prevL, p);
 760                 WMReleasePixmap(p);
 761
 762                 color = WMCreateRGBColor(scr, 0x5100, 0x5100, 0x7100, True);
 763                 XFillRectangle(dpy, panel->preview, WMColorGC(color), 0, 0, 240 - 4, 215 - 4);
 764                 XFillRectangle(dpy, panel->previewNoText, WMColorGC(color), 0, 0, 240 - 4, 215 - 4);
 765                 WMReleaseColor(color);
 766         }
 767
 768         if (elements & (1 << PFOCUSED)) {
 769                 renderPreview(panel, gc, PFOCUSED, RBEV_RAISED2);
 770                 XDrawRectangle(dpy, panel->preview, WMColorGC(black),
 771                                previewPositions[PFOCUSED].pos.x - 1,
 772                                previewPositions[PFOCUSED].pos.y - 1,
 773                                previewPositions[PFOCUSED].size.width, previewPositions[PFOCUSED].size.height);
 774                 XDrawRectangle(dpy, panel->previewNoText, WMColorGC(black),
 775                                previewPositions[PFOCUSED].pos.x - 1,
 776                                previewPositions[PFOCUSED].pos.y - 1,
 777                                previewPositions[PFOCUSED].size.width, previewPositions[PFOCUSED].size.height);
 778                 colorUpdate |= FTITLE_COL;
 779         }
 780         if (elements & (1 << PUNFOCUSED)) {
 781                 renderPreview(panel, gc, PUNFOCUSED, RBEV_RAISED2);
 782                 XDrawRectangle(dpy, panel->preview, WMColorGC(black),
 783                                previewPositions[PUNFOCUSED].pos.x - 1,
 784                                previewPositions[PUNFOCUSED].pos.y - 1,
 785                                previewPositions[PUNFOCUSED].size.width, previewPositions[PUNFOCUSED].size.height);
 786                 XDrawRectangle(dpy, panel->previewNoText, WMColorGC(black),
 787                                previewPositions[PUNFOCUSED].pos.x - 1,
 788                                previewPositions[PUNFOCUSED].pos.y - 1,
 789                                previewPositions[PUNFOCUSED].size.width, previewPositions[PUNFOCUSED].size.height);
 790                 colorUpdate |= UTITLE_COL;
 791         }
 792         if (elements & (1 << POWNER)) {
 793                 renderPreview(panel, gc, POWNER, RBEV_RAISED2);
 794                 XDrawRectangle(dpy, panel->preview, WMColorGC(black),
 795                                previewPositions[POWNER].pos.x - 1,
 796                                previewPositions[POWNER].pos.y - 1,
 797                                previewPositions[POWNER].size.width, previewPositions[POWNER].size.height);
 798                 XDrawRectangle(dpy, panel->previewNoText, WMColorGC(black),
 799                                previewPositions[POWNER].pos.x - 1,
 800                                previewPositions[POWNER].pos.y - 1,
 801                                previewPositions[POWNER].size.width, previewPositions[POWNER].size.height);
 802                 colorUpdate |= OTITLE_COL;
 803         }
 804         if (elements & (1 << PRESIZEBAR)) {
 805                 renderPreview(panel, gc, PRESIZEBAR, RESIZEBAR_BEVEL);
 806         }
 807         if (elements & (1 << PMTITLE)) {
 808                 renderPreview(panel, gc, PMTITLE, RBEV_RAISED2);
 809                 colorUpdate |= MTITLE_COL;
 810         }
 811         if (elements & (1 << PMITEM)) {
 812                 WMListItem *item;
 813                 TextureListItem *titem;
 814
 815                 item = WMGetListItem(panel->texLs, panel->textureIndex[5]);
 816                 titem = (TextureListItem *) item->clientData;
 817
 818                 pix = renderMenu(panel, titem->prop,
 819                                  previewPositions[PMITEM].size.width, previewPositions[PMITEM].size.height / 4);
 820
 821                 XCopyArea(dpy, pix, panel->preview, gc, 0, 0,
 822                           previewPositions[PMITEM].size.width,
 823                           previewPositions[PMITEM].size.height,
 824                           previewPositions[PMITEM].pos.x, previewPositions[PMITEM].pos.y);
 825
 826                 XCopyArea(dpy, pix, panel->previewNoText, gc, 0, 0,
 827                           previewPositions[PMITEM].size.width,
 828                           previewPositions[PMITEM].size.height,
 829                           previewPositions[PMITEM].pos.x, previewPositions[PMITEM].pos.y);
 830
 831                 XFreePixmap(dpy, pix);
 832
 833                 colorUpdate |= MITEM_COL | MDISAB_COL | MHIGH_COL | MHIGHT_COL;
 834         }
 835         if (elements & (1 << PMITEM | 1 << PMTITLE)) {
 836                 XDrawLine(dpy, panel->preview, gc, 29, 120, 29, 120 + 20 * 4 + 20);
 837                 XDrawLine(dpy, panel->preview, gc, 29, 119, 119, 119);
 838
 839                 XDrawLine(dpy, panel->previewNoText, gc, 29, 120, 29, 120 + 20 * 4 + 20);
 840                 XDrawLine(dpy, panel->previewNoText, gc, 29, 119, 119, 119);
 841         }
 842         if (elements & (1 << PICON)) {
 843                 WMListItem *item;
 844                 TextureListItem *titem;
 845
 846                 item = WMGetListItem(panel->texLs, panel->textureIndex[6]);
 847                 titem = (TextureListItem *) item->clientData;
 848
 849                 renderPreview(panel, gc, PICON, titem->ispixmap ? 0 : RBEV_RAISED3);
 850
 851                 colorUpdate |= ICONT_COL | ICONB_COL | CLIP_COL | CCLIP_COL;
 852         }
 853
 854         if (colorUpdate)
 855                 updateColorPreviewBox(panel, colorUpdate);
 856         else
 857                 WMRedisplayWidget(panel->prevL);
 858
 859         XFreeGC(dpy, gc);
 860         WMReleaseColor(black);
 861 }
 862
 863 static void cancelNewTexture(void *data)
 864 {
 865         _Panel *panel = (_Panel *) data;
 866
 867         HideTexturePanel(panel->texturePanel);
 868 }
 869
 870 static char *makeFileName(char *prefix)
 871 {
 872         char *fname;
 873
 874         fname = wstrdup(prefix);
 875
 876         while (access(fname, F_OK) == 0) {
 877                 char buf[30];
 878
 879                 wfree(fname);
 880                 sprintf(buf, "%08lx.cache", time(NULL));
 881                 fname = wstrconcat(prefix, buf);
 882         }
 883
 884         return fname;
 885 }
 886
 887 static void okNewTexture(void *data)
 888 {
 889         _Panel *panel = (_Panel *) data;
 890         WMListItem *item;
 891         char *name;
 892         char *str;
 893         WMPropList *prop;
 894         TextureListItem *titem;
 895         WMScreen *scr = WMWidgetScreen(panel->parent);
 896
 897         titem = wmalloc(sizeof(TextureListItem));
 898
 899         HideTexturePanel(panel->texturePanel);
 900
 901         name = GetTexturePanelTextureName(panel->texturePanel);
 902
 903         prop = GetTexturePanelTexture(panel->texturePanel);
 904
 905         str = WMGetPropListDescription(prop, False);
 906
 907         titem->title = name;
 908         titem->prop = prop;
 909         titem->texture = str;
 910         titem->selectedFor = 0;
 911
 912         titem->ispixmap = isPixmap(prop);
 913
 914         titem->path = makeFileName(panel->fprefix);
 915         titem->preview = renderTexture(scr, prop, TEXPREV_WIDTH, TEXPREV_HEIGHT, titem->path, 0);
 916
 917         item = WMAddListItem(panel->texLs, "");
 918         item->clientData = titem;
 919
 920         WMSetListPosition(panel->texLs, WMGetListNumberOfRows(panel->texLs));
 921 }
 922
 923 static void okEditTexture(void *data)
 924 {
 925         _Panel *panel = (_Panel *) data;
 926         WMListItem *item;
 927         char *name;
 928         char *str;
 929         WMPropList *prop;
 930         TextureListItem *titem;
 931
 932         item = WMGetListItem(panel->texLs, WMGetListSelectedItemRow(panel->texLs));
 933         titem = (TextureListItem *) item->clientData;
 934
 935         HideTexturePanel(panel->texturePanel);
 936
 937         if (titem->current) {
 938                 name = GetTexturePanelTextureName(panel->texturePanel);
 939
 940                 wfree(titem->title);
 941                 titem->title = name;
 942         }
 943
 944         prop = GetTexturePanelTexture(panel->texturePanel);
 945
 946         str = WMGetPropListDescription(prop, False);
 947
 948         WMReleasePropList(titem->prop);
 949         titem->prop = prop;
 950
 951         titem->ispixmap = isPixmap(prop);
 952
 953         wfree(titem->texture);
 954         titem->texture = str;
 955
 956         XFreePixmap(WMScreenDisplay(WMWidgetScreen(panel->texLs)), titem->preview);
 957         titem->preview = renderTexture(WMWidgetScreen(panel->texLs), titem->prop,
 958                                        TEXPREV_WIDTH, TEXPREV_HEIGHT, titem->path, 0);
 959
 960         WMRedisplayWidget(panel->texLs);
 961
 962         if (titem->selectedFor)
 963                 updatePreviewBox(panel, titem->selectedFor);
 964
 965         changePage(panel->secP, panel);
 966 }
 967
 968 static void editTexture(WMWidget * w, void *data)
 969 {
 970         _Panel *panel = (_Panel *) data;
 971         WMListItem *item;
 972         TextureListItem *titem;
 973
 974         item = WMGetListItem(panel->texLs, WMGetListSelectedItemRow(panel->texLs));
 975         titem = (TextureListItem *) item->clientData;
 976
 977         SetTexturePanelPixmapPath(panel->texturePanel, GetObjectForKey("PixmapPath"));
 978
 979         SetTexturePanelTexture(panel->texturePanel, titem->title, titem->prop);
 980
 981         SetTexturePanelCancelAction(panel->texturePanel, cancelNewTexture, panel);
 982         SetTexturePanelOkAction(panel->texturePanel, okEditTexture, panel);
 983
 984         ShowTexturePanel(panel->texturePanel);
 985 }
 986
 987 static void newTexture(WMWidget * w, void *data)
 988 {
 989         _Panel *panel = (_Panel *) data;
 990
 991         SetTexturePanelPixmapPath(panel->texturePanel, GetObjectForKey("PixmapPath"));
 992
 993         SetTexturePanelTexture(panel->texturePanel, "New Texture", NULL);
 994
 995         SetTexturePanelCancelAction(panel->texturePanel, cancelNewTexture, panel);
 996
 997         SetTexturePanelOkAction(panel->texturePanel, okNewTexture, panel);
 998
 999         ShowTexturePanel(panel->texturePanel);
1000 }
1001
1002 static void deleteTexture(WMWidget * w, void *data)
1003 {
1004         _Panel *panel = (_Panel *) data;
1005         WMListItem *item;
1006         TextureListItem *titem;
1007         int row;
1008         int section;
1009
1010         section = WMGetPopUpButtonSelectedItem(panel->secP);
1011         row = WMGetListSelectedItemRow(panel->texLs);
1012         item = WMGetListItem(panel->texLs, row);
1013         titem = (TextureListItem *) item->clientData;
1014
1015         if (titem->selectedFor & (1 << section)) {
1016                 TextureListItem *titem2;
1017
1018                 panel->textureIndex[section] = section;
1019                 item = WMGetListItem(panel->texLs, section);
1020                 titem2 = (TextureListItem *) item->clientData;
1021                 titem2->selectedFor |= 1 << section;
1022         }
1023
1024         wfree(titem->title);
1025         wfree(titem->texture);
1026         WMReleasePropList(titem->prop);
1027         if (titem->path) {
1028                 if (remove(titem->path) < 0 && errno != ENOENT) {
1029                         werror("could not remove file %s", titem->path);
1030                 }
1031                 wfree(titem->path);
1032         }
1033
1034         wfree(titem);
1035
1036         WMRemoveListItem(panel->texLs, row);
1037         WMSetButtonEnabled(panel->delB, False);
1038 }
1039
1040 static void extractTexture(WMWidget * w, void *data)
1041 {
1042         _Panel *panel = (_Panel *) data;
1043         char *path;
1044         WMOpenPanel *opanel;
1045         WMScreen *scr = WMWidgetScreen(w);
1046
1047         opanel = WMGetOpenPanel(scr);
1048         WMSetFilePanelCanChooseDirectories(opanel, False);
1049         WMSetFilePanelCanChooseFiles(opanel, True);
1050
1051         if (WMRunModalFilePanelForDirectory(opanel, panel->parent, wgethomedir(), _("Select File"), NULL)) {
1052                 path = WMGetFilePanelFileName(opanel);
1053
1054                 OpenExtractPanelFor(panel, path);
1055
1056                 wfree(path);
1057         }
1058 }
1059
1060 static void changePage(WMWidget * w, void *data)
1061 {
1062         _Panel *panel = (_Panel *) data;
1063         int section;
1064         WMScreen *scr = WMWidgetScreen(panel->box);
1065         RContext *rc = WMScreenRContext(scr);
1066         static WMPoint positions[] = {
1067                 {5, 10},
1068                 {5, 40},
1069                 {5, 70},
1070                 {5, 100},
1071                 {5, 120},
1072                 {5, 160},
1073                 {130, 150}
1074         };
1075
1076         if (w) {
1077                 section = WMGetPopUpButtonSelectedItem(panel->secP);
1078
1079                 WMSelectListItem(panel->texLs, panel->textureIndex[section]);
1080
1081                 WMSetListPosition(panel->texLs, panel->textureIndex[section] - 2);
1082         }
1083         {
1084                 WMColor *color;
1085
1086                 color = WMCreateRGBColor(scr, 0x5100, 0x5100, 0x7100, True);
1087                 XFillRectangle(rc->dpy, panel->preview, WMColorGC(color),
1088                                positions[panel->oldsection].x, positions[panel->oldsection].y, 22, 22);
1089                 WMReleaseColor(color);
1090         }
1091         if (w) {
1092                 panel->oldsection = section;
1093                 WMDrawPixmap(panel->hand, panel->preview, positions[section].x, positions[section].y);
1094         }
1095         WMRedisplayWidget(panel->prevL);
1096 }
1097
1098 static void previewClick(XEvent * event, void *clientData)
1099 {
1100         _Panel *panel = (_Panel *) clientData;
1101         int i;
1102
1103         switch (panel->oldTabItem) {
1104         case 0:
1105                 for (i = 0; i < sizeof(previewPositions) / sizeof(WMRect); i++) {
1106                         if (event->xbutton.x >= previewPositions[i].pos.x
1107                             && event->xbutton.y >= previewPositions[i].pos.y
1108                             && event->xbutton.x < previewPositions[i].pos.x
1109                             + previewPositions[i].size.width
1110                             && event->xbutton.y < previewPositions[i].pos.y + previewPositions[i].size.height) {
1111
1112                                 WMSetPopUpButtonSelectedItem(panel->secP, i);
1113                                 changePage(panel->secP, panel);
1114                                 return;
1115                         }
1116                 }
1117                 break;
1118         case 1:
1119                 for (i = 0; i < WMGetPopUpButtonNumberOfItems(panel->colP); i++) {
1120                         if (event->xbutton.x >= previewColorPositions[i].pos.x
1121                             && event->xbutton.y >= previewColorPositions[i].pos.y
1122                             && event->xbutton.x < previewColorPositions[i].pos.x
1123                             + previewColorPositions[i].size.width
1124                             && event->xbutton.y < previewColorPositions[i].pos.y
1125                             + previewColorPositions[i].size.height) {
1126
1127                                 /* yuck kluge */
1128                                 if (i == 7)
1129                                         i = 4;
1130
1131                                 WMSetPopUpButtonSelectedItem(panel->colP, i);
1132                                 changeColorPage(panel->colP, panel);
1133                                 return;
1134                         }
1135                 }
1136                 break;
1137         }
1138 }
1139
1140 static void textureClick(WMWidget * w, void *data)
1141 {
1142         _Panel *panel = (_Panel *) data;
1143         int i;
1144         WMListItem *item;
1145         TextureListItem *titem;
1146
1147         i = WMGetListSelectedItemRow(panel->texLs);
1148
1149         item = WMGetListItem(panel->texLs, i);
1150
1151         titem = (TextureListItem *) item->clientData;
1152
1153         if (titem->current) {
1154                 WMSetButtonEnabled(panel->delB, False);
1155         } else {
1156                 WMSetButtonEnabled(panel->delB, True);
1157         }
1158 }
1159
1160 static void textureDoubleClick(WMWidget * w, void *data)
1161 {
1162         _Panel *panel = (_Panel *) data;
1163         int i, section;
1164         WMListItem *item;
1165         TextureListItem *titem;
1166
1167         /* unselect old texture */
1168         section = WMGetPopUpButtonSelectedItem(panel->secP);
1169
1170         item = WMGetListItem(panel->texLs, panel->textureIndex[section]);
1171         titem = (TextureListItem *) item->clientData;
1172         titem->selectedFor &= ~(1 << section);
1173
1174         /* select new texture */
1175         i = WMGetListSelectedItemRow(panel->texLs);
1176
1177         item = WMGetListItem(panel->texLs, i);
1178
1179         titem = (TextureListItem *) item->clientData;
1180
1181         titem->selectedFor |= 1 << section;
1182
1183         panel->textureIndex[section] = i;
1184
1185         WMRedisplayWidget(panel->texLs);
1186
1187         updatePreviewBox(panel, 1 << section);
1188 }
1189
1190 static void paintListItem(WMList * lPtr, int index, Drawable d, char *text, int state, WMRect * rect)
1191 {
1192         _Panel *panel = (_Panel *) WMGetHangedData(lPtr);
1193         WMScreen *scr = WMWidgetScreen(lPtr);
1194         int width, height, x, y;
1195         Display *dpy = WMScreenDisplay(scr);
1196         WMColor *back = (state & WLDSSelected) ? WMWhiteColor(scr) : WMGrayColor(scr);
1197         WMListItem *item;
1198         WMColor *black = WMBlackColor(scr);
1199         TextureListItem *titem;
1200
1201         item = WMGetListItem(lPtr, index);
1202         titem = (TextureListItem *) item->clientData;
1203         if (!titem) {
1204                 WMReleaseColor(back);
1205                 WMReleaseColor(black);
1206                 return;
1207         }
1208
1209         width = rect->size.width;
1210         height = rect->size.height;
1211         x = rect->pos.x;
1212         y = rect->pos.y;
1213
1214         XFillRectangle(dpy, d, WMColorGC(back), x, y, width, height);
1215
1216         if (titem->preview)
1217                 XCopyArea(dpy, titem->preview, d, WMColorGC(black), 0, 0,
1218                           TEXPREV_WIDTH, TEXPREV_HEIGHT, x + 5, y + 5);
1219
1220         if ((1 << WMGetPopUpButtonSelectedItem(panel->secP)) & titem->selectedFor)
1221                 WMDrawPixmap(panel->onLed, d, x + TEXPREV_WIDTH + 10, y + 6);
1222         else if (titem->selectedFor)
1223                 WMDrawPixmap(panel->offLed, d, x + TEXPREV_WIDTH + 10, y + 6);
1224
1225         WMDrawString(scr, d, black, panel->boldFont,
1226                      x + TEXPREV_WIDTH + 22, y + 2, titem->title, strlen(titem->title));
1227
1228         WMDrawString(scr, d, black, panel->smallFont,
1229                      x + TEXPREV_WIDTH + 14, y + 18, titem->texture, strlen(titem->texture));
1230
1231         WMReleaseColor(back);
1232         WMReleaseColor(black);
1233 }
1234
1235 static Pixmap loadRImage(WMScreen * scr, char *path)
1236 {
1237         FILE *f;
1238         RImage *image;
1239         int w, h, d;
1240         Pixmap pixmap;
1241
1242         f = fopen(path, "rb");
1243         if (!f)
1244                 return None;
1245
1246         fscanf(f, "%02x%02x%1x", &w, &h, &d);
1247
1248         image = RCreateImage(w, h, d == 4);
1249         fread(image->data, 1, w * h * d, f);
1250         fclose(f);
1251
1252         RConvertImage(WMScreenRContext(scr), image, &pixmap);
1253         RReleaseImage(image);
1254
1255         return pixmap;
1256 }
1257
1258 static void fillTextureList(WMList * lPtr)
1259 {
1260         WMPropList *textureList;
1261         WMPropList *texture;
1262         WMUserDefaults *udb = WMGetStandardUserDefaults();
1263         TextureListItem *titem;
1264         WMScreen *scr = WMWidgetScreen(lPtr);
1265         int i;
1266
1267         textureList = WMGetUDObjectForKey(udb, "TextureList");
1268         if (!textureList)
1269                 return;
1270
1271         for (i = 0; i < WMGetPropListItemCount(textureList); i++) {
1272                 WMListItem *item;
1273
1274                 texture = WMGetFromPLArray(textureList, i);
1275
1276                 titem = wmalloc(sizeof(TextureListItem));
1277
1278                 titem->title = wstrdup(WMGetFromPLString(WMGetFromPLArray(texture, 0)));
1279                 titem->prop = WMRetainPropList(WMGetFromPLArray(texture, 1));
1280                 titem->texture = WMGetPropListDescription(titem->prop, False);
1281                 titem->selectedFor = 0;
1282                 titem->path = wstrdup(WMGetFromPLString(WMGetFromPLArray(texture, 2)));
1283
1284                 titem->preview = loadRImage(scr, titem->path);
1285                 if (!titem->preview) {
1286                         titem->preview = renderTexture(scr, titem->prop, TEXPREV_WIDTH, TEXPREV_HEIGHT, NULL, 0);
1287                 }
1288                 item = WMAddListItem(lPtr, "");
1289                 item->clientData = titem;
1290         }
1291 }
1292
1293 static void fillColorList(_Panel * panel)
1294 {
1295         WMColor *color;
1296         WMPropList *list;
1297         WMUserDefaults *udb = WMGetStandardUserDefaults();
1298         WMScreen *scr = WMWidgetScreen(panel->box);
1299         int i;
1300
1301         list = WMGetUDObjectForKey(udb, "ColorList");
1302         if (!list) {
1303                 for (i = 0; i < 24; i++) {
1304                         color = WMCreateNamedColor(scr, sampleColors[i], False);
1305                         if (!color)
1306                                 continue;
1307                         WMSetColorWellColor(panel->sampW[i], color);
1308                         WMReleaseColor(color);
1309                 }
1310         } else {
1311                 WMPropList *c;
1312
1313                 for (i = 0; i < WMIN(24, WMGetPropListItemCount(list)); i++) {
1314                         c = WMGetFromPLArray(list, i);
1315                         if (!c || !WMIsPLString(c))
1316                                 continue;
1317                         color = WMCreateNamedColor(scr, WMGetFromPLString(c), False);
1318                         if (!color)
1319                                 continue;
1320                         WMSetColorWellColor(panel->sampW[i], color);
1321                         WMReleaseColor(color);
1322                 }
1323         }
1324 }
1325
1326 /*************************************************************************/
1327
1328 static void changeColorPage(WMWidget * w, void *data)
1329 {
1330         _Panel *panel = (_Panel *) data;
1331         int section;
1332         WMScreen *scr = WMWidgetScreen(panel->box);
1333         RContext *rc = WMScreenRContext(scr);
1334         static WMPoint positions[] = {
1335                 {5, 10},
1336                 {5, 40},
1337                 {5, 70},
1338                 {5, 120},
1339                 {5, 140},
1340                 {5, 160},
1341                 {5, 180},
1342                 {5, 180},
1343                 {130, 140},
1344                 {130, 140},
1345                 {130, 140},
1346                 {130, 140}
1347         };
1348
1349         if (panel->preview) {
1350                 WMColor *color;
1351
1352                 color = WMCreateRGBColor(scr, 0x5100, 0x5100, 0x7100, True);
1353                 XFillRectangle(rc->dpy, panel->preview, WMColorGC(color),
1354                                positions[panel->oldcsection].x, positions[panel->oldcsection].y, 22, 22);
1355                 WMReleaseColor(color);
1356         }
1357         if (w) {
1358                 section = WMGetPopUpButtonSelectedItem(panel->colP);
1359
1360                 panel->oldcsection = section;
1361                 if (panel->preview)
1362                         WMDrawPixmap(panel->hand, panel->preview, positions[section].x, positions[section].y);
1363
1364                 section = WMGetPopUpButtonSelectedItem(panel->colP);
1365
1366                 WMSetColorWellColor(panel->colW, panel->colors[section]);
1367         }
1368         WMRedisplayWidget(panel->prevL);
1369 }
1370
1371 static void
1372 paintText(WMScreen * scr, Drawable d, WMColor * color, WMFont * font,
1373           int x, int y, int w, int h, WMAlignment align, char *text)
1374 {
1375         int l = strlen(text);
1376
1377         switch (align) {
1378         case WALeft:
1379                 x += 5;
1380                 break;
1381         case WARight:
1382                 x += w - 5 - WMWidthOfString(font, text, l);
1383                 break;
1384         default:
1385         case WACenter:
1386                 x += (w - WMWidthOfString(font, text, l)) / 2;
1387                 break;
1388         }
1389         WMDrawString(scr, d, color, font, x, y + (h - WMFontHeight(font)) / 2, text, l);
1390 }
1391
1392 static void updateColorPreviewBox(_Panel * panel, int elements)
1393 {
1394         WMScreen *scr = WMWidgetScreen(panel->box);
1395         Display *dpy = WMScreenDisplay(scr);
1396         Pixmap d, pnot;
1397         GC gc;
1398
1399         d = panel->preview;
1400         pnot = panel->previewNoText;
1401         gc = WMColorGC(panel->colors[0]);
1402
1403         if (elements & FTITLE_COL) {
1404                 XCopyArea(dpy, pnot, d, gc, 30, 10, 190, 20, 30, 10);
1405                 paintText(scr, d, panel->colors[0], panel->boldFont, 30, 10, 190, 20,
1406                           panel->titleAlignment, _("Focused Window"));
1407         }
1408         if (elements & UTITLE_COL) {
1409                 XCopyArea(dpy, pnot, d, gc, 30, 40, 190, 20, 30, 40);
1410                 paintText(scr, d, panel->colors[1], panel->boldFont, 30, 40, 190, 20,
1411                           panel->titleAlignment, _("Unfocused Window"));
1412         }
1413         if (elements & OTITLE_COL) {
1414                 XCopyArea(dpy, pnot, d, gc, 30, 70, 190, 20, 30, 70);
1415                 paintText(scr, d, panel->colors[2], panel->boldFont, 30, 70, 190, 20,
1416                           panel->titleAlignment, _("Owner of Focused Window"));
1417         }
1418         if (elements & MTITLE_COL) {
1419                 XCopyArea(dpy, pnot, d, gc, 30, 120, 90, 20, 30, 120);
1420                 paintText(scr, d, panel->colors[3], panel->boldFont, 30, 120, 90, 20, WALeft, _("Menu Title"));
1421         }
1422         if (elements & MITEM_COL) {
1423                 XCopyArea(dpy, pnot, d, gc, 30, 140, 90, 20, 30, 140);
1424                 paintText(scr, d, panel->colors[4], panel->normalFont, 30, 140, 90, 20, WALeft, _("Normal Item"));
1425                 XCopyArea(dpy, pnot, d, gc, 30, 200, 90, 20, 30, 200);
1426                 paintText(scr, d, panel->colors[4], panel->normalFont, 30, 200, 90, 20, WALeft, _("Normal Item"));
1427         }
1428         if (elements & MDISAB_COL) {
1429                 XCopyArea(dpy, pnot, d, gc, 30, 160, 90, 20, 30, 160);
1430                 paintText(scr, d, panel->colors[5], panel->normalFont, 30, 160, 90, 20,
1431                           WALeft, _("Disabled Item"));
1432         }
1433         if (elements & MHIGH_COL) {
1434                 XFillRectangle(WMScreenDisplay(scr), d, WMColorGC(panel->colors[6]), 31, 181, 87, 17);
1435                 XFillRectangle(WMScreenDisplay(scr), pnot, WMColorGC(panel->colors[6]), 31, 181, 87, 17);
1436                 elements |= MHIGHT_COL;
1437         }
1438         if (elements & MHIGHT_COL) {
1439                 XCopyArea(dpy, pnot, d, gc, 30, 180, 90, 20, 30, 180);
1440                 paintText(scr, d, panel->colors[7], panel->normalFont, 30, 180, 90, 20, WALeft, _("Highlighted"));
1441         }
1442         /*
1443            if (elements & ICONT_COL) {
1444            WRITE(_("Focused Window"), panel->colors[8], panel->boldFont,
1445            155, 130, 64);
1446            }
1447            if (elements & ICONB_COL) {
1448            WRITE(_("Focused Window"), panel->colors[9], panel->boldFont,
1449            0, 0, 30);
1450            }
1451            if (elements & CLIP_COL) {
1452            WRITE(_("Focused Window"), panel->colors[10], panel->boldFont,
1453            0, 0, 30);
1454            }
1455            if (elements & CCLIP_COL) {
1456            WRITE(_("Focused Window"), panel->colors[11], panel->boldFont,
1457            0, 0, 30);
1458            }
1459          */
1460         WMRedisplayWidget(panel->prevL);
1461 }
1462
1463 static void colorWellObserver(void *self, WMNotification * n)
1464 {
1465         _Panel *panel = (_Panel *) self;
1466         int p;
1467
1468         p = WMGetPopUpButtonSelectedItem(panel->colP);
1469
1470         WMReleaseColor(panel->colors[p]);
1471
1472         panel->colors[p] = WMRetainColor(WMGetColorWellColor(panel->colW));
1473
1474         updateColorPreviewBox(panel, 1 << p);
1475 }
1476
1477 static void changedTabItem(struct WMTabViewDelegate *self, WMTabView * tabView, WMTabViewItem * item)
1478 {
1479         _Panel *panel = self->data;
1480         int i;
1481
1482         i = WMGetTabViewItemIdentifier(item);
1483         switch (i) {
1484         case 0:
1485                 switch (panel->oldTabItem) {
1486                 case 1:
1487                         changeColorPage(NULL, panel);
1488                         break;
1489                 }
1490                 changePage(panel->secP, panel);
1491                 break;
1492         case 1:
1493                 switch (panel->oldTabItem) {
1494                 case 0:
1495                         changePage(NULL, panel);
1496                         break;
1497                 }
1498                 changeColorPage(panel->colP, panel);
1499                 break;
1500         case 3:
1501                 switch (panel->oldTabItem) {
1502                 case 0:
1503                         changePage(NULL, panel);
1504                         break;
1505                 case 1:
1506                         changeColorPage(NULL, panel);
1507                         break;
1508                 }
1509                 break;
1510         }
1511
1512         panel->oldTabItem = i;
1513 }
1514
1515 /*************************************************************************/
1516
1517 static void menuStyleCallback(WMWidget * self, void *data)
1518 {
1519         _Panel *panel = (_Panel *) data;
1520
1521         if (self == panel->mstyB[0]) {
1522                 panel->menuStyle = MSTYLE_NORMAL;
1523                 updatePreviewBox(panel, 1 << PMITEM);
1524
1525         } else if (self == panel->mstyB[1]) {
1526                 panel->menuStyle = MSTYLE_SINGLE;
1527                 updatePreviewBox(panel, 1 << PMITEM);
1528
1529         } else if (self == panel->mstyB[2]) {
1530                 panel->menuStyle = MSTYLE_FLAT;
1531                 updatePreviewBox(panel, 1 << PMITEM);
1532         }
1533 }
1534
1535 static void titleAlignCallback(WMWidget * self, void *data)
1536 {
1537         _Panel *panel = (_Panel *) data;
1538
1539         if (self == panel->taliB[0]) {
1540                 panel->titleAlignment = WALeft;
1541                 updatePreviewBox(panel, 1 << PFOCUSED | 1 << PUNFOCUSED | 1 << POWNER);
1542
1543         } else if (self == panel->taliB[1]) {
1544                 panel->titleAlignment = WACenter;
1545                 updatePreviewBox(panel, 1 << PFOCUSED | 1 << PUNFOCUSED | 1 << POWNER);
1546
1547         } else if (self == panel->taliB[2]) {
1548                 panel->titleAlignment = WARight;
1549                 updatePreviewBox(panel, 1 << PFOCUSED | 1 << PUNFOCUSED | 1 << POWNER);
1550         }
1551 }
1552
1553 static void createPanel(Panel * p)
1554 {
1555         _Panel *panel = (_Panel *) p;
1556         WMFont *font;
1557         WMScreen *scr = WMWidgetScreen(panel->parent);
1558         WMTabViewItem *item;
1559         int i;
1560         char *tmp;
1561         Bool ok = True;
1562
1563         panel->fprefix = wstrconcat(wusergnusteppath(), "/Library/WindowMaker");
1564
1565         if (access(panel->fprefix, F_OK) != 0) {
1566                 if (mkdir(panel->fprefix, 0755) < 0) {
1567                         werror("%s", panel->fprefix);
1568                         ok = False;
1569                 }
1570         }
1571         if (ok) {
1572                 tmp = wstrconcat(panel->fprefix, "/WPrefs/");
1573                 wfree(panel->fprefix);
1574                 panel->fprefix = tmp;
1575                 if (access(panel->fprefix, F_OK) != 0) {
1576                         if (mkdir(panel->fprefix, 0755) < 0) {
1577                                 werror("%s", panel->fprefix);
1578                         }
1579                 }
1580         }
1581
1582         panel->smallFont = WMSystemFontOfSize(scr, 10);
1583         panel->normalFont = WMSystemFontOfSize(scr, 12);
1584         panel->boldFont = WMBoldSystemFontOfSize(scr, 12);
1585
1586         panel->onLed = WMCreatePixmapFromXPMData(scr, blueled_xpm);
1587         panel->offLed = WMCreatePixmapFromXPMData(scr, blueled2_xpm);
1588         panel->hand = WMCreatePixmapFromXPMData(scr, hand_xpm);
1589
1590         panel->box = WMCreateBox(panel->parent);
1591         WMSetViewExpandsToParent(WMWidgetView(panel->box), 2, 2, 2, 2);
1592
1593         /* preview box */
1594         panel->prevL = WMCreateLabel(panel->box);
1595         WMResizeWidget(panel->prevL, 240, FRAME_HEIGHT - 20);
1596         WMMoveWidget(panel->prevL, 15, 10);
1597         WMSetLabelRelief(panel->prevL, WRSunken);
1598         WMSetLabelImagePosition(panel->prevL, WIPImageOnly);
1599
1600         WMCreateEventHandler(WMWidgetView(panel->prevL), ButtonPressMask, previewClick, panel);
1601
1602         /* tabview */
1603
1604         tabviewDelegate.data = panel;
1605
1606         panel->tabv = WMCreateTabView(panel->box);
1607         WMResizeWidget(panel->tabv, 245, FRAME_HEIGHT - 20);
1608         WMMoveWidget(panel->tabv, 265, 10);
1609         WMSetTabViewDelegate(panel->tabv, &tabviewDelegate);
1610
1611     /*** texture list ***/
1612
1613         panel->texF = WMCreateFrame(panel->box);
1614         WMSetFrameRelief(panel->texF, WRFlat);
1615
1616         item = WMCreateTabViewItemWithIdentifier(0);
1617         WMSetTabViewItemView(item, WMWidgetView(panel->texF));
1618         WMSetTabViewItemLabel(item, _("Texture"));
1619
1620         WMAddItemInTabView(panel->tabv, item);
1621
1622         panel->secP = WMCreatePopUpButton(panel->texF);
1623         WMResizeWidget(panel->secP, 228, 20);
1624         WMMoveWidget(panel->secP, 7, 7);
1625         WMAddPopUpButtonItem(panel->secP, _("Titlebar of Focused Window"));
1626         WMAddPopUpButtonItem(panel->secP, _("Titlebar of Unfocused Windows"));
1627         WMAddPopUpButtonItem(panel->secP, _("Titlebar of Focused Window's Owner"));
1628         WMAddPopUpButtonItem(panel->secP, _("Window Resizebar"));
1629         WMAddPopUpButtonItem(panel->secP, _("Titlebar of Menus"));
1630         WMAddPopUpButtonItem(panel->secP, _("Menu Items"));
1631         WMAddPopUpButtonItem(panel->secP, _("Icon Background"));
1632         /*    WMAddPopUpButtonItem(panel->secP, _("Workspace Backgrounds"));
1633          */
1634         WMSetPopUpButtonSelectedItem(panel->secP, 0);
1635         WMSetPopUpButtonAction(panel->secP, changePage, panel);
1636
1637         panel->texLs = WMCreateList(panel->texF);
1638         WMResizeWidget(panel->texLs, 165, 155);
1639         WMMoveWidget(panel->texLs, 70, 33);
1640         WMSetListUserDrawItemHeight(panel->texLs, 35);
1641         WMSetListUserDrawProc(panel->texLs, paintListItem);
1642         WMHangData(panel->texLs, panel);
1643         WMSetListAction(panel->texLs, textureClick, panel);
1644         WMSetListDoubleAction(panel->texLs, textureDoubleClick, panel);
1645
1646         WMSetBalloonTextForView(_("Double click in the texture you want to use\n"
1647                                   "for the selected item."), WMWidgetView(panel->texLs));
1648
1649         /* command buttons */
1650
1651         font = WMSystemFontOfSize(scr, 10);
1652
1653         panel->newB = WMCreateCommandButton(panel->texF);
1654         WMResizeWidget(panel->newB, 57, 39);
1655         WMMoveWidget(panel->newB, 7, 33);
1656         WMSetButtonFont(panel->newB, font);
1657         WMSetButtonImagePosition(panel->newB, WIPAbove);
1658         WMSetButtonText(panel->newB, _("New"));
1659         WMSetButtonAction(panel->newB, newTexture, panel);
1660         SetButtonAlphaImage(scr, panel->newB, TNEW_FILE, NULL, NULL);
1661
1662         WMSetBalloonTextForView(_("Create a new texture."), WMWidgetView(panel->newB));
1663
1664         panel->ripB = WMCreateCommandButton(panel->texF);
1665         WMResizeWidget(panel->ripB, 57, 39);
1666         WMMoveWidget(panel->ripB, 7, 72);
1667         WMSetButtonFont(panel->ripB, font);
1668         WMSetButtonImagePosition(panel->ripB, WIPAbove);
1669         WMSetButtonText(panel->ripB, _("Extract..."));
1670         WMSetButtonAction(panel->ripB, extractTexture, panel);
1671         SetButtonAlphaImage(scr, panel->ripB, TEXTR_FILE, NULL, NULL);
1672
1673         WMSetBalloonTextForView(_("Extract texture(s) from a theme or a style file."), WMWidgetView(panel->ripB));
1674
1675         WMSetButtonEnabled(panel->ripB, False);
1676
1677         panel->editB = WMCreateCommandButton(panel->texF);
1678         WMResizeWidget(panel->editB, 57, 39);
1679         WMMoveWidget(panel->editB, 7, 111);
1680         WMSetButtonFont(panel->editB, font);
1681         WMSetButtonImagePosition(panel->editB, WIPAbove);
1682         WMSetButtonText(panel->editB, _("Edit"));
1683         SetButtonAlphaImage(scr, panel->editB, TEDIT_FILE, NULL, NULL);
1684         WMSetButtonAction(panel->editB, editTexture, panel);
1685         WMSetBalloonTextForView(_("Edit the highlighted texture."), WMWidgetView(panel->editB));
1686
1687         panel->delB = WMCreateCommandButton(panel->texF);
1688         WMResizeWidget(panel->delB, 57, 38);
1689         WMMoveWidget(panel->delB, 7, 150);
1690         WMSetButtonFont(panel->delB, font);
1691         WMSetButtonImagePosition(panel->delB, WIPAbove);
1692         WMSetButtonText(panel->delB, _("Delete"));
1693         SetButtonAlphaImage(scr, panel->delB, TDEL_FILE, NULL, NULL);
1694         WMSetButtonEnabled(panel->delB, False);
1695         WMSetButtonAction(panel->delB, deleteTexture, panel);
1696         WMSetBalloonTextForView(_("Delete the highlighted texture."), WMWidgetView(panel->delB));
1697
1698         WMReleaseFont(font);
1699
1700         WMMapSubwidgets(panel->texF);
1701
1702     /*** colors ***/
1703         panel->colF = WMCreateFrame(panel->box);
1704         WMSetFrameRelief(panel->colF, WRFlat);
1705
1706         item = WMCreateTabViewItemWithIdentifier(1);
1707         WMSetTabViewItemView(item, WMWidgetView(panel->colF));
1708         WMSetTabViewItemLabel(item, _("Color"));
1709
1710         WMAddItemInTabView(panel->tabv, item);
1711
1712         panel->colP = WMCreatePopUpButton(panel->colF);
1713         WMResizeWidget(panel->colP, 228, 20);
1714         WMMoveWidget(panel->colP, 7, 7);
1715         WMAddPopUpButtonItem(panel->colP, _("Focused Window Title"));
1716         WMAddPopUpButtonItem(panel->colP, _("Unfocused Window Title"));
1717         WMAddPopUpButtonItem(panel->colP, _("Owner of Focused Window Title"));
1718         WMAddPopUpButtonItem(panel->colP, _("Menu Title"));
1719         WMAddPopUpButtonItem(panel->colP, _("Menu Item Text"));
1720         WMAddPopUpButtonItem(panel->colP, _("Disabled Menu Item Text"));
1721         WMAddPopUpButtonItem(panel->colP, _("Menu Highlight Color"));
1722         WMAddPopUpButtonItem(panel->colP, _("Highlighted Menu Text Color"));
1723         /*
1724            WMAddPopUpButtonItem(panel->colP, _("Miniwindow Title"));
1725            WMAddPopUpButtonItem(panel->colP, _("Miniwindow Title Back"));
1726            WMAddPopUpButtonItem(panel->colP, _("Clip Title"));
1727            WMAddPopUpButtonItem(panel->colP, _("Collapsed Clip Title"));
1728          */
1729
1730         WMSetPopUpButtonSelectedItem(panel->colP, 0);
1731
1732         WMSetPopUpButtonAction(panel->colP, changeColorPage, panel);
1733
1734         panel->colW = WMCreateColorWell(panel->colF);
1735         WMResizeWidget(panel->colW, 65, 50);
1736         WMMoveWidget(panel->colW, 30, 75);
1737         WMAddNotificationObserver(colorWellObserver, panel, WMColorWellDidChangeNotification, panel->colW);
1738
1739         for (i = 0; i < 4; i++) {
1740                 int j;
1741                 for (j = 0; j < 6; j++) {
1742                         panel->sampW[i + j * 4] = WMCreateColorWell(panel->colF);
1743                         WMResizeWidget(panel->sampW[i + j * 4], 22, 22);
1744                         WMMoveWidget(panel->sampW[i + j * 4], 130 + i * 22, 40 + j * 22);
1745                         WSetColorWellBordered(panel->sampW[i + j * 4], False);
1746                 }
1747         }
1748
1749         WMMapSubwidgets(panel->colF);
1750
1751 #ifdef unfinished
1752     /*** root bg ***/
1753
1754         panel->bgF = WMCreateFrame(panel->box);
1755         WMSetFrameRelief(panel->bgF, WRFlat);
1756
1757         item = WMCreateTabViewItemWithIdentifier(2);
1758         WMSetTabViewItemView(item, WMWidgetView(panel->bgF));
1759         WMSetTabViewItemLabel(item, _("Background"));
1760
1761         WMAddItemInTabView(panel->tabv, item);
1762
1763         panel->bgprevL = WMCreateLabel(panel->bgF);
1764         WMResizeWidget(panel->bgprevL, 230, 155);
1765         WMMoveWidget(panel->bgprevL, 5, 5);
1766         WMSetLabelRelief(panel->bgprevL, WRSunken);
1767
1768         panel->selbgB = WMCreateCommandButton(panel->bgF);
1769         WMMoveWidget(panel->selbgB, 5, 165);
1770         WMResizeWidget(panel->selbgB, 100, 24);
1771         WMSetButtonText(panel->selbgB, _("Browse..."));
1772
1773         WMMapSubwidgets(panel->bgF);
1774 #endif                          /* unfinished */
1775     /*** options ***/
1776         panel->optF = WMCreateFrame(panel->box);
1777         WMSetFrameRelief(panel->optF, WRFlat);
1778
1779         item = WMCreateTabViewItemWithIdentifier(3);
1780         WMSetTabViewItemView(item, WMWidgetView(panel->optF));
1781         WMSetTabViewItemLabel(item, _("Options"));
1782
1783         WMAddItemInTabView(panel->tabv, item);
1784
1785         panel->mstyF = WMCreateFrame(panel->optF);
1786         WMResizeWidget(panel->mstyF, 215, 85);
1787         WMMoveWidget(panel->mstyF, 15, 10);
1788         WMSetFrameTitle(panel->mstyF, _("Menu Style"));
1789
1790         for (i = 0; i < 3; i++) {
1791                 WMPixmap *icon;
1792                 char *path;
1793
1794                 panel->mstyB[i] = WMCreateButton(panel->mstyF, WBTOnOff);
1795                 WMResizeWidget(panel->mstyB[i], 54, 54);
1796                 WMMoveWidget(panel->mstyB[i], 15 + i * 65, 20);
1797                 WMSetButtonImagePosition(panel->mstyB[i], WIPImageOnly);
1798                 WMSetButtonAction(panel->mstyB[i], menuStyleCallback, panel);
1799                 switch (i) {
1800                 case 0:
1801                         path = LocateImage(MSTYLE1_FILE);
1802                         break;
1803                 case 1:
1804                         path = LocateImage(MSTYLE2_FILE);
1805                         break;
1806                 case 2:
1807                         path = LocateImage(MSTYLE3_FILE);
1808                         break;
1809                 }
1810                 if (path) {
1811                         icon = WMCreatePixmapFromFile(scr, path);
1812                         if (icon) {
1813                                 WMSetButtonImage(panel->mstyB[i], icon);
1814                                 WMReleasePixmap(icon);
1815                         } else {
1816                                 wwarning(_("could not load icon file %s"), path);
1817                         }
1818                         wfree(path);
1819                 }
1820         }
1821         WMGroupButtons(panel->mstyB[0], panel->mstyB[1]);
1822         WMGroupButtons(panel->mstyB[0], panel->mstyB[2]);
1823
1824         WMMapSubwidgets(panel->mstyF);
1825
1826         panel->taliF = WMCreateFrame(panel->optF);
1827         WMResizeWidget(panel->taliF, 110, 80);
1828         WMMoveWidget(panel->taliF, 15, 100);
1829         WMSetFrameTitle(panel->taliF, _("Title Alignment"));
1830
1831         for (i = 0; i < 3; i++) {
1832                 panel->taliB[i] = WMCreateRadioButton(panel->taliF);
1833                 WMSetButtonAction(panel->taliB[i], titleAlignCallback, panel);
1834                 switch (i) {
1835                 case 0:
1836                         WMSetButtonText(panel->taliB[i], _("Left"));
1837                         break;
1838                 case 1:
1839                         WMSetButtonText(panel->taliB[i], _("Center"));
1840                         break;
1841                 case 2:
1842                         WMSetButtonText(panel->taliB[i], _("Right"));
1843                         break;
1844                 }
1845                 WMResizeWidget(panel->taliB[i], 90, 18);
1846                 WMMoveWidget(panel->taliB[i], 10, 15 + 20 * i);
1847         }
1848         WMGroupButtons(panel->taliB[0], panel->taliB[1]);
1849         WMGroupButtons(panel->taliB[0], panel->taliB[2]);
1850
1851         WMMapSubwidgets(panel->taliF);
1852
1853         WMMapSubwidgets(panel->optF);
1854
1855          /**/ WMRealizeWidget(panel->box);
1856         WMMapSubwidgets(panel->box);
1857
1858         WMSetPopUpButtonSelectedItem(panel->secP, 0);
1859
1860         showData(panel);
1861
1862         changePage(panel->secP, panel);
1863
1864         fillTextureList(panel->texLs);
1865
1866         fillColorList(panel);
1867
1868         panel->texturePanel = CreateTexturePanel(panel->parent);
1869 }
1870
1871 static void setupTextureFor(WMList * list, char *key, char *defValue, char *title, int index)
1872 {
1873         WMListItem *item;
1874         TextureListItem *titem;
1875
1876         titem = wmalloc(sizeof(TextureListItem));
1877
1878         titem->title = wstrdup(title);
1879         titem->prop = GetObjectForKey(key);
1880         if (!titem->prop || !WMIsPLArray(titem->prop)) {
1881                 /* Maybe also give a error message to stderr that the entry is bad? */
1882                 titem->prop = WMCreatePropListFromDescription(defValue);
1883         } else {
1884                 WMRetainPropList(titem->prop);
1885         }
1886         titem->texture = WMGetPropListDescription((WMPropList *) titem->prop, False);
1887         titem->current = 1;
1888         titem->selectedFor = 1 << index;
1889
1890         titem->ispixmap = isPixmap(titem->prop);
1891
1892         titem->preview = renderTexture(WMWidgetScreen(list), titem->prop, TEXPREV_WIDTH, TEXPREV_HEIGHT, NULL, 0);
1893
1894         item = WMAddListItem(list, "");
1895         item->clientData = titem;
1896 }
1897
1898 static void showData(_Panel * panel)
1899 {
1900         int i;
1901         char *str;
1902
1903         str = GetStringForKey("MenuStyle");
1904         if (str && strcasecmp(str, "flat") == 0) {
1905                 panel->menuStyle = MSTYLE_FLAT;
1906         } else if (str && strcasecmp(str, "singletexture") == 0) {
1907                 panel->menuStyle = MSTYLE_SINGLE;
1908         } else {
1909                 panel->menuStyle = MSTYLE_NORMAL;
1910         }
1911
1912         str = GetStringForKey("TitleJustify");
1913         if (str && strcasecmp(str, "left") == 0) {
1914                 panel->titleAlignment = WALeft;
1915         } else if (str && strcasecmp(str, "right") == 0) {
1916                 panel->titleAlignment = WARight;
1917         } else {
1918                 panel->titleAlignment = WACenter;
1919         }
1920
1921         for (i = 0; i < sizeof(colorOptions) / (2 * sizeof(char *)); i++) {
1922                 WMColor *color;
1923
1924                 str = GetStringForKey(colorOptions[i * 2]);
1925                 if (!str)
1926                         str = colorOptions[i * 2 + 1];
1927
1928                 if (!(color = WMCreateNamedColor(WMWidgetScreen(panel->box), str, False))) {
1929                         color = WMCreateNamedColor(WMWidgetScreen(panel->box), "#000000", False);
1930                 }
1931
1932                 panel->colors[i] = color;
1933         }
1934         changeColorPage(panel->colP, panel);
1935
1936         for (i = 0; i < sizeof(textureOptions) / (3 * sizeof(char *)); i++) {
1937                 setupTextureFor(panel->texLs, textureOptions[i * 3],
1938                                 textureOptions[i * 3 + 1], textureOptions[i * 3 + 2], i);
1939                 panel->textureIndex[i] = i;
1940         }
1941         updatePreviewBox(panel, EVERYTHING);
1942
1943         WMSetButtonSelected(panel->mstyB[panel->menuStyle], True);
1944         WMSetButtonSelected(panel->taliB[panel->titleAlignment], True);
1945 }
1946
1947 static void storeData(_Panel * panel)
1948 {
1949         TextureListItem *titem;
1950         WMListItem *item;
1951         int i;
1952
1953         for (i = 0; i < sizeof(textureOptions) / (sizeof(char *) * 3); i++) {
1954                 item = WMGetListItem(panel->texLs, panel->textureIndex[i]);
1955                 titem = (TextureListItem *) item->clientData;
1956                 SetObjectForKey(titem->prop, textureOptions[i * 3]);
1957         }
1958
1959         for (i = 0; i < 8; i++) {
1960                 char *str;
1961
1962                 str = WMGetColorRGBDescription(panel->colors[i]);
1963
1964                 if (str) {
1965                         SetStringForKey(str, colorOptions[i * 2]);
1966                         wfree(str);
1967                 }
1968         }
1969
1970         switch (panel->menuStyle) {
1971         case MSTYLE_SINGLE:
1972                 SetStringForKey("singletexture", "MenuStyle");
1973                 break;
1974         case MSTYLE_FLAT:
1975                 SetStringForKey("flat", "MenuStyle");
1976                 break;
1977         default:
1978         case MSTYLE_NORMAL:
1979                 SetStringForKey("normal", "MenuStyle");
1980                 break;
1981         }
1982         switch (panel->titleAlignment) {
1983         case WALeft:
1984                 SetStringForKey("left", "TitleJustify");
1985                 break;
1986         case WARight:
1987                 SetStringForKey("right", "TitleJustify");
1988                 break;
1989         default:
1990         case WACenter:
1991                 SetStringForKey("center", "TitleJustify");
1992                 break;
1993         }
1994 }
1995
1996 static void prepareForClose(_Panel * panel)
1997 {
1998         WMPropList *textureList;
1999         WMPropList *texture;
2000         TextureListItem *titem;
2001         WMListItem *item;
2002         WMUserDefaults *udb = WMGetStandardUserDefaults();
2003         int i;
2004
2005         textureList = WMCreatePLArray(NULL, NULL);
2006
2007         /* store list of textures */
2008         for (i = 7; i < WMGetListNumberOfRows(panel->texLs); i++) {
2009                 item = WMGetListItem(panel->texLs, i);
2010                 titem = (TextureListItem *) item->clientData;
2011
2012                 texture = WMCreatePLArray(WMCreatePLString(titem->title),
2013                                           WMRetainPropList(titem->prop), WMCreatePLString(titem->path), NULL);
2014
2015                 WMAddToPLArray(textureList, texture);
2016         }
2017
2018         WMSetUDObjectForKey(udb, textureList, "TextureList");
2019         WMReleasePropList(textureList);
2020
2021         /* store list of colors */
2022         textureList = WMCreatePLArray(NULL, NULL);
2023         for (i = 0; i < 24; i++) {
2024                 WMColor *color;
2025                 char *str;
2026
2027                 color = WMGetColorWellColor(panel->sampW[i]);
2028
2029                 str = WMGetColorRGBDescription(color);
2030                 WMAddToPLArray(textureList, WMCreatePLString(str));
2031                 wfree(str);
2032         }
2033         WMSetUDObjectForKey(udb, textureList, "ColorList");
2034         WMReleasePropList(textureList);
2035
2036         WMSynchronizeUserDefaults(udb);
2037 }
2038
2039 Panel *InitAppearance(WMScreen * scr, WMWindow * win)
2040 {
2041         _Panel *panel;
2042
2043         panel = wmalloc(sizeof(_Panel));
2044
2045         panel->sectionName = _("Appearance Preferences");
2046
2047         panel->description = _("Background texture configuration for windows,\n" "menus and icons.");
2048
2049         panel->parent = win;
2050
2051         panel->callbacks.createWidgets = createPanel;
2052         panel->callbacks.updateDomain = storeData;
2053         panel->callbacks.prepareForClose = prepareForClose;
2054
2055         AddSection(panel, ICON_FILE);
2056
2057         return panel;
2058 }
2059
2060 /****************************************************************************/
2061
2062 typedef struct ExtractPanel {
2063         WMWindow *win;
2064
2065         WMLabel *label;
2066         WMList *list;
2067
2068         WMButton *closeB;
2069         WMButton *extrB;
2070 } ExtractPanel;
2071
2072 static void OpenExtractPanelFor(_Panel * panel, char *path)
2073 {
2074         ExtractPanel *epanel;
2075         WMColor *color;
2076         WMFont *font;
2077         WMScreen *scr = WMWidgetScreen(panel->parent);
2078
2079         epanel = wmalloc(sizeof(ExtractPanel));
2080         epanel->win = WMCreatePanelWithStyleForWindow(panel->parent, "extract",
2081                                                       WMTitledWindowMask | WMClosableWindowMask);
2082         WMResizeWidget(epanel->win, 245, 250);
2083         WMSetWindowTitle(epanel->win, _("Extract Texture"));
2084
2085         epanel->label = WMCreateLabel(epanel->win);
2086         WMResizeWidget(epanel->label, 225, 18);
2087         WMMoveWidget(epanel->label, 10, 10);
2088         WMSetLabelTextAlignment(epanel->label, WACenter);
2089         WMSetLabelRelief(epanel->label, WRSunken);
2090
2091         color = WMDarkGrayColor(scr);
2092         WMSetWidgetBackgroundColor(epanel->label, color);
2093         WMReleaseColor(color);
2094
2095         color = WMWhiteColor(scr);
2096         WMSetLabelTextColor(epanel->label, color);
2097         WMReleaseColor(color);
2098
2099         font = WMBoldSystemFontOfSize(scr, 12);
2100         WMSetLabelFont(epanel->label, font);
2101         WMReleaseFont(font);
2102
2103         WMSetLabelText(epanel->label, _("Textures"));
2104
2105         epanel->list = WMCreateList(epanel->win);
2106         WMResizeWidget(epanel->list, 225, 165);
2107         WMMoveWidget(epanel->list, 10, 30);
2108
2109         epanel->closeB = WMCreateCommandButton(epanel->win);
2110         WMResizeWidget(epanel->closeB, 74, 24);
2111         WMMoveWidget(epanel->closeB, 165, 215);
2112         WMSetButtonText(epanel->closeB, _("Close"));
2113
2114         epanel->extrB = WMCreateCommandButton(epanel->win);
2115         WMResizeWidget(epanel->extrB, 74, 24);
2116         WMMoveWidget(epanel->extrB, 80, 215);
2117         WMSetButtonText(epanel->extrB, _("Extract"));
2118
2119         WMMapSubwidgets(epanel->win);
2120
2121         /* take textures from file */
2122
2123         WMRealizeWidget(epanel->win);
2124
2125         WMMapWidget(epanel->win);
2126 }