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