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