WPrefs.app/Appearance.c

   1 /* Apperance.c- color/texture for titlebar etc.
   2  *
   3  *  WPrefs - Window Maker Preferences Program
   4  *
   5  *  Copyright (c) 1999 Alfredo K. Kojima
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20  *  USA.
  21  */
  22
  23
  24 #include "WPrefs.h"
  25
  26 #include <unistd.h>
  27 #include <errno.h>
  28
  29 #include "TexturePanel.h"
  30
  31 typedef struct _Panel {
  32     WMFrame *frame;
  33     char *sectionName;
  34
  35     CallbackRec callbacks;
  36
  37     WMWindow *win;
  38
  39     WMButton *prevB;
  40
  41     WMPopUpButton *secP;
  42
  43     /* texture list */
  44     WMLabel *texL;
  45     WMList *texLs;
  46
  47     WMButton *newB;
  48     WMButton *editB;
  49     WMButton *ripB;
  50     WMButton *delB;
  51
  52
  53     proplist_t ftitleTex;
  54     proplist_t utitleTex;
  55     proplist_t ptitleTex;
  56     proplist_t iconTex;
  57     proplist_t menuTex;
  58     proplist_t mtitleTex;
  59     proplist_t backTex;
  60
  61     int textureIndex[8];
  62
  63     WMFont *smallFont;
  64     WMFont *normalFont;
  65     WMFont *boldFont;
  66
  67     TexturePanel *texturePanel;
  68
  69     WMPixmap *onLed;
  70     WMPixmap *offLed;
  71
  72     /* for preview shit */
  73     Pixmap preview;
  74     Pixmap ftitle;
  75     Pixmap utitle;
  76     Pixmap otitle;
  77     Pixmap icon;
  78     Pixmap back;
  79     Pixmap mtitle;
  80     Pixmap mitem;
  81
  82     char *fprefix;
  83 } _Panel;
  84
  85
  86 typedef struct {
  87     char *title;
  88     char *texture;
  89     proplist_t prop;
  90     Pixmap preview;
  91
  92     char *path;
  93
  94     char selectedFor;
  95     unsigned current:1;
  96 } TextureListItem;
  97
  98
  99 static void showData(_Panel *panel);
 100
 101
 102 #define ICON_FILE       "appearance"
 103
 104 #define TNEW_FILE       "tnew"
 105 #define TDEL_FILE       "tdel"
 106 #define TEDIT_FILE      "tedit"
 107 #define TEXTR_FILE      "textr"
 108
 109
 110
 111 /* XPM */
 112 static char * blueled_xpm[] = {
 113 "8 8 17 1",
 114 "       c None",
 115 ".      c #020204",
 116 "+      c #16B6FC",
 117 "@      c #176AFC",
 118 "#      c #163AFC",
 119 "$      c #72D2FC",
 120 "%      c #224CF4",
 121 "&      c #76D6FC",
 122 "*      c #16AAFC",
 123 "=      c #CEE9FC",
 124 "-      c #229EFC",
 125 ";      c #164CFC",
 126 ">      c #FAFEFC",
 127 ",      c #2482FC",
 128 "'      c #1652FC",
 129 ")      c #1E76FC",
 130 "!      c #1A60FC",
 131 "  ....  ",
 132 " .=>-@. ",
 133 ".=>$@@'.",
 134 ".=$@!;;.",
 135 ".!@*+!#.",
 136 ".#'*+*,.",
 137 " .@)@,. ",
 138 "  ....  "};
 139
 140
 141 /* XPM */
 142 static char *blueled2_xpm[] = {
 143 /* width height num_colors chars_per_pixel */
 144 "     8     8       17            1",
 145 /* colors */
 146 ". c None",
 147 "# c #090909",
 148 "a c #4b63a4",
 149 "b c #011578",
 150 "c c #264194",
 151 "d c #04338c",
 152 "e c #989dac",
 153 "f c #011a7c",
 154 "g c #465c9c",
 155 "h c #03278a",
 156 "i c #6175ac",
 157 "j c #011e74",
 158 "k c #043a90",
 159 "l c #042f94",
 160 "m c #0933a4",
 161 "n c #022184",
 162 "o c #012998",
 163 /* pixels */
 164 "..####..",
 165 ".#aimn#.",
 166 "#aechnf#",
 167 "#gchnjf#",
 168 "#jndknb#",
 169 "#bjdddl#",
 170 ".#nono#.",
 171 "..####.."
 172 };
 173
 174
 175
 176 #define FTITLE  (1<<0)
 177 #define UTITLE  (1<<1)
 178 #define OTITLE  (1<<2)
 179 #define MTITLE  (1<<3)
 180 #define MITEM   (1<<4)
 181 #define ICON    (1<<5)
 182 #define BACK    (1<<6)
 183 #define EVERYTHING      0xff
 184
 185
 186
 187
 188 #define TEXPREV_WIDTH   40
 189 #define TEXPREV_HEIGHT  24
 190
 191
 192
 193
 194
 195 static void
 196 str2rcolor(RContext *rc, char *name, RColor *color)
 197 {
 198     XColor xcolor;
 199
 200     XParseColor(rc->dpy, rc->cmap, name, &xcolor);
 201
 202     color->alpha = 255;
 203     color->red = xcolor.red >> 8;
 204     color->green = xcolor.green >> 8;
 205     color->blue = xcolor.blue >> 8;
 206 }
 207
 208
 209
 210 static void
 211 dumpRImage(char *path, RImage *image)
 212 {
 213     FILE *f;
 214
 215     f = fopen(path, "w");
 216     if (!f) {
 217         wsyserror(path);
 218         return;
 219     }
 220     fprintf(f, "%02x%02x%1x", image->width, image->height,
 221             image->data[3]!=NULL ? 4 : 3);
 222
 223     fwrite(image->data[0], 1, image->width * image->height, f);
 224     fwrite(image->data[1], 1, image->width * image->height, f);
 225     fwrite(image->data[2], 1, image->width * image->height, f);
 226     if (image->data[3])
 227         fwrite(image->data[3], 1, image->width * image->height, f);
 228
 229     if (fclose(f) < 0) {
 230         wsyserror(path);
 231     }
 232 }
 233
 234
 235
 236 static Pixmap
 237 renderTexture(WMScreen *scr, proplist_t texture, int width, int height,
 238               char *path, Bool bordered)
 239 {
 240     char *type;
 241     RImage *image;
 242     Pixmap pixmap;
 243     RContext *rc = WMScreenRContext(scr);
 244     char *str;
 245     RColor rcolor;
 246
 247
 248     type = PLGetString(PLGetArrayElement(texture, 0));
 249
 250     image = RCreateImage(width, height, False);
 251
 252     if (strcasecmp(type, "solid")==0) {
 253
 254         str = PLGetString(PLGetArrayElement(texture, 1));
 255
 256         str2rcolor(rc, str, &rcolor);
 257
 258         RClearImage(image, &rcolor);
 259     } else if (strcasecmp(&type[1], "gradient")==0) {
 260         int style;
 261         RColor rcolor2;
 262
 263         switch (toupper(type[0])) {
 264          case 'V':
 265             style = RVerticalGradient;
 266             break;
 267          case 'H':
 268             style = RHorizontalGradient;
 269             break;
 270          case 'D':
 271             style = RDiagonalGradient;
 272             break;
 273         }
 274
 275         str = PLGetString(PLGetArrayElement(texture, 1));
 276         str2rcolor(rc, str, &rcolor);
 277         str = PLGetString(PLGetArrayElement(texture, 2));
 278         str2rcolor(rc, str, &rcolor2);
 279
 280         image = RRenderGradient(width, height, &rcolor, &rcolor2, style);
 281     } else if (strcasecmp(&type[2], "gradient")==0) {
 282         int style;
 283         RColor **colors;
 284         int i, j;
 285
 286         switch (toupper(type[1])) {
 287          case 'V':
 288             style = RVerticalGradient;
 289             break;
 290          case 'H':
 291             style = RHorizontalGradient;
 292             break;
 293          case 'D':
 294             style = RDiagonalGradient;
 295             break;
 296         }
 297
 298         j = PLGetNumberOfElements(texture);
 299
 300         if (j > 0) {
 301             colors = wmalloc(j * sizeof(RColor*));
 302
 303             for (i = 2; i < j; i++) {
 304                 str = PLGetString(PLGetArrayElement(texture, i));
 305                 colors[i-2] = wmalloc(sizeof(RColor));
 306                 str2rcolor(rc, str, colors[i-2]);
 307             }
 308             colors[i-2] = NULL;
 309
 310             image = RRenderMultiGradient(width, height, colors, style);
 311
 312             for (i = 0; colors[i]!=NULL; i++)
 313                 free(colors[i]);
 314             free(colors);
 315         }
 316     } else if (strcasecmp(&type[1], "pixmap")==0) {
 317         int style;
 318         RImage *timage;
 319         int w, h;
 320         char *path;
 321
 322         str = PLGetString(PLGetArrayElement(texture, 1));
 323
 324         path = wfindfileinarray(GetObjectForKey("PixmapPath"), str);
 325         timage = RLoadImage(rc, path, 0);
 326         free(path);
 327         if (timage) {
 328             w = timage->width;
 329             h = timage->height;
 330
 331             if (w - TEXPREV_WIDTH > h - TEXPREV_HEIGHT) {
 332                 h = (w * TEXPREV_HEIGHT)/TEXPREV_WIDTH;
 333             } else {
 334                 w = (h * TEXPREV_WIDTH)/TEXPREV_HEIGHT;
 335             }
 336
 337             image = RScaleImage(timage, w, h);
 338             RDestroyImage(timage);
 339         }
 340     }
 341
 342     if (path) {
 343         dumpRImage(path, image);
 344     }
 345
 346     RConvertImage(rc, image, &pixmap);
 347     RDestroyImage(image);
 348
 349     return pixmap;
 350 }
 351
 352
 353 #if 0
 354 static void
 355 updatePreviewBox(_Panel *panel, int elements)
 356 {
 357     WMScreen *scr = WMWidgetScreen(panel->win);
 358     Display *dpy = WMScreenDisplay(scr);
 359  /*   RContext *rc = WMScreenRContext(scr);*/
 360     int refresh = 0;
 361     char *tmp;
 362
 363     if (!panel->preview) {
 364         panel->preview = XCreatePixmap(dpy, WMWidgetXID(panel->win),
 365                                        220-4, 185-4, WMScreenDepth(scr));
 366
 367         refresh = -1;
 368     }
 369
 370     if (elements & FTITLE) {
 371         if (panel->ftitle)
 372             XFreePixmap(dpy, panel->ftitle);
 373
 374         panel->ftitle = renderTexture(scr, tmp, 180, 20, NULL, True);
 375         free(tmp);
 376     }
 377
 378     /* have to repaint everything to make things simple, eliminating
 379      * clipping stuff */
 380     if (refresh) {
 381
 382     }
 383
 384     if (refresh<0) {
 385         WMPixmap *pix;
 386         pix = WMCreatePixmapFromXPixmaps(scr, panel->preview, None,
 387                                          220-4, 185-4, WMScreenDepth(scr));
 388
 389         WMSetLabelImage(panel->prevL, pix);
 390         WMReleasePixmap(pix);
 391     }
 392 }
 393
 394
 395
 396 static char*
 397 getStrArrayForKey(char *key)
 398 {
 399     proplist_t v;
 400
 401     v = GetObjectForKey(key);
 402     if (!v)
 403         return NULL;
 404
 405     return PLGetDescription(v);
 406 }
 407 #endif
 408
 409
 410
 411 static void
 412 cancelNewTexture(void *data)
 413 {
 414     _Panel *panel = (_Panel*)data;
 415
 416     HideTexturePanel(panel->texturePanel);
 417 }
 418
 419
 420 static char*
 421 makeFileName(char *prefix, char *name)
 422 {
 423     char *fname, *str;
 424     int i;
 425
 426     str = wstrappend(prefix, name);
 427     fname = wstrdup(str);
 428
 429     i = 1;
 430     while (access(fname, F_OK)==0) {
 431         char buf[16];
 432
 433         free(fname);
 434         sprintf(buf, "%i", i++);
 435         fname = wstrappend(str, buf);
 436     }
 437     free(str);
 438
 439     return fname;
 440 }
 441
 442
 443 static void
 444 okNewTexture(void *data)
 445 {
 446     _Panel *panel = (_Panel*)data;
 447     WMListItem *item;
 448     char *name;
 449     char *str;
 450     proplist_t prop;
 451     TextureListItem *titem;
 452     WMScreen *scr = WMWidgetScreen(panel->win);
 453
 454     titem = wmalloc(sizeof(TextureListItem));
 455     memset(titem, 0, sizeof(TextureListItem));
 456
 457     HideTexturePanel(panel->texturePanel);
 458
 459     name = GetTexturePanelTextureName(panel->texturePanel);
 460
 461     prop = GetTexturePanelTexture(panel->texturePanel);
 462
 463     str = PLGetDescription(prop);
 464
 465     titem->title = name;
 466     titem->prop = prop;
 467     titem->texture = str;
 468     titem->selectedFor = 0;
 469
 470     titem->path = makeFileName(panel->fprefix, name);
 471     titem->preview = renderTexture(scr, prop, TEXPREV_WIDTH, TEXPREV_HEIGHT,
 472                                    titem->path, False);
 473
 474     item = WMAddListItem(panel->texLs, "");
 475     item->clientData = titem;
 476
 477     WMSetListPosition(panel->texLs, WMGetListNumberOfRows(panel->texLs));
 478 }
 479
 480
 481
 482 static void
 483 okEditTexture(void *data)
 484 {
 485     _Panel *panel = (_Panel*)data;
 486     WMListItem *item;
 487     char *name;
 488     char *str;
 489     proplist_t prop;
 490     TextureListItem *titem;
 491
 492     item = WMGetListItem(panel->texLs, WMGetListSelectedItemRow(panel->texLs));
 493     titem = (TextureListItem*)item->clientData;
 494
 495     HideTexturePanel(panel->texturePanel);
 496
 497     if (titem->current) {
 498         name = GetTexturePanelTextureName(panel->texturePanel);
 499
 500         free(titem->title);
 501         titem->title = name;
 502     }
 503
 504     prop = GetTexturePanelTexture(panel->texturePanel);
 505
 506     str = PLGetDescription(prop);
 507
 508     PLRelease(titem->prop);
 509     titem->prop = prop;
 510
 511     free(titem->texture);
 512     titem->texture = str;
 513
 514     XFreePixmap(WMScreenDisplay(WMWidgetScreen(panel->texLs)), titem->preview);
 515     titem->preview = renderTexture(WMWidgetScreen(panel->texLs), titem->prop,
 516                                    TEXPREV_WIDTH, TEXPREV_HEIGHT,
 517                                    titem->path, False);
 518
 519     WMRedisplayWidget(panel->texLs);
 520 }
 521
 522
 523
 524 static void
 525 editTexture(WMWidget *w, void *data)
 526 {
 527     _Panel *panel = (_Panel*)data;
 528     WMListItem *item;
 529     TextureListItem *titem;
 530
 531     item = WMGetListItem(panel->texLs, WMGetListSelectedItemRow(panel->texLs));
 532     titem = (TextureListItem*)item->clientData;
 533
 534     SetTexturePanelTexture(panel->texturePanel, titem->title, titem->prop);
 535
 536     SetTexturePanelCancelAction(panel->texturePanel, cancelNewTexture, panel);
 537     SetTexturePanelOkAction(panel->texturePanel, okEditTexture, panel);
 538
 539     SetTexturePanelPixmapPath(panel->texturePanel,
 540                               GetObjectForKey("PixmapPath"));
 541     ShowTexturePanel(panel->texturePanel);
 542 }
 543
 544
 545
 546 static void
 547 newTexture(WMWidget *w, void *data)
 548 {
 549     _Panel *panel = (_Panel*)data;
 550
 551     SetTexturePanelTexture(panel->texturePanel, "New Texture", NULL);
 552
 553     SetTexturePanelCancelAction(panel->texturePanel, cancelNewTexture, panel);
 554
 555     SetTexturePanelOkAction(panel->texturePanel, okNewTexture, panel);
 556
 557     SetTexturePanelPixmapPath(panel->texturePanel,
 558                               GetObjectForKey("PixmapPath"));
 559     ShowTexturePanel(panel->texturePanel);
 560 }
 561
 562
 563
 564 static void
 565 deleteTexture(WMWidget *w, void *data)
 566 {
 567     _Panel *panel = (_Panel*)data;
 568     WMListItem *item;
 569     TextureListItem *titem;
 570     int row;
 571     int section;
 572
 573     section = WMGetPopUpButtonSelectedItem(panel->secP);
 574     row = WMGetListSelectedItemRow(panel->texLs);
 575     item = WMGetListItem(panel->texLs, row);
 576     titem = (TextureListItem*)item->clientData;
 577
 578     if (titem->selectedFor & (1 << section)) {
 579         TextureListItem *titem2;
 580
 581         panel->textureIndex[section] = section;
 582         item = WMGetListItem(panel->texLs, section);
 583         titem2 = (TextureListItem*)item->clientData;
 584         titem2->selectedFor |= 1 << section;
 585     }
 586
 587     free(titem->title);
 588     free(titem->texture);
 589     PLRelease(titem->prop);
 590     if (titem->path) {
 591         if (remove(titem->path) < 0 && errno != ENOENT) {
 592             wsyserror("could not remove file %s", titem->path);
 593         }
 594         free(titem->path);
 595     }
 596
 597     free(titem);
 598
 599     WMRemoveListItem(panel->texLs, row);
 600     WMSetButtonEnabled(panel->delB, False);
 601 }
 602
 603
 604 static void
 605 changePage(WMWidget *w, void *data)
 606 {
 607     _Panel *panel = (_Panel*)data;
 608     int section;
 609
 610     section = WMGetPopUpButtonSelectedItem(panel->secP);
 611
 612     WMSelectListItem(panel->texLs, panel->textureIndex[section]);
 613
 614     WMSetListPosition(panel->texLs, panel->textureIndex[section]
 615                       - WMGetListNumberOfRows(panel->texLs)/2);
 616 }
 617
 618
 619
 620 static void
 621 textureClick(WMWidget *w, void *data)
 622 {
 623     _Panel *panel = (_Panel*)data;
 624     int i;
 625     WMListItem *item;
 626     TextureListItem *titem;
 627
 628     i = WMGetListSelectedItemRow(panel->texLs);
 629
 630     item = WMGetListItem(panel->texLs, i);
 631
 632     titem = (TextureListItem*)item->clientData;
 633
 634     if (titem->current) {
 635         WMSetButtonEnabled(panel->delB, False);
 636     } else {
 637         WMSetButtonEnabled(panel->delB, True);
 638     }
 639 }
 640
 641
 642
 643 static void
 644 textureDoubleClick(WMWidget *w, void *data)
 645 {
 646     _Panel *panel = (_Panel*)data;
 647     int i, section;
 648     WMListItem *item;
 649     TextureListItem *titem;
 650
 651     /* unselect old texture */
 652     section = WMGetPopUpButtonSelectedItem(panel->secP);
 653
 654     item = WMGetListItem(panel->texLs, panel->textureIndex[section]);
 655     titem = (TextureListItem*)item->clientData;
 656     titem->selectedFor &= ~(1 << section);
 657
 658     /* select new texture */
 659     i = WMGetListSelectedItemRow(panel->texLs);
 660
 661     item = WMGetListItem(panel->texLs, i);
 662
 663     titem = (TextureListItem*)item->clientData;
 664
 665     titem->selectedFor |= 1<<section;
 666
 667     panel->textureIndex[section] = i;
 668
 669     WMRedisplayWidget(panel->texLs);
 670 }
 671
 672
 673
 674
 675 static void
 676 paintListItem(WMList *lPtr, int index, Drawable d, char *text, int state,
 677               WMRect *rect)
 678 {
 679     _Panel *panel = (_Panel*)WMGetHangedData(lPtr);
 680     WMScreen *scr = WMWidgetScreen(lPtr);
 681     int width, height, x, y;
 682     Display *dpy = WMScreenDisplay(scr);
 683     WMColor *white = WMWhiteColor(scr);
 684     WMListItem *item;
 685     WMColor *black = WMBlackColor(scr);
 686     TextureListItem *titem;
 687
 688     width = rect->size.width;
 689     height = rect->size.height;
 690     x = rect->pos.x;
 691     y = rect->pos.y;
 692
 693     if (state & WLDSSelected)
 694         XFillRectangle(dpy, d, WMColorGC(white), x, y, width, height);
 695     else
 696         XClearArea(dpy, d, x, y, width, height, False);
 697
 698     item = WMGetListItem(lPtr, index);
 699     titem = (TextureListItem*)item->clientData;
 700
 701     if (titem->preview)
 702     XCopyArea(dpy, titem->preview, d, WMColorGC(black), 0, 0, TEXPREV_WIDTH,
 703               TEXPREV_HEIGHT, x + 5, y + 5);
 704
 705     if ((1 << WMGetPopUpButtonSelectedItem(panel->secP)) & titem->selectedFor)
 706         WMDrawPixmap(panel->onLed, d, x + TEXPREV_WIDTH + 10, y + 6);
 707     else if (titem->selectedFor)
 708         WMDrawPixmap(panel->offLed, d, x + TEXPREV_WIDTH + 10, y + 6);
 709
 710     WMDrawString(scr, d, WMColorGC(black), panel->boldFont,
 711                  x + TEXPREV_WIDTH + 22, y + 2, titem->title,
 712                  strlen(titem->title));
 713
 714     WMDrawString(scr, d, WMColorGC(black), panel->smallFont,
 715                  x + TEXPREV_WIDTH + 14, y + 18, titem->texture,
 716                  strlen(titem->texture));
 717
 718
 719     WMReleaseColor(white);
 720     WMReleaseColor(black);
 721 }
 722
 723
 724
 725 static Pixmap
 726 loadRImage(WMScreen *scr, char *path)
 727 {
 728     FILE *f;
 729     RImage *image;
 730     int w, h, d;
 731     int i;
 732     Pixmap pixmap;
 733
 734     f = fopen(path, "r");
 735     if (!f)
 736         return None;
 737
 738     fscanf(f, "%02x%02x%1x", &w, &h, &d);
 739
 740     image = RCreateImage(w, h, d == 4);
 741     for (i = 0; i < d; i++) {
 742         fread(image->data[i], 1, w*h, f);
 743     }
 744     fclose(f);
 745
 746     RConvertImage(WMScreenRContext(scr), image, &pixmap);
 747     RDestroyImage(image);
 748
 749     return pixmap;
 750 }
 751
 752
 753 static void
 754 fillTextureList(WMList *lPtr)
 755 {
 756     proplist_t textureList;
 757     proplist_t texture;
 758     WMUserDefaults *udb = WMGetStandardUserDefaults();
 759     int i;
 760     TextureListItem *titem;
 761     WMScreen *scr  = WMWidgetScreen(lPtr);
 762
 763     textureList = WMGetUDObjectForKey(udb, "TextureList");
 764     if (!textureList)
 765         return;
 766
 767     for (i = 0; i < PLGetNumberOfElements(textureList); i++) {
 768         WMListItem *item;
 769
 770         texture = PLGetArrayElement(textureList, i);
 771
 772         titem = wmalloc(sizeof(TextureListItem));
 773         memset(titem, 0, sizeof(TextureListItem));
 774
 775         titem->title = wstrdup(PLGetString(PLGetArrayElement(texture, 0)));
 776         titem->prop = PLRetain(PLGetArrayElement(texture, 1));
 777         titem->texture = PLGetDescription(titem->prop);
 778         titem->selectedFor = 0;
 779         titem->path = wstrdup(PLGetString(PLGetArrayElement(texture, 2)));
 780
 781         puts(titem->path);
 782         titem->preview = loadRImage(scr, titem->path);
 783         if (!titem->preview) {
 784             titem->preview = renderTexture(scr, titem->prop, TEXPREV_WIDTH,
 785                                            TEXPREV_HEIGHT, NULL, False);
 786         }
 787         item = WMAddListItem(lPtr, "");
 788         item->clientData = titem;
 789     }
 790 }
 791
 792
 793 static void
 794 createPanel(Panel *p)
 795 {
 796     _Panel *panel = (_Panel*)p;
 797     WMColor *color;
 798     WMFont *font;
 799     WMScreen *scr = WMWidgetScreen(panel->win);
 800
 801     char *tmp;
 802     Bool ok = True;
 803
 804     panel->fprefix = wstrappend(wusergnusteppath(), "/.AppInfo");
 805
 806     if (access(panel->fprefix, F_OK)!=0) {
 807         if (mkdir(panel->fprefix, 0755) < 0) {
 808             wsyserror(panel->fprefix);
 809             ok = False;
 810         }
 811     }
 812     if (ok) {
 813         tmp = wstrappend(panel->fprefix, "/WPrefs/");
 814         free(panel->fprefix);
 815         panel->fprefix = tmp;
 816         if (access(panel->fprefix, F_OK)!=0) {
 817             if (mkdir(panel->fprefix, 0755) < 0) {
 818                 wsyserror(panel->fprefix);
 819             }
 820         }
 821     }
 822
 823     panel->smallFont = WMSystemFontOfSize(scr, 10);
 824     panel->normalFont = WMSystemFontOfSize(scr, 12);
 825     panel->boldFont = WMBoldSystemFontOfSize(scr, 12);
 826
 827     panel->onLed = WMCreatePixmapFromXPMData(scr, blueled_xpm);
 828     panel->offLed = WMCreatePixmapFromXPMData(scr, blueled2_xpm);
 829
 830     panel->frame = WMCreateFrame(panel->win);
 831     WMResizeWidget(panel->frame, FRAME_WIDTH, FRAME_HEIGHT);
 832     WMMoveWidget(panel->frame, FRAME_LEFT, FRAME_TOP);
 833
 834     /* preview box */
 835     panel->prevB = WMCreateCommandButton(panel->frame);
 836     WMResizeWidget(panel->prevB, 260, 165);
 837     WMMoveWidget(panel->prevB, 15, 10);
 838     WMSetButtonImagePosition(panel->prevB, WIPImageOnly);
 839
 840     panel->secP = WMCreatePopUpButton(panel->frame);
 841     WMResizeWidget(panel->secP, 260, 20);
 842     WMMoveWidget(panel->secP, 15, 180);
 843     WMSetPopUpButtonSelectedItem(panel->secP, 0);
 844     WMAddPopUpButtonItem(panel->secP, _("Titlebar of Focused Window"));
 845     WMAddPopUpButtonItem(panel->secP, _("Titlebar of Unfocused Windows"));
 846     WMAddPopUpButtonItem(panel->secP, _("Titlebar of Focused Window's Owner"));
 847     WMAddPopUpButtonItem(panel->secP, _("Titlebar of Menus"));
 848     WMAddPopUpButtonItem(panel->secP, _("Menu Items"));
 849     WMAddPopUpButtonItem(panel->secP, _("Icon Background"));
 850 /*    WMAddPopUpButtonItem(panel->secP, _("Workspace Backgrounds"));
 851  */
 852     WMSetPopUpButtonAction(panel->secP, changePage, panel);
 853
 854     /* texture list */
 855     font = WMBoldSystemFontOfSize(scr, 12);
 856
 857     panel->texL = WMCreateLabel(panel->frame);
 858     WMResizeWidget(panel->texL, 225, 18);
 859     WMMoveWidget(panel->texL, 285, 10);
 860     WMSetLabelFont(panel->texL, font);
 861     WMSetLabelText(panel->texL, _("Textures"));
 862     WMSetLabelRelief(panel->texL, WRSunken);
 863     WMSetLabelTextAlignment(panel->texL, WACenter);
 864     color = WMDarkGrayColor(scr);
 865     WMSetWidgetBackgroundColor(panel->texL, color);
 866     WMReleaseColor(color);
 867     color = WMWhiteColor(scr);
 868     WMSetLabelTextColor(panel->texL, color);
 869     WMReleaseColor(color);
 870
 871     WMReleaseFont(font);
 872
 873     panel->texLs = WMCreateList(panel->frame);
 874     WMResizeWidget(panel->texLs, 225, 144);
 875     WMMoveWidget(panel->texLs, 285, 30);
 876     WMSetListUserDrawItemHeight(panel->texLs, 35);
 877     WMSetListUserDrawProc(panel->texLs, paintListItem);
 878     WMHangData(panel->texLs, panel);
 879     WMSetListAction(panel->texLs, textureClick, panel);
 880     WMSetListDoubleAction(panel->texLs, textureDoubleClick, panel);
 881
 882     /* command buttons */
 883
 884     font = WMSystemFontOfSize(scr, 10);
 885
 886
 887     panel->newB = WMCreateCommandButton(panel->frame);
 888     WMResizeWidget(panel->newB, 56, 48);
 889     WMMoveWidget(panel->newB, 285, 180);
 890     WMSetButtonFont(panel->newB, font);
 891     WMSetButtonImagePosition(panel->newB, WIPAbove);
 892     WMSetButtonText(panel->newB, _("New"));
 893     WMSetButtonAction(panel->newB, newTexture, panel);
 894     SetButtonAlphaImage(scr, panel->newB, TNEW_FILE);
 895
 896     panel->ripB = WMCreateCommandButton(panel->frame);
 897     WMResizeWidget(panel->ripB, 56, 48);
 898     WMMoveWidget(panel->ripB, 341, 180);
 899     WMSetButtonFont(panel->ripB, font);
 900     WMSetButtonImagePosition(panel->ripB, WIPAbove);
 901     WMSetButtonText(panel->ripB, _("Extract..."));
 902     SetButtonAlphaImage(scr, panel->ripB, TEXTR_FILE);
 903
 904     WMSetButtonEnabled(panel->ripB, False);
 905
 906     panel->editB = WMCreateCommandButton(panel->frame);
 907     WMResizeWidget(panel->editB, 56, 48);
 908     WMMoveWidget(panel->editB, 397, 180);
 909     WMSetButtonFont(panel->editB, font);
 910     WMSetButtonImagePosition(panel->editB, WIPAbove);
 911     WMSetButtonText(panel->editB, _("Edit"));
 912     SetButtonAlphaImage(scr, panel->editB, TEDIT_FILE);
 913     WMSetButtonAction(panel->editB, editTexture, panel);
 914
 915     panel->delB = WMCreateCommandButton(panel->frame);
 916     WMResizeWidget(panel->delB, 56, 48);
 917     WMMoveWidget(panel->delB, 453, 180);
 918     WMSetButtonFont(panel->delB, font);
 919     WMSetButtonImagePosition(panel->delB, WIPAbove);
 920     WMSetButtonText(panel->delB, _("Delete"));
 921     SetButtonAlphaImage(scr, panel->delB, TDEL_FILE);
 922     WMSetButtonEnabled(panel->delB, False);
 923     WMSetButtonAction(panel->delB, deleteTexture, panel);
 924
 925     WMReleaseFont(font);
 926
 927     /**/
 928
 929     WMRealizeWidget(panel->frame);
 930     WMMapSubwidgets(panel->frame);
 931
 932     WMSetPopUpButtonSelectedItem(panel->secP, 0);
 933
 934     showData(panel);
 935
 936     fillTextureList(panel->texLs);
 937
 938     panel->texturePanel = CreateTexturePanel(panel->win);
 939 }
 940
 941
 942
 943 static proplist_t
 944 setupTextureFor(WMList *list, char *key, char *defValue, char *title,
 945                 int index)
 946 {
 947     WMListItem *item;
 948     TextureListItem *titem;
 949
 950     titem = wmalloc(sizeof(TextureListItem));
 951     memset(titem, 0, sizeof(TextureListItem));
 952
 953     titem->title = wstrdup(title);
 954     titem->prop = GetObjectForKey(key);
 955     if (!titem->prop) {
 956         titem->prop = PLGetProplistWithDescription(defValue);
 957     } else {
 958         PLRetain(titem->prop);
 959     }
 960     titem->texture = PLGetDescription((proplist_t)titem->prop);
 961     titem->current = 1;
 962     titem->selectedFor = 1<<index;
 963
 964     titem->preview = renderTexture(WMWidgetScreen(list), titem->prop,
 965                                    TEXPREV_WIDTH, TEXPREV_HEIGHT, NULL, False);
 966
 967     item = WMAddListItem(list, "");
 968     item->clientData = titem;
 969
 970     return titem->prop;
 971 }
 972
 973
 974
 975 static void
 976 showData(_Panel *panel)
 977 {
 978     int i = 0;
 979
 980     panel->ftitleTex = setupTextureFor(panel->texLs, "FTitleBack",
 981                                        "(solid, black)", "[Focused]", i);
 982     panel->textureIndex[i] = i++;
 983
 984     panel->utitleTex = setupTextureFor(panel->texLs, "UTitleBack",
 985                                        "(solid, gray)", "[Unfocused]", i);
 986     panel->textureIndex[i] = i++;
 987
 988     panel->ptitleTex = setupTextureFor(panel->texLs, "PTitleBack",
 989                                        "(solid, \"#616161\")",
 990                                        "[Owner of Focused]", i);
 991     panel->textureIndex[i] = i++;
 992
 993     panel->mtitleTex = setupTextureFor(panel->texLs, "MenuTitleBack",
 994                                        "(solid, black)", "[Menu Title]", i);
 995     panel->textureIndex[i] = i++;
 996
 997     panel->menuTex = setupTextureFor(panel->texLs, "MenuTextBack",
 998                                      "(solid, gray)", "[Menu Item]", i);
 999     panel->textureIndex[i] = i++;
1000
1001     panel->iconTex = setupTextureFor(panel->texLs, "IconBack",
1002                                      "(solid, gray)", "[Icon]", i);
1003     panel->textureIndex[i] = i++;
1004 /*
1005     panel->backTex = setupTextureFor(panel->texLs, "WorkspaceBack",
1006                                      "(solid, black)", "[Workspace]", i);
1007     panel->textureIndex[i] = i++;
1008  */
1009 }
1010
1011
1012
1013 static void
1014 storeData(_Panel *panel)
1015 {
1016     proplist_t textureList;
1017     proplist_t texture;
1018     int i;
1019     TextureListItem *titem;
1020     WMListItem *item;
1021     WMUserDefaults *udb = WMGetStandardUserDefaults();
1022
1023     textureList = PLMakeArrayFromElements(NULL, NULL);
1024
1025     /* store list of textures */
1026     for (i = 6; i < WMGetListNumberOfRows(panel->texLs); i++) {
1027         item = WMGetListItem(panel->texLs, i);
1028         titem = (TextureListItem*)item->clientData;
1029
1030         texture = PLMakeArrayFromElements(PLMakeString(titem->title),
1031                                           PLRetain(titem->prop),
1032                                           PLMakeString(titem->path),
1033                                           NULL);
1034
1035         PLAppendArrayElement(textureList, texture);
1036     }
1037
1038     WMSetUDObjectForKey(udb, textureList, "TextureList");
1039     PLRelease(textureList);
1040
1041     item = WMGetListItem(panel->texLs, panel->textureIndex[0]);
1042     titem = (TextureListItem*)item->clientData;
1043     SetObjectForKey(titem->prop, "FTitleBack");
1044
1045     item = WMGetListItem(panel->texLs, panel->textureIndex[1]);
1046     titem = (TextureListItem*)item->clientData;
1047     SetObjectForKey(titem->prop, "UTitleBack");
1048
1049     item = WMGetListItem(panel->texLs, panel->textureIndex[2]);
1050     titem = (TextureListItem*)item->clientData;
1051     SetObjectForKey(titem->prop, "PTitleBack");
1052
1053     item = WMGetListItem(panel->texLs, panel->textureIndex[3]);
1054     titem = (TextureListItem*)item->clientData;
1055     SetObjectForKey(titem->prop, "MenuTitleBack");
1056
1057     item = WMGetListItem(panel->texLs, panel->textureIndex[4]);
1058     titem = (TextureListItem*)item->clientData;
1059     SetObjectForKey(titem->prop, "MenuTextBack");
1060
1061     item = WMGetListItem(panel->texLs, panel->textureIndex[5]);
1062     titem = (TextureListItem*)item->clientData;
1063     SetObjectForKey(titem->prop, "IconBack");
1064
1065 }
1066
1067
1068
1069 Panel*
1070 InitAppearance(WMScreen *scr, WMWindow *win)
1071 {
1072     _Panel *panel;
1073
1074     panel = wmalloc(sizeof(_Panel));
1075     memset(panel, 0, sizeof(_Panel));
1076
1077     panel->sectionName = _("Appearance Preferences");
1078
1079     panel->win = win;
1080
1081     panel->callbacks.createWidgets = createPanel;
1082     panel->callbacks.updateDomain = storeData;
1083
1084     AddSection(panel, ICON_FILE);
1085
1086     return panel;
1087 }