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