Change to the linux kernel coding style
[wmaker-crm.git] / WPrefs.app / TexturePanel.c
blob4a8335686be5f5b6e26042165c9df1e26b939ea3
1 /* TexturePanel.c- texture editting panel
2 *
3 * WPrefs - WindowMaker Preferences Program
4 *
5 * Copyright (c) 1998-2003 Alfredo K. Kojima
6 * Copyright (c) 1998 James Thompson
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
21 * USA.
22 *
23 */
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <unistd.h>
29 #include <ctype.h>
31 #include <X11/Xlib.h>
33 #include <WINGs/WINGs.h>
35 #include "WPrefs.h"
37 #include "TexturePanel.h"
39 #define MAX_SECTION_PARTS 5
41 typedef struct _TexturePanel {
42 WMWindow *win;
44 /* texture name */
45 WMFrame *nameF;
46 WMTextField *nameT;
48 /* texture type */
49 WMPopUpButton *typeP;
51 /* default color */
52 WMFrame *defcF;
53 WMColorWell *defcW;
55 WMFont *listFont;
57 /*-- Gradient --*/
59 Pixmap gimage;
61 /* colors */
62 WMFrame *gcolF;
63 WMList *gcolL;
64 WMButton *gcolaB;
65 WMButton *gcoldB;
66 WMSlider *ghueS;
67 WMSlider *gsatS;
68 WMSlider *gvalS;
70 WMSlider *gbriS;
71 WMSlider *gconS;
73 /* direction (common) */
74 WMFrame *dirF;
75 WMButton *dirhB;
76 WMButton *dirvB;
77 WMButton *dirdB;
79 /*-- Simple Gradient --*/
81 /*-- Textured Gradient --*/
83 WMFrame *tcolF;
84 WMColorWell *tcol1W;
85 WMColorWell *tcol2W;
87 WMFrame *topaF;
88 WMSlider *topaS;
90 /*-- Image --*/
91 WMFrame *imageF;
92 WMScrollView *imageV;
93 WMTextField *imageT;
94 WMLabel *imageL;
95 WMButton *browB;
96 WMButton *dispB;
97 WMPopUpButton *arrP;
99 RImage *image;
100 char *imageFile;
102 /*****/
104 WMButton *okB;
105 WMButton *cancelB;
107 WMCallback *okAction;
108 void *okData;
110 WMCallback *cancelAction;
111 void *cancelData;
113 /****/
114 WMWidget *sectionParts[5][MAX_SECTION_PARTS];
116 int currentType;
118 WMPropList *pathList;
120 } _TexturePanel;
122 #define TYPE_SOLID 0
123 #define TYPE_GRADIENT 1
124 #define TYPE_SGRADIENT 2
125 #define TYPE_TGRADIENT 3
126 #define TYPE_PIXMAP 4
128 #define PTYPE_TILE 0
129 #define PTYPE_SCALE 1
130 #define PTYPE_CENTER 2
131 #define PTYPE_MAXIMIZE 3
133 /*
134 *--------------------------------------------------------------------------
135 * Private Functions
136 *--------------------------------------------------------------------------
137 */
139 /************/
141 static void updateGradButtons(TexturePanel * panel)
143 RImage *image;
144 WMPixmap *pixmap;
145 int colorn;
146 RColor **colors;
148 colorn = WMGetListNumberOfRows(panel->gcolL);
149 if (colorn < 1) {
150 pixmap = NULL;
151 } else {
152 int i;
153 WMListItem *item;
155 colors = wmalloc(sizeof(RColor *) * (colorn + 1));
157 for (i = 0; i < colorn; i++) {
158 item = WMGetListItem(panel->gcolL, i);
159 colors[i] = (RColor *) item->clientData;
161 colors[i] = NULL;
163 image = RRenderMultiGradient(80, 30, colors, RHorizontalGradient);
164 pixmap = WMCreatePixmapFromRImage(WMWidgetScreen(panel->gcolL), image, 128);
165 RReleaseImage(image);
166 WMSetButtonImage(panel->dirhB, pixmap);
167 WMReleasePixmap(pixmap);
169 image = RRenderMultiGradient(80, 30, colors, RVerticalGradient);
170 pixmap = WMCreatePixmapFromRImage(WMWidgetScreen(panel->gcolL), image, 128);
171 RReleaseImage(image);
172 WMSetButtonImage(panel->dirvB, pixmap);
173 WMReleasePixmap(pixmap);
175 image = RRenderMultiGradient(80, 30, colors, RDiagonalGradient);
176 pixmap = WMCreatePixmapFromRImage(WMWidgetScreen(panel->gcolL), image, 128);
177 RReleaseImage(image);
178 WMSetButtonImage(panel->dirdB, pixmap);
179 WMReleasePixmap(pixmap);
181 wfree(colors);
185 static void updateTGradImage(TexturePanel * panel)
187 RImage *image, *gradient;
188 WMPixmap *pixmap;
189 RColor from;
190 RColor to;
191 WMColor *color;
193 if (!panel->image)
194 return;
196 color = WMGetColorWellColor(panel->tcol1W);
197 from.red = WMRedComponentOfColor(color) >> 8;
198 from.green = WMGreenComponentOfColor(color) >> 8;
199 from.blue = WMBlueComponentOfColor(color) >> 8;
201 color = WMGetColorWellColor(panel->tcol2W);
202 to.red = WMRedComponentOfColor(color) >> 8;
203 to.green = WMGreenComponentOfColor(color) >> 8;
204 to.blue = WMBlueComponentOfColor(color) >> 8;
206 if (panel->image->width < 141 || panel->image->height < 91) {
207 image = RMakeTiledImage(panel->image, 141, 91);
208 } else {
209 image = RCloneImage(panel->image);
212 if (WMGetButtonSelected(panel->dirhB)) {
213 gradient = RRenderGradient(image->width, image->height, &from, &to, RHorizontalGradient);
214 } else if (WMGetButtonSelected(panel->dirvB)) {
215 gradient = RRenderGradient(image->width, image->height, &from, &to, RVerticalGradient);
216 } else {
217 gradient = RRenderGradient(image->width, image->height, &from, &to, RDiagonalGradient);
220 RCombineImagesWithOpaqueness(image, gradient, WMGetSliderValue(panel->topaS));
221 RReleaseImage(gradient);
222 pixmap = WMCreatePixmapFromRImage(WMWidgetScreen(panel->win), image, 128);
224 WMSetLabelImage(panel->imageL, pixmap);
225 WMReleasePixmap(pixmap);
226 WMResizeWidget(panel->imageL, image->width, image->height);
227 RReleaseImage(image);
230 static void updateSGradButtons(TexturePanel * panel)
232 RImage *image;
233 WMPixmap *pixmap;
234 RColor from;
235 RColor to;
236 WMColor *color;
238 color = WMGetColorWellColor(panel->tcol1W);
239 from.red = WMRedComponentOfColor(color) >> 8;
240 from.green = WMGreenComponentOfColor(color) >> 8;
241 from.blue = WMBlueComponentOfColor(color) >> 8;
243 color = WMGetColorWellColor(panel->tcol2W);
244 to.red = WMRedComponentOfColor(color) >> 8;
245 to.green = WMGreenComponentOfColor(color) >> 8;
246 to.blue = WMBlueComponentOfColor(color) >> 8;
248 image = RRenderGradient(80, 30, &from, &to, RHorizontalGradient);
249 pixmap = WMCreatePixmapFromRImage(WMWidgetScreen(panel->gcolL), image, 128);
250 RReleaseImage(image);
251 WMSetButtonImage(panel->dirhB, pixmap);
252 WMReleasePixmap(pixmap);
254 image = RRenderGradient(80, 30, &from, &to, RVerticalGradient);
255 pixmap = WMCreatePixmapFromRImage(WMWidgetScreen(panel->gcolL), image, 128);
256 RReleaseImage(image);
257 WMSetButtonImage(panel->dirvB, pixmap);
258 WMReleasePixmap(pixmap);
260 image = RRenderGradient(80, 30, &from, &to, RDiagonalGradient);
261 pixmap = WMCreatePixmapFromRImage(WMWidgetScreen(panel->gcolL), image, 128);
262 RReleaseImage(image);
263 WMSetButtonImage(panel->dirdB, pixmap);
264 WMReleasePixmap(pixmap);
267 /*********** Gradient ************/
269 static void updateSVSlider(WMSlider * sPtr, Bool saturation, WMFont * font, RHSVColor * hsv)
271 RImage *image;
272 WMPixmap *pixmap;
273 WMScreen *scr = WMWidgetScreen(sPtr);
274 RColor from, to;
275 RHSVColor tmp;
276 char *buffer;
278 tmp = *hsv;
279 if (saturation) {
280 tmp.saturation = 0;
281 RHSVtoRGB(&tmp, &from);
282 tmp.saturation = 255;
283 RHSVtoRGB(&tmp, &to);
284 } else {
285 tmp.value = 0;
286 RHSVtoRGB(&tmp, &from);
287 tmp.value = 255;
288 RHSVtoRGB(&tmp, &to);
290 image = RRenderGradient(130, 16, &from, &to, RHorizontalGradient);
291 pixmap = WMCreatePixmapFromRImage(scr, image, 128);
292 RReleaseImage(image);
294 if (saturation)
295 buffer = wstrdup(_("Saturation"));
296 else
297 buffer = wstrdup(_("Brightness"));
299 if (hsv->value < 128 || !saturation) {
300 WMColor *col = WMWhiteColor(scr);
302 WMDrawString(scr, WMGetPixmapXID(pixmap), col, font, 2,
303 (16 - WMFontHeight(font)) / 2 - 1, buffer, strlen(buffer));
304 WMReleaseColor(col);
305 } else {
306 WMColor *col = WMBlackColor(scr);
308 WMDrawString(scr, WMGetPixmapXID(pixmap), col, font, 2,
309 (16 - WMFontHeight(font)) / 2 - 1, buffer, strlen(buffer));
310 WMReleaseColor(col);
312 wfree(buffer);
313 WMSetSliderImage(sPtr, pixmap);
314 WMReleasePixmap(pixmap);
317 static void updateHueSlider(WMSlider * sPtr, WMFont * font, RHSVColor * hsv)
319 RColor *colors[8];
320 RImage *image;
321 WMPixmap *pixmap;
322 WMScreen *scr = WMWidgetScreen(sPtr);
323 RHSVColor thsv;
324 int i;
326 thsv = *hsv;
327 for (i = 0; i <= 6; i++) {
328 thsv.hue = (360 * i) / 6;
329 colors[i] = wmalloc(sizeof(RColor));
330 RHSVtoRGB(&thsv, colors[i]);
332 colors[i] = NULL;
334 image = RRenderMultiGradient(130, 16, colors, RGRD_HORIZONTAL);
335 pixmap = WMCreatePixmapFromRImage(scr, image, 128);
336 RReleaseImage(image);
338 if (hsv->value < 128) {
339 WMColor *col = WMWhiteColor(scr);
341 WMDrawString(scr, WMGetPixmapXID(pixmap), col, font, 2,
342 (16 - WMFontHeight(font)) / 2 - 1, _("Hue"), strlen(_("Hue")));
343 WMReleaseColor(col);
344 } else {
345 WMColor *col = WMBlackColor(scr);
347 WMDrawString(scr, WMGetPixmapXID(pixmap), col, font, 2,
348 (16 - WMFontHeight(font)) / 2 - 1, _("Hue"), strlen(_("Hue")));
349 WMReleaseColor(col);
351 WMSetSliderImage(sPtr, pixmap);
352 WMReleasePixmap(pixmap);
354 for (i = 0; i <= 6; i++)
355 wfree(colors[i]);
358 static void sliderChangeCallback(WMWidget * w, void *data)
360 TexturePanel *panel = (TexturePanel *) data;
361 RHSVColor hsv;
362 int row, rows;
363 WMListItem *item;
364 RColor **colors;
365 int i;
366 RImage *image;
367 WMScreen *scr = WMWidgetScreen(w);
369 hsv.hue = WMGetSliderValue(panel->ghueS);
370 hsv.saturation = WMGetSliderValue(panel->gsatS);
371 hsv.value = WMGetSliderValue(panel->gvalS);
373 row = WMGetListSelectedItemRow(panel->gcolL);
374 if (row >= 0) {
375 RColor *rgb;
377 item = WMGetListItem(panel->gcolL, row);
379 rgb = (RColor *) item->clientData;
381 RHSVtoRGB(&hsv, rgb);
383 sprintf(item->text, "%02x,%02x,%02x", rgb->red, rgb->green, rgb->blue);
386 if (w == panel->ghueS) {
387 updateSVSlider(panel->gsatS, True, panel->listFont, &hsv);
388 updateSVSlider(panel->gvalS, False, panel->listFont, &hsv);
389 } else if (w == panel->gsatS) {
390 updateHueSlider(panel->ghueS, panel->listFont, &hsv);
391 updateSVSlider(panel->gvalS, False, panel->listFont, &hsv);
392 } else {
393 updateHueSlider(panel->ghueS, panel->listFont, &hsv);
394 updateSVSlider(panel->gsatS, True, panel->listFont, &hsv);
397 rows = WMGetListNumberOfRows(panel->gcolL);
398 if (rows == 0)
399 return;
401 colors = wmalloc(sizeof(RColor *) * (rows + 1));
403 for (i = 0; i < rows; i++) {
404 item = WMGetListItem(panel->gcolL, i);
406 colors[i] = (RColor *) item->clientData;
408 colors[i] = NULL;
410 if (panel->gimage != None) {
411 XFreePixmap(WMScreenDisplay(scr), panel->gimage);
414 image = RRenderMultiGradient(30, i * WMGetListItemHeight(panel->gcolL), colors, RVerticalGradient);
415 RConvertImage(WMScreenRContext(scr), image, &panel->gimage);
416 RReleaseImage(image);
418 wfree(colors);
420 WMRedisplayWidget(panel->gcolL);
422 updateGradButtons(panel);
425 static void paintGradListItem(WMList * lPtr, int index, Drawable d, char *text, int state, WMRect * rect)
427 TexturePanel *panel = (TexturePanel *) WMGetHangedData(lPtr);
428 WMScreen *scr = WMWidgetScreen(lPtr);
429 WMColor *white = WMWhiteColor(scr);
430 WMColor *black = WMBlackColor(scr);
431 WMColor *gray = WMGrayColor(scr);
432 WMListItem *item;
433 int width, height, x, y;
434 Display *dpy;
436 dpy = WMScreenDisplay(scr);
438 width = rect->size.width;
439 height = rect->size.height;
440 x = rect->pos.x;
441 y = rect->pos.y;
443 if (state & WLDSSelected)
444 XFillRectangle(dpy, d, WMColorGC(white), x, y, width, height);
445 else
446 XFillRectangle(dpy, d, WMColorGC(gray), x, y, width, height);
448 item = WMGetListItem(lPtr, index);
450 if (panel->gimage) {
451 XCopyArea(WMScreenDisplay(scr), panel->gimage, d, WMColorGC(white),
452 0, height * index, 30, height, x + 5, y);
454 WMDrawString(scr, d, black, panel->listFont, x + 40, y + 1, text, strlen(text));
456 WMReleaseColor(white);
457 WMReleaseColor(black);
458 WMReleaseColor(gray);
461 static void gradAddCallback(WMWidget * w, void *data)
463 TexturePanel *panel = (TexturePanel *) data;
464 WMListItem *item;
465 int row;
466 RColor *rgb;
468 row = WMGetListSelectedItemRow(panel->gcolL) + 1;
469 item = WMInsertListItem(panel->gcolL, row, "00,00,00");
470 rgb = wmalloc(sizeof(RColor));
471 memset(rgb, 0, sizeof(RColor));
472 item->clientData = rgb;
474 WMSelectListItem(panel->gcolL, row);
476 updateGradButtons(panel);
478 sliderChangeCallback(panel->ghueS, panel);
480 WMSetButtonEnabled(panel->okB, WMGetListNumberOfRows(panel->gcolL) > 1);
483 static void gradClickCallback(WMWidget * w, void *data)
485 TexturePanel *panel = (TexturePanel *) data;
486 WMListItem *item;
487 int row;
488 RHSVColor hsv;
490 row = WMGetListSelectedItemRow(w);
491 if (row < 0)
492 return;
494 item = WMGetListItem(panel->gcolL, row);
495 RRGBtoHSV((RColor *) item->clientData, &hsv);
497 WMSetSliderValue(panel->ghueS, hsv.hue);
498 WMSetSliderValue(panel->gsatS, hsv.saturation);
499 WMSetSliderValue(panel->gvalS, hsv.value);
501 sliderChangeCallback(panel->ghueS, panel);
502 sliderChangeCallback(panel->gsatS, panel);
505 static void gradDeleteCallback(WMWidget * w, void *data)
507 TexturePanel *panel = (TexturePanel *) data;
508 WMListItem *item;
509 int row;
511 row = WMGetListSelectedItemRow(panel->gcolL);
512 if (row < 0)
513 return;
515 item = WMGetListItem(panel->gcolL, row);
516 wfree(item->clientData);
518 WMRemoveListItem(panel->gcolL, row);
520 WMSelectListItem(panel->gcolL, row - 1);
522 updateGradButtons(panel);
524 gradClickCallback(panel->gcolL, panel);
526 WMSetButtonEnabled(panel->okB, WMGetListNumberOfRows(panel->gcolL) > 1);
529 /*************** Simple Gradient ***************/
531 static void colorWellObserver(void *self, WMNotification * n)
533 updateSGradButtons(self);
536 static void opaqChangeCallback(WMWidget * w, void *data)
538 TexturePanel *panel = (TexturePanel *) data;
540 updateTGradImage(panel);
543 /****************** Image ******************/
545 static void updateImage(TexturePanel * panel, char *path)
547 WMScreen *scr = WMWidgetScreen(panel->win);
548 RImage *image;
549 WMPixmap *pixmap;
550 WMSize size;
552 if (path) {
553 image = RLoadImage(WMScreenRContext(scr), path, 0);
554 if (!image) {
555 char *message;
557 message = wstrconcat(_("Could not load the selected file: "),
558 (char *)RMessageForError(RErrorCode));
560 WMRunAlertPanel(scr, panel->win, _("Error"), message, _("OK"), NULL, NULL);
562 if (!panel->image)
563 WMSetButtonEnabled(panel->okB, False);
565 wfree(message);
566 return;
569 WMSetButtonEnabled(panel->okB, True);
571 if (panel->image)
572 RReleaseImage(panel->image);
573 panel->image = image;
574 } else {
575 image = panel->image;
578 if (WMGetPopUpButtonSelectedItem(panel->typeP) == TYPE_PIXMAP) {
579 if (image) {
580 pixmap = WMCreatePixmapFromRImage(scr, image, 128);
582 size = WMGetPixmapSize(pixmap);
583 WMSetLabelImage(panel->imageL, pixmap);
584 WMResizeWidget(panel->imageL, size.width, size.height);
586 WMReleasePixmap(pixmap);
588 } else {
589 updateTGradImage(panel);
593 static void browseImageCallback(WMWidget * w, void *data)
595 TexturePanel *panel = (TexturePanel *) data;
596 WMOpenPanel *opanel;
597 WMScreen *scr = WMWidgetScreen(w);
598 static char *ipath = NULL;
600 opanel = WMGetOpenPanel(scr);
601 WMSetFilePanelCanChooseDirectories(opanel, False);
602 WMSetFilePanelCanChooseFiles(opanel, True);
604 if (!ipath)
605 ipath = wstrdup(wgethomedir());
607 if (WMRunModalFilePanelForDirectory(opanel, panel->win, ipath, _("Open Image"), NULL)) {
608 char *path, *fullpath;
609 char *tmp, *tmp2;
611 tmp = WMGetFilePanelFileName(opanel);
612 if (!tmp)
613 return;
614 fullpath = tmp;
616 wfree(ipath);
617 ipath = fullpath;
619 path = wstrdup(fullpath);
621 tmp2 = strrchr(fullpath, '/');
622 if (tmp2)
623 tmp2++;
625 tmp = wfindfileinarray(panel->pathList, tmp2);
627 if (tmp) {
628 if (strcmp(fullpath, tmp) == 0) {
629 wfree(path);
630 path = tmp2;
632 wfree(tmp);
635 if (!RGetImageFileFormat(fullpath)) {
636 WMRunAlertPanel(scr, panel->win, _("Error"),
637 _("The selected file does not contain a supported image."),
638 _("OK"), NULL, NULL);
639 wfree(path);
640 } else {
641 updateImage(panel, fullpath);
642 wfree(panel->imageFile);
643 panel->imageFile = path;
645 WMSetTextFieldText(panel->imageT, path);
650 static void buttonCallback(WMWidget * w, void *data)
652 TexturePanel *panel = (TexturePanel *) data;
654 if (w == panel->okB) {
655 (*panel->okAction) (panel->okData);
656 } else {
657 (*panel->cancelAction) (panel->cancelData);
661 static void changeTypeCallback(WMWidget * w, void *data)
663 TexturePanel *panel = (TexturePanel *) data;
664 int newType;
665 int i;
667 newType = WMGetPopUpButtonSelectedItem(w);
668 if (newType == panel->currentType)
669 return;
671 if (panel->currentType >= 0) {
672 for (i = 0; i < MAX_SECTION_PARTS; i++) {
673 if (panel->sectionParts[panel->currentType][i] == NULL)
674 break;
675 WMUnmapWidget(panel->sectionParts[panel->currentType][i]);
679 for (i = 0; i < MAX_SECTION_PARTS; i++) {
680 if (panel->sectionParts[newType][i] == NULL)
681 break;
682 WMMapWidget(panel->sectionParts[newType][i]);
684 panel->currentType = newType;
686 switch (newType) {
687 case TYPE_SGRADIENT:
688 updateSGradButtons(panel);
689 WMSetButtonEnabled(panel->okB, True);
690 break;
691 case TYPE_GRADIENT:
692 updateGradButtons(panel);
693 WMSetButtonEnabled(panel->okB, WMGetListNumberOfRows(panel->gcolL) > 1);
694 break;
695 case TYPE_TGRADIENT:
696 case TYPE_PIXMAP:
697 updateImage(panel, NULL);
698 WMSetButtonEnabled(panel->okB, panel->image != NULL);
699 break;
700 default:
701 WMSetButtonEnabled(panel->okB, True);
702 break;
706 /*
707 *--------------------------------------------------------------------------
708 * Public functions
709 *--------------------------------------------------------------------------
710 */
711 void DestroyTexturePanel(TexturePanel * panel)
716 void ShowTexturePanel(TexturePanel * panel)
718 Display *dpy = WMScreenDisplay(WMWidgetScreen(panel->win));
719 Screen *scr = DefaultScreenOfDisplay(dpy);
721 WMSetWindowInitialPosition(panel->win,
722 (WidthOfScreen(scr) - WMWidgetWidth(panel->win)) / 2,
723 (HeightOfScreen(scr) - WMWidgetHeight(panel->win)) / 2);
724 WMMapWidget(panel->win);
727 void HideTexturePanel(TexturePanel * panel)
729 WMUnmapWidget(panel->win);
732 void SetTexturePanelOkAction(TexturePanel * panel, WMCallback * action, void *clientData)
734 panel->okAction = action;
735 panel->okData = clientData;
738 void SetTexturePanelCancelAction(TexturePanel * panel, WMCallback * action, void *clientData)
740 panel->cancelAction = action;
741 panel->cancelData = clientData;
744 void SetTexturePanelTexture(TexturePanel * panel, char *name, WMPropList * texture)
746 WMScreen *scr = WMWidgetScreen(panel->win);
747 char *str, *type;
748 WMPropList *p;
749 WMColor *color;
750 int i;
751 char buffer[64];
752 int gradient = 0;
754 WMSetTextFieldText(panel->nameT, name);
756 if (!texture)
757 return;
759 p = WMGetFromPLArray(texture, 0);
760 if (!p) {
761 goto bad_texture;
763 type = WMGetFromPLString(p);
765 /*............................................... */
766 if (strcasecmp(type, "solid") == 0) {
768 WMSetPopUpButtonSelectedItem(panel->typeP, TYPE_SOLID);
770 p = WMGetFromPLArray(texture, 1);
771 if (!p) {
772 str = "black";
773 } else {
774 str = WMGetFromPLString(p);
776 color = WMCreateNamedColor(scr, str, False);
778 WMSetColorWellColor(panel->defcW, color);
780 WMReleaseColor(color);
781 /*............................................... */
782 } else if (strcasecmp(type, "hgradient") == 0
783 || strcasecmp(type, "vgradient") == 0 || strcasecmp(type, "dgradient") == 0) {
785 WMSetPopUpButtonSelectedItem(panel->typeP, TYPE_SGRADIENT);
787 p = WMGetFromPLArray(texture, 1);
788 if (!p) {
789 str = "black";
790 } else {
791 str = WMGetFromPLString(p);
793 color = WMCreateNamedColor(scr, str, False);
795 WMSetColorWellColor(panel->tcol1W, color);
797 WMReleaseColor(color);
799 p = WMGetFromPLArray(texture, 2);
800 if (!p) {
801 str = "black";
802 } else {
803 str = WMGetFromPLString(p);
805 color = WMCreateNamedColor(scr, str, False);
807 WMSetColorWellColor(panel->tcol2W, color);
809 WMReleaseColor(color);
811 gradient = type[0];
812 /*............................................... */
813 } else if (strcasecmp(type, "thgradient") == 0
814 || strcasecmp(type, "tvgradient") == 0 || strcasecmp(type, "tdgradient") == 0) {
815 int i;
817 WMSetPopUpButtonSelectedItem(panel->typeP, TYPE_TGRADIENT);
819 gradient = type[1];
821 WMSetTextFieldText(panel->imageT, WMGetFromPLString(WMGetFromPLArray(texture, 1)));
822 if (panel->imageFile)
823 wfree(panel->imageFile);
824 panel->imageFile = wstrdup(WMGetFromPLString(WMGetFromPLArray(texture, 1)));
826 i = 180;
827 sscanf(WMGetFromPLString(WMGetFromPLArray(texture, 2)), "%i", &i);
828 WMSetSliderValue(panel->topaS, i);
830 p = WMGetFromPLArray(texture, 3);
831 if (!p) {
832 str = "black";
833 } else {
834 str = WMGetFromPLString(p);
836 color = WMCreateNamedColor(scr, str, False);
838 WMSetColorWellColor(panel->tcol1W, color);
840 WMReleaseColor(color);
842 p = WMGetFromPLArray(texture, 4);
843 if (!p) {
844 str = "black";
845 } else {
846 str = WMGetFromPLString(p);
848 color = WMCreateNamedColor(scr, str, False);
850 WMSetColorWellColor(panel->tcol2W, color);
852 WMReleaseColor(color);
854 WMSetTextFieldText(panel->imageT, WMGetFromPLString(WMGetFromPLArray(texture, 1)));
856 if (panel->imageFile)
857 wfree(panel->imageFile);
858 if ((panel->imageFile = wfindfileinarray(panel->pathList,
859 WMGetFromPLString(WMGetFromPLArray(texture, 1)))) !=
860 NULL) {
862 panel->image = RLoadImage(WMScreenRContext(scr), panel->imageFile, 0);
863 updateTGradImage(panel);
865 updateSGradButtons(panel);
866 } else
867 wwarning(_("could not load file '%s': %s"), panel->imageFile,
868 RMessageForError(RErrorCode));
870 /*............................................... */
871 } else if (strcasecmp(type, "mhgradient") == 0
872 || strcasecmp(type, "mvgradient") == 0 || strcasecmp(type, "mdgradient") == 0) {
873 WMListItem *item;
875 for (i = 0; i < WMGetListNumberOfRows(panel->gcolL); i++) {
876 item = WMGetListItem(panel->gcolL, i);
877 wfree(item->clientData);
879 WMClearList(panel->gcolL);
881 WMSetPopUpButtonSelectedItem(panel->typeP, TYPE_GRADIENT);
883 p = WMGetFromPLArray(texture, 1);
884 if (!p) {
885 str = "black";
886 } else {
887 str = WMGetFromPLString(p);
889 color = WMCreateNamedColor(scr, str, False);
891 WMSetColorWellColor(panel->defcW, color);
893 WMReleaseColor(color);
895 for (i = 2; i < WMGetPropListItemCount(texture); i++) {
896 RColor *rgb;
897 XColor xcolor;
899 p = WMGetFromPLArray(texture, i);
900 if (!p) {
901 str = "black";
902 } else {
903 str = WMGetFromPLString(p);
906 XParseColor(WMScreenDisplay(scr), WMScreenRContext(scr)->cmap, str, &xcolor);
908 rgb = wmalloc(sizeof(RColor));
909 rgb->red = xcolor.red >> 8;
910 rgb->green = xcolor.green >> 8;
911 rgb->blue = xcolor.blue >> 8;
912 sprintf(buffer, "%02x,%02x,%02x", rgb->red, rgb->green, rgb->blue);
914 item = WMAddListItem(panel->gcolL, buffer);
915 item->clientData = rgb;
918 sliderChangeCallback(panel->ghueS, panel);
920 gradient = type[1];
921 /*............................................... */
922 } else if (strcasecmp(type, "cpixmap") == 0
923 || strcasecmp(type, "spixmap") == 0
924 || strcasecmp(type, "mpixmap") == 0 || strcasecmp(type, "tpixmap") == 0) {
926 WMSetPopUpButtonSelectedItem(panel->typeP, TYPE_PIXMAP);
928 switch (toupper(type[0])) {
929 case 'C':
930 WMSetPopUpButtonSelectedItem(panel->arrP, PTYPE_CENTER);
931 break;
932 case 'S':
933 WMSetPopUpButtonSelectedItem(panel->arrP, PTYPE_SCALE);
934 break;
935 case 'M':
936 WMSetPopUpButtonSelectedItem(panel->arrP, PTYPE_MAXIMIZE);
937 break;
938 default:
939 case 'T':
940 WMSetPopUpButtonSelectedItem(panel->arrP, PTYPE_TILE);
941 break;
944 WMSetTextFieldText(panel->imageT, WMGetFromPLString(WMGetFromPLArray(texture, 1)));
946 if (panel->imageFile)
947 wfree(panel->imageFile);
948 panel->imageFile = wfindfileinarray(panel->pathList,
949 WMGetFromPLString(WMGetFromPLArray(texture, 1)));
951 color = WMCreateNamedColor(scr, WMGetFromPLString(WMGetFromPLArray(texture, 2)), False);
952 WMSetColorWellColor(panel->defcW, color);
953 WMReleaseColor(color);
955 updateImage(panel, panel->imageFile);
958 changeTypeCallback(panel->typeP, panel);
960 if (gradient > 0) {
961 updateGradButtons(panel);
963 switch (toupper(gradient)) {
964 case 'H':
965 WMPerformButtonClick(panel->dirhB);
966 break;
967 case 'V':
968 WMPerformButtonClick(panel->dirvB);
969 break;
970 default:
971 case 'D':
972 WMPerformButtonClick(panel->dirdB);
973 break;
977 return;
979 bad_texture:
980 str = WMGetPropListDescription(texture, False);
981 wwarning(_("error creating texture %s"), str);
982 wfree(str);
986 char *GetTexturePanelTextureName(TexturePanel * panel)
988 return WMGetTextFieldText(panel->nameT);
992 WMPropList *GetTexturePanelTexture(TexturePanel * panel)
994 WMPropList *prop = NULL;
995 WMColor *color;
996 char *str, *str2;
997 char buff[32];
998 int i;
1000 switch (WMGetPopUpButtonSelectedItem(panel->typeP)) {
1002 case TYPE_SOLID:
1003 color = WMGetColorWellColor(panel->defcW);
1004 str = WMGetColorRGBDescription(color);
1005 prop = WMCreatePLArray(WMCreatePLString("solid"), WMCreatePLString(str), NULL);
1006 wfree(str);
1008 break;
1010 case TYPE_PIXMAP:
1011 color = WMGetColorWellColor(panel->defcW);
1012 str = WMGetColorRGBDescription(color);
1014 switch (WMGetPopUpButtonSelectedItem(panel->arrP)) {
1015 case PTYPE_SCALE:
1016 prop = WMCreatePLArray(WMCreatePLString("spixmap"),
1017 WMCreatePLString(panel->imageFile), WMCreatePLString(str), NULL);
1018 break;
1019 case PTYPE_MAXIMIZE:
1020 prop = WMCreatePLArray(WMCreatePLString("mpixmap"),
1021 WMCreatePLString(panel->imageFile), WMCreatePLString(str), NULL);
1022 break;
1023 case PTYPE_CENTER:
1024 prop = WMCreatePLArray(WMCreatePLString("cpixmap"),
1025 WMCreatePLString(panel->imageFile), WMCreatePLString(str), NULL);
1026 break;
1027 case PTYPE_TILE:
1028 prop = WMCreatePLArray(WMCreatePLString("tpixmap"),
1029 WMCreatePLString(panel->imageFile), WMCreatePLString(str), NULL);
1030 break;
1032 wfree(str);
1033 break;
1035 case TYPE_TGRADIENT:
1036 color = WMGetColorWellColor(panel->tcol1W);
1037 str = WMGetColorRGBDescription(color);
1039 color = WMGetColorWellColor(panel->tcol2W);
1040 str2 = WMGetColorRGBDescription(color);
1042 sprintf(buff, "%i", WMGetSliderValue(panel->topaS));
1044 if (WMGetButtonSelected(panel->dirdB)) {
1045 prop = WMCreatePLArray(WMCreatePLString("tdgradient"),
1046 WMCreatePLString(panel->imageFile),
1047 WMCreatePLString(buff),
1048 WMCreatePLString(str), WMCreatePLString(str2), NULL);
1049 } else if (WMGetButtonSelected(panel->dirvB)) {
1050 prop = WMCreatePLArray(WMCreatePLString("tvgradient"),
1051 WMCreatePLString(panel->imageFile),
1052 WMCreatePLString(buff),
1053 WMCreatePLString(str), WMCreatePLString(str2), NULL);
1054 } else {
1055 prop = WMCreatePLArray(WMCreatePLString("thgradient"),
1056 WMCreatePLString(panel->imageFile),
1057 WMCreatePLString(buff),
1058 WMCreatePLString(str), WMCreatePLString(str2), NULL);
1060 wfree(str);
1061 wfree(str2);
1062 break;
1064 case TYPE_SGRADIENT:
1065 color = WMGetColorWellColor(panel->tcol1W);
1066 str = WMGetColorRGBDescription(color);
1068 color = WMGetColorWellColor(panel->tcol2W);
1069 str2 = WMGetColorRGBDescription(color);
1071 if (WMGetButtonSelected(panel->dirdB)) {
1072 prop = WMCreatePLArray(WMCreatePLString("dgradient"),
1073 WMCreatePLString(str), WMCreatePLString(str2), NULL);
1074 } else if (WMGetButtonSelected(panel->dirvB)) {
1075 prop = WMCreatePLArray(WMCreatePLString("vgradient"),
1076 WMCreatePLString(str), WMCreatePLString(str2), NULL);
1077 } else {
1078 prop = WMCreatePLArray(WMCreatePLString("hgradient"),
1079 WMCreatePLString(str), WMCreatePLString(str2), NULL);
1081 wfree(str);
1082 wfree(str2);
1083 break;
1085 case TYPE_GRADIENT:
1086 color = WMGetColorWellColor(panel->defcW);
1087 str = WMGetColorRGBDescription(color);
1089 if (WMGetButtonSelected(panel->dirdB)) {
1090 prop = WMCreatePLArray(WMCreatePLString("mdgradient"), WMCreatePLString(str), NULL);
1091 } else if (WMGetButtonSelected(panel->dirvB)) {
1092 prop = WMCreatePLArray(WMCreatePLString("mvgradient"), WMCreatePLString(str), NULL);
1093 } else {
1094 prop = WMCreatePLArray(WMCreatePLString("mhgradient"), WMCreatePLString(str), NULL);
1096 wfree(str);
1098 for (i = 0; i < WMGetListNumberOfRows(panel->gcolL); i++) {
1099 RColor *rgb;
1100 WMListItem *item;
1102 item = WMGetListItem(panel->gcolL, i);
1104 rgb = (RColor *) item->clientData;
1106 sprintf(buff, "#%02x%02x%02x", rgb->red, rgb->green, rgb->blue);
1108 WMAddToPLArray(prop, WMCreatePLString(buff));
1110 break;
1113 return prop;
1116 void SetTexturePanelPixmapPath(TexturePanel * panel, WMPropList * array)
1118 panel->pathList = array;
1121 TexturePanel *CreateTexturePanel(WMWindow * keyWindow)
1122 /*CreateTexturePanel(WMScreen *scr)*/
1124 TexturePanel *panel;
1125 WMScreen *scr = WMWidgetScreen(keyWindow);
1127 panel = wmalloc(sizeof(TexturePanel));
1128 memset(panel, 0, sizeof(TexturePanel));
1130 panel->listFont = WMSystemFontOfSize(scr, 12);
1132 panel->win = WMCreatePanelWithStyleForWindow(keyWindow, "texturePanel",
1133 WMTitledWindowMask | WMClosableWindowMask);
1134 /*
1135 panel->win = WMCreateWindowWithStyle(scr, "texturePanel",
1136 WMTitledWindowMask
1137 |WMClosableWindowMask);
1138 */
1140 WMResizeWidget(panel->win, 325, 423);
1141 WMSetWindowTitle(panel->win, _("Texture Panel"));
1142 WMSetWindowCloseAction(panel->win, buttonCallback, panel);
1144 /* texture name */
1145 panel->nameF = WMCreateFrame(panel->win);
1146 WMResizeWidget(panel->nameF, 185, 50);
1147 WMMoveWidget(panel->nameF, 15, 10);
1148 WMSetFrameTitle(panel->nameF, _("Texture Name"));
1150 panel->nameT = WMCreateTextField(panel->nameF);
1151 WMResizeWidget(panel->nameT, 160, 20);
1152 WMMoveWidget(panel->nameT, 12, 18);
1154 WMMapSubwidgets(panel->nameF);
1156 /* texture types */
1157 panel->typeP = WMCreatePopUpButton(panel->win);
1158 WMResizeWidget(panel->typeP, 185, 20);
1159 WMMoveWidget(panel->typeP, 15, 65);
1160 WMAddPopUpButtonItem(panel->typeP, _("Solid Color"));
1161 WMAddPopUpButtonItem(panel->typeP, _("Gradient Texture"));
1162 WMAddPopUpButtonItem(panel->typeP, _("Simple Gradient Texture"));
1163 WMAddPopUpButtonItem(panel->typeP, _("Textured Gradient"));
1164 WMAddPopUpButtonItem(panel->typeP, _("Image Texture"));
1165 WMSetPopUpButtonSelectedItem(panel->typeP, 0);
1166 WMSetPopUpButtonAction(panel->typeP, changeTypeCallback, panel);
1168 /* color */
1169 panel->defcF = WMCreateFrame(panel->win);
1170 WMResizeWidget(panel->defcF, 100, 75);
1171 WMMoveWidget(panel->defcF, 210, 10);
1172 WMSetFrameTitle(panel->defcF, _("Default Color"));
1174 panel->defcW = WMCreateColorWell(panel->defcF);
1175 WMResizeWidget(panel->defcW, 60, 45);
1176 WMMoveWidget(panel->defcW, 20, 20);
1178 WMMapSubwidgets(panel->defcF);
1180 /****** Gradient ******/
1181 panel->gcolF = WMCreateFrame(panel->win);
1182 WMResizeWidget(panel->gcolF, 295, 205);
1183 WMMoveWidget(panel->gcolF, 15, 95);
1184 WMSetFrameTitle(panel->gcolF, _("Gradient Colors"));
1186 panel->gcolL = WMCreateList(panel->gcolF);
1187 WMResizeWidget(panel->gcolL, 130, 140);
1188 WMMoveWidget(panel->gcolL, 10, 25);
1189 WMHangData(panel->gcolL, panel);
1190 WMSetListUserDrawProc(panel->gcolL, paintGradListItem);
1191 WMSetListAction(panel->gcolL, gradClickCallback, panel);
1193 panel->gcolaB = WMCreateCommandButton(panel->gcolF);
1194 WMResizeWidget(panel->gcolaB, 64, 24);
1195 WMMoveWidget(panel->gcolaB, 10, 170);
1196 WMSetButtonText(panel->gcolaB, _("Add"));
1197 WMSetButtonAction(panel->gcolaB, gradAddCallback, panel);
1199 panel->gcoldB = WMCreateCommandButton(panel->gcolF);
1200 WMResizeWidget(panel->gcoldB, 64, 24);
1201 WMMoveWidget(panel->gcoldB, 75, 170);
1202 WMSetButtonText(panel->gcoldB, _("Delete"));
1203 WMSetButtonAction(panel->gcoldB, gradDeleteCallback, panel);
1205 #if 0
1206 panel->gbriS = WMCreateSlider(panel->gcolF);
1207 WMResizeWidget(panel->gbriS, 130, 16);
1208 WMMoveWidget(panel->gbriS, 150, 25);
1209 WMSetSliderKnobThickness(panel->gbriS, 8);
1210 WMSetSliderMaxValue(panel->gbriS, 100);
1211 WMSetSliderAction(panel->gbriS, sliderChangeCallback, panel);
1213 WMPixmap *pixmap;
1214 WMColor *color;
1216 pixmap = WMCreatePixmap(scr, 130, 16, WMScreenDepth(scr), False);
1217 color = WMDarkGrayColor(scr);
1218 XFillRectangle(WMScreenDisplay(scr), WMGetPixmapXID(pixmap), WMColorGC(color), 0, 0, 130, 16);
1219 WMReleaseColor(color);
1220 color = WMWhiteColor(color);
1221 WMDrawString(scr, WMGetPixmapXID(pixmap), color,
1222 panel->listFont, 2, (16 - WMFontHeight(panel->listFont)) / 2 - 1, "Brightness", 10);
1223 WMSetSliderImage(panel->gbriS, pixmap);
1224 WMReleasePixmap(pixmap);
1227 panel->gconS = WMCreateSlider(panel->gcolF);
1228 WMResizeWidget(panel->gconS, 130, 16);
1229 WMMoveWidget(panel->gconS, 150, 50);
1230 WMSetSliderKnobThickness(panel->gconS, 8);
1231 WMSetSliderMaxValue(panel->gconS, 100);
1232 WMSetSliderAction(panel->gconS, sliderChangeCallback, panel);
1234 WMPixmap *pixmap;
1235 WMColor *color;
1237 pixmap = WMCreatePixmap(scr, 130, 16, WMScreenDepth(scr), False);
1238 color = WMDarkGrayColor(scr);
1239 XFillRectangle(WMScreenDisplay(scr), WMGetPixmapXID(pixmap), WMColorGC(color), 0, 0, 130, 16);
1240 WMReleaseColor(color);
1241 color = WMWhiteColor(scr);
1242 WMDrawString(scr, WMGetPixmapXID(pixmap), color,
1243 panel->listFont, 2, (16 - WMFontHeight(panel->listFont)) / 2 - 1, "Contrast", 8);
1244 WMSetSliderImage(panel->gconS, pixmap);
1245 WMReleasePixmap(pixmap);
1247 #endif
1248 panel->ghueS = WMCreateSlider(panel->gcolF);
1249 WMResizeWidget(panel->ghueS, 130, 16);
1250 WMMoveWidget(panel->ghueS, 150, 100);
1251 WMSetSliderKnobThickness(panel->ghueS, 8);
1252 WMSetSliderMaxValue(panel->ghueS, 359);
1253 WMSetSliderAction(panel->ghueS, sliderChangeCallback, panel);
1255 panel->gsatS = WMCreateSlider(panel->gcolF);
1256 WMResizeWidget(panel->gsatS, 130, 16);
1257 WMMoveWidget(panel->gsatS, 150, 125);
1258 WMSetSliderKnobThickness(panel->gsatS, 8);
1259 WMSetSliderMaxValue(panel->gsatS, 255);
1260 WMSetSliderAction(panel->gsatS, sliderChangeCallback, panel);
1262 panel->gvalS = WMCreateSlider(panel->gcolF);
1263 WMResizeWidget(panel->gvalS, 130, 16);
1264 WMMoveWidget(panel->gvalS, 150, 150);
1265 WMSetSliderKnobThickness(panel->gvalS, 8);
1266 WMSetSliderMaxValue(panel->gvalS, 255);
1267 WMSetSliderAction(panel->gvalS, sliderChangeCallback, panel);
1269 WMMapSubwidgets(panel->gcolF);
1271 /** Direction **/
1272 panel->dirF = WMCreateFrame(panel->win);
1273 WMSetFrameTitle(panel->dirF, _("Direction"));
1274 WMResizeWidget(panel->dirF, 295, 75);
1275 WMMoveWidget(panel->dirF, 15, 305);
1277 panel->dirvB = WMCreateButton(panel->dirF, WBTOnOff);
1278 WMSetButtonImagePosition(panel->dirvB, WIPImageOnly);
1279 WMResizeWidget(panel->dirvB, 90, 40);
1280 WMMoveWidget(panel->dirvB, 10, 20);
1282 panel->dirhB = WMCreateButton(panel->dirF, WBTOnOff);
1283 WMSetButtonImagePosition(panel->dirhB, WIPImageOnly);
1284 WMResizeWidget(panel->dirhB, 90, 40);
1285 WMMoveWidget(panel->dirhB, 102, 20);
1287 panel->dirdB = WMCreateButton(panel->dirF, WBTOnOff);
1288 WMSetButtonImagePosition(panel->dirdB, WIPImageOnly);
1289 WMResizeWidget(panel->dirdB, 90, 40);
1290 WMMoveWidget(panel->dirdB, 194, 20);
1292 WMGroupButtons(panel->dirvB, panel->dirhB);
1293 WMGroupButtons(panel->dirvB, panel->dirdB);
1295 WMMapSubwidgets(panel->dirF);
1297 /****************** Textured Gradient ******************/
1298 panel->tcolF = WMCreateFrame(panel->win);
1299 WMResizeWidget(panel->tcolF, 100, 135);
1300 WMMoveWidget(panel->tcolF, 210, 10);
1301 WMSetFrameTitle(panel->tcolF, _("Gradient"));
1303 panel->tcol1W = WMCreateColorWell(panel->tcolF);
1304 WMResizeWidget(panel->tcol1W, 60, 45);
1305 WMMoveWidget(panel->tcol1W, 20, 25);
1306 WMAddNotificationObserver(colorWellObserver, panel, WMColorWellDidChangeNotification, panel->tcol1W);
1308 panel->tcol2W = WMCreateColorWell(panel->tcolF);
1309 WMResizeWidget(panel->tcol2W, 60, 45);
1310 WMMoveWidget(panel->tcol2W, 20, 75);
1311 WMAddNotificationObserver(colorWellObserver, panel, WMColorWellDidChangeNotification, panel->tcol2W);
1313 /** Opacity */
1314 panel->topaF = WMCreateFrame(panel->win);
1315 WMResizeWidget(panel->topaF, 185, 50);
1316 WMMoveWidget(panel->topaF, 15, 95);
1317 WMSetFrameTitle(panel->topaF, _("Gradient Opacity"));
1319 panel->topaS = WMCreateSlider(panel->topaF);
1320 WMResizeWidget(panel->topaS, 155, 18);
1321 WMMoveWidget(panel->topaS, 15, 20);
1322 WMSetSliderMaxValue(panel->topaS, 255);
1323 WMSetSliderValue(panel->topaS, 200);
1324 WMSetSliderContinuous(panel->topaS, False);
1325 WMSetSliderAction(panel->topaS, opaqChangeCallback, panel);
1327 WMMapSubwidgets(panel->topaF);
1330 WMPixmap *pixmap;
1331 Pixmap p;
1332 WMColor *color;
1334 pixmap = WMCreatePixmap(scr, 155, 18, WMScreenDepth(scr), False);
1335 p = WMGetPixmapXID(pixmap);
1337 color = WMDarkGrayColor(scr);
1338 XFillRectangle(WMScreenDisplay(scr), p, WMColorGC(color), 0, 0, 155, 18);
1339 WMReleaseColor(color);
1341 color = WMWhiteColor(scr);
1342 WMDrawString(scr, p, color, panel->listFont, 2, 1, "0%", 2);
1343 WMDrawString(scr, p, color, panel->listFont,
1344 153 - WMWidthOfString(panel->listFont, "100%", 4), 1, "100%", 4);
1345 WMReleaseColor(color);
1347 WMSetSliderImage(panel->topaS, pixmap);
1348 WMReleasePixmap(pixmap);
1351 WMMapSubwidgets(panel->tcolF);
1353 /****************** Image ******************/
1354 panel->imageF = WMCreateFrame(panel->win);
1355 WMResizeWidget(panel->imageF, 295, 150);
1356 WMMoveWidget(panel->imageF, 15, 150);
1357 WMSetFrameTitle(panel->imageF, _("Image"));
1359 panel->imageL = WMCreateLabel(panel->imageF);
1360 WMSetLabelImagePosition(panel->imageL, WIPImageOnly);
1362 panel->imageT = WMCreateTextField(panel->imageF);
1363 WMResizeWidget(panel->imageT, 90, 20);
1364 WMMoveWidget(panel->imageT, 190, 25);
1366 panel->imageV = WMCreateScrollView(panel->imageF);
1367 WMResizeWidget(panel->imageV, 165, 115);
1368 WMMoveWidget(panel->imageV, 15, 20);
1369 WMSetScrollViewRelief(panel->imageV, WRSunken);
1370 WMSetScrollViewHasHorizontalScroller(panel->imageV, True);
1371 WMSetScrollViewHasVerticalScroller(panel->imageV, True);
1372 WMSetScrollViewContentView(panel->imageV, WMWidgetView(panel->imageL));
1374 panel->browB = WMCreateCommandButton(panel->imageF);
1375 WMResizeWidget(panel->browB, 90, 24);
1376 WMMoveWidget(panel->browB, 190, 50);
1377 WMSetButtonText(panel->browB, _("Browse..."));
1378 WMSetButtonAction(panel->browB, browseImageCallback, panel);
1380 /* panel->dispB = WMCreateCommandButton(panel->imageF);
1381 WMResizeWidget(panel->dispB, 90, 24);
1382 WMMoveWidget(panel->dispB, 190, 80);
1383 WMSetButtonText(panel->dispB, _("Show"));
1384 */
1386 panel->arrP = WMCreatePopUpButton(panel->imageF);
1387 WMResizeWidget(panel->arrP, 90, 20);
1388 WMMoveWidget(panel->arrP, 190, 120);
1389 WMAddPopUpButtonItem(panel->arrP, _("Tile"));
1390 WMAddPopUpButtonItem(panel->arrP, _("Scale"));
1391 WMAddPopUpButtonItem(panel->arrP, _("Center"));
1392 WMAddPopUpButtonItem(panel->arrP, _("Maximize"));
1393 WMSetPopUpButtonSelectedItem(panel->arrP, 0);
1395 WMMapSubwidgets(panel->imageF);
1397 /****/
1399 panel->okB = WMCreateCommandButton(panel->win);
1400 WMResizeWidget(panel->okB, 84, 24);
1401 WMMoveWidget(panel->okB, 225, 390);
1402 WMSetButtonText(panel->okB, _("OK"));
1403 WMSetButtonAction(panel->okB, buttonCallback, panel);
1405 panel->cancelB = WMCreateCommandButton(panel->win);
1406 WMResizeWidget(panel->cancelB, 84, 24);
1407 WMMoveWidget(panel->cancelB, 130, 390);
1408 WMSetButtonText(panel->cancelB, _("Cancel"));
1409 WMSetButtonAction(panel->cancelB, buttonCallback, panel);
1411 WMMapWidget(panel->nameF);
1412 WMMapWidget(panel->typeP);
1413 WMMapWidget(panel->okB);
1414 WMMapWidget(panel->cancelB);
1416 WMUnmapWidget(panel->arrP);
1418 WMRealizeWidget(panel->win);
1420 panel->currentType = -1;
1422 panel->sectionParts[TYPE_SOLID][0] = panel->defcF;
1424 panel->sectionParts[TYPE_GRADIENT][0] = panel->defcF;
1425 panel->sectionParts[TYPE_GRADIENT][1] = panel->gcolF;
1426 panel->sectionParts[TYPE_GRADIENT][2] = panel->dirF;
1428 panel->sectionParts[TYPE_SGRADIENT][0] = panel->tcolF;
1429 panel->sectionParts[TYPE_SGRADIENT][1] = panel->dirF;
1431 panel->sectionParts[TYPE_TGRADIENT][0] = panel->tcolF;
1432 panel->sectionParts[TYPE_TGRADIENT][1] = panel->dirF;
1433 panel->sectionParts[TYPE_TGRADIENT][2] = panel->imageF;
1434 panel->sectionParts[TYPE_TGRADIENT][3] = panel->topaF;
1435 panel->sectionParts[TYPE_TGRADIENT][4] = panel->arrP;
1437 panel->sectionParts[TYPE_PIXMAP][0] = panel->defcF;
1438 panel->sectionParts[TYPE_PIXMAP][1] = panel->imageF;
1439 panel->sectionParts[TYPE_PIXMAP][2] = panel->arrP;
1441 /* setup for first time */
1443 changeTypeCallback(panel->typeP, panel);
1445 sliderChangeCallback(panel->ghueS, panel);
1446 sliderChangeCallback(panel->gsatS, panel);
1448 return panel;
1451 /*
1452 *--------------------------------------------------------------------------
1453 * Test stuff
1454 *--------------------------------------------------------------------------
1455 */
1457 #if 0
1459 char *ProgName = "test";
1461 void testOKButton(WMWidget * self, void *data)
1463 char *test;
1464 Display *dpy;
1465 Window win;
1466 Pixmap pix;
1467 RImage *image;
1469 TexturePanel *panel = (TexturePanel *) data;
1470 /* test = GetTexturePanelTextureString(panel); */
1472 wwarning(test);
1474 dpy = WMScreenDisplay(WMWidgetScreen(panel->okB));
1475 win = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 10, 10, 250, 250, 0, 0, 0);
1476 XMapRaised(dpy, win);
1477 XFlush(dpy);
1479 /* image = RenderTexturePanelTexture(panel, 250, 250); */
1481 RConvertImage(WMScreenRContext(WMWidgetScreen(panel->okB)), image, &pix);
1483 XCopyArea(dpy, pix, win, (WMScreenRContext(WMWidgetScreen(panel->okB)))->copy_gc, 0, 0, image->width,
1484 image->height, 0, 0);
1486 wfree(test);
1490 void testCancelButton(WMWidget * self, void *data)
1492 wwarning("Exiting test....");
1493 exit(0);
1496 void wAbort()
1498 exit(1);
1501 int main(int argc, char **argv)
1503 TexturePanel *panel;
1505 Display *dpy = XOpenDisplay("");
1506 WMScreen *scr;
1508 /* char *test; */
1510 WMInitializeApplication("Test", &argc, argv);
1512 if (!dpy) {
1513 wfatal("could not open display");
1514 exit(1);
1517 scr = WMCreateSimpleApplicationScreen(dpy);
1519 panel = CreateTexturePanel(scr);
1521 SetTexturePanelOkAction(panel, (WMAction *) testOKButton, panel);
1522 SetTexturePanelCancelAction(panel, (WMAction *) testCancelButton, panel);
1524 SetTexturePanelTexture(panel, "pinky",
1525 WMCreatePropListFromDescription("(mdgradient, pink, red, blue, yellow)"));
1527 ShowTexturePanel(panel);
1529 WMScreenMainLoop(scr);
1530 return 0;
1532 #endif