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