static void
Bound(AG_Event *event)
{
AG_HSVPal *hsv = AG_SELF();
AG_Variable *V = AG_PTR(1);
if (AG_VARIABLE_TYPE(V) == AG_VARIABLE_UINT32 &&
strcmp(V->name, "pixel") == 0) {
#if 0
hsv->flags |= AG_HSVPAL_PIXEL;
#endif
UpdateHSVFromPixel(hsv, *(Uint32 *)V->data.p);
} else if (strcmp(V->name, "RGBAv") == 0) {
UpdateHSVFromRGBAv(hsv);
} else if (strcmp(V->name, "RGBv") == 0) {
UpdateHSVFromRGBv(hsv);
} else if (strcmp(V->name, "pixel-format") == 0) {
if (!(hsv->flags & AG_HSVPAL_FORCE_NOALPHA)) {
AG_PixelFormat **pFormat = (AG_PixelFormat **)V->data.p;
if ((*pFormat)->Amask != 0) {
hsv->flags &= ~(AG_HSVPAL_NOALPHA);
} else {
hsv->flags |= AG_HSVPAL_NOALPHA;
}
}
}
AG_Redraw(hsv);
}
static __inline__ void
SetAlpha8(AG_HSVPal *pal, Uint8 a)
{
AG_Variable *bAlpha;
void *pAlpha;
bAlpha = AG_GetVariable(pal, "alpha", &pAlpha);
switch (AG_VARIABLE_TYPE(bAlpha)) {
case AG_VARIABLE_FLOAT:
*(float *)pAlpha = (float)(((float)a)/255.0);
break;
case AG_VARIABLE_DOUBLE:
*(double *)pAlpha = (double)(((double)a)/255.0);
break;
case AG_VARIABLE_INT:
*(int *)pAlpha = (int)a;
break;
case AG_VARIABLE_UINT8:
*(Uint8 *)pAlpha = (Uint8)a;
break;
default:
break;
}
AG_UnlockVariable(bAlpha);
AG_Redraw(pal);
}
static void
SetState(AG_Button *bu, AG_Variable *binding, void *p, int v)
{
switch (AG_VARIABLE_TYPE(binding)) {
case AG_VARIABLE_INT:
*(int *)p = v;
break;
case AG_VARIABLE_UINT8:
*(Uint8 *)p = v;
break;
case AG_VARIABLE_UINT16:
*(Uint16 *)p = v;
break;
case AG_VARIABLE_UINT32:
*(Uint32 *)p = v;
break;
case AG_VARIABLE_P_FLAG:
AG_SETFLAGS(*(int *)p, (int)binding->info.bitmask, v);
break;
case AG_VARIABLE_P_FLAG8:
AG_SETFLAGS(*(Uint8 *)p, (Uint8)binding->info.bitmask, v);
break;
case AG_VARIABLE_P_FLAG16:
AG_SETFLAGS(*(Uint16 *)p, (Uint16)binding->info.bitmask, v);
break;
case AG_VARIABLE_P_FLAG32:
AG_SETFLAGS(*(Uint32 *)p, (Uint32)binding->info.bitmask, v);
break;
}
AG_Redraw(bu);
}
/* Return the 8-bit representation of the current alpha value. */
static __inline__ Uint8
GetAlpha8(AG_HSVPal *pal)
{
AG_Variable *bAlpha;
Uint8 a = 255;
void *p;
bAlpha = AG_GetVariable(pal, "alpha", &p);
switch (AG_VARIABLE_TYPE(bAlpha)) {
case AG_VARIABLE_FLOAT:
a = (Uint8)((*(float *)p)*255.0);
break;
case AG_VARIABLE_DOUBLE:
a = (Uint8)((*(double *)p)*255.0);
break;
case AG_VARIABLE_INT:
a = (int)((*(int *)p));
break;
case AG_VARIABLE_UINT8:
a = (int)((*(Uint8 *)p));
break;
default:
break;
}
AG_UnlockVariable(bAlpha);
return (a);
}
static void
UpdateHSVFromRGBAv(AG_HSVPal *hsv)
{
AG_Variable *bRGBAv;
void *RGBAv;
Uint8 r, g, b, a;
float h, s, v;
if ((bRGBAv = AG_GetVariable(hsv, "RGBAv", &RGBAv)) == NULL) {
return;
}
switch (AG_VARIABLE_TYPE(bRGBAv)) {
case AG_VARIABLE_FLOAT:
r = (Uint8)(((float *)RGBAv)[0] * 255.0);
g = (Uint8)(((float *)RGBAv)[1] * 255.0);
b = (Uint8)(((float *)RGBAv)[2] * 255.0);
a = (Uint8)(((float *)RGBAv)[3] * 255.0);
break;
case AG_VARIABLE_DOUBLE:
r = (Uint8)(((double *)RGBAv)[0] * 255.0);
g = (Uint8)(((double *)RGBAv)[1] * 255.0);
b = (Uint8)(((double *)RGBAv)[2] * 255.0);
a = (Uint8)(((double *)RGBAv)[3] * 255.0);
break;
case AG_VARIABLE_INT:
r = (Uint8)(((int *)RGBAv)[0]);
g = (Uint8)(((int *)RGBAv)[1]);
b = (Uint8)(((int *)RGBAv)[2]);
a = (Uint8)(((int *)RGBAv)[3]);
break;
case AG_VARIABLE_UINT8:
r = ((Uint8 *)RGBAv)[0];
g = ((Uint8 *)RGBAv)[1];
b = ((Uint8 *)RGBAv)[2];
a = ((Uint8 *)RGBAv)[3];
break;
default:
r = 0;
g = 0;
b = 0;
a = 0;
break;
}
AG_RGB2HSV(r, g, b, &h, &s, &v);
AG_SetFloat(hsv, "hue", h);
AG_SetFloat(hsv, "saturation", s);
AG_SetFloat(hsv, "value", v);
SetAlpha8(hsv, a);
AG_UnlockVariable(bRGBAv);
hsv->flags |= AG_HSVPAL_DIRTY;
AG_Redraw(hsv);
}
static void
UpdateAlpha(AG_HSVPal *pal, int x)
{
AG_Variable *bAlpha;
void *pAlpha;
bAlpha = AG_GetVariable(pal, "alpha", &pAlpha);
switch (AG_VARIABLE_TYPE(bAlpha)) {
case AG_VARIABLE_FLOAT:
*(float *)pAlpha = ((float)x)/((float)pal->rAlpha.w);
if (*(float *)pAlpha > 1.0) {
*(float *)pAlpha = 1.0;
} else if (*(float *)pAlpha < 0.0) {
*(float *)pAlpha = 0.0;
}
break;
case AG_VARIABLE_DOUBLE:
*(double *)pAlpha = ((double)x)/((double)pal->rAlpha.w);
if (*(double *)pAlpha > 1.0) {
*(double *)pAlpha = 1.0;
} else if (*(double *)pAlpha < 0.0) {
*(double *)pAlpha = 0.0;
}
break;
case AG_VARIABLE_INT:
*(int *)pAlpha = x/pal->rAlpha.w;
if (*(int *)pAlpha > 255) {
*(int *)pAlpha = 255;
} else if (*(int *)pAlpha < 0) {
*(int *)pAlpha = 0;
}
break;
case AG_VARIABLE_UINT8:
*(Uint8 *)pAlpha = (Uint8)(x/pal->rAlpha.w);
break;
default:
break;
}
AG_UnlockVariable(bAlpha);
UpdatePixelFromHSVA(pal);
AG_PostEvent(NULL, pal, "a-changed", NULL);
AG_Redraw(pal);
}
static __inline__ int
GetPosition(AG_Slider *sl, int *x)
{
AG_Variable *bMin, *bMax, *bVal;
void *pMin, *pMax, *pVal;
bVal = AG_GetVariable(sl, "value", &pVal);
bMin = AG_GetVariable(sl, "min", &pMin);
bMax = AG_GetVariable(sl, "max", &pMax);
switch (AG_VARIABLE_TYPE(bVal)) {
case AG_VARIABLE_FLOAT: GET_POSITION(float); break;
case AG_VARIABLE_DOUBLE: GET_POSITION(double); break;
#ifdef HAVE_LONG_DOUBLE
case AG_VARIABLE_LONG_DOUBLE: GET_POSITION(long double); break;
#endif
case AG_VARIABLE_INT: GET_POSITION(int); break;
case AG_VARIABLE_UINT: GET_POSITION(Uint); break;
case AG_VARIABLE_UINT8: GET_POSITION(Uint8); break;
case AG_VARIABLE_SINT8: GET_POSITION(Sint8); break;
case AG_VARIABLE_UINT16: GET_POSITION(Uint16); break;
case AG_VARIABLE_SINT16: GET_POSITION(Sint16); break;
case AG_VARIABLE_UINT32: GET_POSITION(Uint32); break;
case AG_VARIABLE_SINT32: GET_POSITION(Sint32); break;
#ifdef HAVE_64BIT
case AG_VARIABLE_UINT64: GET_POSITION(Uint64); break;
case AG_VARIABLE_SINT64: GET_POSITION(Sint64); break;
#endif
default: *x = 0; break;
}
AG_UnlockVariable(bMax);
AG_UnlockVariable(bMin);
AG_UnlockVariable(bVal);
return (0);
fail:
AG_UnlockVariable(bMax);
AG_UnlockVariable(bMin);
AG_UnlockVariable(bVal);
return (-1);
}
static void
Decrement(AG_Slider *sl)
{
AG_Variable *bVal, *bMin, *bMax, *bInc;
void *pVal, *pMin, *pMax, *pInc;
bVal = AG_GetVariable(sl, "value", &pVal);
bMin = AG_GetVariable(sl, "min", &pMin);
bMax = AG_GetVariable(sl, "max", &pMax);
bInc = AG_GetVariable(sl, "inc", &pInc);
switch (AG_VARIABLE_TYPE(bVal)) {
case AG_VARIABLE_FLOAT: DECREMENT(float); break;
case AG_VARIABLE_DOUBLE: DECREMENT(double); break;
#ifdef HAVE_LONG_DOUBLE
case AG_VARIABLE_LONG_DOUBLE: DECREMENT(long double); break;
#endif
case AG_VARIABLE_INT: DECREMENT(int); break;
case AG_VARIABLE_UINT: DECREMENT(Uint); break;
case AG_VARIABLE_UINT8: DECREMENT(Uint8); break;
case AG_VARIABLE_SINT8: DECREMENT(Sint8); break;
case AG_VARIABLE_UINT16: DECREMENT(Uint16); break;
case AG_VARIABLE_SINT16: DECREMENT(Sint16); break;
case AG_VARIABLE_UINT32: DECREMENT(Uint32); break;
case AG_VARIABLE_SINT32: DECREMENT(Sint32); break;
#ifdef HAVE_64BIT
case AG_VARIABLE_UINT64: DECREMENT(Uint64); break;
case AG_VARIABLE_SINT64: DECREMENT(Sint64); break;
#endif
default: break;
}
AG_PostEvent(NULL, sl, "slider-changed", NULL);
AG_UnlockVariable(bVal);
AG_UnlockVariable(bMin);
AG_UnlockVariable(bMax);
AG_UnlockVariable(bInc);
AG_Redraw(sl);
}
static void
OnShow(AG_Event *event)
{
AG_Slider *sl = AG_SELF();
AG_Variable *V;
if ((V = AG_GetVariable(sl, "value", NULL)) == NULL) {
V = AG_SetInt(sl, "value", 0);
AG_LockVariable(V);
}
switch (AG_VARIABLE_TYPE(V)) {
case AG_VARIABLE_FLOAT: SET_DEF(AG_SetFloat, 0.0f, 1.0f, 0.1f); break;
case AG_VARIABLE_DOUBLE: SET_DEF(AG_SetDouble, 0.0, 1.0, 0.1); break;
#ifdef HAVE_LONG_DOUBLE
case AG_VARIABLE_LONG_DOUBLE: SET_DEF(AG_SetLongDouble, 0.0l, 1.0l, 0.1l); break;
#endif
case AG_VARIABLE_INT: SET_DEF(AG_SetInt, AG_INT_MIN+1, AG_INT_MAX-1, 1); break;
case AG_VARIABLE_UINT: SET_DEF(AG_SetUint, 0U, AG_UINT_MAX-1, 1U); break;
case AG_VARIABLE_UINT8: SET_DEF(AG_SetUint8, 0U, 0xffU, 1U); break;
case AG_VARIABLE_SINT8: SET_DEF(AG_SetSint8, -0x7f, 0x7f, 1); break;
case AG_VARIABLE_UINT16: SET_DEF(AG_SetUint16, 0U, 0xffffU, 1U); break;
case AG_VARIABLE_SINT16: SET_DEF(AG_SetSint16, -0x7fff, 0x7fff, 1); break;
case AG_VARIABLE_UINT32: SET_DEF(AG_SetUint32, 0UL, 0xffffffffUL, 1UL); break;
case AG_VARIABLE_SINT32: SET_DEF(AG_SetSint32, -0x7fffffffL, 0x7fffffffL, 1L); break;
#ifdef HAVE_64BIT
case AG_VARIABLE_UINT64: SET_DEF(AG_SetUint64, 0ULL, 0xffffffffffffffffULL, 1ULL); break;
case AG_VARIABLE_SINT64: SET_DEF(AG_SetSint64, -0x7fffffffffffffffLL, 0x7fffffffffffffffLL, 1LL); break;
#endif
default: break;
}
AG_UnlockVariable(V);
if ((sl->flags & AG_SLIDER_EXCL) == 0) {
AG_RedrawOnChange(sl, 100, "value");
AG_RedrawOnChange(sl, 1000, "min");
AG_RedrawOnChange(sl, 1000, "max");
}
}
static __inline__ void
SeekToPosition(AG_Slider *sl, int x)
{
AG_Variable *bMin, *bMax, *bVal;
void *pMin, *pMax, *pVal;
bVal = AG_GetVariable(sl, "value", &pVal);
bMin = AG_GetVariable(sl, "min", &pMin);
bMax = AG_GetVariable(sl, "max", &pMax);
switch (AG_VARIABLE_TYPE(bVal)) {
case AG_VARIABLE_FLOAT: SEEK_TO_POSITION(float); break;
case AG_VARIABLE_DOUBLE: SEEK_TO_POSITION(double); break;
#ifdef HAVE_LONG_DOUBLE
case AG_VARIABLE_LONG_DOUBLE: SEEK_TO_POSITION(long double); break;
#endif
case AG_VARIABLE_INT: SEEK_TO_POSITION(int); break;
case AG_VARIABLE_UINT: SEEK_TO_POSITION(Uint); break;
case AG_VARIABLE_UINT8: SEEK_TO_POSITION(Uint8); break;
case AG_VARIABLE_SINT8: SEEK_TO_POSITION(Sint8); break;
case AG_VARIABLE_UINT16: SEEK_TO_POSITION(Uint16); break;
case AG_VARIABLE_SINT16: SEEK_TO_POSITION(Sint16); break;
case AG_VARIABLE_UINT32: SEEK_TO_POSITION(Uint32); break;
case AG_VARIABLE_SINT32: SEEK_TO_POSITION(Sint32); break;
#ifdef HAVE_64BIT
case AG_VARIABLE_UINT64: SEEK_TO_POSITION(Uint64); break;
case AG_VARIABLE_SINT64: SEEK_TO_POSITION(Sint64); break;
#endif
default: break;
}
AG_PostEvent(NULL, sl, "slider-changed", NULL);
AG_UnlockVariable(bMax);
AG_UnlockVariable(bMin);
AG_UnlockVariable(bVal);
AG_Redraw(sl);
}
static int
GetState(AG_Button *bu, AG_Variable *binding, void *p)
{
int v = 0;
switch (AG_VARIABLE_TYPE(binding)) {
case AG_VARIABLE_INT:
v = *(int *)p;
break;
case AG_VARIABLE_UINT8:
v = (int)(*(Uint8 *)p);
break;
case AG_VARIABLE_UINT16:
v = (int)(*(Uint16 *)p);
break;
case AG_VARIABLE_UINT32:
v = (int)(*(Uint32 *)p);
break;
case AG_VARIABLE_P_FLAG:
v = (*(int *)p & (int)binding->info.bitmask);
break;
case AG_VARIABLE_P_FLAG8:
v = (int)(*(Uint8 *)p & (Uint8)binding->info.bitmask);
break;
case AG_VARIABLE_P_FLAG16:
v = (int)(*(Uint16 *)p & (Uint16)binding->info.bitmask);
break;
case AG_VARIABLE_P_FLAG32:
v = (int)(*(Uint32 *)p & (Uint32)binding->info.bitmask);
break;
}
if (bu->flags & AG_BUTTON_INVSTATE) {
v = !v;
}
return (v);
}
static void
EditNumValues(AG_Event *event)
{
AG_HSVPal *pal = AG_PTR(1);
AG_Window *pwin;
AG_Window *win;
AG_Numerical *num;
AG_Variable *b1, *b2;
float v;
if ((pwin = AG_ParentWindow(pal)) == NULL)
return;
if ((win = AG_WindowNewNamed(AG_WINDOW_NOMAXIMIZE, "hsvpal-%p-numedit",
pal)) == NULL) {
return;
}
AG_WindowSetCaption(win, _("Color values"));
AG_WindowSetPosition(win, AG_WINDOW_LOWER_LEFT, 0);
AG_WindowSetCloseAction(win, AG_WINDOW_DETACH);
{
AG_Variable *bAlpha;
void *pAlpha;
num = AG_NumericalNew(win, 0, NULL, _("Hue: "));
AG_NumericalSizeHint(num, "000");
AG_WidgetCopyBinding(num, "value", pal, "hue");
AG_NumericalSetRange(num, 0.0, 359.0);
AG_NumericalSetIncrement(num, 1);
AG_NumericalSetPrecision(num, "f", 0);
num = AG_NumericalNew(win, 0, NULL, _("Saturation: "));
AG_NumericalSizeHint(num, "00.00");
AG_WidgetCopyBinding(num, "value", pal, "saturation");
AG_NumericalSetRange(num, 0.0, 1.0);
AG_NumericalSetIncrement(num, 0.01);
AG_NumericalSetPrecision(num, "f", 2);
num = AG_NumericalNew(win, 0, NULL, _("Value: "));
AG_NumericalSizeHint(num, "00.00");
AG_WidgetCopyBinding(num, "value", pal, "value");
AG_NumericalSetRange(num, 0.0, 1.0);
AG_NumericalSetIncrement(num, 0.01);
AG_NumericalSetPrecision(num, "f", 2);
num = AG_NumericalNew(win, 0, NULL, _("Alpha: "));
AG_NumericalSizeHint(num, "0.000");
AG_WidgetCopyBinding(num, "value", pal, "alpha");
bAlpha = AG_GetVariable(pal, "alpha", &pAlpha);
switch (AG_VARIABLE_TYPE(bAlpha)) {
case AG_VARIABLE_FLOAT:
case AG_VARIABLE_DOUBLE:
AG_NumericalSetRange(num, 0.0, 1.0);
AG_NumericalSetIncrement(num, 0.005);
AG_NumericalSetPrecision(num, "f", 3);
break;
case AG_VARIABLE_INT:
case AG_VARIABLE_UINT:
case AG_VARIABLE_UINT8:
AG_NumericalSetRange(num, 0.0, 255.0);
AG_NumericalSetIncrement(num, 1.0);
AG_NumericalSetPrecision(num, "f", 0);
break;
default:
break;
}
AG_UnlockVariable(bAlpha);
}
AG_WindowAttach(pwin, win);
AG_WindowShow(win);
}
static __inline__ void
UpdatePixelFromHSVA(AG_HSVPal *pal)
{
Uint8 r, g, b, a;
AG_Variable *bFormat, *bColor, *bv;
AG_PixelFormat **pFormat;
AG_Color *pColor;
void *v;
AG_HSV2RGB(AG_GetFloat(pal, "hue"),
AG_GetFloat(pal, "saturation"),
AG_GetFloat(pal, "value"), &r, &g, &b);
a = GetAlpha8(pal);
if ((bv = AG_GetVariable(pal, "RGBv", &v)) != NULL) {
switch (AG_VARIABLE_TYPE(bv)) {
case AG_VARIABLE_FLOAT:
((float *)v)[0] = (float)r/255.0;
((float *)v)[1] = (float)g/255.0;
((float *)v)[2] = (float)b/255.0;
break;
case AG_VARIABLE_DOUBLE:
((double *)v)[0] = (double)r/255.0;
((double *)v)[1] = (double)g/255.0;
((double *)v)[2] = (double)b/255.0;
break;
case AG_VARIABLE_INT:
((int *)v)[0] = (int)r;
((int *)v)[1] = (int)g;
((int *)v)[2] = (int)b;
break;
case AG_VARIABLE_UINT8:
((Uint8 *)v)[0] = r;
((Uint8 *)v)[1] = g;
((Uint8 *)v)[2] = b;
break;
default:
break;
}
AG_UnlockVariable(bv);
}
if ((bv = AG_GetVariable(pal, "RGBAv", &v)) != NULL) {
switch (AG_VARIABLE_TYPE(bv)) {
case AG_VARIABLE_FLOAT:
((float *)v)[0] = (float)r/255.0;
((float *)v)[1] = (float)g/255.0;
((float *)v)[2] = (float)b/255.0;
((float *)v)[3] = (float)a/255.0;
break;
case AG_VARIABLE_DOUBLE:
((double *)v)[0] = (double)r/255.0;
((double *)v)[1] = (double)g/255.0;
((double *)v)[2] = (double)b/255.0;
((double *)v)[3] = (double)a/255.0;
break;
case AG_VARIABLE_INT:
((int *)v)[0] = (int)r;
((int *)v)[1] = (int)g;
((int *)v)[2] = (int)b;
((int *)v)[3] = (int)a;
break;
case AG_VARIABLE_UINT8:
((Uint8 *)v)[0] = r;
((Uint8 *)v)[1] = g;
((Uint8 *)v)[2] = b;
((Uint8 *)v)[3] = a;
break;
default:
break;
}
AG_UnlockVariable(bv);
}
bFormat = AG_GetVariable(pal, "pixel-format", &pFormat);
AG_SetUint32(pal, "pixel", AG_MapPixelRGBA(*pFormat, r,g,b,a));
AG_UnlockVariable(bFormat);
bColor = AG_GetVariable(pal, "color", &pColor);
pColor->r = r;
pColor->g = g;
pColor->b = b;
pColor->a = a;
AG_UnlockVariable(bColor);
AG_Redraw(pal);
}
