diff options
Diffstat (limited to 'generic')
| -rw-r--r-- | generic/Color.c | 814 |
1 files changed, 603 insertions, 211 deletions
diff --git a/generic/Color.c b/generic/Color.c index c83631d..ed2d17f 100644 --- a/generic/Color.c +++ b/generic/Color.c @@ -43,6 +43,7 @@ #include "Image.h" #include "Color.h" #include "Geo.h" +#include "Transfo.h" /* @@ -91,7 +92,8 @@ ColorInit() /* *---------------------------------------------------------------------- * - * ZnGetGradientColor -- + * ZnGetGradientColor + * ZnInterpGradientColor -- * *---------------------------------------------------------------------- */ @@ -100,28 +102,28 @@ ZnGetGradientColor(ZnGradient *grad, ZnReal position, unsigned short *alpha) { - int index, min, max; - XColor *shade=NULL; + int index, min, max; + XColor *shade=NULL; - if ((grad->num_colors == 1) || (position <= 0.0)) { + if ((grad->num_actual_colors == 1) || (position <= 0.0)) { if (alpha) { - *alpha = grad->colors[0].alpha; + *alpha = grad->actual_colors[0].alpha; } - return grad->colors[0].rgb; + return grad->actual_colors[0].rgb; } if (position >= 100.0) { if (alpha) { - *alpha = grad->colors[grad->num_colors-1].alpha; + *alpha = grad->actual_colors[grad->num_actual_colors-1].alpha; } - shade = grad->colors[grad->num_colors-1].rgb; + shade = grad->actual_colors[grad->num_actual_colors-1].rgb; } else { min = 0; - max = grad->num_colors-1; + max = grad->num_actual_colors-1; index = (max + min) / 2; while (max - min != 1) { /*printf("color index %d, min: %d, max: %d\n", index, min, max);*/ - if (grad->colors[index].position < position) { + if (grad->actual_colors[index].position < position) { min = index; } else { @@ -129,15 +131,76 @@ ZnGetGradientColor(ZnGradient *grad, } index = (max + min) / 2; } - shade = grad->colors[index].rgb; + shade = grad->actual_colors[index].rgb; if (alpha) { - *alpha = grad->colors[index].alpha; + *alpha = grad->actual_colors[index].alpha; } } return shade; } +void +ZnInterpGradientColor(ZnGradient *grad, + ZnReal position, + XColor *color, + unsigned short *alpha) +{ + int index, min, max; + ZnGradientColor *gc1, *gc2; + ZnReal rel_pos; + + if ((grad->num_actual_colors == 1) || (position <= 0.0)) { + *alpha = grad->actual_colors[0].alpha; + *color = *grad->actual_colors[0].rgb; + } + else if (position >= 100.0) { + *alpha = grad->actual_colors[grad->num_actual_colors-1].alpha; + *color = *grad->actual_colors[grad->num_actual_colors-1].rgb; + } + else { + min = 0; + max = grad->num_actual_colors-1; + index = (max + min) / 2; + while (max - min != 1) { + /*printf("color index %d, min: %d, max: %d\n", index, min, max);*/ + if (grad->actual_colors[index].position < position) { + min = index; + } + else { + max = index; + } + index = (max + min) / 2; + } + gc1 = &grad->actual_colors[index]; + gc2 = &grad->actual_colors[index+1]; + rel_pos = (position - gc1->position) * 100.0 / (gc2->position - gc1->position); + + if (rel_pos > gc1->control) { + rel_pos = (rel_pos - gc1->control) * 100.0 / (100.0 - gc1->control); + color->red = gc1->mid_rgb->red + + (gc2->rgb->red - gc1->mid_rgb->red) * rel_pos / 100.0; + color->green = gc1->mid_rgb->green + + (gc2->rgb->green - gc1->mid_rgb->green) * rel_pos / 100.0; + color->blue = gc1->mid_rgb->blue + + (gc2->rgb->blue - gc1->mid_rgb->blue) * rel_pos / 100.0; + *alpha = gc1->mid_alpha + + (gc2->alpha - gc1->mid_alpha) * rel_pos / 100.0; + } + else { + rel_pos = rel_pos * 100.0 / gc1->control; + color->red = gc1->rgb->red + + (gc1->mid_rgb->red - gc1->rgb->red) * rel_pos / 100.0; + color->green = gc1->rgb->green + + (gc1->mid_rgb->green - gc1->rgb->green) * rel_pos / 100.0; + color->blue = gc1->rgb->blue + + (gc1->mid_rgb->blue - gc1->rgb->blue) * rel_pos / 100.0; + *alpha = gc1->alpha + + (gc1->mid_alpha - gc1->alpha) * rel_pos / 100.0; + } + } +} + /* *-------------------------------------------------------------- @@ -152,7 +215,7 @@ ZnGetGradientColor(ZnGradient *grad, ZnBool ZnGradientFlat(ZnGradient *grad) { - return (grad->num_colors == 1); + return (grad->num_actual_colors == 1); } @@ -305,12 +368,6 @@ ZnNameGradient(Tcl_Interp *interp, ZnGradient *grad; XColor color; - grad = ZnGetGradient(interp, tkwin, grad_descr); - if (!grad) { - Tcl_AppendResult(interp, "gradient specification \"", grad_descr, - "\", is invalid", NULL); - return False; - } /* * First try to find if the name interfere with a color name, * this must be avoided. Gradients may be described by a single @@ -322,8 +379,15 @@ ZnNameGradient(Tcl_Interp *interp, "\", is a color name", NULL); return False; } + grad = ZnGetGradient(interp, tkwin, grad_descr); + if (!grad) { + Tcl_AppendResult(interp, "gradient specification \"", grad_descr, + "\", is invalid", NULL); + return False; + } hash = Tcl_CreateHashEntry(&gradient_table, Tk_GetUid(name), &new); if (!new) { + ZnFreeGradient(grad); Tcl_AppendResult(interp, "gradient name \"", name, "\", is already in use", NULL); return False; @@ -360,6 +424,290 @@ ZnDeleteGradientName(char *name) } } +static void +InterpolateGradientColor(Tk_Window tkwin, + ZnGradientColor *gc1, /* First color */ + ZnGradientColor *gc2, /* Next color */ + ZnGradientColor *gc_interp,/* New interpolated color */ + ZnGradientColor *gc_adjust,/* Adjusted first color. + * Needed if interested in + * the range color1 interp + * color. */ + int interp_pos, + int min_pos, + int span) +{ + int pos1, pos2, interp_rel_pos, tmp; + XColor rgb; + + pos1 = (gc1->position-min_pos)/span; + pos2 = (gc2->position-min_pos)/span; + interp_rel_pos = (interp_pos-pos1)*100/(pos2-pos1); + if (interp_rel_pos < gc1->control) { + tmp = interp_rel_pos*gc1->control; + rgb.red = gc1->rgb->red + (gc1->mid_rgb->red - gc1->rgb->red)*tmp/10000; + rgb.green = gc1->rgb->green + (gc1->mid_rgb->green - gc1->rgb->green)*tmp/10000; + rgb.blue = gc1->rgb->blue + (gc1->mid_rgb->blue - gc1->rgb->blue)*tmp/10000; + } + else if (interp_rel_pos > gc1->control) { + tmp = (interp_rel_pos-gc1->control)*gc1->control; + rgb.red = gc1->rgb->red + (gc1->mid_rgb->red - gc1->rgb->red)*tmp/10000; + rgb.green = gc1->rgb->green + (gc1->mid_rgb->green - gc1->rgb->green)*tmp/10000; + rgb.blue = gc1->rgb->blue + (gc1->mid_rgb->blue - gc1->rgb->blue)*tmp/10000; + } + else { + rgb = *gc1->mid_rgb; + gc_interp->alpha = gc1->mid_alpha; + } + rgb.red = gc1->rgb->red+(gc2->rgb->red-gc1->rgb->red)*interp_rel_pos/100; + rgb.green = gc1->rgb->green+(gc2->rgb->green-gc1->rgb->green)*interp_rel_pos/100; + rgb.blue = gc1->rgb->blue+(gc2->rgb->blue-gc1->rgb->blue)*interp_rel_pos/100; + gc_interp->rgb = Tk_GetColorByValue(tkwin, &rgb); + gc_interp->alpha = gc1->alpha+(gc2->alpha-gc1->alpha)*interp_rel_pos/100; + if (!gc_adjust) { + /* + * Interested in the segment from the interpolated color + * to color 2. + */ + gc_interp->position = 0; + if (interp_rel_pos < gc1->control) { + gc_interp->control = gc1->control-interp_rel_pos; + gc_interp->mid_rgb = Tk_GetColorByValue(tkwin, gc1->mid_rgb); + gc_interp->mid_alpha = gc1->mid_alpha; + } + else { + rgb.red = gc_interp->rgb->red+(gc2->rgb->red-gc_interp->rgb->red)/2; + rgb.green = gc_interp->rgb->green+(gc2->rgb->green-gc_interp->rgb->green)/2; + rgb.blue = gc_interp->rgb->blue+(gc2->rgb->blue-gc_interp->rgb->blue)/2; + gc_interp->mid_rgb = Tk_GetColorByValue(tkwin, &rgb); + gc_interp->mid_alpha = gc_interp->mid_alpha + + (gc2->mid_alpha - gc_interp->mid_alpha)/2; + gc_interp->control = 50; + } + } + else { + /* + * Interested in the segment form color 1 (color adjusted) to + * interpolated color. + */ + gc_interp->position = 100; + gc_interp->mid_rgb = NULL; + if (interp_rel_pos > gc1->control) { + gc_adjust->control = gc1->control+interp_rel_pos; + } + else { + rgb.red = gc1->rgb->red+(gc_interp->rgb->red-gc1->rgb->red)/2; + rgb.green = gc1->rgb->green+(gc_interp->rgb->green-gc1->rgb->green)/2; + rgb.blue = gc1->rgb->blue+(gc_interp->rgb->blue-gc1->rgb->blue)/2; + Tk_FreeColor(gc_adjust->mid_rgb); + gc_adjust->mid_rgb = Tk_GetColorByValue(tkwin, &rgb); + gc_adjust->mid_alpha = gc1->mid_alpha + + (gc_interp->mid_alpha - gc1->mid_alpha)/2; + gc_adjust->control = 50; + } + } +} + + +static void +ReduceGradient(Tk_Window tkwin, + ZnGradient *grad) +{ + ZnReal dx, dy, len, angle; + ZnTransfo t; + ZnPoint pbbox[4], pgrad[4]; + ZnReal maxx, minx, span, start_in_new, end_in_new; + int minx100, maxx100, span100; + int i, j, first_color, last_color; + ZnBool interpolate_first, interpolate_last; + + dx = grad->e.x - grad->p.x; + dy = grad->e.y - grad->p.y; + len = sqrt(dx*dx+dy*dy); + angle = acos(dx/len); + if (dy < 0) { + angle = 2*M_PI - angle; + } + grad->angle = (int) -ZnRadDeg(angle); + + if (grad->type == ZN_CONICAL_GRADIENT) { + unchanged: + grad->actual_colors = grad->colors_in; + grad->num_actual_colors = grad->num_colors_in; + return; + } + + ZnTransfoSetIdentity(&t); + ZnTranslate(&t, -grad->p.x, -grad->p.y); + ZnRotateRad(&t, -angle); + ZnScale(&t, 1/len, 1/len); + pbbox[0].x = -50; + pbbox[0].y = 50; + pbbox[1].x = 50; + pbbox[1].y = 50; + pbbox[2].x = 50; + pbbox[2].y = -50; + pbbox[3].x = -50; + pbbox[3].y = -50; + ZnTransformPoints(&t, pbbox, pgrad, 4); + maxx = minx = pgrad[0].x; + for (i = 1; i < 4; i++) { + if (pgrad[i].x > maxx) { + maxx = pgrad[i].x; + } + if (pgrad[i].x < minx) { + minx = pgrad[i].x; + } + } + + span = maxx-minx; + if (grad->type == ZN_RADIAL_GRADIENT) { + start_in_new = 0; + end_in_new = 100/span; + } + else { + start_in_new = -minx*100/span; + end_in_new = (1-minx)*100/span; + } + + /*printf("minx: %g, maxx: %g, start%%: %g, end%%: %g\n", + minx, maxx, start_in_new, end_in_new);*/ + + /* + * Gradient is unchanged + */ + if ((ABS(start_in_new) < PRECISION_LIMIT) && + (ABS(end_in_new-100.0) < PRECISION_LIMIT)) { + goto unchanged; + } + if ((start_in_new > 100.0) || (end_in_new < 0.0)) { + grad->num_actual_colors = 1; + grad->actual_colors = ZnMalloc(sizeof(ZnGradientColor)); + if (end_in_new < 0.0) { + grad->actual_colors[0].alpha = grad->colors_in[0].alpha; + grad->actual_colors[0].rgb = Tk_GetColorByValue(tkwin, + grad->colors_in[0].rgb); + } + else { + grad->actual_colors[0].alpha = grad->colors_in[grad->num_colors_in].alpha; + grad->actual_colors[0].rgb = Tk_GetColorByValue(tkwin, + grad->colors_in[grad->num_colors_in].rgb); + } + } + + grad->num_actual_colors = grad->num_colors_in; + interpolate_first = False; + minx100 = (int) (minx*100); + maxx100 = (int) (maxx*100); + span100 = (int) (span*100); + if (start_in_new < 0.0) { + /* Find the closest color inside the active area */ + first_color = 1; + while ((first_color < (int) grad->num_colors_in) && + (grad->colors_in[first_color].position < minx100)) { + first_color++; + grad->num_actual_colors--; + } + if (grad->colors_in[first_color].position == minx100) { + grad->num_actual_colors--; + } + else { + interpolate_first = True; + /*printf("interpolate first color\n");*/ + } + } + else { + first_color = 0; + if (grad->type != ZN_RADIAL_GRADIENT) { + grad->num_actual_colors++; + } + } + interpolate_last = False; + if (end_in_new > 100.0) { + /* Find the closest color inside the active area */ + last_color = grad->num_colors_in-2; + while ((last_color >= 0) && + (grad->colors_in[last_color].position > maxx100)) { + last_color--; + grad->num_actual_colors--; + } + if (grad->colors_in[last_color].position == maxx100) { + grad->num_actual_colors--; + } + else { + interpolate_last = True; + /*printf("interpolate last color\n");*/ + } + } + else { + last_color = grad->num_colors_in-1; + grad->num_actual_colors++; + } + + grad->actual_colors = ZnMalloc(grad->num_actual_colors*sizeof(ZnGradientColor)); + j = 0; + if (interpolate_first) { + InterpolateGradientColor(tkwin, + &grad->colors_in[first_color-1], + &grad->colors_in[first_color], + &grad->actual_colors[j], + NULL, + minx100, minx100, span100); + j++; + } + else if ((first_color == 0) && (grad->type != ZN_RADIAL_GRADIENT)) { + grad->actual_colors[j] = grad->colors_in[0]; + grad->actual_colors[j].rgb = + Tk_GetColorByValue(tkwin, grad->colors_in[0].rgb); + if (grad->colors_in[0].mid_rgb) { + grad->actual_colors[j].mid_rgb = + Tk_GetColorByValue(tkwin, grad->colors_in[0].mid_rgb); + } + grad->actual_colors[0].position = 0; + grad->actual_colors[0].control = 50; + j++; + /*printf("adding a color at start\n");*/ + } + + /*printf("first color: %d, last color: %d, num colors: %d\n", + first_color, last_color, grad->num_actual_colors);*/ + for (i = first_color; i <= last_color; i++, j++) { + grad->actual_colors[j] = grad->colors_in[i]; + grad->actual_colors[j].rgb = + Tk_GetColorByValue(tkwin, grad->colors_in[i].rgb); + if (grad->colors_in[i].mid_rgb) { + grad->actual_colors[j].mid_rgb = + Tk_GetColorByValue(tkwin, grad->colors_in[i].mid_rgb); + } + grad->actual_colors[j].position = + (grad->colors_in[i].position-minx100)*100/span100; + /*printf("i: %d, j: %d, minx: %d, span: %d, position av: %d position ap: %d\n", + i, j, minx100, span100, grad->colors_in[i].position, grad->actual_colors[j].position);*/ + } + + if (interpolate_last) { + InterpolateGradientColor(tkwin, + &grad->colors_in[last_color], + &grad->colors_in[last_color+1], + &grad->actual_colors[j], + &grad->actual_colors[j-1], + maxx100, minx100, span100); + } + else if (last_color == ((int) grad->num_colors_in)-1) { + i = grad->num_colors_in-1; + grad->actual_colors[j] = grad->colors_in[i]; + grad->actual_colors[j].rgb = + Tk_GetColorByValue(tkwin, grad->colors_in[i].rgb); + if (grad->colors_in[i].mid_rgb) { + grad->actual_colors[j].mid_rgb = + Tk_GetColorByValue(tkwin, grad->colors_in[i].mid_rgb); + } + /*printf("adding a color at end\n");*/ + } + grad->actual_colors[j].position = 100; +} + + /* *-------------------------------------------------------------- * @@ -463,15 +811,16 @@ ZnGetGradient(Tcl_Interp *interp, Tcl_HashEntry *hash; ZnGradient *grad; unsigned int i, j, nspace, num_colors; - unsigned int size, num_coords; + unsigned int size, num_coords=0; char type; char const *scan_ptr, *next_ptr, *str_ptr; - int angle, position, control; + ZnReal angle, position, control; ZnReal coords[4]; char *color_ptr, *end, segment[SEGMENT_SIZE]; ZnGradientColor *first, *last; XColor color; int new, red_range, green_range, blue_range; + ZnBool simple; /* printf("ZnGetGradient : %s\n", desc);*/ if (!desc || !*desc) { @@ -487,213 +836,231 @@ ZnGetGradient(Tcl_Interp *interp, */ desc = Tk_GetUid(desc); + /*printf("get gradient: %s\n", desc);*/ hash = Tcl_CreateHashEntry(&gradient_table, desc, &new); if (!new) { grad = (ZnGradient *) Tcl_GetHashValue(hash); grad->ref_count++; + return grad; } - else { - /* - * No satisfactory gradient exists yet. Initialize a new one. - */ - type = ZN_AXIAL_GRADIENT; - angle = 0; - /* - * Skip the trailing spaces. - */ - while (*desc == ' ') { - desc++; - } - /* - * Count the sections in the description. It should give - * the number of colors plus may be the gradient description. - */ - scan_ptr = desc; - /* - * If the first section is the gradient description, start color - * counts up from zero. - */ - num_colors = (*scan_ptr == '=') ? 0 : 1; - while ((scan_ptr = strchr(scan_ptr, '|'))) { - num_colors++; - scan_ptr++; - } - if (num_colors == 0) { - Tcl_AppendResult(interp, "gradient should have at least one color \"", - desc, "\",", NULL); - grad_err1: - Tcl_DeleteHashEntry(hash); - /*printf("ZnGetGradient error : %s\n", desc);*/ - return NULL; - } - /* - * Then look at the gradient type. - */ - scan_ptr = desc; - /* - * next_ptr can't be NULL in the following code, - * we checked that at least one color was specified - * after the gradient description. - */ - next_ptr = strchr(scan_ptr, '|'); - if (*scan_ptr == '=') { - scan_ptr++; - if ((*scan_ptr == 'a') && (strncmp(scan_ptr, "axial", 5) == 0)) { + + /* + * No satisfactory gradient exists yet. Initialize a new one. + */ + type = ZN_AXIAL_GRADIENT; + angle = 0.0; + /* + * Skip the trailing spaces. + */ + while (*desc == ' ') { + desc++; + } + /* + * Count the sections in the description. It should give + * the number of colors plus may be the gradient description. + */ + scan_ptr = desc; + /* + * If the first section is the gradient description, start color + * counts up from zero. + */ + num_colors = (*scan_ptr == '=') ? 0 : 1; + while ((scan_ptr = strchr(scan_ptr, '|'))) { + num_colors++; + scan_ptr++; + } + if (num_colors == 0) { + Tcl_AppendResult(interp, "gradient should have at least one color \"", + desc, "\",", NULL); + grad_err1: + Tcl_DeleteHashEntry(hash); + /*printf("ZnGetGradient error : %s\n", desc);*/ + return NULL; + } + /* + * Then look at the gradient type. + */ + scan_ptr = desc; + /* + * next_ptr can't be NULL in the following code, + * we checked that at least one color was specified + * after the gradient description. + */ + next_ptr = strchr(scan_ptr, '|'); + if (*scan_ptr == '=') { + scan_ptr++; + if (((*scan_ptr == 'a') && (strncmp(scan_ptr, "axial", 5) == 0)) || + ((*scan_ptr == 'c') && (strncmp(scan_ptr, "conical", 7) == 0))) { + if (*scan_ptr == 'a') { scan_ptr += 5; - if (ParseRealList(scan_ptr, next_ptr, coords, 1) != 1) { - grad_err3: - Tcl_AppendResult(interp, "invalid gradient parameter \"", - desc, "\",", NULL); - goto grad_err1; - } - angle = (int) coords[0]; - } - else if (((*scan_ptr == 'r') && (strncmp(scan_ptr, "radial", 6) == 0)) || - ((*scan_ptr == 'p') && (strncmp(scan_ptr, "path", 4) == 0))) { - if (*scan_ptr == 'r') { - type = ZN_RADIAL_GRADIENT; - scan_ptr += 6; - } - else { - type = ZN_PATH_GRADIENT; - scan_ptr += 4; - } - num_coords = ParseRealList(scan_ptr, next_ptr, coords, 4); - if ((num_coords != 2) && (num_coords != 4)) { - goto grad_err3; - } } else { - Tcl_AppendResult(interp, "invalid gradient type \"", + scan_ptr += 7; + type = ZN_CONICAL_GRADIENT; + } + num_coords = ParseRealList(scan_ptr, next_ptr, coords, 4); + if ((num_coords != 1) && (num_coords != 4)) { + grad_err3: + Tcl_AppendResult(interp, "invalid gradient parameter \"", desc, "\",", NULL); goto grad_err1; } - scan_ptr = next_ptr + 1; - next_ptr = strchr(scan_ptr, '|'); + angle = (init) coords[0]; } - /* - * Create the gradient structure. - */ - grad = (ZnGradient *) ZnMalloc(sizeof(ZnGradient) + - sizeof(ZnGradientColor)*(num_colors-1)); - grad->ref_count = 1; - grad->simple = True; - grad->num_colors = num_colors; - grad->type = type; - if (type == ZN_AXIAL_GRADIENT) { - if (num_coords == 4) { - grad->simple = False; - grad->g.p.x = coords[0]; - grad->g.p.y = coords[1]; - grad->e.x = coords[2]; - grad->e.y = coords[3]; + else if (((*scan_ptr == 'r') && (strncmp(scan_ptr, "radial", 6) == 0)) || + ((*scan_ptr == 'p') && (strncmp(scan_ptr, "path", 4) == 0))) { + if (*scan_ptr == 'r') { + type = ZN_RADIAL_GRADIENT; + scan_ptr += 6; } else { - grad->g.angle = angle; + type = ZN_PATH_GRADIENT; + scan_ptr += 4; + } + num_coords = ParseRealList(scan_ptr, next_ptr, coords, 4); + if ((num_coords != 2) && (num_coords != 4)) { + goto grad_err3; } } else { - grad->g.p.x = coords[0]; - grad->g.p.y = coords[1]; - if (num_coords == 4) { - grad->simple = False; - grad->e.x = coords[2]; - grad->e.y = coords[3]; - } + Tcl_AppendResult(interp, "invalid gradient type \"", + desc, "\",", NULL); + goto grad_err1; } - grad->hash = hash; - Tcl_SetHashValue(hash, grad); - - for (i = 0; i < num_colors; i++) { - grad->colors[i].alpha = 100; - /* - * Try to parse the color name. - */ - nspace = strspn(scan_ptr, " \t"); - scan_ptr += nspace; - str_ptr = strpbrk(scan_ptr, " \t|"); - if (str_ptr) { - size = str_ptr - scan_ptr; - } - else { - size = strlen(scan_ptr); - } - if (size > (SEGMENT_SIZE-1)) { - Tcl_AppendResult(interp, "color name too long in gradient \"", - desc, "\",", NULL); - grad_err2: - for (j = 0; j < i; j++) { - Tk_FreeColor(grad->colors[j].rgb); - } - ZnFree(grad); - goto grad_err1; + scan_ptr = next_ptr + 1; + next_ptr = strchr(scan_ptr, '|'); + } + /* + * Create the gradient structure. + */ + grad = (ZnGradient *) ZnMalloc(sizeof(ZnGradient) + + sizeof(ZnGradientColor)*(num_colors-1)); + grad->ref_count = 1; + simple = True; + grad->num_colors_in = num_colors; + grad->type = type; + switch (type) { + case ZN_AXIAL_GRADIENT: + case ZN_CONICAL_GRADIENT: + if ((num_coords == 4) && + ((coords[0] != coords[2]) || (coords[1] != coords[3]))) { + grad->p.x = coords[0]; + grad->p.y = coords[1]; + simple = False; + grad->e.x = coords[2]; + grad->e.y = coords[3]; + } + else { + grad->angle = (int) angle; + } + break; + case ZN_RADIAL_GRADIENT: + grad->p.x = coords[0]; + grad->p.y = coords[1]; + if ((num_coords == 4) && + ((coords[0] != coords[2]) || (coords[1] != coords[3]))) { + simple = False; + grad->e.x = coords[2]; + grad->e.y = coords[3]; + } + break; + case ZN_PATH_GRADIENT: + grad->p.x = coords[0]; + grad->p.y = coords[1]; + break; + } + grad->hash = hash; + Tcl_SetHashValue(hash, grad); + + for (i = 0; i < num_colors; i++) { + grad->colors_in[i].alpha = 100; + /* + * Try to parse the color name. + */ + nspace = strspn(scan_ptr, " \t"); + scan_ptr += nspace; + str_ptr = strpbrk(scan_ptr, " \t|"); + if (str_ptr) { + size = str_ptr - scan_ptr; + } + else { + size = strlen(scan_ptr); + } + if (size > (SEGMENT_SIZE-1)) { + Tcl_AppendResult(interp, "color name too long in gradient \"", + desc, "\",", NULL); + grad_err2: + for (j = 0; j < i; j++) { + Tk_FreeColor(grad->colors_in[j].rgb); } - strncpy(segment, scan_ptr, size); - segment[size] = 0; - scan_ptr += size; + ZnFree(grad); + goto grad_err1; + } + strncpy(segment, scan_ptr, size); + segment[size] = 0; + scan_ptr += size; + /* + * Try to parse the color position. + */ + grad->colors_in[i].position = 0; + grad->colors_in[i].control = 50; + position = strtod(scan_ptr, &end); + if (end != scan_ptr) { + grad->colors_in[i].position = (int) position; + scan_ptr = end; /* - * Try to parse the color position. + * Try to parse the control point */ - grad->colors[i].position = 0; - grad->colors[i].control = 50; - position = strtol(scan_ptr, &end, 10); + control = strtod(scan_ptr, &end); if (end != scan_ptr) { - grad->colors[i].position = position; + grad->colors_in[i].control = (int) control; scan_ptr = end; - /* - * Try to parse the control point - */ - control = strtol(scan_ptr, &end, 10); - if (end != scan_ptr) { - grad->colors[i].control = control; - scan_ptr = end; - } - } - nspace = strspn(scan_ptr, " \t"); - if ((scan_ptr[nspace] != 0) && (scan_ptr+nspace != next_ptr)) { - Tcl_AppendResult(interp, "incorrect color description in gradient \"", - desc, "\",", NULL); - goto grad_err2; - } - - color_ptr = strchr(segment, ';'); - if (color_ptr) { - *color_ptr = 0; - } - grad->colors[i].rgb = Tk_GetColor(interp, tkwin, Tk_GetUid(segment)); - if (grad->colors[i].rgb == NULL) { - Tcl_AppendResult(interp, "incorrect color value in gradient \"", - desc, "\",", NULL); - goto grad_err2; - } - if (color_ptr) { - color_ptr++; - grad->colors[i].alpha = atoi(color_ptr); - } - if (i == 0) { - grad->colors[i].position = 0; - } - else if (i == num_colors - 1) { - grad->colors[i].position = 100; - } - if ((i > 0) && - ((grad->colors[i].position > 100) || - (grad->colors[i].position < grad->colors[i-1].position))) { - Tcl_AppendResult(interp, "incorrect color position in gradient \"", - desc, "\",", NULL); - goto grad_err2; - } - if (grad->colors[i].control > 100) { - grad->colors[i].control = 100; - } - if (grad->colors[i].alpha > 100) { - grad->colors[i].alpha = 100; - } - if (next_ptr) { - scan_ptr = next_ptr + 1; - next_ptr = strchr(scan_ptr, '|'); } } + nspace = strspn(scan_ptr, " \t"); + if ((scan_ptr[nspace] != 0) && (scan_ptr+nspace != next_ptr)) { + Tcl_AppendResult(interp, "incorrect color description in gradient \"", + desc, "\",", NULL); + goto grad_err2; + } + + color_ptr = strchr(segment, ';'); + if (color_ptr) { + *color_ptr = 0; + } + grad->colors_in[i].rgb = Tk_GetColor(interp, tkwin, Tk_GetUid(segment)); + if (grad->colors_in[i].rgb == NULL) { + Tcl_AppendResult(interp, "incorrect color value in gradient \"", + desc, "\",", NULL); + goto grad_err2; + } + if (color_ptr) { + color_ptr++; + grad->colors_in[i].alpha = atoi(color_ptr); + } + if (i == 0) { + grad->colors_in[i].position = 0; + } + else if (i == num_colors - 1) { + grad->colors_in[i].position = 100; + } + if ((i > 0) && + ((grad->colors_in[i].position > 100) || + (grad->colors_in[i].position < grad->colors_in[i-1].position))) { + Tcl_AppendResult(interp, "incorrect color position in gradient \"", + desc, "\",", NULL); + goto grad_err2; + } + if (grad->colors_in[i].control > 100) { + grad->colors_in[i].control = 100; + } + if (grad->colors_in[i].alpha > 100) { + grad->colors_in[i].alpha = 100; + } + if (next_ptr) { + scan_ptr = next_ptr + 1; + next_ptr = strchr(scan_ptr, '|'); + } } /* @@ -701,9 +1068,9 @@ ZnGetGradient(Tcl_Interp *interp, * used by the gradient rendering primitives when a control * is not at mid range. The last color has no mid_* values. */ - for (i = 0; i < grad->num_colors-1; i++) { - first = &grad->colors[i]; - last = &grad->colors[i+1]; + for (i = 0; i < grad->num_colors_in-1; i++) { + first = &grad->colors_in[i]; + last = &grad->colors_in[i+1]; red_range = (int) last->rgb->red - (int) first->rgb->red; green_range = (int) last->rgb->green - (int) first->rgb->green; blue_range = (int) last->rgb->blue - (int) first->rgb->blue; @@ -713,8 +1080,24 @@ ZnGetGradient(Tcl_Interp *interp, first->mid_rgb = Tk_GetColorByValue(tkwin, &color); first->mid_alpha = first->alpha + (last->alpha-first->alpha)/2; } - grad->colors[grad->num_colors-1].mid_rgb = NULL; + grad->colors_in[grad->num_colors_in-1].mid_rgb = NULL; + + /* + * If the gradient is 'simple' ie. described by a single point + * or an angle for axial gradients, the processing is finished. + * If not, we have to reduce the gradient to a simple one by adding + * or suppressing colors and adjusting the relative position of + * each remaining color. + */ + if (simple) { + grad->num_actual_colors = grad->num_colors_in; + grad->actual_colors = grad->colors_in; + } + else if (type != ZN_PATH_GRADIENT) { + ReduceGradient(tkwin, grad); + } + /*printf("num in: %d, num actual: %d\n", grad->num_colors_in,grad->num_actual_colors);*/ /* printf("ZnGetGradient end : %s\n", desc);*/ return grad; } @@ -770,11 +1153,20 @@ ZnFreeGradient(ZnGradient *grad) grad->ref_count--; if (grad->ref_count == 0) { Tcl_DeleteHashEntry(grad->hash); - for (i = 0; i < grad->num_colors; i++) { - Tk_FreeColor(grad->colors[i].rgb); - if (grad->colors[i].mid_rgb) { - Tk_FreeColor(grad->colors[i].mid_rgb); + for (i = 0; i < grad->num_colors_in; i++) { + Tk_FreeColor(grad->colors_in[i].rgb); + if (grad->colors_in[i].mid_rgb) { + Tk_FreeColor(grad->colors_in[i].mid_rgb); + } + } + if (grad->actual_colors != grad->colors_in) { + for (i = 0; i < grad->num_actual_colors; i++) { + Tk_FreeColor(grad->actual_colors[i].rgb); + if (grad->actual_colors[i].mid_rgb) { + Tk_FreeColor(grad->actual_colors[i].mid_rgb); + } } + ZnFree(grad->actual_colors); } ZnFree(grad); } |