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, const 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, const 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(const 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, const 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(const 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         /* Parameter not used, but tell the compiler that it is ok */
 975         (void) w;
 976
 977         item = WMGetListItem(panel->texLs, WMGetListSelectedItemRow(panel->texLs));
 978         titem = (TextureListItem *) item->clientData;
 979
 980         SetTexturePanelPixmapPath(panel->texturePanel, GetObjectForKey("PixmapPath"));
 981
 982         SetTexturePanelTexture(panel->texturePanel, titem->title, titem->prop);
 983
 984         SetTexturePanelCancelAction(panel->texturePanel, cancelNewTexture, panel);
 985         SetTexturePanelOkAction(panel->texturePanel, okEditTexture, panel);
 986
 987         ShowTexturePanel(panel->texturePanel);
 988 }
 989
 990 static void newTexture(WMWidget * w, void *data)
 991 {
 992         _Panel *panel = (_Panel *) data;
 993
 994         /* Parameter not used, but tell the compiler that it is ok */
 995         (void) w;
 996
 997         SetTexturePanelPixmapPath(panel->texturePanel, GetObjectForKey("PixmapPath"));
 998
 999         SetTexturePanelTexture(panel->texturePanel, "New Texture", NULL);
1000
1001         SetTexturePanelCancelAction(panel->texturePanel, cancelNewTexture, panel);
1002
1003         SetTexturePanelOkAction(panel->texturePanel, okNewTexture, panel);
1004
1005         ShowTexturePanel(panel->texturePanel);
1006 }
1007
1008 static void deleteTexture(WMWidget * w, void *data)
1009 {
1010         _Panel *panel = (_Panel *) data;
1011         WMListItem *item;
1012         TextureListItem *titem;
1013         int row;
1014         int section;
1015
1016         /* Parameter not used, but tell the compiler that it is ok */
1017         (void) w;
1018
1019         section = WMGetPopUpButtonSelectedItem(panel->secP);
1020         row = WMGetListSelectedItemRow(panel->texLs);
1021         item = WMGetListItem(panel->texLs, row);
1022         titem = (TextureListItem *) item->clientData;
1023
1024         if (titem->selectedFor & (1 << section)) {
1025                 TextureListItem *titem2;
1026
1027                 panel->textureIndex[section] = section;
1028                 item = WMGetListItem(panel->texLs, section);
1029                 titem2 = (TextureListItem *) item->clientData;
1030                 titem2->selectedFor |= 1 << section;
1031         }
1032
1033         wfree(titem->title);
1034         wfree(titem->texture);
1035         WMReleasePropList(titem->prop);
1036         if (titem->path) {
1037                 if (remove(titem->path) < 0 && errno != ENOENT) {
1038                         werror("could not remove file %s", titem->path);
1039                 }
1040                 wfree(titem->path);
1041         }
1042
1043         wfree(titem);
1044
1045         WMRemoveListItem(panel->texLs, row);
1046         WMSetButtonEnabled(panel->delB, False);
1047 }
1048
1049 static void extractTexture(WMWidget * w, void *data)
1050 {
1051         _Panel *panel = (_Panel *) data;
1052         char *path;
1053         WMOpenPanel *opanel;
1054         WMScreen *scr = WMWidgetScreen(w);
1055
1056         opanel = WMGetOpenPanel(scr);
1057         WMSetFilePanelCanChooseDirectories(opanel, False);
1058         WMSetFilePanelCanChooseFiles(opanel, True);
1059
1060         if (WMRunModalFilePanelForDirectory(opanel, panel->parent, wgethomedir(), _("Select File"), NULL)) {
1061                 path = WMGetFilePanelFileName(opanel);
1062
1063                 OpenExtractPanelFor(panel, path);
1064
1065                 wfree(path);
1066         }
1067 }
1068
1069 static void changePage(WMWidget * w, void *data)
1070 {
1071         _Panel *panel = (_Panel *) data;
1072         int section;
1073         WMScreen *scr = WMWidgetScreen(panel->box);
1074         RContext *rc = WMScreenRContext(scr);
1075         static WMPoint positions[] = {
1076                 {5, 10},
1077                 {5, 40},
1078                 {5, 70},
1079                 {5, 100},
1080                 {5, 120},
1081                 {5, 160},
1082                 {130, 150}
1083         };
1084
1085         if (w) {
1086                 section = WMGetPopUpButtonSelectedItem(panel->secP);
1087
1088                 WMSelectListItem(panel->texLs, panel->textureIndex[section]);
1089
1090                 WMSetListPosition(panel->texLs, panel->textureIndex[section] - 2);
1091         }
1092         {
1093                 WMColor *color;
1094
1095                 color = WMCreateRGBColor(scr, 0x5100, 0x5100, 0x7100, True);
1096                 XFillRectangle(rc->dpy, panel->preview, WMColorGC(color),
1097                                positions[panel->oldsection].x, positions[panel->oldsection].y, 22, 22);
1098                 WMReleaseColor(color);
1099         }
1100         if (w) {
1101                 panel->oldsection = section;
1102                 WMDrawPixmap(panel->hand, panel->preview, positions[section].x, positions[section].y);
1103         }
1104         WMRedisplayWidget(panel->prevL);
1105 }
1106
1107 static void previewClick(XEvent * event, void *clientData)
1108 {
1109         _Panel *panel = (_Panel *) clientData;
1110         int i;
1111
1112         switch (panel->oldTabItem) {
1113         case 0:
1114                 for (i = 0; i < sizeof(previewPositions) / sizeof(previewPositions[0]); i++) {
1115                         if (event->xbutton.x >= previewPositions[i].pos.x
1116                             && event->xbutton.y >= previewPositions[i].pos.y
1117                             && event->xbutton.x < previewPositions[i].pos.x
1118                             + previewPositions[i].size.width
1119                             && event->xbutton.y < previewPositions[i].pos.y + previewPositions[i].size.height) {
1120
1121                                 WMSetPopUpButtonSelectedItem(panel->secP, i);
1122                                 changePage(panel->secP, panel);
1123                                 return;
1124                         }
1125                 }
1126                 break;
1127         case 1:
1128                 for (i = 0; i < WMGetPopUpButtonNumberOfItems(panel->colP); i++) {
1129                         if (event->xbutton.x >= previewColorPositions[i].pos.x
1130                             && event->xbutton.y >= previewColorPositions[i].pos.y
1131                             && event->xbutton.x < previewColorPositions[i].pos.x
1132                             + previewColorPositions[i].size.width
1133                             && event->xbutton.y < previewColorPositions[i].pos.y
1134                             + previewColorPositions[i].size.height) {
1135
1136                                 /* yuck kluge */
1137                                 if (i == 7)
1138                                         i = 4;
1139
1140                                 WMSetPopUpButtonSelectedItem(panel->colP, i);
1141                                 changeColorPage(panel->colP, panel);
1142                                 return;
1143                         }
1144                 }
1145                 break;
1146         }
1147 }
1148
1149 static void textureClick(WMWidget * w, void *data)
1150 {
1151         _Panel *panel = (_Panel *) data;
1152         int i;
1153         WMListItem *item;
1154         TextureListItem *titem;
1155
1156         /* Parameter not used, but tell the compiler that it is ok */
1157         (void) w;
1158
1159         i = WMGetListSelectedItemRow(panel->texLs);
1160
1161         item = WMGetListItem(panel->texLs, i);
1162
1163         titem = (TextureListItem *) item->clientData;
1164
1165         if (titem->current) {
1166                 WMSetButtonEnabled(panel->delB, False);
1167         } else {
1168                 WMSetButtonEnabled(panel->delB, True);
1169         }
1170 }
1171
1172 static void textureDoubleClick(WMWidget * w, void *data)
1173 {
1174         _Panel *panel = (_Panel *) data;
1175         int i, section;
1176         WMListItem *item;
1177         TextureListItem *titem;
1178
1179         /* Parameter not used, but tell the compiler that it is ok */
1180         (void) w;
1181
1182         /* unselect old texture */
1183         section = WMGetPopUpButtonSelectedItem(panel->secP);
1184
1185         item = WMGetListItem(panel->texLs, panel->textureIndex[section]);
1186         titem = (TextureListItem *) item->clientData;
1187         titem->selectedFor &= ~(1 << section);
1188
1189         /* select new texture */
1190         i = WMGetListSelectedItemRow(panel->texLs);
1191
1192         item = WMGetListItem(panel->texLs, i);
1193
1194         titem = (TextureListItem *) item->clientData;
1195
1196         titem->selectedFor |= 1 << section;
1197
1198         panel->textureIndex[section] = i;
1199
1200         WMRedisplayWidget(panel->texLs);
1201
1202         updatePreviewBox(panel, 1 << section);
1203 }
1204
1205 static void paintListItem(WMList * lPtr, int index, Drawable d, char *text, int state, WMRect * rect)
1206 {
1207         _Panel *panel = (_Panel *) WMGetHangedData(lPtr);
1208         WMScreen *scr = WMWidgetScreen(lPtr);
1209         int width, height, x, y;
1210         Display *dpy = WMScreenDisplay(scr);
1211         WMColor *back = (state & WLDSSelected) ? WMWhiteColor(scr) : WMGrayColor(scr);
1212         WMListItem *item;
1213         WMColor *black = WMBlackColor(scr);
1214         TextureListItem *titem;
1215
1216         item = WMGetListItem(lPtr, index);
1217         titem = (TextureListItem *) item->clientData;
1218         if (!titem) {
1219                 WMReleaseColor(back);
1220                 WMReleaseColor(black);
1221                 return;
1222         }
1223
1224         width = rect->size.width;
1225         height = rect->size.height;
1226         x = rect->pos.x;
1227         y = rect->pos.y;
1228
1229         XFillRectangle(dpy, d, WMColorGC(back), x, y, width, height);
1230
1231         if (titem->preview)
1232                 XCopyArea(dpy, titem->preview, d, WMColorGC(black), 0, 0,
1233                           TEXPREV_WIDTH, TEXPREV_HEIGHT, x + 5, y + 5);
1234
1235         if ((1 << WMGetPopUpButtonSelectedItem(panel->secP)) & titem->selectedFor)
1236                 WMDrawPixmap(panel->onLed, d, x + TEXPREV_WIDTH + 10, y + 6);
1237         else if (titem->selectedFor)
1238                 WMDrawPixmap(panel->offLed, d, x + TEXPREV_WIDTH + 10, y + 6);
1239
1240         WMDrawString(scr, d, black, panel->boldFont,
1241                      x + TEXPREV_WIDTH + 22, y + 2, titem->title, strlen(titem->title));
1242
1243         WMDrawString(scr, d, black, panel->smallFont,
1244                      x + TEXPREV_WIDTH + 14, y + 18, titem->texture, strlen(titem->texture));
1245
1246         WMReleaseColor(back);
1247         WMReleaseColor(black);
1248 }
1249
1250 static Pixmap loadRImage(WMScreen * scr, const char *path)
1251 {
1252         FILE *f;
1253         RImage *image;
1254         int w, h, d;
1255         Pixmap pixmap;
1256
1257         f = fopen(path, "rb");
1258         if (!f)
1259                 return None;
1260
1261         fscanf(f, "%02x%02x%1x", &w, &h, &d);
1262
1263         image = RCreateImage(w, h, d == 4);
1264         fread(image->data, 1, w * h * d, f);
1265         fclose(f);
1266
1267         RConvertImage(WMScreenRContext(scr), image, &pixmap);
1268         RReleaseImage(image);
1269
1270         return pixmap;
1271 }
1272
1273 static void fillTextureList(WMList * lPtr)
1274 {
1275         WMPropList *textureList;
1276         WMPropList *texture;
1277         WMUserDefaults *udb = WMGetStandardUserDefaults();
1278         TextureListItem *titem;
1279         WMScreen *scr = WMWidgetScreen(lPtr);
1280         int i;
1281
1282         textureList = WMGetUDObjectForKey(udb, "TextureList");
1283         if (!textureList)
1284                 return;
1285
1286         for (i = 0; i < WMGetPropListItemCount(textureList); i++) {
1287                 WMListItem *item;
1288
1289                 texture = WMGetFromPLArray(textureList, i);
1290
1291                 titem = wmalloc(sizeof(TextureListItem));
1292
1293                 titem->title = wstrdup(WMGetFromPLString(WMGetFromPLArray(texture, 0)));
1294                 titem->prop = WMRetainPropList(WMGetFromPLArray(texture, 1));
1295                 titem->texture = WMGetPropListDescription(titem->prop, False);
1296                 titem->selectedFor = 0;
1297                 titem->path = wstrdup(WMGetFromPLString(WMGetFromPLArray(texture, 2)));
1298
1299                 titem->preview = loadRImage(scr, titem->path);
1300                 if (!titem->preview) {
1301                         titem->preview = renderTexture(scr, titem->prop, TEXPREV_WIDTH, TEXPREV_HEIGHT, NULL, 0);
1302                 }
1303                 item = WMAddListItem(lPtr, "");
1304                 item->clientData = titem;
1305         }
1306 }
1307
1308 static void fillColorList(_Panel * panel)
1309 {
1310         WMColor *color;
1311         WMPropList *list;
1312         WMUserDefaults *udb = WMGetStandardUserDefaults();
1313         WMScreen *scr = WMWidgetScreen(panel->box);
1314         int i;
1315
1316         list = WMGetUDObjectForKey(udb, "ColorList");
1317         if (!list) {
1318                 for (i = 0; i < 24; i++) {
1319                         color = WMCreateNamedColor(scr, sampleColors[i], False);
1320                         if (!color)
1321                                 continue;
1322                         WMSetColorWellColor(panel->sampW[i], color);
1323                         WMReleaseColor(color);
1324                 }
1325         } else {
1326                 WMPropList *c;
1327
1328                 for (i = 0; i < WMIN(24, WMGetPropListItemCount(list)); i++) {
1329                         c = WMGetFromPLArray(list, i);
1330                         if (!c || !WMIsPLString(c))
1331                                 continue;
1332                         color = WMCreateNamedColor(scr, WMGetFromPLString(c), False);
1333                         if (!color)
1334                                 continue;
1335                         WMSetColorWellColor(panel->sampW[i], color);
1336                         WMReleaseColor(color);
1337                 }
1338         }
1339 }
1340
1341 /*************************************************************************/
1342
1343 static void changeColorPage(WMWidget * w, void *data)
1344 {
1345         _Panel *panel = (_Panel *) data;
1346         int section;
1347         WMScreen *scr = WMWidgetScreen(panel->box);
1348         RContext *rc = WMScreenRContext(scr);
1349         static WMPoint positions[] = {
1350                 {5, 10},
1351                 {5, 40},
1352                 {5, 70},
1353                 {5, 120},
1354                 {5, 140},
1355                 {5, 160},
1356                 {5, 180},
1357                 {5, 180},
1358                 {130, 140},
1359                 {130, 140},
1360                 {130, 140},
1361                 {130, 140}
1362         };
1363
1364         if (panel->preview) {
1365                 WMColor *color;
1366
1367                 color = WMCreateRGBColor(scr, 0x5100, 0x5100, 0x7100, True);
1368                 XFillRectangle(rc->dpy, panel->preview, WMColorGC(color),
1369                                positions[panel->oldcsection].x, positions[panel->oldcsection].y, 22, 22);
1370                 WMReleaseColor(color);
1371         }
1372         if (w) {
1373                 section = WMGetPopUpButtonSelectedItem(panel->colP);
1374
1375                 panel->oldcsection = section;
1376                 if (panel->preview)
1377                         WMDrawPixmap(panel->hand, panel->preview, positions[section].x, positions[section].y);
1378
1379                 section = WMGetPopUpButtonSelectedItem(panel->colP);
1380
1381                 WMSetColorWellColor(panel->colW, panel->colors[section]);
1382         }
1383         WMRedisplayWidget(panel->prevL);
1384 }
1385
1386 static void
1387 paintText(WMScreen * scr, Drawable d, WMColor * color, WMFont * font,
1388           int x, int y, int w, int h, WMAlignment align, char *text)
1389 {
1390         int l = strlen(text);
1391
1392         switch (align) {
1393         case WALeft:
1394                 x += 5;
1395                 break;
1396         case WARight:
1397                 x += w - 5 - WMWidthOfString(font, text, l);
1398                 break;
1399         default:
1400         case WACenter:
1401                 x += (w - WMWidthOfString(font, text, l)) / 2;
1402                 break;
1403         }
1404         WMDrawString(scr, d, color, font, x, y + (h - WMFontHeight(font)) / 2, text, l);
1405 }
1406
1407 static void updateColorPreviewBox(_Panel * panel, int elements)
1408 {
1409         WMScreen *scr = WMWidgetScreen(panel->box);
1410         Display *dpy = WMScreenDisplay(scr);
1411         Pixmap d, pnot;
1412         GC gc;
1413
1414         d = panel->preview;
1415         pnot = panel->previewNoText;
1416         gc = WMColorGC(panel->colors[0]);
1417
1418         if (elements & FTITLE_COL) {
1419                 XCopyArea(dpy, pnot, d, gc, 30, 10, 190, 20, 30, 10);
1420                 paintText(scr, d, panel->colors[0], panel->boldFont, 30, 10, 190, 20,
1421                           panel->titleAlignment, _("Focused Window"));
1422         }
1423         if (elements & UTITLE_COL) {
1424                 XCopyArea(dpy, pnot, d, gc, 30, 40, 190, 20, 30, 40);
1425                 paintText(scr, d, panel->colors[1], panel->boldFont, 30, 40, 190, 20,
1426                           panel->titleAlignment, _("Unfocused Window"));
1427         }
1428         if (elements & OTITLE_COL) {
1429                 XCopyArea(dpy, pnot, d, gc, 30, 70, 190, 20, 30, 70);
1430                 paintText(scr, d, panel->colors[2], panel->boldFont, 30, 70, 190, 20,
1431                           panel->titleAlignment, _("Owner of Focused Window"));
1432         }
1433         if (elements & MTITLE_COL) {
1434                 XCopyArea(dpy, pnot, d, gc, 30, 120, 90, 20, 30, 120);
1435                 paintText(scr, d, panel->colors[3], panel->boldFont, 30, 120, 90, 20, WALeft, _("Menu Title"));
1436         }
1437         if (elements & MITEM_COL) {
1438                 XCopyArea(dpy, pnot, d, gc, 30, 140, 90, 20, 30, 140);
1439                 paintText(scr, d, panel->colors[4], panel->normalFont, 30, 140, 90, 20, WALeft, _("Normal Item"));
1440                 XCopyArea(dpy, pnot, d, gc, 30, 200, 90, 20, 30, 200);
1441                 paintText(scr, d, panel->colors[4], panel->normalFont, 30, 200, 90, 20, WALeft, _("Normal Item"));
1442         }
1443         if (elements & MDISAB_COL) {
1444                 XCopyArea(dpy, pnot, d, gc, 30, 160, 90, 20, 30, 160);
1445                 paintText(scr, d, panel->colors[5], panel->normalFont, 30, 160, 90, 20,
1446                           WALeft, _("Disabled Item"));
1447         }
1448         if (elements & MHIGH_COL) {
1449                 XFillRectangle(WMScreenDisplay(scr), d, WMColorGC(panel->colors[6]), 31, 181, 87, 17);
1450                 XFillRectangle(WMScreenDisplay(scr), pnot, WMColorGC(panel->colors[6]), 31, 181, 87, 17);
1451                 elements |= MHIGHT_COL;
1452         }
1453         if (elements & MHIGHT_COL) {
1454                 XCopyArea(dpy, pnot, d, gc, 30, 180, 90, 20, 30, 180);
1455                 paintText(scr, d, panel->colors[7], panel->normalFont, 30, 180, 90, 20, WALeft, _("Highlighted"));
1456         }
1457         /*
1458            if (elements & ICONT_COL) {
1459            WRITE(_("Focused Window"), panel->colors[8], panel->boldFont,
1460            155, 130, 64);
1461            }
1462            if (elements & ICONB_COL) {
1463            WRITE(_("Focused Window"), panel->colors[9], panel->boldFont,
1464            0, 0, 30);
1465            }
1466            if (elements & CLIP_COL) {
1467            WRITE(_("Focused Window"), panel->colors[10], panel->boldFont,
1468            0, 0, 30);
1469            }
1470            if (elements & CCLIP_COL) {
1471            WRITE(_("Focused Window"), panel->colors[11], panel->boldFont,
1472            0, 0, 30);
1473            }
1474          */
1475         WMRedisplayWidget(panel->prevL);
1476 }
1477
1478 static void colorWellObserver(void *self, WMNotification * n)
1479 {
1480         _Panel *panel = (_Panel *) self;
1481         int p;
1482
1483         /* Parameter not used, but tell the compiler that it is ok */
1484         (void) n;
1485
1486         p = WMGetPopUpButtonSelectedItem(panel->colP);
1487
1488         WMReleaseColor(panel->colors[p]);
1489
1490         panel->colors[p] = WMRetainColor(WMGetColorWellColor(panel->colW));
1491
1492         updateColorPreviewBox(panel, 1 << p);
1493 }
1494
1495 static void changedTabItem(struct WMTabViewDelegate *self, WMTabView * tabView, WMTabViewItem * item)
1496 {
1497         _Panel *panel = self->data;
1498         int i;
1499
1500         i = WMGetTabViewItemIdentifier(item);
1501         switch (i) {
1502         case 0:
1503                 switch (panel->oldTabItem) {
1504                 case 1:
1505                         changeColorPage(NULL, panel);
1506                         break;
1507                 }
1508                 changePage(panel->secP, panel);
1509                 break;
1510         case 1:
1511                 switch (panel->oldTabItem) {
1512                 case 0:
1513                         changePage(NULL, panel);
1514                         break;
1515                 }
1516                 changeColorPage(panel->colP, panel);
1517                 break;
1518         case 3:
1519                 switch (panel->oldTabItem) {
1520                 case 0:
1521                         changePage(NULL, panel);
1522                         break;
1523                 case 1:
1524                         changeColorPage(NULL, panel);
1525                         break;
1526                 }
1527                 break;
1528         }
1529
1530         panel->oldTabItem = i;
1531 }
1532
1533 /*************************************************************************/
1534
1535 static void menuStyleCallback(WMWidget * self, void *data)
1536 {
1537         _Panel *panel = (_Panel *) data;
1538
1539         if (self == panel->mstyB[0]) {
1540                 panel->menuStyle = MSTYLE_NORMAL;
1541                 updatePreviewBox(panel, 1 << PMITEM);
1542
1543         } else if (self == panel->mstyB[1]) {
1544                 panel->menuStyle = MSTYLE_SINGLE;
1545                 updatePreviewBox(panel, 1 << PMITEM);
1546
1547         } else if (self == panel->mstyB[2]) {
1548                 panel->menuStyle = MSTYLE_FLAT;
1549                 updatePreviewBox(panel, 1 << PMITEM);
1550         }
1551 }
1552
1553 static void titleAlignCallback(WMWidget * self, void *data)
1554 {
1555         _Panel *panel = (_Panel *) data;
1556
1557         if (self == panel->taliB[0]) {
1558                 panel->titleAlignment = WALeft;
1559                 updatePreviewBox(panel, 1 << PFOCUSED | 1 << PUNFOCUSED | 1 << POWNER);
1560
1561         } else if (self == panel->taliB[1]) {
1562                 panel->titleAlignment = WACenter;
1563                 updatePreviewBox(panel, 1 << PFOCUSED | 1 << PUNFOCUSED | 1 << POWNER);
1564
1565         } else if (self == panel->taliB[2]) {
1566                 panel->titleAlignment = WARight;
1567                 updatePreviewBox(panel, 1 << PFOCUSED | 1 << PUNFOCUSED | 1 << POWNER);
1568         }
1569 }
1570
1571 static void createPanel(Panel * p)
1572 {
1573         _Panel *panel = (_Panel *) p;
1574         WMFont *font;
1575         WMScreen *scr = WMWidgetScreen(panel->parent);
1576         WMTabViewItem *item;
1577         int i;
1578         char *tmp;
1579         Bool ok = True;
1580
1581         panel->fprefix = wstrconcat(wusergnusteppath(), "/Library/WindowMaker");
1582
1583         if (access(panel->fprefix, F_OK) != 0) {
1584                 if (mkdir(panel->fprefix, 0755) < 0) {
1585                         werror("%s", panel->fprefix);
1586                         ok = False;
1587                 }
1588         }
1589         if (ok) {
1590                 tmp = wstrconcat(panel->fprefix, "/WPrefs/");
1591                 wfree(panel->fprefix);
1592                 panel->fprefix = tmp;
1593                 if (access(panel->fprefix, F_OK) != 0) {
1594                         if (mkdir(panel->fprefix, 0755) < 0) {
1595                                 werror("%s", panel->fprefix);
1596                         }
1597                 }
1598         }
1599
1600         panel->smallFont = WMSystemFontOfSize(scr, 10);
1601         panel->normalFont = WMSystemFontOfSize(scr, 12);
1602         panel->boldFont = WMBoldSystemFontOfSize(scr, 12);
1603
1604         panel->onLed = WMCreatePixmapFromXPMData(scr, blueled_xpm);
1605         panel->offLed = WMCreatePixmapFromXPMData(scr, blueled2_xpm);
1606         panel->hand = WMCreatePixmapFromXPMData(scr, hand_xpm);
1607
1608         panel->box = WMCreateBox(panel->parent);
1609         WMSetViewExpandsToParent(WMWidgetView(panel->box), 2, 2, 2, 2);
1610
1611         /* preview box */
1612         panel->prevL = WMCreateLabel(panel->box);
1613         WMResizeWidget(panel->prevL, 240, FRAME_HEIGHT - 20);
1614         WMMoveWidget(panel->prevL, 15, 10);
1615         WMSetLabelRelief(panel->prevL, WRSunken);
1616         WMSetLabelImagePosition(panel->prevL, WIPImageOnly);
1617
1618         WMCreateEventHandler(WMWidgetView(panel->prevL), ButtonPressMask, previewClick, panel);
1619
1620         /* tabview */
1621
1622         tabviewDelegate.data = panel;
1623
1624         panel->tabv = WMCreateTabView(panel->box);
1625         WMResizeWidget(panel->tabv, 245, FRAME_HEIGHT - 20);
1626         WMMoveWidget(panel->tabv, 265, 10);
1627         WMSetTabViewDelegate(panel->tabv, &tabviewDelegate);
1628
1629     /*** texture list ***/
1630
1631         panel->texF = WMCreateFrame(panel->box);
1632         WMSetFrameRelief(panel->texF, WRFlat);
1633
1634         item = WMCreateTabViewItemWithIdentifier(0);
1635         WMSetTabViewItemView(item, WMWidgetView(panel->texF));
1636         WMSetTabViewItemLabel(item, _("Texture"));
1637
1638         WMAddItemInTabView(panel->tabv, item);
1639
1640         panel->secP = WMCreatePopUpButton(panel->texF);
1641         WMResizeWidget(panel->secP, 228, 20);
1642         WMMoveWidget(panel->secP, 7, 7);
1643         WMAddPopUpButtonItem(panel->secP, _("Titlebar of Focused Window"));
1644         WMAddPopUpButtonItem(panel->secP, _("Titlebar of Unfocused Windows"));
1645         WMAddPopUpButtonItem(panel->secP, _("Titlebar of Focused Window's Owner"));
1646         WMAddPopUpButtonItem(panel->secP, _("Window Resizebar"));
1647         WMAddPopUpButtonItem(panel->secP, _("Titlebar of Menus"));
1648         WMAddPopUpButtonItem(panel->secP, _("Menu Items"));
1649         WMAddPopUpButtonItem(panel->secP, _("Icon Background"));
1650         /*    WMAddPopUpButtonItem(panel->secP, _("Workspace Backgrounds"));
1651          */
1652         WMSetPopUpButtonSelectedItem(panel->secP, 0);
1653         WMSetPopUpButtonAction(panel->secP, changePage, panel);
1654
1655         panel->texLs = WMCreateList(panel->texF);
1656         WMResizeWidget(panel->texLs, 165, 155);
1657         WMMoveWidget(panel->texLs, 70, 33);
1658         WMSetListUserDrawItemHeight(panel->texLs, 35);
1659         WMSetListUserDrawProc(panel->texLs, paintListItem);
1660         WMHangData(panel->texLs, panel);
1661         WMSetListAction(panel->texLs, textureClick, panel);
1662         WMSetListDoubleAction(panel->texLs, textureDoubleClick, panel);
1663
1664         WMSetBalloonTextForView(_("Double click in the texture you want to use\n"
1665                                   "for the selected item."), WMWidgetView(panel->texLs));
1666
1667         /* command buttons */
1668
1669         font = WMSystemFontOfSize(scr, 10);
1670
1671         panel->newB = WMCreateCommandButton(panel->texF);
1672         WMResizeWidget(panel->newB, 57, 39);
1673         WMMoveWidget(panel->newB, 7, 33);
1674         WMSetButtonFont(panel->newB, font);
1675         WMSetButtonImagePosition(panel->newB, WIPAbove);
1676         WMSetButtonText(panel->newB, _("New"));
1677         WMSetButtonAction(panel->newB, newTexture, panel);
1678         SetButtonAlphaImage(scr, panel->newB, TNEW_FILE, NULL, NULL);
1679
1680         WMSetBalloonTextForView(_("Create a new texture."), WMWidgetView(panel->newB));
1681
1682         panel->ripB = WMCreateCommandButton(panel->texF);
1683         WMResizeWidget(panel->ripB, 57, 39);
1684         WMMoveWidget(panel->ripB, 7, 72);
1685         WMSetButtonFont(panel->ripB, font);
1686         WMSetButtonImagePosition(panel->ripB, WIPAbove);
1687         WMSetButtonText(panel->ripB, _("Extract..."));
1688         WMSetButtonAction(panel->ripB, extractTexture, panel);
1689         SetButtonAlphaImage(scr, panel->ripB, TEXTR_FILE, NULL, NULL);
1690
1691         WMSetBalloonTextForView(_("Extract texture(s) from a theme or a style file."), WMWidgetView(panel->ripB));
1692
1693         WMSetButtonEnabled(panel->ripB, False);
1694
1695         panel->editB = WMCreateCommandButton(panel->texF);
1696         WMResizeWidget(panel->editB, 57, 39);
1697         WMMoveWidget(panel->editB, 7, 111);
1698         WMSetButtonFont(panel->editB, font);
1699         WMSetButtonImagePosition(panel->editB, WIPAbove);
1700         WMSetButtonText(panel->editB, _("Edit"));
1701         SetButtonAlphaImage(scr, panel->editB, TEDIT_FILE, NULL, NULL);
1702         WMSetButtonAction(panel->editB, editTexture, panel);
1703         WMSetBalloonTextForView(_("Edit the highlighted texture."), WMWidgetView(panel->editB));
1704
1705         panel->delB = WMCreateCommandButton(panel->texF);
1706         WMResizeWidget(panel->delB, 57, 38);
1707         WMMoveWidget(panel->delB, 7, 150);
1708         WMSetButtonFont(panel->delB, font);
1709         WMSetButtonImagePosition(panel->delB, WIPAbove);
1710         WMSetButtonText(panel->delB, _("Delete"));
1711         SetButtonAlphaImage(scr, panel->delB, TDEL_FILE, NULL, NULL);
1712         WMSetButtonEnabled(panel->delB, False);
1713         WMSetButtonAction(panel->delB, deleteTexture, panel);
1714         WMSetBalloonTextForView(_("Delete the highlighted texture."), WMWidgetView(panel->delB));
1715
1716         WMReleaseFont(font);
1717
1718         WMMapSubwidgets(panel->texF);
1719
1720     /*** colors ***/
1721         panel->colF = WMCreateFrame(panel->box);
1722         WMSetFrameRelief(panel->colF, WRFlat);
1723
1724         item = WMCreateTabViewItemWithIdentifier(1);
1725         WMSetTabViewItemView(item, WMWidgetView(panel->colF));
1726         WMSetTabViewItemLabel(item, _("Color"));
1727
1728         WMAddItemInTabView(panel->tabv, item);
1729
1730         panel->colP = WMCreatePopUpButton(panel->colF);
1731         WMResizeWidget(panel->colP, 228, 20);
1732         WMMoveWidget(panel->colP, 7, 7);
1733         WMAddPopUpButtonItem(panel->colP, _("Focused Window Title"));
1734         WMAddPopUpButtonItem(panel->colP, _("Unfocused Window Title"));
1735         WMAddPopUpButtonItem(panel->colP, _("Owner of Focused Window Title"));
1736         WMAddPopUpButtonItem(panel->colP, _("Menu Title"));
1737         WMAddPopUpButtonItem(panel->colP, _("Menu Item Text"));
1738         WMAddPopUpButtonItem(panel->colP, _("Disabled Menu Item Text"));
1739         WMAddPopUpButtonItem(panel->colP, _("Menu Highlight Color"));
1740         WMAddPopUpButtonItem(panel->colP, _("Highlighted Menu Text Color"));
1741         /*
1742            WMAddPopUpButtonItem(panel->colP, _("Miniwindow Title"));
1743            WMAddPopUpButtonItem(panel->colP, _("Miniwindow Title Back"));
1744            WMAddPopUpButtonItem(panel->colP, _("Clip Title"));
1745            WMAddPopUpButtonItem(panel->colP, _("Collapsed Clip Title"));
1746          */
1747
1748         WMSetPopUpButtonSelectedItem(panel->colP, 0);
1749
1750         WMSetPopUpButtonAction(panel->colP, changeColorPage, panel);
1751
1752         panel->colW = WMCreateColorWell(panel->colF);
1753         WMResizeWidget(panel->colW, 65, 50);
1754         WMMoveWidget(panel->colW, 30, 75);
1755         WMAddNotificationObserver(colorWellObserver, panel, WMColorWellDidChangeNotification, panel->colW);
1756
1757         for (i = 0; i < 4; i++) {
1758                 int j;
1759                 for (j = 0; j < 6; j++) {
1760                         panel->sampW[i + j * 4] = WMCreateColorWell(panel->colF);
1761                         WMResizeWidget(panel->sampW[i + j * 4], 22, 22);
1762                         WMMoveWidget(panel->sampW[i + j * 4], 130 + i * 22, 40 + j * 22);
1763                         WSetColorWellBordered(panel->sampW[i + j * 4], False);
1764                 }
1765         }
1766
1767         WMMapSubwidgets(panel->colF);
1768
1769 #ifdef unfinished
1770     /*** root bg ***/
1771
1772         panel->bgF = WMCreateFrame(panel->box);
1773         WMSetFrameRelief(panel->bgF, WRFlat);
1774
1775         item = WMCreateTabViewItemWithIdentifier(2);
1776         WMSetTabViewItemView(item, WMWidgetView(panel->bgF));
1777         WMSetTabViewItemLabel(item, _("Background"));
1778
1779         WMAddItemInTabView(panel->tabv, item);
1780
1781         panel->bgprevL = WMCreateLabel(panel->bgF);
1782         WMResizeWidget(panel->bgprevL, 230, 155);
1783         WMMoveWidget(panel->bgprevL, 5, 5);
1784         WMSetLabelRelief(panel->bgprevL, WRSunken);
1785
1786         panel->selbgB = WMCreateCommandButton(panel->bgF);
1787         WMMoveWidget(panel->selbgB, 5, 165);
1788         WMResizeWidget(panel->selbgB, 100, 24);
1789         WMSetButtonText(panel->selbgB, _("Browse..."));
1790
1791         WMMapSubwidgets(panel->bgF);
1792 #endif                          /* unfinished */
1793     /*** options ***/
1794         panel->optF = WMCreateFrame(panel->box);
1795         WMSetFrameRelief(panel->optF, WRFlat);
1796
1797         item = WMCreateTabViewItemWithIdentifier(3);
1798         WMSetTabViewItemView(item, WMWidgetView(panel->optF));
1799         WMSetTabViewItemLabel(item, _("Options"));
1800
1801         WMAddItemInTabView(panel->tabv, item);
1802
1803         panel->mstyF = WMCreateFrame(panel->optF);
1804         WMResizeWidget(panel->mstyF, 215, 85);
1805         WMMoveWidget(panel->mstyF, 15, 10);
1806         WMSetFrameTitle(panel->mstyF, _("Menu Style"));
1807
1808         for (i = 0; i < 3; i++) {
1809                 WMPixmap *icon;
1810                 char *path;
1811
1812                 panel->mstyB[i] = WMCreateButton(panel->mstyF, WBTOnOff);
1813                 WMResizeWidget(panel->mstyB[i], 54, 54);
1814                 WMMoveWidget(panel->mstyB[i], 15 + i * 65, 20);
1815                 WMSetButtonImagePosition(panel->mstyB[i], WIPImageOnly);
1816                 WMSetButtonAction(panel->mstyB[i], menuStyleCallback, panel);
1817                 switch (i) {
1818                 case 0:
1819                         path = LocateImage(MSTYLE1_FILE);
1820                         break;
1821                 case 1:
1822                         path = LocateImage(MSTYLE2_FILE);
1823                         break;
1824                 case 2:
1825                         path = LocateImage(MSTYLE3_FILE);
1826                         break;
1827                 }
1828                 if (path) {
1829                         icon = WMCreatePixmapFromFile(scr, path);
1830                         if (icon) {
1831                                 WMSetButtonImage(panel->mstyB[i], icon);
1832                                 WMReleasePixmap(icon);
1833                         } else {
1834                                 wwarning(_("could not load icon file %s"), path);
1835                         }
1836                         wfree(path);
1837                 }
1838         }
1839         WMGroupButtons(panel->mstyB[0], panel->mstyB[1]);
1840         WMGroupButtons(panel->mstyB[0], panel->mstyB[2]);
1841
1842         WMMapSubwidgets(panel->mstyF);
1843
1844         panel->taliF = WMCreateFrame(panel->optF);
1845         WMResizeWidget(panel->taliF, 110, 80);
1846         WMMoveWidget(panel->taliF, 15, 100);
1847         WMSetFrameTitle(panel->taliF, _("Title Alignment"));
1848
1849         for (i = 0; i < 3; i++) {
1850                 panel->taliB[i] = WMCreateRadioButton(panel->taliF);
1851                 WMSetButtonAction(panel->taliB[i], titleAlignCallback, panel);
1852                 switch (i) {
1853                 case 0:
1854                         WMSetButtonText(panel->taliB[i], _("Left"));
1855                         break;
1856                 case 1:
1857                         WMSetButtonText(panel->taliB[i], _("Center"));
1858                         break;
1859                 case 2:
1860                         WMSetButtonText(panel->taliB[i], _("Right"));
1861                         break;
1862                 }
1863                 WMResizeWidget(panel->taliB[i], 90, 18);
1864                 WMMoveWidget(panel->taliB[i], 10, 15 + 20 * i);
1865         }
1866         WMGroupButtons(panel->taliB[0], panel->taliB[1]);
1867         WMGroupButtons(panel->taliB[0], panel->taliB[2]);
1868
1869         WMMapSubwidgets(panel->taliF);
1870
1871         WMMapSubwidgets(panel->optF);
1872
1873          /**/ WMRealizeWidget(panel->box);
1874         WMMapSubwidgets(panel->box);
1875
1876         WMSetPopUpButtonSelectedItem(panel->secP, 0);
1877
1878         showData(panel);
1879
1880         changePage(panel->secP, panel);
1881
1882         fillTextureList(panel->texLs);
1883
1884         fillColorList(panel);
1885
1886         panel->texturePanel = CreateTexturePanel(panel->parent);
1887 }
1888
1889 static void setupTextureFor(WMList * list, const char *key, char *defValue, const char *title, int index)
1890 {
1891         WMListItem *item;
1892         TextureListItem *titem;
1893
1894         titem = wmalloc(sizeof(TextureListItem));
1895
1896         titem->title = wstrdup(title);
1897         titem->prop = GetObjectForKey(key);
1898         if (!titem->prop || !WMIsPLArray(titem->prop)) {
1899                 /* Maybe also give a error message to stderr that the entry is bad? */
1900                 titem->prop = WMCreatePropListFromDescription(defValue);
1901         } else {
1902                 WMRetainPropList(titem->prop);
1903         }
1904         titem->texture = WMGetPropListDescription((WMPropList *) titem->prop, False);
1905         titem->current = 1;
1906         titem->selectedFor = 1 << index;
1907
1908         titem->ispixmap = isPixmap(titem->prop);
1909
1910         titem->preview = renderTexture(WMWidgetScreen(list), titem->prop, TEXPREV_WIDTH, TEXPREV_HEIGHT, NULL, 0);
1911
1912         item = WMAddListItem(list, "");
1913         item->clientData = titem;
1914 }
1915
1916 static void showData(_Panel * panel)
1917 {
1918         int i;
1919         char *str;
1920
1921         str = GetStringForKey("MenuStyle");
1922         if (str && strcasecmp(str, "flat") == 0) {
1923                 panel->menuStyle = MSTYLE_FLAT;
1924         } else if (str && strcasecmp(str, "singletexture") == 0) {
1925                 panel->menuStyle = MSTYLE_SINGLE;
1926         } else {
1927                 panel->menuStyle = MSTYLE_NORMAL;
1928         }
1929
1930         str = GetStringForKey("TitleJustify");
1931         if (str && strcasecmp(str, "left") == 0) {
1932                 panel->titleAlignment = WALeft;
1933         } else if (str && strcasecmp(str, "right") == 0) {
1934                 panel->titleAlignment = WARight;
1935         } else {
1936                 panel->titleAlignment = WACenter;
1937         }
1938
1939         for (i = 0; i < sizeof(colorOptions) / (2 * sizeof(char *)); i++) {
1940                 WMColor *color;
1941
1942                 str = GetStringForKey(colorOptions[i * 2]);
1943                 if (!str)
1944                         str = colorOptions[i * 2 + 1];
1945
1946                 if (!(color = WMCreateNamedColor(WMWidgetScreen(panel->box), str, False))) {
1947                         color = WMCreateNamedColor(WMWidgetScreen(panel->box), "#000000", False);
1948                 }
1949
1950                 panel->colors[i] = color;
1951         }
1952         changeColorPage(panel->colP, panel);
1953
1954         for (i = 0; i < sizeof(textureOptions) / (3 * sizeof(char *)); i++) {
1955                 setupTextureFor(panel->texLs, textureOptions[i * 3],
1956                                 textureOptions[i * 3 + 1], textureOptions[i * 3 + 2], i);
1957                 panel->textureIndex[i] = i;
1958         }
1959         updatePreviewBox(panel, EVERYTHING);
1960
1961         WMSetButtonSelected(panel->mstyB[panel->menuStyle], True);
1962         WMSetButtonSelected(panel->taliB[panel->titleAlignment], True);
1963 }
1964
1965 static void storeData(_Panel * panel)
1966 {
1967         TextureListItem *titem;
1968         WMListItem *item;
1969         int i;
1970
1971         for (i = 0; i < sizeof(textureOptions) / (sizeof(char *) * 3); i++) {
1972                 item = WMGetListItem(panel->texLs, panel->textureIndex[i]);
1973                 titem = (TextureListItem *) item->clientData;
1974                 SetObjectForKey(titem->prop, textureOptions[i * 3]);
1975         }
1976
1977         for (i = 0; i < 8; i++) {
1978                 char *str;
1979
1980                 str = WMGetColorRGBDescription(panel->colors[i]);
1981
1982                 if (str) {
1983                         SetStringForKey(str, colorOptions[i * 2]);
1984                         wfree(str);
1985                 }
1986         }
1987
1988         switch (panel->menuStyle) {
1989         case MSTYLE_SINGLE:
1990                 SetStringForKey("singletexture", "MenuStyle");
1991                 break;
1992         case MSTYLE_FLAT:
1993                 SetStringForKey("flat", "MenuStyle");
1994                 break;
1995         default:
1996         case MSTYLE_NORMAL:
1997                 SetStringForKey("normal", "MenuStyle");
1998                 break;
1999         }
2000         switch (panel->titleAlignment) {
2001         case WALeft:
2002                 SetStringForKey("left", "TitleJustify");
2003                 break;
2004         case WARight:
2005                 SetStringForKey("right", "TitleJustify");
2006                 break;
2007         default:
2008         case WACenter:
2009                 SetStringForKey("center", "TitleJustify");
2010                 break;
2011         }
2012 }
2013
2014 static void prepareForClose(_Panel * panel)
2015 {
2016         WMPropList *textureList;
2017         WMPropList *texture;
2018         TextureListItem *titem;
2019         WMListItem *item;
2020         WMUserDefaults *udb = WMGetStandardUserDefaults();
2021         int i;
2022
2023         textureList = WMCreatePLArray(NULL, NULL);
2024
2025         /* store list of textures */
2026         for (i = 7; i < WMGetListNumberOfRows(panel->texLs); i++) {
2027                 item = WMGetListItem(panel->texLs, i);
2028                 titem = (TextureListItem *) item->clientData;
2029
2030                 texture = WMCreatePLArray(WMCreatePLString(titem->title),
2031                                           WMRetainPropList(titem->prop), WMCreatePLString(titem->path), NULL);
2032
2033                 WMAddToPLArray(textureList, texture);
2034         }
2035
2036         WMSetUDObjectForKey(udb, textureList, "TextureList");
2037         WMReleasePropList(textureList);
2038
2039         /* store list of colors */
2040         textureList = WMCreatePLArray(NULL, NULL);
2041         for (i = 0; i < 24; i++) {
2042                 WMColor *color;
2043                 char *str;
2044
2045                 color = WMGetColorWellColor(panel->sampW[i]);
2046
2047                 str = WMGetColorRGBDescription(color);
2048                 WMAddToPLArray(textureList, WMCreatePLString(str));
2049                 wfree(str);
2050         }
2051         WMSetUDObjectForKey(udb, textureList, "ColorList");
2052         WMReleasePropList(textureList);
2053
2054         WMSynchronizeUserDefaults(udb);
2055 }
2056
2057 Panel *InitAppearance(WMScreen *scr, WMWidget *parent)
2058 {
2059         _Panel *panel;
2060
2061         panel = wmalloc(sizeof(_Panel));
2062
2063         panel->sectionName = _("Appearance Preferences");
2064
2065         panel->description = _("Background texture configuration for windows,\n" "menus and icons.");
2066
2067         panel->parent = parent;
2068
2069         panel->callbacks.createWidgets = createPanel;
2070         panel->callbacks.updateDomain = storeData;
2071         panel->callbacks.prepareForClose = prepareForClose;
2072
2073         AddSection(panel, ICON_FILE);
2074
2075         return panel;
2076 }
2077
2078 /****************************************************************************/
2079
2080 typedef struct ExtractPanel {
2081         WMWindow *win;
2082
2083         WMLabel *label;
2084         WMList *list;
2085
2086         WMButton *closeB;
2087         WMButton *extrB;
2088 } ExtractPanel;
2089
2090 static void OpenExtractPanelFor(_Panel * panel, const char *path)
2091 {
2092         ExtractPanel *epanel;
2093         WMColor *color;
2094         WMFont *font;
2095         WMScreen *scr = WMWidgetScreen(panel->parent);
2096
2097         epanel = wmalloc(sizeof(ExtractPanel));
2098         epanel->win = WMCreatePanelWithStyleForWindow(panel->parent, "extract",
2099                                                       WMTitledWindowMask | WMClosableWindowMask);
2100         WMResizeWidget(epanel->win, 245, 250);
2101         WMSetWindowTitle(epanel->win, _("Extract Texture"));
2102
2103         epanel->label = WMCreateLabel(epanel->win);
2104         WMResizeWidget(epanel->label, 225, 18);
2105         WMMoveWidget(epanel->label, 10, 10);
2106         WMSetLabelTextAlignment(epanel->label, WACenter);
2107         WMSetLabelRelief(epanel->label, WRSunken);
2108
2109         color = WMDarkGrayColor(scr);
2110         WMSetWidgetBackgroundColor(epanel->label, color);
2111         WMReleaseColor(color);
2112
2113         color = WMWhiteColor(scr);
2114         WMSetLabelTextColor(epanel->label, color);
2115         WMReleaseColor(color);
2116
2117         font = WMBoldSystemFontOfSize(scr, 12);
2118         WMSetLabelFont(epanel->label, font);
2119         WMReleaseFont(font);
2120
2121         WMSetLabelText(epanel->label, _("Textures"));
2122
2123         epanel->list = WMCreateList(epanel->win);
2124         WMResizeWidget(epanel->list, 225, 165);
2125         WMMoveWidget(epanel->list, 10, 30);
2126
2127         epanel->closeB = WMCreateCommandButton(epanel->win);
2128         WMResizeWidget(epanel->closeB, 74, 24);
2129         WMMoveWidget(epanel->closeB, 165, 215);
2130         WMSetButtonText(epanel->closeB, _("Close"));
2131
2132         epanel->extrB = WMCreateCommandButton(epanel->win);
2133         WMResizeWidget(epanel->extrB, 74, 24);
2134         WMMoveWidget(epanel->extrB, 80, 215);
2135         WMSetButtonText(epanel->extrB, _("Extract"));
2136
2137         WMMapSubwidgets(epanel->win);
2138
2139         /* take textures from file */
2140
2141         WMRealizeWidget(epanel->win);
2142
2143         WMMapWidget(epanel->win);
2144 }