gryf/wmaker
1
0
Fork 0
mirror of https://github.com/gryf/wmaker.git synced 2025-12-19 20:38:08 +01:00
Code Issues Projects Releases Wiki Activity
Files
e7495baff72166ad37010259e04c0a272d0898e8
wmaker/WPrefs.app/TexturePanel.c

1027 lines
29 KiB
C
Raw Blame History

/* TexturePanel.c- texture editting panel
*
* WPrefs - WindowMaker Preferences Program
*
* Copyright (c) 1998 Alfredo K. Kojima
* Copyright (c) 1998 James Thompson
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
* USA.
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <X11/Xlib.h>
#include <WINGs.h>
#include <WUtil.h>
#include "TexturePanel.h"
#include "TexturePanel.icons"
typedef struct _TexturePanel {
WMWindow *win;
WMFrame *typeF;
WMButton *tsoliB;
WMButton *tgradB;
WMButton *tpixmB;
WMButton *okB;
WMButton *cancB;
/* solid */
WMFrame *scolorF;
WMColorWell *scolorW;
/* gradient */
WMFrame *gcolorF;
WMList *gcolorLs;
WMColorWell *gcolorW;
WMButton *gaddB;
WMButton *gremB;
WMButton *gupdB;
WMFrame *gdirF;
WMButton *ghorB;
WMButton *gverB;
WMButton *gdiaB;
/* pixmap */
WMFrame *pimagF;
WMLabel *pimagL;
WMTextField *pimagT;
WMButton *pbrowB;
WMFrame *pcolorF;
WMColorWell *pcolorW;
WMFrame *pmodeF;
WMButton *pscalB;
WMButton *ptileB;
WMAction *okAction;
void *okData;
WMAction *cancelAction;
void *cancelData;
} _TexturePanel;
char *WMGetColorWellRGBString(WMColorWell *cPtr) {
char *rgbString;
WMColor *color;
rgbString = wmalloc(13);
color = WMGetColorWellColor(cPtr);
if (color) {
sprintf(rgbString,"rgb:%02x/%02x/%02x",
(WMRedComponentOfColor(color) >> 8),
(WMGreenComponentOfColor(color) >> 8),
(WMBlueComponentOfColor(color) >> 8));
}
return rgbString;
}
/*
*--------------------------------------------------------------------------
* Private Functions
*--------------------------------------------------------------------------
*/
static void buttonCallback(WMWidget *self, void *data);
static void renderTextureButtons (_TexturePanel *panel);
static void paintListItem(WMList *lPtr, int index, Drawable d, char *text, int state, WMRect *rect);
static void notificationObserver(void *self, WMNotification *notif);
static void
notificationObserver(void *self, WMNotification *notif)
{
_TexturePanel *panel = (_TexturePanel*)self;
void *object = WMGetNotificationObject(notif);
char *text;
if (WMGetNotificationName(notif) == WMTextDidChangeNotification) {
if (object == panel->pimagT) {
text = WMGetTextFieldText(panel->pimagT);
if (strlen(text)) {
WMSetButtonEnabled(panel->okB, True);
} else {
WMSetButtonEnabled(panel->okB, False);
}
free(text);
}
}
}
static void
paintListItem(WMList *lPtr, int index, Drawable d, char *text, int state, WMRect *rect)
{
WMScreen *scr;
int width, height, x, y;
GC gc;
Display *dpy;
scr = WMWidgetScreen(lPtr);
dpy = WMScreenDisplay(scr);
width = rect->size.width;
height = rect->size.height;
x = rect->pos.x;
y = rect->pos.y;
if (state & WLDSSelected)
XFillRectangle(dpy, d, WMColorGC(WMWhiteColor(scr)), x, y,width, height);
else
XClearArea(WMScreenDisplay(scr), d, x, y, width, height, False);
gc = XCreateGC(dpy, RootWindow(dpy, 0),0,NULL);
WMSetColorInGC(WMCreateNamedColor(scr, text, True),gc);
XFillRectangle (dpy, d, gc,x+5,y+3,width-8,height-6);
XFreeGC(dpy,gc);
}
static void
buttonCallback(WMWidget *self, void *data)
{
_TexturePanel *panel = (_TexturePanel*)data;
char *text, *color;
WMOpenPanel *op;
int itemRow;
WMSetButtonEnabled(panel->okB, True);
/* Global Buttons */
if (self == panel->okB) {
if (panel->okAction) {
(*panel->okAction)(self, panel->okData);
} else {
wwarning ("Texture panel OK button undefined");
}
} else if (self == panel->cancB) {
if (panel->cancelAction) {
(*panel->cancelAction)(self, panel->cancelData);
} else {
wwarning ("Texture panel CANCEL button undefined");
}
} else if (self == panel->tsoliB) {
WMMapWidget(panel->scolorF);
WMUnmapWidget(panel->gcolorF);
WMUnmapWidget(panel->gdirF);
WMUnmapWidget(panel->pimagF);
WMUnmapWidget(panel->pcolorF);
WMUnmapWidget(panel->pmodeF);
} else if (self == panel->tgradB) {
WMMapWidget(panel->gcolorF);
WMMapWidget(panel->gdirF);
WMUnmapWidget(panel->scolorF);
WMUnmapWidget(panel->pimagF);
WMUnmapWidget(panel->pcolorF);
WMUnmapWidget(panel->pmodeF);
} else if (self == panel->tpixmB) {
WMMapWidget(panel->pimagF);
WMMapWidget(panel->pcolorF);
WMMapWidget(panel->pmodeF);
WMUnmapWidget(panel->gcolorF);
WMUnmapWidget(panel->gdirF);
WMUnmapWidget(panel->scolorF);
text = WMGetTextFieldText(panel->pimagT);
if (!strlen(text)) {
WMSetButtonEnabled(panel->okB, False);
}
free(text);
/* Gradient Panel Buttons */
} else if (self == panel->gaddB) {
color = WMGetColorWellRGBString(panel->gcolorW);
itemRow = WMGetListSelectedItemRow(panel->gcolorLs);
WMInsertListItem(panel->gcolorLs,itemRow, color);
free(color);
renderTextureButtons(panel);
} else if (self == panel->gremB) {
if (WMGetListNumberOfRows(panel->gcolorLs) != 1) {
itemRow = WMGetListSelectedItemRow(panel->gcolorLs);
WMRemoveListItem(panel->gcolorLs,itemRow);
renderTextureButtons(panel);
}
} else if (self == panel->gupdB) {
color = WMGetColorWellRGBString(panel->gcolorW);
itemRow = WMGetListSelectedItemRow(panel->gcolorLs);
WMRemoveListItem(panel->gcolorLs,itemRow);
WMInsertListItem(panel->gcolorLs,itemRow, color);
free(color);
renderTextureButtons(panel);
/* Pixmap Panel Buttons */
} else if (self == panel->pbrowB) {
op = WMGetOpenPanel(WMWidgetScreen(panel->pbrowB));
if (WMRunModalFilePanelForDirectory(op, NULL, "/usr/local", NULL, NULL)) {
char *path;
path = WMGetFilePanelFileName(op);
WMSetTextFieldText(panel->pimagT, path);
if (strlen(path)) {
WMSetButtonEnabled(panel->okB, True);
}
free(path);
}
WMFreeFilePanel(op);
}
}
#if 0
static void
changePanel(WMWidget *self, void *data)
{
_TexturePanel *panel = (_TexturePanel*)data;
char *text = NULL;
WMSetButtonEnabled(panel->okB, True);
if (self == panel->tsoliB) {
WMMapWidget(panel->scolorF);
WMUnmapWidget(panel->gcolorF);
WMUnmapWidget(panel->gdirF);
WMUnmapWidget(panel->pimagF);
WMUnmapWidget(panel->pcolorF);
WMUnmapWidget(panel->pmodeF);
} else if (self == panel->tgradB) {
WMMapWidget(panel->gcolorF);
WMMapWidget(panel->gdirF);
WMUnmapWidget(panel->scolorF);
WMUnmapWidget(panel->pimagF);
WMUnmapWidget(panel->pcolorF);
WMUnmapWidget(panel->pmodeF);
} else {
WMMapWidget(panel->pimagF);
WMMapWidget(panel->pcolorF);
WMMapWidget(panel->pmodeF);
WMUnmapWidget(panel->gcolorF);
WMUnmapWidget(panel->gdirF);
WMUnmapWidget(panel->scolorF);
text = WMGetTextFieldText(panel->pimagT);
if (!strlen(text)) {
WMSetButtonEnabled(panel->okB, False);
}
free(text);
}
}
static void
modifyGradientList(WMWidget *self, void *data)
{
_TexturePanel *panel = (_TexturePanel*)data;
char *color = NULL;
int itemRow;
itemRow = WMGetListSelectedItemRow(panel->gcolorLs);
color = WMGetColorWellRGBString(panel->gcolorW);
if (self == panel->gaddB) {
WMInsertListItem(panel->gcolorLs,itemRow, color);
} else if (self == panel->gremB) {
if (WMGetListNumberOfRows(panel->gcolorLs) != 1) {
WMRemoveListItem(panel->gcolorLs,itemRow);
}
} else {
WMRemoveListItem(panel->gcolorLs,itemRow);
WMInsertListItem(panel->gcolorLs,itemRow, color);
}
free (color);
renderTextureButtons(panel);
}
#endif
static void
renderTextureButtons(_TexturePanel *panel)
{
RColor **colors = NULL;
XColor color;
WMPixmap *icon;
RImage *imgh, *imgv, *imgd;
WMScreen *scr;
int i, listRows;
scr = WMWidgetScreen(panel->gcolorLs);
listRows = WMGetListNumberOfRows(panel->gcolorLs);
colors = wmalloc(sizeof(RColor*)*(listRows+1));
for (i=0; i < listRows; i++) {
if (!XParseColor(WMScreenDisplay(scr), (WMScreenRContext(scr))->cmap,
wstrdup(WMGetListItem(panel->gcolorLs, i)->text),&color)) {
wfatal("could not parse color \"%s\"\n", WMGetListItem(panel->gcolorLs, i)->text);
exit(1);
} else {
colors[i] = malloc(sizeof(RColor));
colors[i]->red = color.red >> 8;
colors[i]->green = color.green >> 8;
colors[i]->blue = color.blue >> 8;
}
}
colors[i] = NULL;
imgh = RRenderMultiGradient(50, 20, colors, RGRD_HORIZONTAL);
if (!imgh) {
wwarning("internal error:%s", RMessageForError(RErrorCode));
} else {
icon = WMCreatePixmapFromRImage(scr, imgh, 120);
RDestroyImage(imgh);
WMSetButtonImage(panel->ghorB, icon);
WMReleasePixmap(icon);
}
imgv = RRenderMultiGradient(50, 20, colors, RGRD_VERTICAL);
if (!imgv) {
wwarning("internal error:%s", RMessageForError(RErrorCode));
} else {
icon = WMCreatePixmapFromRImage(scr, imgv, 120);
RDestroyImage(imgv);
WMSetButtonImage(panel->gverB, icon);
WMReleasePixmap(icon);
}
imgd = RRenderMultiGradient(50, 20, colors, RGRD_DIAGONAL);
if (!imgd) {
wwarning("internal error:%s", RMessageForError(RErrorCode));
} else {
icon = WMCreatePixmapFromRImage(scr, imgd, 120);
RDestroyImage(imgd);
WMSetButtonImage(panel->gdiaB, icon);
WMReleasePixmap(icon);
}
free(colors);
}
/*
*--------------------------------------------------------------------------
* Public functions
*--------------------------------------------------------------------------
*/
void
DestroyTexturePanel(TexturePanel *panel)
{
WMUnmapWidget(panel->win);
WMDestroyWidget(panel->win);
free(panel);
}
void
ShowTexturePanel(TexturePanel *panel)
{
WMMapWidget(panel->win);
}
void
HideTexturePanel(TexturePanel *panel)
{
WMUnmapWidget(panel->win);
}
void
SetTexturePanelOkAction(TexturePanel *panel, WMAction *action, void *clientData)
{
panel->okAction = action;
panel->okData = clientData;
}
void
SetTexturePanelCancelAction(TexturePanel *panel, WMAction *action, void *clientData)
{
panel->cancelAction = action;
panel->cancelData = clientData;
}
void
SetTexturePanelTexture(TexturePanel *panel, char *texture)
{
char *parseString;
char *parseStringPosition;
char *enclosures = "( )";
char *seperators = " ,\"";
char *filename;
WMSetButtonSelected(panel->tsoliB, False);
WMSetButtonSelected(panel->tgradB, False);
WMSetButtonSelected(panel->tpixmB, False);
parseString = wstrdup(texture);
parseStringPosition = parseString;
parseStringPosition = strtok(parseStringPosition,seperators);
wwarning ("Parsing...");
while (parseStringPosition) {
if (!strpbrk(parseStringPosition,enclosures)) {
if (strcasecmp(parseStringPosition,"solid") == 0) {
wwarning("Switch to solid");
WMPerformButtonClick(panel->tsoliB);
parseStringPosition = strtok(NULL,seperators);
while (parseStringPosition) {
if (!strpbrk(parseStringPosition,enclosures)) {
WMSetColorWellColor(panel->scolorW,WMCreateNamedColor(WMWidgetScreen(panel->scolorW), parseStringPosition, True));
}
parseStringPosition = strtok(NULL,seperators);
}
} else if ((strstr(parseStringPosition,"pixmap")) && (strcasecmp(strstr(parseStringPosition,"pixmap"),"pixmap") == 0)) {
WMSetButtonSelected(panel->ptileB, False);
WMSetButtonSelected(panel->pscalB, False);
WMPerformButtonClick(panel->tpixmB);
if (tolower(*parseStringPosition) == 't') {
wwarning ("Switch to Tiled Pixmap");
WMPerformButtonClick(panel->ptileB);
} else {
wwarning ("Switch to Scaled Pixmap");
WMPerformButtonClick(panel->pscalB);
}
filename = NULL;
parseStringPosition = strtok(NULL,seperators);
do {
if (filename) filename = wstrappend(filename," ");
filename = wstrappend(filename,parseStringPosition);
parseStringPosition = strtok(NULL,seperators);
} while (!strstr(parseStringPosition,"rgb:"));
WMSetTextFieldText(panel->pimagT, filename);
free(filename);
/* parseStringPosition = strtok(NULL,seperators); */
WMSetColorWellColor(panel->pcolorW,WMCreateNamedColor(WMWidgetScreen(panel->scolorW), parseStringPosition, True));
} else if ((strstr(parseStringPosition,"gradient")) && (strcasecmp(strstr(parseStringPosition,"gradient"),"gradient") == 0)) {
WMSetButtonSelected(panel->ghorB, False);
WMSetButtonSelected(panel->gverB, False);
WMSetButtonSelected(panel->gdiaB, False);
WMPerformButtonClick(panel->tgradB);
if (strstr(parseStringPosition,"h")) {
WMPerformButtonClick(panel->ghorB);
} else if (strstr(parseStringPosition,"v")) {
WMPerformButtonClick(panel->gverB);
} else {
WMPerformButtonClick(panel->gdiaB);
}
WMClearList(panel->gcolorLs);
parseStringPosition = strtok(NULL,seperators);
while (parseStringPosition) {
if (!strpbrk(parseStringPosition,enclosures)) {
WMAddListItem(panel->gcolorLs, parseStringPosition);
WMSetColorWellColor(panel->gcolorW,WMCreateNamedColor(WMWidgetScreen(panel->scolorW), parseStringPosition, True));
}
parseStringPosition = strtok(NULL,seperators);
}
} else {
wfatal("Unknown Texture Type");
}
while (parseStringPosition) {
parseStringPosition = strtok(NULL,seperators);
}
}
parseStringPosition = strtok(NULL,seperators);
}
renderTextureButtons (panel);
free(parseString);
}
char*
GetTexturePanelTextureString(TexturePanel *panel)
{
char *colorString = NULL;
char *start = "( ";
char *finish = " )";
char *seperator = ", ";
char *quote = "\"";
int i, listRows;
colorString = wstrappend(colorString,start);
if (WMGetButtonSelected(panel->tsoliB)) {
colorString = wstrappend(colorString,"solid");
colorString = wstrappend(colorString,seperator);
colorString = wstrappend(colorString, quote);
colorString = wstrappend(colorString,WMGetColorWellRGBString(panel->scolorW));
colorString = wstrappend(colorString, quote);
} else if (WMGetButtonSelected(panel->tgradB)) {
listRows = WMGetListNumberOfRows(panel->gcolorLs);
if (listRows > 2) {
colorString = wstrappend(colorString,"m");
}
if (WMGetButtonSelected(panel->ghorB)) {
colorString = wstrappend(colorString,"hgradient");
} else if (WMGetButtonSelected(panel->gverB)) {
colorString = wstrappend(colorString,"vgradient");
} else {
colorString = wstrappend(colorString,"dgradient");
}
for (i=0; i < listRows; i++) {
colorString = wstrappend(colorString, seperator);
colorString = wstrappend(colorString, quote);
colorString = wstrappend(colorString, wstrdup(WMGetListItem(panel->gcolorLs, i)->text));
colorString = wstrappend(colorString, quote);
}
} else if (WMGetButtonSelected(panel->tpixmB)) {
if (WMGetButtonSelected(panel->pscalB)) {
colorString = wstrappend(colorString,"spixmap");
} else {
colorString = wstrappend(colorString,"tpixmap");
}
colorString = wstrappend(colorString,seperator);
colorString = wstrappend(colorString, WMGetTextFieldText(panel->pimagT));
colorString = wstrappend(colorString,seperator);
colorString = wstrappend(colorString, quote);
colorString = wstrappend(colorString, WMGetColorWellRGBString(panel->pcolorW));
colorString = wstrappend(colorString, quote);
}
colorString = wstrappend(colorString,finish);
return colorString;
}
RImage*
RenderTexturePanelTexture(TexturePanel *panel, unsigned width, unsigned height)
{
XColor color;
RContext *ctx;
RColor solidColor;
RColor **colors = NULL;
RImage *image=NULL, *fileImage;
WMScreen *scr;
WMColor *wellColor;
int i, listRows, style;
scr = WMWidgetScreen(panel->gcolorLs);
ctx = WMScreenRContext(scr);
if (WMGetButtonSelected(panel->tsoliB)) {
image = RCreateImage(width, height, 1);
wellColor = WMGetColorWellColor(panel->scolorW);
solidColor.red = (WMRedComponentOfColor(wellColor) >> 8);
solidColor.green = (WMGreenComponentOfColor(wellColor) >> 8) ;
solidColor.blue = (WMBlueComponentOfColor(wellColor) >> 8);
solidColor.alpha = 0xff;
WMReleaseColor(wellColor);
RClearImage(image, &solidColor);
} else if (WMGetButtonSelected(panel->tgradB)) {
if (WMGetButtonSelected(panel->ghorB)) {
style = RGRD_HORIZONTAL;
} else if (WMGetButtonSelected(panel->gverB)) {
style = RGRD_VERTICAL;
} else {
style = RGRD_DIAGONAL;
}
listRows = WMGetListNumberOfRows(panel->gcolorLs);
colors = wmalloc(sizeof(RColor*)*(listRows+1));
for (i=0; i < listRows; i++) {
if (!XParseColor(WMScreenDisplay(scr), ctx->cmap,
wstrdup(WMGetListItem(panel->gcolorLs, i)->text),&color)) {
wfatal("could not parse color \"%s\"\n", WMGetListItem(panel->gcolorLs, i)->text);
exit(1);
} else {
colors[i] = malloc(sizeof(RColor));
colors[i]->red = color.red >> 8;
colors[i]->green = color.green >> 8;
colors[i]->blue = color.blue >> 8;
}
}
colors[i] = NULL;
image = RRenderMultiGradient(width, height, colors, style);
} else if (WMGetButtonSelected(panel->tpixmB)) {
if (fopen(WMGetTextFieldText(panel->pimagT),"r")) {
fileImage = RLoadImage(ctx, WMGetTextFieldText(panel->pimagT), 0);
if (WMGetButtonSelected(panel->pscalB)) {
image = RScaleImage(fileImage, width, height);
} else {
image = RMakeTiledImage(fileImage, width, height);;
}
} else {
wwarning ("Invalid File Name");
return RCreateImage(1,1,1);
}
}
return image;
}
TexturePanel*
CreateTexturePanel(WMScreen *scr)
{
RImage *image;
WMPixmap *icon;
WMColor *red;
TexturePanel *panel;
RColor white,black;
white.red=255;
white.blue=255;
white.green=255;
white.alpha=255;
black.red=0;
black.blue=0;
black.green=0;
black.alpha=0;
panel = wmalloc(sizeof(_TexturePanel));
memset(panel, 0, sizeof(_TexturePanel));
red = WMCreateRGBColor(scr,100,100,100,True);
panel->win = WMCreateWindow(scr, "textureBuilder");
WMResizeWidget(panel->win, 275, 365);
WMSetWindowTitle(panel->win, "Texture Builder");
/***************** Generic stuff ****************/
panel->typeF = WMCreateFrame(panel->win);
WMResizeWidget(panel->typeF, 245, 80);
WMMoveWidget(panel->typeF, 15, 10);
WMSetFrameTitle(panel->typeF, "Texture Type");
panel->tsoliB = WMCreateButton(panel->typeF, WBTOnOff);
WMResizeWidget(panel->tsoliB, 48, 48);
WMMoveWidget(panel->tsoliB, 42, 20);
WMSetButtonImagePosition(panel->tsoliB, WIPImageOnly);
image = RGetImageFromXPMData(WMScreenRContext(scr), solid_xpm);
if (!image) {
wwarning("internal error:%s", RMessageForError(RErrorCode));
} else {
icon = WMCreatePixmapFromRImage(scr, image, 120);
RDestroyImage(image);
WMSetButtonImage(panel->tsoliB, icon);
WMReleasePixmap(icon);
}
WMSetButtonAction(panel->tsoliB, buttonCallback, panel);
panel->tgradB = WMCreateButton(panel->typeF, WBTOnOff);
WMGroupButtons(panel->tsoliB, panel->tgradB);
WMResizeWidget(panel->tgradB, 48, 48);
WMMoveWidget(panel->tgradB, 98, 20);
WMSetButtonImagePosition(panel->tgradB, WIPImageOnly);
image = RGetImageFromXPMData(WMScreenRContext(scr), gradient_xpm);
if (!image) {
wwarning("internal error:%s", RMessageForError(RErrorCode));
} else {
icon = WMCreatePixmapFromRImage(scr, image, 120);
RDestroyImage(image);
WMSetButtonImage(panel->tgradB, icon);
WMReleasePixmap(icon);
}
WMSetButtonAction(panel->tgradB, buttonCallback, panel);
panel->tpixmB = WMCreateButton(panel->typeF, WBTOnOff);
WMGroupButtons(panel->tsoliB, panel->tpixmB);
WMResizeWidget(panel->tpixmB, 48, 48);
WMMoveWidget(panel->tpixmB, 154, 20);
WMSetButtonImagePosition(panel->tpixmB, WIPImageOnly);
image = RGetImageFromXPMData(WMScreenRContext(scr), pixmap_xpm);
if (!image) {
wwarning("internal error:%s", RMessageForError(RErrorCode));
} else {
icon = WMCreatePixmapFromRImage(scr, image, 120);
RDestroyImage(image);
WMSetButtonImage(panel->tpixmB, icon);
WMReleasePixmap(icon);
}
WMSetButtonAction(panel->tpixmB, buttonCallback, panel);
panel->okB = WMCreateCommandButton(panel->win);
WMResizeWidget(panel->okB, 70, 28);
WMMoveWidget(panel->okB, 110, 325);
WMSetButtonText(panel->okB, "OK");
WMSetButtonAction(panel->okB,buttonCallback,panel);
panel->cancB = WMCreateCommandButton(panel->win);
WMResizeWidget(panel->cancB, 70, 28);
WMMoveWidget(panel->cancB, 190, 325);
WMSetButtonText(panel->cancB, "Cancel");
WMSetButtonAction(panel->cancB,buttonCallback,panel);
WMMapSubwidgets(panel->typeF);
/***************** Solid *****************/
panel->scolorF = WMCreateFrame(panel->win);
WMResizeWidget(panel->scolorF, 245, 125);
WMMoveWidget(panel->scolorF, 15, 140);
WMSetFrameTitle(panel->scolorF, "Color");
panel->scolorW = WMCreateColorWell(panel->scolorF);
WMResizeWidget(panel->scolorW, 60, 45);
WMMoveWidget(panel->scolorW, 95, 40);
WMSetColorWellColor(panel->scolorW,WMCreateRGBColor(scr, 0xddff, 0xddff, 0, True));
WMMapSubwidgets(panel->scolorF);
/***************** Gradient *****************/
panel->gcolorF = WMCreateFrame(panel->win);
WMResizeWidget(panel->gcolorF, 245, 145);
WMMoveWidget(panel->gcolorF, 15, 95);
WMSetFrameTitle(panel->gcolorF, "Colors");
panel->gcolorLs = WMCreateList(panel->gcolorF);
WMResizeWidget(panel->gcolorLs, 120, 84);
WMMoveWidget(panel->gcolorLs, 20, 20);
WMSetListUserDrawProc(panel->gcolorLs, paintListItem);
WMAddListItem(panel->gcolorLs, "rgb:ff/ff/ff");
WMAddListItem(panel->gcolorLs, "rgb:00/00/ff");
panel->gcolorW = WMCreateColorWell(panel->gcolorF);
WMResizeWidget(panel->gcolorW, 60, 45);
WMMoveWidget(panel->gcolorW, 160, 40);
WMSetColorWellColor(panel->gcolorW,WMCreateRGBColor(scr, 0xffff, 0, 0, True));
panel->gremB = WMCreateCommandButton(panel->gcolorF);
WMResizeWidget(panel->gremB, 64, 24);
WMMoveWidget(panel->gremB, 20, 110);
WMSetButtonText(panel->gremB, "Remove");
WMSetButtonAction(panel->gremB,(WMAction*)buttonCallback,panel);
panel->gupdB = WMCreateCommandButton(panel->gcolorF);
WMResizeWidget(panel->gupdB, 64, 24);
WMMoveWidget(panel->gupdB, 90, 110);
WMSetButtonText(panel->gupdB, "Update");
WMSetButtonAction(panel->gupdB,(WMAction*)buttonCallback,panel);
panel->gaddB = WMCreateCommandButton(panel->gcolorF);
WMResizeWidget(panel->gaddB, 64, 24);
WMMoveWidget(panel->gaddB, 160, 110);
WMSetButtonText(panel->gaddB, "Add");
WMSetButtonAction(panel->gaddB,(WMAction*)buttonCallback,panel);
WMMapSubwidgets(panel->gcolorF);
panel->gdirF = WMCreateFrame(panel->win);
WMResizeWidget(panel->gdirF, 245, 65);
WMMoveWidget(panel->gdirF, 15, 245);
WMSetFrameTitle(panel->gdirF, "Direction");
panel->ghorB = WMCreateButton(panel->gdirF, WBTOnOff);
WMResizeWidget(panel->ghorB, 64, 34);
WMMoveWidget(panel->ghorB, 20, 20);
WMSetButtonImagePosition(panel->ghorB, WIPImageOnly);
WMPerformButtonClick(panel->ghorB);
panel->gverB = WMCreateButton(panel->gdirF, WBTOnOff);
WMResizeWidget(panel->gverB, 64, 34);
WMMoveWidget(panel->gverB, 90, 20);
WMSetButtonImagePosition(panel->gverB, WIPImageOnly);
WMGroupButtons(panel->ghorB, panel->gverB);
panel->gdiaB = WMCreateButton(panel->gdirF, WBTOnOff);
WMResizeWidget(panel->gdiaB, 64, 34);
WMMoveWidget(panel->gdiaB, 160, 20);
WMSetButtonImagePosition(panel->gdiaB, WIPImageOnly);
WMGroupButtons(panel->ghorB, panel->gdiaB);
WMMapSubwidgets(panel->gdirF);
/***************** Pixmap *****************/
panel->pimagF = WMCreateFrame(panel->win);
WMResizeWidget(panel->pimagF, 245, 140);
WMMoveWidget(panel->pimagF, 15, 96);
WMSetFrameTitle(panel->pimagF, "Image");
panel->pimagL = WMCreateLabel(panel->pimagF);
WMResizeWidget(panel->pimagL, 220, 83);
WMMoveWidget(panel->pimagL, 10, 20);
WMSetLabelImagePosition(panel->pimagL, WIPImageOnly);
panel->pimagT = WMCreateTextField(panel->pimagF);
WMResizeWidget(panel->pimagT, 147, 20);
WMMoveWidget(panel->pimagT, 10, 110);
panel->pbrowB = WMCreateCommandButton(panel->pimagF);
WMResizeWidget(panel->pbrowB, 68, 24);
WMMoveWidget(panel->pbrowB, 165, 108);
WMSetButtonText(panel->pbrowB, "Browse...");
WMSetButtonAction(panel->pbrowB,buttonCallback,panel);
WMMapSubwidgets(panel->pimagF);
panel->pcolorF = WMCreateFrame(panel->win);
WMResizeWidget(panel->pcolorF, 90, 75);
WMMoveWidget(panel->pcolorF, 15, 240);
WMSetFrameTitle(panel->pcolorF, "Color");
panel->pcolorW = WMCreateColorWell(panel->pcolorF);
WMResizeWidget(panel->pcolorW, 60, 45);
WMMoveWidget(panel->pcolorW, 15, 20);
WMSetColorWellColor(panel->pcolorW,WMCreateRGBColor(scr, 0x00, 0xddff, 0xffff, True));
WMMapSubwidgets(panel->pcolorF);
panel->pmodeF = WMCreateFrame(panel->win);
WMResizeWidget(panel->pmodeF, 145, 70);
WMMoveWidget(panel->pmodeF, 115, 245);
panel->pscalB = WMCreateButton(panel->pmodeF, WBTOnOff);
WMResizeWidget(panel->pscalB, 54, 50);
WMMoveWidget(panel->pscalB, 10, 10);
WMSetButtonImagePosition(panel->pscalB, WIPImageOnly);
WMPerformButtonClick(panel->pscalB);
image = RGetImageFromXPMData(WMScreenRContext(scr), scaled_xpm);
if (!image) {
wwarning("internal error:%s", RMessageForError(RErrorCode));
} else {
icon = WMCreatePixmapFromRImage(scr, image, 120);
RDestroyImage(image);
WMSetButtonImage(panel->pscalB, icon);
WMReleasePixmap(icon);
}
panel->ptileB = WMCreateButton(panel->pmodeF, WBTOnOff);
WMResizeWidget(panel->ptileB, 54, 50);
WMMoveWidget(panel->ptileB, 75, 10);
WMSetButtonImagePosition(panel->ptileB, WIPImageOnly);
image = RGetImageFromXPMData(WMScreenRContext(scr), tiled_xpm);
if (!image) {
wwarning("internal error:%s", RMessageForError(RErrorCode));
} else {
icon = WMCreatePixmapFromRImage(scr, image, 120);
RDestroyImage(image);
WMSetButtonImage(panel->ptileB, icon);
WMReleasePixmap(icon);
}
WMGroupButtons(panel->pscalB, panel->ptileB);
WMMapSubwidgets(panel->pmodeF);
WMRealizeWidget(panel->win);
WMMapSubwidgets(panel->win);
WMPerformButtonClick(panel->tsoliB);
WMMapWidget(panel->win);
renderTextureButtons (panel);
/* register notification observers */
WMAddNotificationObserver(notificationObserver, panel,
WMTextDidChangeNotification,
panel->pimagT);
return panel;
}
/*
*--------------------------------------------------------------------------
* Test stuff
*--------------------------------------------------------------------------
*/
#ifdef test
char *ProgName = "test";
void testOKButton(WMWidget *self, void *data){
char *test;
Display *dpy;
Window win;
Pixmap pix;
RImage *image;
TexturePanel *panel = (TexturePanel*)data;
test = GetTexturePanelTextureString(panel);
wwarning(test);
dpy = WMScreenDisplay(WMWidgetScreen(panel->okB));
win = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 10, 10, 250, 250,
0, 0, 0);
XMapRaised(dpy, win);
XFlush(dpy);
image = RenderTexturePanelTexture(panel, 250, 250);
RConvertImage(WMScreenRContext(WMWidgetScreen(panel->okB)), image, &pix);
XCopyArea(dpy, pix, win, (WMScreenRContext(WMWidgetScreen(panel->okB)))->copy_gc, 0, 0, image->width, image->height,
0, 0);
SetTexturePanelTexture(panel, test);
free (test);
}
void testCancelButton(WMWidget *self, void *data){
wwarning("Exiting test....");
exit(0);
}
void wAbort()
{
exit(1);
}
int main(int argc, char **argv)
{
TexturePanel *panel;
Display *dpy = XOpenDisplay("");
WMScreen *scr;
/* char *test; */
WMInitializeApplication("Test", &argc, argv);
if (!dpy) {
wfatal("could not open display");
exit(1);
}
scr = WMCreateSimpleApplicationScreen(dpy);
panel = CreateTexturePanel(scr);
SetTexturePanelOkAction(panel,(WMAction*)testOKButton,panel);
SetTexturePanelCancelAction(panel,(WMAction*)testCancelButton,panel);
ShowTexturePanel(panel);
SetTexturePanelTexture(panel," ( tpixmap, ballot box.xpm, \"rgb:ff/de/ff\" ) ");
WMScreenMainLoop(scr);
return 0;
}
#endif
Reference in New Issue View Git Blame Copy Permalink