?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix some "'var' may be used uninitialized" warnings
[wmaker-crm.git] / WPrefs.app / Appearance.c
blob47eafd4320d642fe6f17bbf1cd9865abbb48b8c3
1 /* Apperance.c- color/texture for titlebar etc.
2 *
3 * WPrefs - Window Maker Preferences Program
4 *
5 * Copyright (c) 1999-2003 Alfredo K. Kojima
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 */
21
22 #include "WPrefs.h"
23
24 #include <unistd.h>
25 #include <errno.h>
26 #include <ctype.h>
27 #include <time.h>
28 #include <sys/stat.h>
29 #include <sys/types.h>
30 #include <fcntl.h>
31
32 #include "TexturePanel.h"
33
34 typedef struct _Panel {
35 WMBox *box;
36 char *sectionName;
37
38 char *description;
39
40 CallbackRec callbacks;
41
42 WMWidget *parent;
43
44 WMLabel *prevL;
45
46 WMTabView *tabv;
47
48 /* texture list */
49 WMFrame *texF;
50 WMList *texLs;
51
52 WMPopUpButton *secP;
53
54 WMButton *newB;
55 WMButton *editB;
56 WMButton *ripB;
57 WMButton *delB;
58
59 /* text color */
60 WMFrame *colF;
61
62 WMPopUpButton *colP;
63 WMColor *colors[14];
64
65 WMColorWell *colW;
66
67 WMColorWell *sampW[24];
68
69 /* options */
70 WMFrame *optF;
71
72 WMFrame *mstyF;
73 WMButton *mstyB[3];
74
75 WMFrame *taliF;
76 WMButton *taliB[3];
77
78 /* root bg */
79 WMFrame *bgF;
80
81 WMLabel *bgprevL;
82 WMButton *selbgB;
83
84 WMPopUpButton *modeB[3];
85
86 /* */
87
88 int textureIndex[8];
89
90 WMFont *smallFont;
91 WMFont *normalFont;
92 WMFont *boldFont;
93
94 TexturePanel *texturePanel;
95
96 WMPixmap *onLed;
97 WMPixmap *offLed;
98 WMPixmap *hand;
99
100 int oldsection;
101 int oldcsection;
102
103 char oldTabItem;
104
105 int menuStyle;
106
107 int titleAlignment;
108
109 Pixmap preview;
110 Pixmap previewNoText;
111
112 char *fprefix;
113 } _Panel;
114
115 typedef struct {
116 char *title;
117 char *texture;
118 WMPropList *prop;
119 Pixmap preview;
120
121 char *path;
122
123 char selectedFor;
124 unsigned current:1;
125 unsigned ispixmap:1;
126 } TextureListItem;
127
128 static void updateColorPreviewBox(_Panel * panel, int elements);
129
130 static void showData(_Panel * panel);
131
132 static void changePage(WMWidget * w, void *data);
133
134 static void changeColorPage(WMWidget * w, void *data);
135
136 static void OpenExtractPanelFor(_Panel * panel, char *path);
137
138 static void changedTabItem(struct WMTabViewDelegate *self, WMTabView * tabView, WMTabViewItem * item);
139
140 static WMTabViewDelegate tabviewDelegate = {
141 NULL,
142 NULL, /* didChangeNumberOfItems */
143 changedTabItem, /* didSelectItem */
144 NULL, /* shouldSelectItem */
145 NULL /* willSelectItem */
146 };
147
148 #define ICON_FILE "appearance"
149
150 #define TNEW_FILE "tnew"
151 #define TDEL_FILE "tdel"
152 #define TEDIT_FILE "tedit"
153 #define TEXTR_FILE "textr"
154
155 #define MSTYLE1_FILE "msty1"
156 #define MSTYLE2_FILE "msty2"
157 #define MSTYLE3_FILE "msty3"
158
159 /* XPM */
160 static char *blueled_xpm[] = {
161 "8 8 17 1",
162 " c None",
163 ". c #020204",
164 "+ c #16B6FC",
165 "@ c #176AFC",
166 "# c #163AFC",
167 "$ c #72D2FC",
168 "% c #224CF4",
169 "& c #76D6FC",
170 "* c #16AAFC",
171 "= c #CEE9FC",
172 "- c #229EFC",
173 "; c #164CFC",
174 "> c #FAFEFC",
175 ", c #2482FC",
176 "' c #1652FC",
177 ") c #1E76FC",
178 "! c #1A60FC",
179 " .... ",
180 " .=>-@. ",
181 ".=>$@@'.",
182 ".=$@!;;.",
183 ".!@*+!#.",
184 ".#'*+*,.",
185 " .@)@,. ",
186 " .... "
187 };
188
189 /* XPM */
190 static char *blueled2_xpm[] = {
191 /* width height num_colors chars_per_pixel */
192 " 8 8 17 1",
193 /* colors */
194 ". c None",
195 "# c #090909",
196 "a c #4b63a4",
197 "b c #011578",
198 "c c #264194",
199 "d c #04338c",
200 "e c #989dac",
201 "f c #011a7c",
202 "g c #465c9c",
203 "h c #03278a",
204 "i c #6175ac",
205 "j c #011e74",
206 "k c #043a90",
207 "l c #042f94",
208 "m c #0933a4",
209 "n c #022184",
210 "o c #012998",
211 /* pixels */
212 "..####..",
213 ".#aimn#.",
214 "#aechnf#",
215 "#gchnjf#",
216 "#jndknb#",
217 "#bjdddl#",
218 ".#nono#.",
219 "..####.."
220 };
221
222 /* XPM */
223 static char *hand_xpm[] = {
224 "22 21 19 1",
225 " c None",
226 ". c #030305",
227 "+ c #7F7F7E",
228 "@ c #B5B5B6",
229 "# c #C5C5C6",
230 "$ c #969697",
231 "% c #FDFDFB",
232 "& c #F2F2F4",
233 "* c #E5E5E4",
234 "= c #ECECEC",
235 "- c #DCDCDC",
236 "; c #D2D2D0",
237 "> c #101010",
238 ", c #767674",
239 "' c #676767",
240 ") c #535355",
241 "! c #323234",
242 "~ c #3E3C56",
243 "{ c #333147",
244 " ",
245 " ..... ",
246 " ..+@##$. ",
247 " .%%%&@.......... ",
248 " .%*%%&#%%%%%%%%%$. ",
249 " .*#%%%%%%%%%&&&&==. ",
250 " .-%%%%%%%%%=*-;;;#$. ",
251 " .-%%%%%%%%&..>..... ",
252 " >-%%%%%%%%%*#+. ",
253 " >-%%%%%%%%%*@,. ",
254 " >#%%%%%%%%%*@'. ",
255 " >$&&%%%%%%=... ",
256 " .+@@;=&%%&;$,> ",
257 " .',$@####$+). ",
258 " .!',+$++,'. ",
259 " ..>>>>>. ",
260 " ",
261 " ~~{{{~~ ",
262 " {{{{{{{{{{{ ",
263 " ~~{{{~~ ",
264 " "
265 };
266
267 static char *sampleColors[] = {
268 "black",
269 "#292929",
270 "#525252",
271 "#848484",
272 "#adadad",
273 "#d6d6d6",
274 "white",
275 "#d6d68c",
276 "#d6a57b",
277 "#8cd68c",
278 "#8cd6ce",
279 "#d68c8c",
280 "#8c9cd6",
281 "#bd86d6",
282 "#d68cbd",
283 "#d64a4a",
284 "#4a5ad6",
285 "#4ad6ce",
286 "#4ad65a",
287 "#ced64a",
288 "#d6844a",
289 "#8ad631",
290 "#ce29c6",
291 "#ce2973",
292 "black"
293 };
294
295 static char *textureOptions[] = {
296 "FTitleBack", "(solid, black)", "[Focused]",
297 "UTitleBack", "(solid, gray)", "[Unfocused]",
298 "PTitleBack", "(solid, \"#616161\")", "[Owner of Focused]",
299 "ResizebarBack", "(solid, gray)", "[Resizebar]",
300 "MenuTitleBack", "(solid, black)", "[Menu Title]",
301 "MenuTextBack", "(solid, gray)", "[Menu Item]",
302 "IconBack", "(solid, gray)", "[Icon]"
303 };
304
305 #define RESIZEBAR_BEVEL -1
306 #define MENU_BEVEL -2
307
308 #define TEXPREV_WIDTH 40
309 #define TEXPREV_HEIGHT 24
310
311 #define MSTYLE_NORMAL 0
312 #define MSTYLE_SINGLE 1
313 #define MSTYLE_FLAT 2
314
315 #define FTITLE_COL (1<<0)
316 #define UTITLE_COL (1<<1)
317 #define OTITLE_COL (1<<2)
318 #define MTITLE_COL (1<<3)
319 #define MITEM_COL (1<<4)
320 #define MDISAB_COL (1<<5)
321 #define MHIGH_COL (1<<6)
322 #define MHIGHT_COL (1<<7)
323 #define ICONT_COL (1<<8)
324 #define ICONB_COL (1<<9)
325 #define CLIP_COL (1<<10)
326 #define CCLIP_COL (1<<11)
327
328 static char *colorOptions[] = {
329 "FTitleColor", "white",
330 "UTitleColor", "black",
331 "PTitleColor", "white",
332 "MenuTitleColor", "white",
333 "MenuTextColor", "black",
334 "MenuDisabledColor", "#616161",
335 "HighlightColor", "white",
336 "HighlightTextColor", "black",
337 "IconTitleColor", "white",
338 "IconTitleBack", "black",
339 "ClipTitleColor", "black",
340 "CClipTitleColor", "#454045"
341 };
342
343 static WMRect previewPositions[] = {
344 #define PFOCUSED 0
345 {{30, 10}, {190, 20}},
346 #define PUNFOCUSED 1
347 {{30, 40}, {190, 20}},
348 #define POWNER 2
349 {{30, 70}, {190, 20}},
350 #define PRESIZEBAR 3
351 {{30, 100}, {190, 9}},
352 #define PMTITLE 4
353 {{30, 120}, {90, 20}},
354 #define PMITEM 5
355 {{30, 140}, {90, 20 * 4}},
356 #define PICON 6
357 {{155, 130}, {64, 64}}
358 };
359
360 #define EVERYTHING 0xff
361
362 static WMRect previewColorPositions[] = {
363 {{30, 10}, {190, 20}},
364 {{30, 40}, {190, 20}},
365 {{30, 70}, {190, 20}},
366 {{30, 120}, {90, 20}},
367 {{30, 140}, {90, 20}},
368 {{30, 160}, {90, 20}},
369 {{30, 180}, {90, 20}},
370 {{30, 200}, {90, 20}},
371 {{155, 130}, {64, 64}},
372 {{155, 130}, {64, 64}},
373 {{155, 130}, {64, 64}},
374 {{155, 130}, {64, 64}}
375 };
376
377 static void str2rcolor(RContext * rc, char *name, RColor * color)
378 {
379 XColor xcolor;
380
381 XParseColor(rc->dpy, rc->cmap, name, &xcolor);
382
383 color->alpha = 255;
384 color->red = xcolor.red >> 8;
385 color->green = xcolor.green >> 8;
386 color->blue = xcolor.blue >> 8;
387 }
388
389 static void dumpRImage(char *path, RImage * image)
390 {
391 FILE *f;
392 int channels = (image->format == RRGBAFormat ? 4 : 3);
393
394 f = fopen(path, "wb");
395 if (!f) {
396 werror("%s", path);
397 return;
398 }
399 fprintf(f, "%02x%02x%1x", image->width, image->height, channels);
400
401 fwrite(image->data, 1, image->width * image->height * channels, f);
402
403 fsync(fileno(f));
404 if (fclose(f) < 0) {
405 werror("%s", path);
406 }
407 }
408
409 static int isPixmap(WMPropList * prop)
410 {
411 WMPropList *p;
412 char *s;
413
414 p = WMGetFromPLArray(prop, 0);
415 s = WMGetFromPLString(p);
416 if (strcasecmp(&s[1], "pixmap") == 0)
417 return 1;
418 else
419 return 0;
420 }
421
422 /**********************************************************************/
423
424 static void drawResizebarBevel(RImage * img)
425 {
426 RColor light;
427 RColor dark;
428 RColor black;
429 int width = img->width;
430 int height = img->height;
431 int cwidth = 28;
432
433 black.alpha = 255;
434 black.red = black.green = black.blue = 0;
435
436 light.alpha = 0;
437 light.red = light.green = light.blue = 80;
438
439 dark.alpha = 0;
440 dark.red = dark.green = dark.blue = 40;
441
442 ROperateLine(img, RSubtractOperation, 0, 0, width - 1, 0, &dark);
443 ROperateLine(img, RAddOperation, 0, 1, width - 1, 1, &light);
444
445 ROperateLine(img, RSubtractOperation, cwidth, 2, cwidth, height - 1, &dark);
446 ROperateLine(img, RAddOperation, cwidth + 1, 2, cwidth + 1, height - 1, &light);
447
448 ROperateLine(img, RSubtractOperation, width - cwidth - 2, 2, width - cwidth - 2, height - 1, &dark);
449 ROperateLine(img, RAddOperation, width - cwidth - 1, 2, width - cwidth - 1, height - 1, &light);
450
451 RDrawLine(img, 0, height - 1, width - 1, height - 1, &black);
452 RDrawLine(img, 0, 0, 0, height - 1, &black);
453 RDrawLine(img, width - 1, 0, width - 1, height - 1, &black);
454 }
455
456 static void drawMenuBevel(RImage * img)
457 {
458 RColor light, dark, mid;
459 int i;
460 int iheight = img->height / 4;
461
462 light.alpha = 0;
463 light.red = light.green = light.blue = 80;
464
465 dark.alpha = 255;
466 dark.red = dark.green = dark.blue = 0;
467
468 mid.alpha = 0;
469 mid.red = mid.green = mid.blue = 40;
470
471 for (i = 1; i < 4; i++) {
472 ROperateLine(img, RSubtractOperation, 0, i * iheight - 2, img->width - 1, i * iheight - 2, &mid);
473
474 RDrawLine(img, 0, i * iheight - 1, img->width - 1, i * iheight - 1, &dark);
475
476 ROperateLine(img, RAddOperation, 1, i * iheight, img->width - 2, i * iheight, &light);
477 }
478 }
479
480 static Pixmap renderTexture(WMScreen * scr, WMPropList * texture, int width, int height, char *path, int border)
481 {
482 char *type;
483 RImage *image = NULL;
484 Pixmap pixmap;
485 RContext *rc = WMScreenRContext(scr);
486 char *str;
487 RColor rcolor;
488
489 type = WMGetFromPLString(WMGetFromPLArray(texture, 0));
490
491 if (strcasecmp(type, "solid") == 0) {
492
493 str = WMGetFromPLString(WMGetFromPLArray(texture, 1));
494
495 str2rcolor(rc, str, &rcolor);
496
497 image = RCreateImage(width, height, False);
498 RClearImage(image, &rcolor);
499 } else if (strcasecmp(type, "igradient") == 0) {
500 int t1, t2;
501 RColor c1[2], c2[2];
502
503 str = WMGetFromPLString(WMGetFromPLArray(texture, 1));
504 str2rcolor(rc, str, &c1[0]);
505 str = WMGetFromPLString(WMGetFromPLArray(texture, 2));
506 str2rcolor(rc, str, &c1[1]);
507 str = WMGetFromPLString(WMGetFromPLArray(texture, 3));
508 t1 = atoi(str);
509
510 str = WMGetFromPLString(WMGetFromPLArray(texture, 4));
511 str2rcolor(rc, str, &c2[0]);
512 str = WMGetFromPLString(WMGetFromPLArray(texture, 5));
513 str2rcolor(rc, str, &c2[1]);
514 str = WMGetFromPLString(WMGetFromPLArray(texture, 6));
515 t2 = atoi(str);
516
517 image = RRenderInterwovenGradient(width, height, c1, t1, c2, t2);
518 } else if (strcasecmp(&type[1], "gradient") == 0) {
519 int style;
520 RColor rcolor2;
521
522 switch (toupper(type[0])) {
523 case 'V':
524 style = RVerticalGradient;
525 break;
526 case 'H':
527 style = RHorizontalGradient;
528 break;
529 default:
530 case 'D':
531 style = RDiagonalGradient;
532 break;
533 }
534
535 str = WMGetFromPLString(WMGetFromPLArray(texture, 1));
536 str2rcolor(rc, str, &rcolor);
537 str = WMGetFromPLString(WMGetFromPLArray(texture, 2));
538 str2rcolor(rc, str, &rcolor2);
539
540 image = RRenderGradient(width, height, &rcolor, &rcolor2, style);
541 } else if (strcasecmp(&type[2], "gradient") == 0 && toupper(type[0]) == 'T') {
542 int style;
543 RColor rcolor2;
544 int i;
545 RImage *grad, *timage = NULL;
546 char *path;
547
548 switch (toupper(type[1])) {
549 case 'V':
550 style = RVerticalGradient;
551 break;
552 case 'H':
553 style = RHorizontalGradient;
554 break;
555 default:
556 case 'D':
557 style = RDiagonalGradient;
558 break;
559 }
560
561 str = WMGetFromPLString(WMGetFromPLArray(texture, 3));
562 str2rcolor(rc, str, &rcolor);
563 str = WMGetFromPLString(WMGetFromPLArray(texture, 4));
564 str2rcolor(rc, str, &rcolor2);
565
566 str = WMGetFromPLString(WMGetFromPLArray(texture, 1));
567
568 if ((path = wfindfileinarray(GetObjectForKey("PixmapPath"), str)) != NULL)
569 timage = RLoadImage(rc, path, 0);
570
571 if (!path || !timage) {
572 wwarning("could not load file '%s': %s", path, RMessageForError(RErrorCode));
573 } else {
574 grad = RRenderGradient(width, height, &rcolor, &rcolor2, style);
575
576 image = RMakeTiledImage(timage, width, height);
577 RReleaseImage(timage);
578
579 i = atoi(WMGetFromPLString(WMGetFromPLArray(texture, 2)));
580
581 RCombineImagesWithOpaqueness(image, grad, i);
582 RReleaseImage(grad);
583 }
584 } else if (strcasecmp(&type[2], "gradient") == 0 && toupper(type[0]) == 'M') {
585 int style;
586 RColor **colors;
587 int i, j;
588
589 switch (toupper(type[1])) {
590 case 'V':
591 style = RVerticalGradient;
592 break;
593 case 'H':
594 style = RHorizontalGradient;
595 break;
596 default:
597 case 'D':
598 style = RDiagonalGradient;
599 break;
600 }
601
602 j = WMGetPropListItemCount(texture);
603
604 if (j > 0) {
605 colors = wmalloc(j * sizeof(RColor *));
606
607 for (i = 2; i < j; i++) {
608 str = WMGetFromPLString(WMGetFromPLArray(texture, i));
609 colors[i - 2] = wmalloc(sizeof(RColor));
610 str2rcolor(rc, str, colors[i - 2]);
611 }
612 colors[i - 2] = NULL;
613
614 image = RRenderMultiGradient(width, height, colors, style);
615
616 for (i = 0; colors[i] != NULL; i++)
617 wfree(colors[i]);
618 wfree(colors);
619 }
620 } else if (strcasecmp(&type[1], "pixmap") == 0) {
621 RImage *timage = NULL;
622 char *path;
623 RColor color;
624
625 str = WMGetFromPLString(WMGetFromPLArray(texture, 1));
626
627 if ((path = wfindfileinarray(GetObjectForKey("PixmapPath"), str)) != NULL)
628 timage = RLoadImage(rc, path, 0);
629
630 if (!path || !timage) {
631 wwarning("could not load file '%s': %s", path ? path : str, RMessageForError(RErrorCode));
632 } else {
633 str = WMGetFromPLString(WMGetFromPLArray(texture, 2));
634 str2rcolor(rc, str, &color);
635
636 switch (toupper(type[0])) {
637 case 'T':
638 image = RMakeTiledImage(timage, width, height);
639 RReleaseImage(timage);
640 timage = image;
641 break;
642 case 'C':
643 image = RMakeCenteredImage(timage, width, height, &color);
644 RReleaseImage(timage);
645 timage = image;
646 break;
647 case 'S':
648 case 'M':
649 image = RScaleImage(timage, width, height);
650 RReleaseImage(timage);
651 timage = image;
652 break;
653 }
654
655 }
656 wfree(path);
657 }
658
659 if (!image)
660 return None;
661
662 if (path) {
663 dumpRImage(path, image);
664 }
665
666 if (border < 0) {
667 if (border == RESIZEBAR_BEVEL) {
668 drawResizebarBevel(image);
669 } else if (border == MENU_BEVEL) {
670 drawMenuBevel(image);
671 RBevelImage(image, RBEV_RAISED2);
672 }
673 } else if (border) {
674 RBevelImage(image, border);
675 }
676
677 RConvertImage(rc, image, &pixmap);
678 RReleaseImage(image);
679
680 return pixmap;
681 }
682
683 static Pixmap renderMenu(_Panel * panel, WMPropList * texture, int width, int iheight)
684 {
685 WMScreen *scr = WMWidgetScreen(panel->parent);
686 Display *dpy = WMScreenDisplay(scr);
687 Pixmap pix, tmp;
688 GC gc = XCreateGC(dpy, WMWidgetXID(panel->parent), 0, NULL);
689 int i;
690
691 switch (panel->menuStyle) {
692 case MSTYLE_NORMAL:
693 tmp = renderTexture(scr, texture, width, iheight, NULL, RBEV_RAISED2);
694
695 pix = XCreatePixmap(dpy, tmp, width, iheight * 4, WMScreenDepth(scr));
696 for (i = 0; i < 4; i++) {
697 XCopyArea(dpy, tmp, pix, gc, 0, 0, width, iheight, 0, iheight * i);
698 }
699 XFreePixmap(dpy, tmp);
700 break;
701 case MSTYLE_SINGLE:
702 pix = renderTexture(scr, texture, width, iheight * 4, NULL, MENU_BEVEL);
703 break;
704 case MSTYLE_FLAT:
705 pix = renderTexture(scr, texture, width, iheight * 4, NULL, RBEV_RAISED2);
706 break;
707 default:
708 pix = None;
709 }
710 XFreeGC(dpy, gc);
711
712 return pix;
713 }
714
715 static void renderPreview(_Panel * panel, GC gc, int part, int relief)
716 {
717 WMListItem *item;
718 TextureListItem *titem;
719 Pixmap pix;
720 WMScreen *scr = WMWidgetScreen(panel->box);
721
722 item = WMGetListItem(panel->texLs, panel->textureIndex[part]);
723 titem = (TextureListItem *) item->clientData;
724
725 pix = renderTexture(scr, titem->prop,
726 previewPositions[part].size.width, previewPositions[part].size.height, NULL, relief);
727
728 XCopyArea(WMScreenDisplay(scr), pix, panel->preview, gc, 0, 0,
729 previewPositions[part].size.width,
730 previewPositions[part].size.height, previewPositions[part].pos.x, previewPositions[part].pos.y);
731
732 XCopyArea(WMScreenDisplay(scr), pix, panel->previewNoText, gc, 0, 0,
733 previewPositions[part].size.width,
734 previewPositions[part].size.height, previewPositions[part].pos.x, previewPositions[part].pos.y);
735
736 XFreePixmap(WMScreenDisplay(scr), pix);
737 }
738
739 static void updatePreviewBox(_Panel * panel, int elements)
740 {
741 WMScreen *scr = WMWidgetScreen(panel->parent);
742 Display *dpy = WMScreenDisplay(scr);
743 Pixmap pix;
744 GC gc;
745 int colorUpdate = 0;
746 WMColor *black = WMBlackColor(scr);
747
748 gc = XCreateGC(dpy, WMWidgetXID(panel->parent), 0, NULL);
749
750 if (panel->preview == None) {
751 WMColor *color;
752 WMPixmap *p;
753
754 panel->previewNoText = XCreatePixmap(dpy, WMWidgetXID(panel->parent),
755 240 - 4, 215 - 4, WMScreenDepth(scr));
756
757 p = WMCreatePixmap(scr, 240 - 4, 215 - 4, WMScreenDepth(scr), False);
758 panel->preview = WMGetPixmapXID(p);
759 WMSetLabelImage(panel->prevL, p);
760 WMReleasePixmap(p);
761
762 color = WMCreateRGBColor(scr, 0x5100, 0x5100, 0x7100, True);
763 XFillRectangle(dpy, panel->preview, WMColorGC(color), 0, 0, 240 - 4, 215 - 4);
764 XFillRectangle(dpy, panel->previewNoText, WMColorGC(color), 0, 0, 240 - 4, 215 - 4);
765 WMReleaseColor(color);
766 }
767
768 if (elements & (1 << PFOCUSED)) {
769 renderPreview(panel, gc, PFOCUSED, RBEV_RAISED2);
770 XDrawRectangle(dpy, panel->preview, WMColorGC(black),
771 previewPositions[PFOCUSED].pos.x - 1,
772 previewPositions[PFOCUSED].pos.y - 1,
773 previewPositions[PFOCUSED].size.width, previewPositions[PFOCUSED].size.height);
774 XDrawRectangle(dpy, panel->previewNoText, WMColorGC(black),
775 previewPositions[PFOCUSED].pos.x - 1,
776 previewPositions[PFOCUSED].pos.y - 1,
777 previewPositions[PFOCUSED].size.width, previewPositions[PFOCUSED].size.height);
778 colorUpdate |= FTITLE_COL;
779 }
780 if (elements & (1 << PUNFOCUSED)) {
781 renderPreview(panel, gc, PUNFOCUSED, RBEV_RAISED2);
782 XDrawRectangle(dpy, panel->preview, WMColorGC(black),
783 previewPositions[PUNFOCUSED].pos.x - 1,
784 previewPositions[PUNFOCUSED].pos.y - 1,
785 previewPositions[PUNFOCUSED].size.width, previewPositions[PUNFOCUSED].size.height);
786 XDrawRectangle(dpy, panel->previewNoText, WMColorGC(black),
787 previewPositions[PUNFOCUSED].pos.x - 1,
788 previewPositions[PUNFOCUSED].pos.y - 1,
789 previewPositions[PUNFOCUSED].size.width, previewPositions[PUNFOCUSED].size.height);
790 colorUpdate |= UTITLE_COL;
791 }
792 if (elements & (1 << POWNER)) {
793 renderPreview(panel, gc, POWNER, RBEV_RAISED2);
794 XDrawRectangle(dpy, panel->preview, WMColorGC(black),
795 previewPositions[POWNER].pos.x - 1,
796 previewPositions[POWNER].pos.y - 1,
797 previewPositions[POWNER].size.width, previewPositions[POWNER].size.height);
798 XDrawRectangle(dpy, panel->previewNoText, WMColorGC(black),
799 previewPositions[POWNER].pos.x - 1,
800 previewPositions[POWNER].pos.y - 1,
801 previewPositions[POWNER].size.width, previewPositions[POWNER].size.height);
802 colorUpdate |= OTITLE_COL;
803 }
804 if (elements & (1 << PRESIZEBAR)) {
805 renderPreview(panel, gc, PRESIZEBAR, RESIZEBAR_BEVEL);
806 }
807 if (elements & (1 << PMTITLE)) {
808 renderPreview(panel, gc, PMTITLE, RBEV_RAISED2);
809 colorUpdate |= MTITLE_COL;
810 }
811 if (elements & (1 << PMITEM)) {
812 WMListItem *item;
813 TextureListItem *titem;
814
815 item = WMGetListItem(panel->texLs, panel->textureIndex[5]);
816 titem = (TextureListItem *) item->clientData;
817
818 pix = renderMenu(panel, titem->prop,
819 previewPositions[PMITEM].size.width, previewPositions[PMITEM].size.height / 4);
820
821 XCopyArea(dpy, pix, panel->preview, gc, 0, 0,
822 previewPositions[PMITEM].size.width,
823 previewPositions[PMITEM].size.height,
824 previewPositions[PMITEM].pos.x, previewPositions[PMITEM].pos.y);
825
826 XCopyArea(dpy, pix, panel->previewNoText, gc, 0, 0,
827 previewPositions[PMITEM].size.width,
828 previewPositions[PMITEM].size.height,
829 previewPositions[PMITEM].pos.x, previewPositions[PMITEM].pos.y);
830
831 XFreePixmap(dpy, pix);
832
833 colorUpdate |= MITEM_COL | MDISAB_COL | MHIGH_COL | MHIGHT_COL;
834 }
835 if (elements & (1 << PMITEM | 1 << PMTITLE)) {
836 XDrawLine(dpy, panel->preview, gc, 29, 120, 29, 120 + 20 * 4 + 20);
837 XDrawLine(dpy, panel->preview, gc, 29, 119, 119, 119);
838
839 XDrawLine(dpy, panel->previewNoText, gc, 29, 120, 29, 120 + 20 * 4 + 20);
840 XDrawLine(dpy, panel->previewNoText, gc, 29, 119, 119, 119);
841 }
842 if (elements & (1 << PICON)) {
843 WMListItem *item;
844 TextureListItem *titem;
845
846 item = WMGetListItem(panel->texLs, panel->textureIndex[6]);
847 titem = (TextureListItem *) item->clientData;
848
849 renderPreview(panel, gc, PICON, titem->ispixmap ? 0 : RBEV_RAISED3);
850
851 colorUpdate |= ICONT_COL | ICONB_COL | CLIP_COL | CCLIP_COL;
852 }
853
854 if (colorUpdate)
855 updateColorPreviewBox(panel, colorUpdate);
856 else
857 WMRedisplayWidget(panel->prevL);
858
859 XFreeGC(dpy, gc);
860 WMReleaseColor(black);
861 }
862
863 static void cancelNewTexture(void *data)
864 {
865 _Panel *panel = (_Panel *) data;
866
867 HideTexturePanel(panel->texturePanel);
868 }
869
870 static char *makeFileName(char *prefix)
871 {
872 char *fname;
873
874 fname = wstrdup(prefix);
875
876 while (access(fname, F_OK) == 0) {
877 char buf[30];
878
879 wfree(fname);
880 sprintf(buf, "%08lx.cache", time(NULL));
881 fname = wstrconcat(prefix, buf);
882 }
883
884 return fname;
885 }
886
887 static void okNewTexture(void *data)
888 {
889 _Panel *panel = (_Panel *) data;
890 WMListItem *item;
891 char *name;
892 char *str;
893 WMPropList *prop;
894 TextureListItem *titem;
895 WMScreen *scr = WMWidgetScreen(panel->parent);
896
897 titem = wmalloc(sizeof(TextureListItem));
898 memset(titem, 0, sizeof(TextureListItem));
899
900 HideTexturePanel(panel->texturePanel);
901
902 name = GetTexturePanelTextureName(panel->texturePanel);
903
904 prop = GetTexturePanelTexture(panel->texturePanel);
905
906 str = WMGetPropListDescription(prop, False);
907
908 titem->title = name;
909 titem->prop = prop;
910 titem->texture = str;
911 titem->selectedFor = 0;
912
913 titem->ispixmap = isPixmap(prop);
914
915 titem->path = makeFileName(panel->fprefix);
916 titem->preview = renderTexture(scr, prop, TEXPREV_WIDTH, TEXPREV_HEIGHT, titem->path, 0);
917
918 item = WMAddListItem(panel->texLs, "");
919 item->clientData = titem;
920
921 WMSetListPosition(panel->texLs, WMGetListNumberOfRows(panel->texLs));
922 }
923
924 static void okEditTexture(void *data)
925 {
926 _Panel *panel = (_Panel *) data;
927 WMListItem *item;
928 char *name;
929 char *str;
930 WMPropList *prop;
931 TextureListItem *titem;
932
933 item = WMGetListItem(panel->texLs, WMGetListSelectedItemRow(panel->texLs));
934 titem = (TextureListItem *) item->clientData;
935
936 HideTexturePanel(panel->texturePanel);
937
938 if (titem->current) {
939 name = GetTexturePanelTextureName(panel->texturePanel);
940
941 wfree(titem->title);
942 titem->title = name;
943 }
944
945 prop = GetTexturePanelTexture(panel->texturePanel);
946
947 str = WMGetPropListDescription(prop, False);
948
949 WMReleasePropList(titem->prop);
950 titem->prop = prop;
951
952 titem->ispixmap = isPixmap(prop);
953
954 wfree(titem->texture);
955 titem->texture = str;
956
957 XFreePixmap(WMScreenDisplay(WMWidgetScreen(panel->texLs)), titem->preview);
958 titem->preview = renderTexture(WMWidgetScreen(panel->texLs), titem->prop,
959 TEXPREV_WIDTH, TEXPREV_HEIGHT, titem->path, 0);
960
961 WMRedisplayWidget(panel->texLs);
962
963 if (titem->selectedFor)
964 updatePreviewBox(panel, titem->selectedFor);
965
966 changePage(panel->secP, panel);
967 }
968
969 static void editTexture(WMWidget * w, void *data)
970 {
971 _Panel *panel = (_Panel *) data;
972 WMListItem *item;
973 TextureListItem *titem;
974
975 item = WMGetListItem(panel->texLs, WMGetListSelectedItemRow(panel->texLs));
976 titem = (TextureListItem *) item->clientData;
977
978 SetTexturePanelPixmapPath(panel->texturePanel, GetObjectForKey("PixmapPath"));
979
980 SetTexturePanelTexture(panel->texturePanel, titem->title, titem->prop);
981
982 SetTexturePanelCancelAction(panel->texturePanel, cancelNewTexture, panel);
983 SetTexturePanelOkAction(panel->texturePanel, okEditTexture, panel);
984
985 ShowTexturePanel(panel->texturePanel);
986 }
987
988 static void newTexture(WMWidget * w, void *data)
989 {
990 _Panel *panel = (_Panel *) data;
991
992 SetTexturePanelPixmapPath(panel->texturePanel, GetObjectForKey("PixmapPath"));
993
994 SetTexturePanelTexture(panel->texturePanel, "New Texture", NULL);
995
996 SetTexturePanelCancelAction(panel->texturePanel, cancelNewTexture, panel);
997
998 SetTexturePanelOkAction(panel->texturePanel, okNewTexture, panel);
999
1000 ShowTexturePanel(panel->texturePanel);
1001 }
1002
1003 static void deleteTexture(WMWidget * w, void *data)
1004 {
1005 _Panel *panel = (_Panel *) data;
1006 WMListItem *item;
1007 TextureListItem *titem;
1008 int row;
1009 int section;
1010
1011 section = WMGetPopUpButtonSelectedItem(panel->secP);
1012 row = WMGetListSelectedItemRow(panel->texLs);
1013 item = WMGetListItem(panel->texLs, row);
1014 titem = (TextureListItem *) item->clientData;
1015
1016 if (titem->selectedFor & (1 << section)) {
1017 TextureListItem *titem2;
1018
1019 panel->textureIndex[section] = section;
1020 item = WMGetListItem(panel->texLs, section);
1021 titem2 = (TextureListItem *) item->clientData;
1022 titem2->selectedFor |= 1 << section;
1023 }
1024
1025 wfree(titem->title);
1026 wfree(titem->texture);
1027 WMReleasePropList(titem->prop);
1028 if (titem->path) {
1029 if (remove(titem->path) < 0 && errno != ENOENT) {
1030 werror("could not remove file %s", titem->path);
1031 }
1032 wfree(titem->path);
1033 }
1034
1035 wfree(titem);
1036
1037 WMRemoveListItem(panel->texLs, row);
1038 WMSetButtonEnabled(panel->delB, False);
1039 }
1040
1041 static void extractTexture(WMWidget * w, void *data)
1042 {
1043 _Panel *panel = (_Panel *) data;
1044 char *path;
1045 WMOpenPanel *opanel;
1046 WMScreen *scr = WMWidgetScreen(w);
1047
1048 opanel = WMGetOpenPanel(scr);
1049 WMSetFilePanelCanChooseDirectories(opanel, False);
1050 WMSetFilePanelCanChooseFiles(opanel, True);
1051
1052 if (WMRunModalFilePanelForDirectory(opanel, panel->parent, wgethomedir(), _("Select File"), NULL)) {
1053 path = WMGetFilePanelFileName(opanel);
1054
1055 OpenExtractPanelFor(panel, path);
1056
1057 wfree(path);
1058 }
1059 }
1060
1061 static void changePage(WMWidget * w, void *data)
1062 {
1063 _Panel *panel = (_Panel *) data;
1064 int section;
1065 WMScreen *scr = WMWidgetScreen(panel->box);
1066 RContext *rc = WMScreenRContext(scr);
1067 static WMPoint positions[] = {
1068 {5, 10},
1069 {5, 40},
1070 {5, 70},
1071 {5, 100},
1072 {5, 120},
1073 {5, 160},
1074 {130, 150}
1075 };
1076
1077 if (w) {
1078 section = WMGetPopUpButtonSelectedItem(panel->secP);
1079
1080 WMSelectListItem(panel->texLs, panel->textureIndex[section]);
1081
1082 WMSetListPosition(panel->texLs, panel->textureIndex[section] - 2);
1083 }
1084 {
1085 WMColor *color;
1086
1087 color = WMCreateRGBColor(scr, 0x5100, 0x5100, 0x7100, True);
1088 XFillRectangle(rc->dpy, panel->preview, WMColorGC(color),
1089 positions[panel->oldsection].x, positions[panel->oldsection].y, 22, 22);
1090 WMReleaseColor(color);
1091 }
1092 if (w) {
1093 panel->oldsection = section;
1094 WMDrawPixmap(panel->hand, panel->preview, positions[section].x, positions[section].y);
1095 }
1096 WMRedisplayWidget(panel->prevL);
1097 }
1098
1099 static void previewClick(XEvent * event, void *clientData)
1100 {
1101 _Panel *panel = (_Panel *) clientData;
1102 int i;
1103
1104 switch (panel->oldTabItem) {
1105 case 0:
1106 for (i = 0; i < sizeof(previewPositions) / sizeof(WMRect); i++) {
1107 if (event->xbutton.x >= previewPositions[i].pos.x
1108 && event->xbutton.y >= previewPositions[i].pos.y
1109 && event->xbutton.x < previewPositions[i].pos.x
1110 + previewPositions[i].size.width
1111 && event->xbutton.y < previewPositions[i].pos.y + previewPositions[i].size.height) {
1112
1113 WMSetPopUpButtonSelectedItem(panel->secP, i);
1114 changePage(panel->secP, panel);
1115 return;
1116 }
1117 }
1118 break;
1119 case 1:
1120 for (i = 0; i < WMGetPopUpButtonNumberOfItems(panel->colP); i++) {
1121 if (event->xbutton.x >= previewColorPositions[i].pos.x
1122 && event->xbutton.y >= previewColorPositions[i].pos.y
1123 && event->xbutton.x < previewColorPositions[i].pos.x
1124 + previewColorPositions[i].size.width
1125 && event->xbutton.y < previewColorPositions[i].pos.y
1126 + previewColorPositions[i].size.height) {
1127
1128 /* yuck kluge */
1129 if (i == 7)
1130 i = 4;
1131
1132 WMSetPopUpButtonSelectedItem(panel->colP, i);
1133 changeColorPage(panel->colP, panel);
1134 return;
1135 }
1136 }
1137 break;
1138 }
1139 }
1140
1141 static void textureClick(WMWidget * w, void *data)
1142 {
1143 _Panel *panel = (_Panel *) data;
1144 int i;
1145 WMListItem *item;
1146 TextureListItem *titem;
1147
1148 i = WMGetListSelectedItemRow(panel->texLs);
1149
1150 item = WMGetListItem(panel->texLs, i);
1151
1152 titem = (TextureListItem *) item->clientData;
1153
1154 if (titem->current) {
1155 WMSetButtonEnabled(panel->delB, False);
1156 } else {
1157 WMSetButtonEnabled(panel->delB, True);
1158 }
1159 }
1160
1161 static void textureDoubleClick(WMWidget * w, void *data)
1162 {
1163 _Panel *panel = (_Panel *) data;
1164 int i, section;
1165 WMListItem *item;
1166 TextureListItem *titem;
1167
1168 /* unselect old texture */
1169 section = WMGetPopUpButtonSelectedItem(panel->secP);
1170
1171 item = WMGetListItem(panel->texLs, panel->textureIndex[section]);
1172 titem = (TextureListItem *) item->clientData;
1173 titem->selectedFor &= ~(1 << section);
1174
1175 /* select new texture */
1176 i = WMGetListSelectedItemRow(panel->texLs);
1177
1178 item = WMGetListItem(panel->texLs, i);
1179
1180 titem = (TextureListItem *) item->clientData;
1181
1182 titem->selectedFor |= 1 << section;
1183
1184 panel->textureIndex[section] = i;
1185
1186 WMRedisplayWidget(panel->texLs);
1187
1188 updatePreviewBox(panel, 1 << section);
1189 }
1190
1191 static void paintListItem(WMList * lPtr, int index, Drawable d, char *text, int state, WMRect * rect)
1192 {
1193 _Panel *panel = (_Panel *) WMGetHangedData(lPtr);
1194 WMScreen *scr = WMWidgetScreen(lPtr);
1195 int width, height, x, y;
1196 Display *dpy = WMScreenDisplay(scr);
1197 WMColor *back = (state & WLDSSelected) ? WMWhiteColor(scr) : WMGrayColor(scr);
1198 WMListItem *item;
1199 WMColor *black = WMBlackColor(scr);
1200 TextureListItem *titem;
1201
1202 item = WMGetListItem(lPtr, index);
1203 titem = (TextureListItem *) item->clientData;
1204 if (!titem) {
1205 WMReleaseColor(back);
1206 WMReleaseColor(black);
1207 return;
1208 }
1209
1210 width = rect->size.width;
1211 height = rect->size.height;
1212 x = rect->pos.x;
1213 y = rect->pos.y;
1214
1215 XFillRectangle(dpy, d, WMColorGC(back), x, y, width, height);
1216
1217 if (titem->preview)
1218 XCopyArea(dpy, titem->preview, d, WMColorGC(black), 0, 0,
1219 TEXPREV_WIDTH, TEXPREV_HEIGHT, x + 5, y + 5);
1220
1221 if ((1 << WMGetPopUpButtonSelectedItem(panel->secP)) & titem->selectedFor)
1222 WMDrawPixmap(panel->onLed, d, x + TEXPREV_WIDTH + 10, y + 6);
1223 else if (titem->selectedFor)
1224 WMDrawPixmap(panel->offLed, d, x + TEXPREV_WIDTH + 10, y + 6);
1225
1226 WMDrawString(scr, d, black, panel->boldFont,
1227 x + TEXPREV_WIDTH + 22, y + 2, titem->title, strlen(titem->title));
1228
1229 WMDrawString(scr, d, black, panel->smallFont,
1230 x + TEXPREV_WIDTH + 14, y + 18, titem->texture, strlen(titem->texture));
1231
1232 WMReleaseColor(back);
1233 WMReleaseColor(black);
1234 }
1235
1236 static Pixmap loadRImage(WMScreen * scr, char *path)
1237 {
1238 FILE *f;
1239 RImage *image;
1240 int w, h, d;
1241 Pixmap pixmap;
1242
1243 f = fopen(path, "rb");
1244 if (!f)
1245 return None;
1246
1247 fscanf(f, "%02x%02x%1x", &w, &h, &d);
1248
1249 image = RCreateImage(w, h, d == 4);
1250 fread(image->data, 1, w * h * d, f);
1251 fclose(f);
1252
1253 RConvertImage(WMScreenRContext(scr), image, &pixmap);
1254 RReleaseImage(image);
1255
1256 return pixmap;
1257 }
1258
1259 static void fillTextureList(WMList * lPtr)
1260 {
1261 WMPropList *textureList;
1262 WMPropList *texture;
1263 WMUserDefaults *udb = WMGetStandardUserDefaults();
1264 TextureListItem *titem;
1265 WMScreen *scr = WMWidgetScreen(lPtr);
1266 int i;
1267
1268 textureList = WMGetUDObjectForKey(udb, "TextureList");
1269 if (!textureList)
1270 return;
1271
1272 for (i = 0; i < WMGetPropListItemCount(textureList); i++) {
1273 WMListItem *item;
1274
1275 texture = WMGetFromPLArray(textureList, i);
1276
1277 titem = wmalloc(sizeof(TextureListItem));
1278 memset(titem, 0, sizeof(TextureListItem));
1279
1280 titem->title = wstrdup(WMGetFromPLString(WMGetFromPLArray(texture, 0)));
1281 titem->prop = WMRetainPropList(WMGetFromPLArray(texture, 1));
1282 titem->texture = WMGetPropListDescription(titem->prop, False);
1283 titem->selectedFor = 0;
1284 titem->path = wstrdup(WMGetFromPLString(WMGetFromPLArray(texture, 2)));
1285
1286 titem->preview = loadRImage(scr, titem->path);
1287 if (!titem->preview) {
1288 titem->preview = renderTexture(scr, titem->prop, TEXPREV_WIDTH, TEXPREV_HEIGHT, NULL, 0);
1289 }
1290 item = WMAddListItem(lPtr, "");
1291 item->clientData = titem;
1292 }
1293 }
1294
1295 static void fillColorList(_Panel * panel)
1296 {
1297 WMColor *color;
1298 WMPropList *list;
1299 WMUserDefaults *udb = WMGetStandardUserDefaults();
1300 WMScreen *scr = WMWidgetScreen(panel->box);
1301 int i;
1302
1303 list = WMGetUDObjectForKey(udb, "ColorList");
1304 if (!list) {
1305 for (i = 0; i < 24; i++) {
1306 color = WMCreateNamedColor(scr, sampleColors[i], False);
1307 if (!color)
1308 continue;
1309 WMSetColorWellColor(panel->sampW[i], color);
1310 WMReleaseColor(color);
1311 }
1312 } else {
1313 WMPropList *c;
1314
1315 for (i = 0; i < WMIN(24, WMGetPropListItemCount(list)); i++) {
1316 c = WMGetFromPLArray(list, i);
1317 if (!c || !WMIsPLString(c))
1318 continue;
1319 color = WMCreateNamedColor(scr, WMGetFromPLString(c), False);
1320 if (!color)
1321 continue;
1322 WMSetColorWellColor(panel->sampW[i], color);
1323 WMReleaseColor(color);
1324 }
1325 }
1326 }
1327
1328 /*************************************************************************/
1329
1330 static void changeColorPage(WMWidget * w, void *data)
1331 {
1332 _Panel *panel = (_Panel *) data;
1333 int section;
1334 WMScreen *scr = WMWidgetScreen(panel->box);
1335 RContext *rc = WMScreenRContext(scr);
1336 static WMPoint positions[] = {
1337 {5, 10},
1338 {5, 40},
1339 {5, 70},
1340 {5, 120},
1341 {5, 140},
1342 {5, 160},
1343 {5, 180},
1344 {5, 180},
1345 {130, 140},
1346 {130, 140},
1347 {130, 140},
1348 {130, 140}
1349 };
1350
1351 if (panel->preview) {
1352 WMColor *color;
1353
1354 color = WMCreateRGBColor(scr, 0x5100, 0x5100, 0x7100, True);
1355 XFillRectangle(rc->dpy, panel->preview, WMColorGC(color),
1356 positions[panel->oldcsection].x, positions[panel->oldcsection].y, 22, 22);
1357 WMReleaseColor(color);
1358 }
1359 if (w) {
1360 section = WMGetPopUpButtonSelectedItem(panel->colP);
1361
1362 panel->oldcsection = section;
1363 if (panel->preview)
1364 WMDrawPixmap(panel->hand, panel->preview, positions[section].x, positions[section].y);
1365
1366 section = WMGetPopUpButtonSelectedItem(panel->colP);
1367
1368 WMSetColorWellColor(panel->colW, panel->colors[section]);
1369 }
1370 WMRedisplayWidget(panel->prevL);
1371 }
1372
1373 static void
1374 paintText(WMScreen * scr, Drawable d, WMColor * color, WMFont * font,
1375 int x, int y, int w, int h, WMAlignment align, char *text)
1376 {
1377 int l = strlen(text);
1378
1379 switch (align) {
1380 case WALeft:
1381 x += 5;
1382 break;
1383 case WARight:
1384 x += w - 5 - WMWidthOfString(font, text, l);
1385 break;
1386 default:
1387 case WACenter:
1388 x += (w - WMWidthOfString(font, text, l)) / 2;
1389 break;
1390 }
1391 WMDrawString(scr, d, color, font, x, y + (h - WMFontHeight(font)) / 2, text, l);
1392 }
1393
1394 static void updateColorPreviewBox(_Panel * panel, int elements)
1395 {
1396 WMScreen *scr = WMWidgetScreen(panel->box);
1397 Display *dpy = WMScreenDisplay(scr);
1398 Pixmap d, pnot;
1399 GC gc;
1400
1401 d = panel->preview;
1402 pnot = panel->previewNoText;
1403 gc = WMColorGC(panel->colors[0]);
1404
1405 if (elements & FTITLE_COL) {
1406 XCopyArea(dpy, pnot, d, gc, 30, 10, 190, 20, 30, 10);
1407 paintText(scr, d, panel->colors[0], panel->boldFont, 30, 10, 190, 20,
1408 panel->titleAlignment, _("Focused Window"));
1409 }
1410 if (elements & UTITLE_COL) {
1411 XCopyArea(dpy, pnot, d, gc, 30, 40, 190, 20, 30, 40);
1412 paintText(scr, d, panel->colors[1], panel->boldFont, 30, 40, 190, 20,
1413 panel->titleAlignment, _("Unfocused Window"));
1414 }
1415 if (elements & OTITLE_COL) {
1416 XCopyArea(dpy, pnot, d, gc, 30, 70, 190, 20, 30, 70);
1417 paintText(scr, d, panel->colors[2], panel->boldFont, 30, 70, 190, 20,
1418 panel->titleAlignment, _("Owner of Focused Window"));
1419 }
1420 if (elements & MTITLE_COL) {
1421 XCopyArea(dpy, pnot, d, gc, 30, 120, 90, 20, 30, 120);
1422 paintText(scr, d, panel->colors[3], panel->boldFont, 30, 120, 90, 20, WALeft, _("Menu Title"));
1423 }
1424 if (elements & MITEM_COL) {
1425 XCopyArea(dpy, pnot, d, gc, 30, 140, 90, 20, 30, 140);
1426 paintText(scr, d, panel->colors[4], panel->normalFont, 30, 140, 90, 20, WALeft, _("Normal Item"));
1427 XCopyArea(dpy, pnot, d, gc, 30, 200, 90, 20, 30, 200);
1428 paintText(scr, d, panel->colors[4], panel->normalFont, 30, 200, 90, 20, WALeft, _("Normal Item"));
1429 }
1430 if (elements & MDISAB_COL) {
1431 XCopyArea(dpy, pnot, d, gc, 30, 160, 90, 20, 30, 160);
1432 paintText(scr, d, panel->colors[5], panel->normalFont, 30, 160, 90, 20,
1433 WALeft, _("Disabled Item"));
1434 }
1435 if (elements & MHIGH_COL) {
1436 XFillRectangle(WMScreenDisplay(scr), d, WMColorGC(panel->colors[6]), 31, 181, 87, 17);
1437 XFillRectangle(WMScreenDisplay(scr), pnot, WMColorGC(panel->colors[6]), 31, 181, 87, 17);
1438 elements |= MHIGHT_COL;
1439 }
1440 if (elements & MHIGHT_COL) {
1441 XCopyArea(dpy, pnot, d, gc, 30, 180, 90, 20, 30, 180);
1442 paintText(scr, d, panel->colors[7], panel->normalFont, 30, 180, 90, 20, WALeft, _("Highlighted"));
1443 }
1444 /*
1445 if (elements & ICONT_COL) {
1446 WRITE(_("Focused Window"), panel->colors[8], panel->boldFont,
1447 155, 130, 64);
1448 }
1449 if (elements & ICONB_COL) {
1450 WRITE(_("Focused Window"), panel->colors[9], panel->boldFont,
1451 0, 0, 30);
1452 }
1453 if (elements & CLIP_COL) {
1454 WRITE(_("Focused Window"), panel->colors[10], panel->boldFont,
1455 0, 0, 30);
1456 }
1457 if (elements & CCLIP_COL) {
1458 WRITE(_("Focused Window"), panel->colors[11], panel->boldFont,
1459 0, 0, 30);
1460 }
1461 */
1462 WMRedisplayWidget(panel->prevL);
1463 }
1464
1465 static void colorWellObserver(void *self, WMNotification * n)
1466 {
1467 _Panel *panel = (_Panel *) self;
1468 int p;
1469
1470 p = WMGetPopUpButtonSelectedItem(panel->colP);
1471
1472 WMReleaseColor(panel->colors[p]);
1473
1474 panel->colors[p] = WMRetainColor(WMGetColorWellColor(panel->colW));
1475
1476 updateColorPreviewBox(panel, 1 << p);
1477 }
1478
1479 static void changedTabItem(struct WMTabViewDelegate *self, WMTabView * tabView, WMTabViewItem * item)
1480 {
1481 _Panel *panel = self->data;
1482 int i;
1483
1484 i = WMGetTabViewItemIdentifier(item);
1485 switch (i) {
1486 case 0:
1487 switch (panel->oldTabItem) {
1488 case 1:
1489 changeColorPage(NULL, panel);
1490 break;
1491 }
1492 changePage(panel->secP, panel);
1493 break;
1494 case 1:
1495 switch (panel->oldTabItem) {
1496 case 0:
1497 changePage(NULL, panel);
1498 break;
1499 }
1500 changeColorPage(panel->colP, panel);
1501 break;
1502 case 3:
1503 switch (panel->oldTabItem) {
1504 case 0:
1505 changePage(NULL, panel);
1506 break;
1507 case 1:
1508 changeColorPage(NULL, panel);
1509 break;
1510 }
1511 break;
1512 }
1513
1514 panel->oldTabItem = i;
1515 }
1516
1517 /*************************************************************************/
1518
1519 static void menuStyleCallback(WMWidget * self, void *data)
1520 {
1521 _Panel *panel = (_Panel *) data;
1522
1523 if (self == panel->mstyB[0]) {
1524 panel->menuStyle = MSTYLE_NORMAL;
1525 updatePreviewBox(panel, 1 << PMITEM);
1526
1527 } else if (self == panel->mstyB[1]) {
1528 panel->menuStyle = MSTYLE_SINGLE;
1529 updatePreviewBox(panel, 1 << PMITEM);
1530
1531 } else if (self == panel->mstyB[2]) {
1532 panel->menuStyle = MSTYLE_FLAT;
1533 updatePreviewBox(panel, 1 << PMITEM);
1534 }
1535 }
1536
1537 static void titleAlignCallback(WMWidget * self, void *data)
1538 {
1539 _Panel *panel = (_Panel *) data;
1540
1541 if (self == panel->taliB[0]) {
1542 panel->titleAlignment = WALeft;
1543 updatePreviewBox(panel, 1 << PFOCUSED | 1 << PUNFOCUSED | 1 << POWNER);
1544
1545 } else if (self == panel->taliB[1]) {
1546 panel->titleAlignment = WACenter;
1547 updatePreviewBox(panel, 1 << PFOCUSED | 1 << PUNFOCUSED | 1 << POWNER);
1548
1549 } else if (self == panel->taliB[2]) {
1550 panel->titleAlignment = WARight;
1551 updatePreviewBox(panel, 1 << PFOCUSED | 1 << PUNFOCUSED | 1 << POWNER);
1552 }
1553 }
1554
1555 static void createPanel(Panel * p)
1556 {
1557 _Panel *panel = (_Panel *) p;
1558 WMFont *font;
1559 WMScreen *scr = WMWidgetScreen(panel->parent);
1560 WMTabViewItem *item;
1561 int i;
1562 char *tmp;
1563 Bool ok = True;
1564
1565 panel->fprefix = wstrconcat(wusergnusteppath(), "/Library/WindowMaker");
1566
1567 if (access(panel->fprefix, F_OK) != 0) {
1568 if (mkdir(panel->fprefix, 0755) < 0) {
1569 werror("%s", panel->fprefix);
1570 ok = False;
1571 }
1572 }
1573 if (ok) {
1574 tmp = wstrconcat(panel->fprefix, "/WPrefs/");
1575 wfree(panel->fprefix);
1576 panel->fprefix = tmp;
1577 if (access(panel->fprefix, F_OK) != 0) {
1578 if (mkdir(panel->fprefix, 0755) < 0) {
1579 werror("%s", panel->fprefix);
1580 }
1581 }
1582 }
1583
1584 panel->smallFont = WMSystemFontOfSize(scr, 10);
1585 panel->normalFont = WMSystemFontOfSize(scr, 12);
1586 panel->boldFont = WMBoldSystemFontOfSize(scr, 12);
1587
1588 panel->onLed = WMCreatePixmapFromXPMData(scr, blueled_xpm);
1589 panel->offLed = WMCreatePixmapFromXPMData(scr, blueled2_xpm);
1590 panel->hand = WMCreatePixmapFromXPMData(scr, hand_xpm);
1591
1592 panel->box = WMCreateBox(panel->parent);
1593 WMSetViewExpandsToParent(WMWidgetView(panel->box), 2, 2, 2, 2);
1594
1595 /* preview box */
1596 panel->prevL = WMCreateLabel(panel->box);
1597 WMResizeWidget(panel->prevL, 240, FRAME_HEIGHT - 20);
1598 WMMoveWidget(panel->prevL, 15, 10);
1599 WMSetLabelRelief(panel->prevL, WRSunken);
1600 WMSetLabelImagePosition(panel->prevL, WIPImageOnly);
1601
1602 WMCreateEventHandler(WMWidgetView(panel->prevL), ButtonPressMask, previewClick, panel);
1603
1604 /* tabview */
1605
1606 tabviewDelegate.data = panel;
1607
1608 panel->tabv = WMCreateTabView(panel->box);
1609 WMResizeWidget(panel->tabv, 245, FRAME_HEIGHT - 20);
1610 WMMoveWidget(panel->tabv, 265, 10);
1611 WMSetTabViewDelegate(panel->tabv, &tabviewDelegate);
1612
1613 /*** texture list ***/
1614
1615 panel->texF = WMCreateFrame(panel->box);
1616 WMSetFrameRelief(panel->texF, WRFlat);
1617
1618 item = WMCreateTabViewItemWithIdentifier(0);
1619 WMSetTabViewItemView(item, WMWidgetView(panel->texF));
1620 WMSetTabViewItemLabel(item, _("Texture"));
1621
1622 WMAddItemInTabView(panel->tabv, item);
1623
1624 panel->secP = WMCreatePopUpButton(panel->texF);
1625 WMResizeWidget(panel->secP, 228, 20);
1626 WMMoveWidget(panel->secP, 7, 7);
1627 WMAddPopUpButtonItem(panel->secP, _("Titlebar of Focused Window"));
1628 WMAddPopUpButtonItem(panel->secP, _("Titlebar of Unfocused Windows"));
1629 WMAddPopUpButtonItem(panel->secP, _("Titlebar of Focused Window's Owner"));
1630 WMAddPopUpButtonItem(panel->secP, _("Window Resizebar"));
1631 WMAddPopUpButtonItem(panel->secP, _("Titlebar of Menus"));
1632 WMAddPopUpButtonItem(panel->secP, _("Menu Items"));
1633 WMAddPopUpButtonItem(panel->secP, _("Icon Background"));
1634 /* WMAddPopUpButtonItem(panel->secP, _("Workspace Backgrounds"));
1635 */
1636 WMSetPopUpButtonSelectedItem(panel->secP, 0);
1637 WMSetPopUpButtonAction(panel->secP, changePage, panel);
1638
1639 panel->texLs = WMCreateList(panel->texF);
1640 WMResizeWidget(panel->texLs, 165, 155);
1641 WMMoveWidget(panel->texLs, 70, 33);
1642 WMSetListUserDrawItemHeight(panel->texLs, 35);
1643 WMSetListUserDrawProc(panel->texLs, paintListItem);
1644 WMHangData(panel->texLs, panel);
1645 WMSetListAction(panel->texLs, textureClick, panel);
1646 WMSetListDoubleAction(panel->texLs, textureDoubleClick, panel);
1647
1648 WMSetBalloonTextForView(_("Double click in the texture you want to use\n"
1649 "for the selected item."), WMWidgetView(panel->texLs));
1650
1651 /* command buttons */
1652
1653 font = WMSystemFontOfSize(scr, 10);
1654
1655 panel->newB = WMCreateCommandButton(panel->texF);
1656 WMResizeWidget(panel->newB, 57, 39);
1657 WMMoveWidget(panel->newB, 7, 33);
1658 WMSetButtonFont(panel->newB, font);
1659 WMSetButtonImagePosition(panel->newB, WIPAbove);
1660 WMSetButtonText(panel->newB, _("New"));
1661 WMSetButtonAction(panel->newB, newTexture, panel);
1662 SetButtonAlphaImage(scr, panel->newB, TNEW_FILE, NULL, NULL);
1663
1664 WMSetBalloonTextForView(_("Create a new texture."), WMWidgetView(panel->newB));
1665
1666 panel->ripB = WMCreateCommandButton(panel->texF);
1667 WMResizeWidget(panel->ripB, 57, 39);
1668 WMMoveWidget(panel->ripB, 7, 72);
1669 WMSetButtonFont(panel->ripB, font);
1670 WMSetButtonImagePosition(panel->ripB, WIPAbove);
1671 WMSetButtonText(panel->ripB, _("Extract..."));
1672 WMSetButtonAction(panel->ripB, extractTexture, panel);
1673 SetButtonAlphaImage(scr, panel->ripB, TEXTR_FILE, NULL, NULL);
1674
1675 WMSetBalloonTextForView(_("Extract texture(s) from a theme or a style file."), WMWidgetView(panel->ripB));
1676
1677 WMSetButtonEnabled(panel->ripB, False);
1678
1679 panel->editB = WMCreateCommandButton(panel->texF);
1680 WMResizeWidget(panel->editB, 57, 39);
1681 WMMoveWidget(panel->editB, 7, 111);
1682 WMSetButtonFont(panel->editB, font);
1683 WMSetButtonImagePosition(panel->editB, WIPAbove);
1684 WMSetButtonText(panel->editB, _("Edit"));
1685 SetButtonAlphaImage(scr, panel->editB, TEDIT_FILE, NULL, NULL);
1686 WMSetButtonAction(panel->editB, editTexture, panel);
1687 WMSetBalloonTextForView(_("Edit the highlighted texture."), WMWidgetView(panel->editB));
1688
1689 panel->delB = WMCreateCommandButton(panel->texF);
1690 WMResizeWidget(panel->delB, 57, 38);
1691 WMMoveWidget(panel->delB, 7, 150);
1692 WMSetButtonFont(panel->delB, font);
1693 WMSetButtonImagePosition(panel->delB, WIPAbove);
1694 WMSetButtonText(panel->delB, _("Delete"));
1695 SetButtonAlphaImage(scr, panel->delB, TDEL_FILE, NULL, NULL);
1696 WMSetButtonEnabled(panel->delB, False);
1697 WMSetButtonAction(panel->delB, deleteTexture, panel);
1698 WMSetBalloonTextForView(_("Delete the highlighted texture."), WMWidgetView(panel->delB));
1699
1700 WMReleaseFont(font);
1701
1702 WMMapSubwidgets(panel->texF);
1703
1704 /*** colors ***/
1705 panel->colF = WMCreateFrame(panel->box);
1706 WMSetFrameRelief(panel->colF, WRFlat);
1707
1708 item = WMCreateTabViewItemWithIdentifier(1);
1709 WMSetTabViewItemView(item, WMWidgetView(panel->colF));
1710 WMSetTabViewItemLabel(item, _("Color"));
1711
1712 WMAddItemInTabView(panel->tabv, item);
1713
1714 panel->colP = WMCreatePopUpButton(panel->colF);
1715 WMResizeWidget(panel->colP, 228, 20);
1716 WMMoveWidget(panel->colP, 7, 7);
1717 WMAddPopUpButtonItem(panel->colP, _("Focused Window Title"));
1718 WMAddPopUpButtonItem(panel->colP, _("Unfocused Window Title"));
1719 WMAddPopUpButtonItem(panel->colP, _("Owner of Focused Window Title"));
1720 WMAddPopUpButtonItem(panel->colP, _("Menu Title"));
1721 WMAddPopUpButtonItem(panel->colP, _("Menu Item Text"));
1722 WMAddPopUpButtonItem(panel->colP, _("Disabled Menu Item Text"));
1723 WMAddPopUpButtonItem(panel->colP, _("Menu Highlight Color"));
1724 WMAddPopUpButtonItem(panel->colP, _("Highlighted Menu Text Color"));
1725 /*
1726 WMAddPopUpButtonItem(panel->colP, _("Miniwindow Title"));
1727 WMAddPopUpButtonItem(panel->colP, _("Miniwindow Title Back"));
1728 WMAddPopUpButtonItem(panel->colP, _("Clip Title"));
1729 WMAddPopUpButtonItem(panel->colP, _("Collapsed Clip Title"));
1730 */
1731
1732 WMSetPopUpButtonSelectedItem(panel->colP, 0);
1733
1734 WMSetPopUpButtonAction(panel->colP, changeColorPage, panel);
1735
1736 panel->colW = WMCreateColorWell(panel->colF);
1737 WMResizeWidget(panel->colW, 65, 50);
1738 WMMoveWidget(panel->colW, 30, 75);
1739 WMAddNotificationObserver(colorWellObserver, panel, WMColorWellDidChangeNotification, panel->colW);
1740
1741 for (i = 0; i < 4; i++) {
1742 int j;
1743 for (j = 0; j < 6; j++) {
1744 panel->sampW[i + j * 4] = WMCreateColorWell(panel->colF);
1745 WMResizeWidget(panel->sampW[i + j * 4], 22, 22);
1746 WMMoveWidget(panel->sampW[i + j * 4], 130 + i * 22, 40 + j * 22);
1747 WSetColorWellBordered(panel->sampW[i + j * 4], False);
1748 }
1749 }
1750
1751 WMMapSubwidgets(panel->colF);
1752
1753 #ifdef unfinished
1754 /*** root bg ***/
1755
1756 panel->bgF = WMCreateFrame(panel->box);
1757 WMSetFrameRelief(panel->bgF, WRFlat);
1758
1759 item = WMCreateTabViewItemWithIdentifier(2);
1760 WMSetTabViewItemView(item, WMWidgetView(panel->bgF));
1761 WMSetTabViewItemLabel(item, _("Background"));
1762
1763 WMAddItemInTabView(panel->tabv, item);
1764
1765 panel->bgprevL = WMCreateLabel(panel->bgF);
1766 WMResizeWidget(panel->bgprevL, 230, 155);
1767 WMMoveWidget(panel->bgprevL, 5, 5);
1768 WMSetLabelRelief(panel->bgprevL, WRSunken);
1769
1770 panel->selbgB = WMCreateCommandButton(panel->bgF);
1771 WMMoveWidget(panel->selbgB, 5, 165);
1772 WMResizeWidget(panel->selbgB, 100, 24);
1773 WMSetButtonText(panel->selbgB, _("Browse..."));
1774
1775 WMMapSubwidgets(panel->bgF);
1776 #endif /* unfinished */
1777 /*** options ***/
1778 panel->optF = WMCreateFrame(panel->box);
1779 WMSetFrameRelief(panel->optF, WRFlat);
1780
1781 item = WMCreateTabViewItemWithIdentifier(3);
1782 WMSetTabViewItemView(item, WMWidgetView(panel->optF));
1783 WMSetTabViewItemLabel(item, _("Options"));
1784
1785 WMAddItemInTabView(panel->tabv, item);
1786
1787 panel->mstyF = WMCreateFrame(panel->optF);
1788 WMResizeWidget(panel->mstyF, 215, 85);
1789 WMMoveWidget(panel->mstyF, 15, 10);
1790 WMSetFrameTitle(panel->mstyF, _("Menu Style"));
1791
1792 for (i = 0; i < 3; i++) {
1793 WMPixmap *icon;
1794 char *path;
1795
1796 panel->mstyB[i] = WMCreateButton(panel->mstyF, WBTOnOff);
1797 WMResizeWidget(panel->mstyB[i], 54, 54);
1798 WMMoveWidget(panel->mstyB[i], 15 + i * 65, 20);
1799 WMSetButtonImagePosition(panel->mstyB[i], WIPImageOnly);
1800 WMSetButtonAction(panel->mstyB[i], menuStyleCallback, panel);
1801 switch (i) {
1802 case 0:
1803 path = LocateImage(MSTYLE1_FILE);
1804 break;
1805 case 1:
1806 path = LocateImage(MSTYLE2_FILE);
1807 break;
1808 case 2:
1809 path = LocateImage(MSTYLE3_FILE);
1810 break;
1811 }
1812 if (path) {
1813 icon = WMCreatePixmapFromFile(scr, path);
1814 if (icon) {
1815 WMSetButtonImage(panel->mstyB[i], icon);
1816 WMReleasePixmap(icon);
1817 } else {
1818 wwarning(_("could not load icon file %s"), path);
1819 }
1820 wfree(path);
1821 }
1822 }
1823 WMGroupButtons(panel->mstyB[0], panel->mstyB[1]);
1824 WMGroupButtons(panel->mstyB[0], panel->mstyB[2]);
1825
1826 WMMapSubwidgets(panel->mstyF);
1827
1828 panel->taliF = WMCreateFrame(panel->optF);
1829 WMResizeWidget(panel->taliF, 110, 80);
1830 WMMoveWidget(panel->taliF, 15, 100);
1831 WMSetFrameTitle(panel->taliF, _("Title Alignment"));
1832
1833 for (i = 0; i < 3; i++) {
1834 panel->taliB[i] = WMCreateRadioButton(panel->taliF);
1835 WMSetButtonAction(panel->taliB[i], titleAlignCallback, panel);
1836 switch (i) {
1837 case 0:
1838 WMSetButtonText(panel->taliB[i], _("Left"));
1839 break;
1840 case 1:
1841 WMSetButtonText(panel->taliB[i], _("Center"));
1842 break;
1843 case 2:
1844 WMSetButtonText(panel->taliB[i], _("Right"));
1845 break;
1846 }
1847 WMResizeWidget(panel->taliB[i], 90, 18);
1848 WMMoveWidget(panel->taliB[i], 10, 15 + 20 * i);
1849 }
1850 WMGroupButtons(panel->taliB[0], panel->taliB[1]);
1851 WMGroupButtons(panel->taliB[0], panel->taliB[2]);
1852
1853 WMMapSubwidgets(panel->taliF);
1854
1855 WMMapSubwidgets(panel->optF);
1856
1857 /**/ WMRealizeWidget(panel->box);
1858 WMMapSubwidgets(panel->box);
1859
1860 WMSetPopUpButtonSelectedItem(panel->secP, 0);
1861
1862 showData(panel);
1863
1864 changePage(panel->secP, panel);
1865
1866 fillTextureList(panel->texLs);
1867
1868 fillColorList(panel);
1869
1870 panel->texturePanel = CreateTexturePanel(panel->parent);
1871 }
1872
1873 static void setupTextureFor(WMList * list, char *key, char *defValue, char *title, int index)
1874 {
1875 WMListItem *item;
1876 TextureListItem *titem;
1877
1878 titem = wmalloc(sizeof(TextureListItem));
1879 memset(titem, 0, sizeof(TextureListItem));
1880
1881 titem->title = wstrdup(title);
1882 titem->prop = GetObjectForKey(key);
1883 if (!titem->prop || !WMIsPLArray(titem->prop)) {
1884 /* Maybe also give a error message to stderr that the entry is bad? */
1885 titem->prop = WMCreatePropListFromDescription(defValue);
1886 } else {
1887 WMRetainPropList(titem->prop);
1888 }
1889 titem->texture = WMGetPropListDescription((WMPropList *) titem->prop, False);
1890 titem->current = 1;
1891 titem->selectedFor = 1 << index;
1892
1893 titem->ispixmap = isPixmap(titem->prop);
1894
1895 titem->preview = renderTexture(WMWidgetScreen(list), titem->prop, TEXPREV_WIDTH, TEXPREV_HEIGHT, NULL, 0);
1896
1897 item = WMAddListItem(list, "");
1898 item->clientData = titem;
1899 }
1900
1901 static void showData(_Panel * panel)
1902 {
1903 int i;
1904 char *str;
1905
1906 str = GetStringForKey("MenuStyle");
1907 if (str && strcasecmp(str, "flat") == 0) {
1908 panel->menuStyle = MSTYLE_FLAT;
1909 } else if (str && strcasecmp(str, "singletexture") == 0) {
1910 panel->menuStyle = MSTYLE_SINGLE;
1911 } else {
1912 panel->menuStyle = MSTYLE_NORMAL;
1913 }
1914
1915 str = GetStringForKey("TitleJustify");
1916 if (str && strcasecmp(str, "left") == 0) {
1917 panel->titleAlignment = WALeft;
1918 } else if (str && strcasecmp(str, "right") == 0) {
1919 panel->titleAlignment = WARight;
1920 } else {
1921 panel->titleAlignment = WACenter;
1922 }
1923
1924 for (i = 0; i < sizeof(colorOptions) / (2 * sizeof(char *)); i++) {
1925 WMColor *color;
1926
1927 str = GetStringForKey(colorOptions[i * 2]);
1928 if (!str)
1929 str = colorOptions[i * 2 + 1];
1930
1931 if (!(color = WMCreateNamedColor(WMWidgetScreen(panel->box), str, False))) {
1932 color = WMCreateNamedColor(WMWidgetScreen(panel->box), "#000000", False);
1933 }
1934
1935 panel->colors[i] = color;
1936 }
1937 changeColorPage(panel->colP, panel);
1938
1939 for (i = 0; i < sizeof(textureOptions) / (3 * sizeof(char *)); i++) {
1940 setupTextureFor(panel->texLs, textureOptions[i * 3],
1941 textureOptions[i * 3 + 1], textureOptions[i * 3 + 2], i);
1942 panel->textureIndex[i] = i;
1943 }
1944 updatePreviewBox(panel, EVERYTHING);
1945
1946 WMSetButtonSelected(panel->mstyB[panel->menuStyle], True);
1947 WMSetButtonSelected(panel->taliB[panel->titleAlignment], True);
1948 }
1949
1950 static void storeData(_Panel * panel)
1951 {
1952 TextureListItem *titem;
1953 WMListItem *item;
1954 int i;
1955
1956 for (i = 0; i < sizeof(textureOptions) / (sizeof(char *) * 3); i++) {
1957 item = WMGetListItem(panel->texLs, panel->textureIndex[i]);
1958 titem = (TextureListItem *) item->clientData;
1959 SetObjectForKey(titem->prop, textureOptions[i * 3]);
1960 }
1961
1962 for (i = 0; i < 8; i++) {
1963 char *str;
1964
1965 str = WMGetColorRGBDescription(panel->colors[i]);
1966
1967 if (str) {
1968 SetStringForKey(str, colorOptions[i * 2]);
1969 wfree(str);
1970 }
1971 }
1972
1973 switch (panel->menuStyle) {
1974 case MSTYLE_SINGLE:
1975 SetStringForKey("singletexture", "MenuStyle");
1976 break;
1977 case MSTYLE_FLAT:
1978 SetStringForKey("flat", "MenuStyle");
1979 break;
1980 default:
1981 case MSTYLE_NORMAL:
1982 SetStringForKey("normal", "MenuStyle");
1983 break;
1984 }
1985 switch (panel->titleAlignment) {
1986 case WALeft:
1987 SetStringForKey("left", "TitleJustify");
1988 break;
1989 case WARight:
1990 SetStringForKey("right", "TitleJustify");
1991 break;
1992 default:
1993 case WACenter:
1994 SetStringForKey("center", "TitleJustify");
1995 break;
1996 }
1997 }
1998
1999 static void prepareForClose(_Panel * panel)
2000 {
2001 WMPropList *textureList;
2002 WMPropList *texture;
2003 TextureListItem *titem;
2004 WMListItem *item;
2005 WMUserDefaults *udb = WMGetStandardUserDefaults();
2006 int i;
2007
2008 textureList = WMCreatePLArray(NULL, NULL);
2009
2010 /* store list of textures */
2011 for (i = 7; i < WMGetListNumberOfRows(panel->texLs); i++) {
2012 item = WMGetListItem(panel->texLs, i);
2013 titem = (TextureListItem *) item->clientData;
2014
2015 texture = WMCreatePLArray(WMCreatePLString(titem->title),
2016 WMRetainPropList(titem->prop), WMCreatePLString(titem->path), NULL);
2017
2018 WMAddToPLArray(textureList, texture);
2019 }
2020
2021 WMSetUDObjectForKey(udb, textureList, "TextureList");
2022 WMReleasePropList(textureList);
2023
2024 /* store list of colors */
2025 textureList = WMCreatePLArray(NULL, NULL);
2026 for (i = 0; i < 24; i++) {
2027 WMColor *color;
2028 char *str;
2029
2030 color = WMGetColorWellColor(panel->sampW[i]);
2031
2032 str = WMGetColorRGBDescription(color);
2033 WMAddToPLArray(textureList, WMCreatePLString(str));
2034 wfree(str);
2035 }
2036 WMSetUDObjectForKey(udb, textureList, "ColorList");
2037 WMReleasePropList(textureList);
2038
2039 WMSynchronizeUserDefaults(udb);
2040 }
2041
2042 Panel *InitAppearance(WMScreen * scr, WMWindow * win)
2043 {
2044 _Panel *panel;
2045
2046 panel = wmalloc(sizeof(_Panel));
2047 memset(panel, 0, sizeof(_Panel));
2048
2049 panel->sectionName = _("Appearance Preferences");
2050
2051 panel->description = _("Background texture configuration for windows,\n" "menus and icons.");
2052
2053 panel->parent = win;
2054
2055 panel->callbacks.createWidgets = createPanel;
2056 panel->callbacks.updateDomain = storeData;
2057 panel->callbacks.prepareForClose = prepareForClose;
2058
2059 AddSection(panel, ICON_FILE);
2060
2061 return panel;
2062 }
2063
2064 /****************************************************************************/
2065
2066 typedef struct ExtractPanel {
2067 WMWindow *win;
2068
2069 WMLabel *label;
2070 WMList *list;
2071
2072 WMButton *closeB;
2073 WMButton *extrB;
2074 } ExtractPanel;
2075
2076 static void OpenExtractPanelFor(_Panel * panel, char *path)
2077 {
2078 ExtractPanel *epanel;
2079 WMColor *color;
2080 WMFont *font;
2081 WMScreen *scr = WMWidgetScreen(panel->parent);
2082
2083 epanel = wmalloc(sizeof(ExtractPanel));
2084 epanel->win = WMCreatePanelWithStyleForWindow(panel->parent, "extract",
2085 WMTitledWindowMask | WMClosableWindowMask);
2086 WMResizeWidget(epanel->win, 245, 250);
2087 WMSetWindowTitle(epanel->win, _("Extract Texture"));
2088
2089 epanel->label = WMCreateLabel(epanel->win);
2090 WMResizeWidget(epanel->label, 225, 18);
2091 WMMoveWidget(epanel->label, 10, 10);
2092 WMSetLabelTextAlignment(epanel->label, WACenter);
2093 WMSetLabelRelief(epanel->label, WRSunken);
2094
2095 color = WMDarkGrayColor(scr);
2096 WMSetWidgetBackgroundColor(epanel->label, color);
2097 WMReleaseColor(color);
2098
2099 color = WMWhiteColor(scr);
2100 WMSetLabelTextColor(epanel->label, color);
2101 WMReleaseColor(color);
2102
2103 font = WMBoldSystemFontOfSize(scr, 12);
2104 WMSetLabelFont(epanel->label, font);
2105 WMReleaseFont(font);
2106
2107 WMSetLabelText(epanel->label, _("Textures"));
2108
2109 epanel->list = WMCreateList(epanel->win);
2110 WMResizeWidget(epanel->list, 225, 165);
2111 WMMoveWidget(epanel->list, 10, 30);
2112
2113 epanel->closeB = WMCreateCommandButton(epanel->win);
2114 WMResizeWidget(epanel->closeB, 74, 24);
2115 WMMoveWidget(epanel->closeB, 165, 215);
2116 WMSetButtonText(epanel->closeB, _("Close"));
2117
2118 epanel->extrB = WMCreateCommandButton(epanel->win);
2119 WMResizeWidget(epanel->extrB, 74, 24);
2120 WMMoveWidget(epanel->extrB, 80, 215);
2121 WMSetButtonText(epanel->extrB, _("Extract"));
2122
2123 WMMapSubwidgets(epanel->win);
2124
2125 /* take textures from file */
2126
2127 WMRealizeWidget(epanel->win);
2128
2129 WMMapWidget(epanel->win);
2130 }
The Window Maker window manager