Passage des couleurs en gradients pour uniformiser

1 files changed, 97 insertions, 126 deletions

diff --git a/generic/Item.c b/generic/Item.c
index 2ac02b0..067754a 100644
--- a/generic/Item.c
+++ b/generic/Item.c
@@ -70,10 +70,10 @@ static	ZnList	item_stack = NULL;
  */
 typedef struct _FieldStruct {
   /* Public data */
-  ZnColor	color;
+  ZnGradient	*color;
   ZnGradient	*fill_color;
   Pixmap	fill_pattern;
-  ZnColor	border_color;
+  ZnGradient	*border_color;
   char		*text;
   char		*image_name;
   char		*tile_name;
@@ -116,9 +116,9 @@ ZnAttrConfig	field_attrs[] = {
     ZN_DRAW_FLAG|ZN_BORDER_FLAG, False },
   { ZN_CONFIG_BORDER, "-border", NULL,
     Tk_Offset(FieldStruct, border_edges), 0, ZN_DRAW_FLAG, False },
-  { ZN_CONFIG_COLOR, "-bordercolor", NULL,
+  { ZN_CONFIG_GRADIENT, "-bordercolor", NULL,
     Tk_Offset(FieldStruct, border_color), 0, ZN_DRAW_FLAG, False },
-  { ZN_CONFIG_COLOR, "-color", NULL,
+  { ZN_CONFIG_GRADIENT, "-color", NULL,
     Tk_Offset(FieldStruct, color), 0, ZN_DRAW_FLAG, False },
   { ZN_CONFIG_BOOL, "-filled", NULL,
     Tk_Offset(FieldStruct, flags), FILLED_BIT, ZN_COORDS_FLAG, False },
@@ -155,7 +155,6 @@ ZnAttrConfig	field_attrs[] = {
 static char *attribute_type_strings[] = {
   "",
   "color",
-  "colors",
   "boolean",
   "pattern",
   "patterns",
@@ -185,6 +184,7 @@ static char *attribute_type_strings[] = {
   "joinstyle",
   "capstyle",
   "gradient",
+  "gradients",
   "window",
   "alpha",
 };
@@ -400,112 +400,91 @@ ConfigureAttributes(char		*record,
 	    }
 	    break;
 	  }
-	case ZN_CONFIG_COLORS:
+	case ZN_CONFIG_GRADIENT:
 	  {
-	    ZnList		new_color_list = NULL;
-	    ZnGradientColor	*colors;
-	    int			num_colors, j, k;
-	    Tcl_Obj		**elems;
-	    char		*color_ptr;
+	    ZnGradient *g;
+	    Tk_Uid new_name = Tk_GetUid(Tcl_GetString(args[i+1]));
+	    char   *name = NULL;
+	    if (*((ZnGradient **) valp)) {
+	      name = ZnNameOfGradient(*((ZnGradient **) valp));
+	    }
+	    if (name != new_name) {
+	      g = ZnGetGradient(wi->interp, wi->win, new_name);
+	      if (!g) {
+		Tcl_AppendResult(wi->interp,
+				 " gradient expected for attribute \"",
+				 Tcl_GetString(args[i]), "\"", NULL);
+		return ZN_ERROR;
+	      }
+	      if (*((ZnGradient **) valp)) {
+		ZnFreeGradient(*((ZnGradient **) valp));
+	      }
+	      *((ZnGradient **) valp) = g;
+	      *flags |= desc->flags;
+	    }
+	    break;
+	  }
+	case ZN_CONFIG_GRADIENTS:
+	  {
+	    ZnList	new_grad_list = NULL;
+	    ZnGradient	**grads;
+	    int		num_grads, j, k;
+	    Tcl_Obj	**elems;
 	    
 	    if (Tcl_ListObjGetElements(wi->interp, args[i+1],
-				       &num_colors, &elems) == ZN_ERROR) {
+				       &num_grads, &elems) == ZN_ERROR) {
 	      Tcl_AppendResult(wi->interp,
-			       " color list expected for attribute \"",
+			       " gradient list expected for attribute \"",
 			       Tcl_GetString(args[i]), "\"", NULL);
 	      return ZN_ERROR;
 	    }
-	    if (num_colors) {
-	      new_color_list = ZnListNew(num_colors, sizeof(ZnGradientColor));
-	      ZnListAssertSize(new_color_list, num_colors);
-	      colors = ZnListArray(new_color_list);
-	      for (j = 0; j < num_colors; j++) {
+	    if (num_grads) {
+	      new_grad_list = ZnListNew(num_grads, sizeof(ZnGradient *));
+	      ZnListAssertSize(new_grad_list, num_grads);
+	      grads = ZnListArray(new_grad_list);
+	      for (j = 0; j < num_grads; j++) {
 		str = Tcl_GetString(elems[j]);
-		if (strlen(str) != 0) {
-		  color_ptr = strchr(str, ':');
-		  if (color_ptr) {
-		    *color_ptr = 0;
-		  }
-		  colors[j].shades[0] = ZnGetColor(wi->interp, wi->win, Tk_GetUid(str));
-		  if (color_ptr) {
-		    *color_ptr = ':';
-		  }
-		  if (!colors[j].shades[0]) {
-		    Tcl_AppendResult(wi->interp, " unknown color \"", str,
-				     "\" in color list", NULL);
-		  colors_err:
-		    for (k = 0; k < j; k++) {
-		      ZnFreeColor(colors[k].shades[0]);
-		    }
-		    ZnListFree(new_color_list);
-		    return ZN_ERROR;
-		  }
-		  if (color_ptr) {
-		    colors[j].alpha = atoi(color_ptr+1);
-		    if (colors[j].alpha > 100) {
-		      colors[j].alpha = 100;
-		    }
-		  }
-		  else {
-		    colors[j].alpha = 100;
+		if (!*str) {
+		  if (j == 0) {
+		    goto grads_err;
 		  }
+		  grads[j] = grads[j-1];
 		}
 		else {
-		  if (j == 0) {
-		    Tcl_AppendResult(wi->interp, " first color must not be void", NULL);
-		    goto colors_err;
-		  }
-		  else {
-		    colors[j].alpha = colors[j-1].alpha;
-		    colors[j].shades[0] = ZnGetColorByValue(wi->win, colors[j-1].shades[0]);
+		  grads[j] = ZnGetGradient(wi->interp, wi->win, str);
+		}
+		if (!grads[j]) {
+		grads_err:
+		  Tcl_AppendResult(wi->interp, " invalid gradient \"", str,
+				   "\" in gradient list", NULL);
+		  for (k = 0; k < j; k++) {
+		    ZnFreeGradient(grads[k]);
 		  }
+		  ZnListFree(new_grad_list);
+		  return ZN_ERROR;
 		}
 	      }
 	    }
 	    if (*((ZnList *) valp)) {
-	      num_colors = ZnListSize(*((ZnList *) valp));
-	      colors = ZnListArray(*((ZnList *) valp));
-	      for (j = 0; j < num_colors; j++) {
-		if (colors[j].shades[0]) {
-		  ZnFreeColor(colors[j].shades[0]);
+	      num_grads = ZnListSize(*((ZnList *) valp));
+	      grads = ZnListArray(*((ZnList *) valp));
+	      for (j = 0; j < num_grads; j++) {
+		if (grads[j]) {
+		  ZnFreeGradient(grads[j]);
 		}
 	      }
 	      ZnListFree(*((ZnList *) valp));
-	      *((ZnList *) valp) = new_color_list;
+	      *((ZnList *) valp) = new_grad_list;
 	      *flags |= desc->flags;
 	    }
 	    else {
-	      if (new_color_list) {
-		*((ZnList *) valp) = new_color_list;
+	      if (new_grad_list) {
+		*((ZnList *) valp) = new_grad_list;
 		*flags |= desc->flags;
 	      }
 	    }
 	    break;
 	  }
-	case ZN_CONFIG_GRADIENT:
-	  {
-	    ZnGradient *g;
-	    Tk_Uid new_name = Tk_GetUid(Tcl_GetString(args[i+1]));
-	    char   *name = NULL;
-	    if (*((ZnGradient **) valp)) {
-	      name = ZnNameOfGradient(*((ZnGradient **) valp));
-	    }
-	    if (name != new_name) {
-	      g = ZnGetGradient(wi->interp, wi->win, new_name);
-	      if (!g) {
-		Tcl_AppendResult(wi->interp,
-				 " gradient expected for attribute \"",
-				 Tcl_GetString(args[i]), "\"", NULL);
-		return ZN_ERROR;
-	      }
-	      if (*((ZnGradient **) valp)) {
-		ZnFreeGradient(*((ZnGradient **) valp));
-	      }
-	      *((ZnGradient **) valp) = g;
-	      *flags |= desc->flags;
-	    }
-	    break;
-	  }
 	case ZN_CONFIG_BOOL:
 	  {
 	    int	b;
@@ -1282,36 +1261,28 @@ AttributeToObj(WidgetInfo	*wi,
       Tcl_SetStringObj(result, str, strlen(str));
     }
     break;
-  case ZN_CONFIG_COLORS:
+  case ZN_CONFIG_GRADIENT:
+    if (*((ZnGradient **) valp)) {
+      str = ZnNameOfGradient(*((ZnGradient **) valp));
+      Tcl_SetStringObj(result, str, strlen(str));
+    }
+    break;
+  case ZN_CONFIG_GRADIENTS:
     {
-      int		num_colors;
-      ZnGradientColor	*colors;
+      int		num_grads;
+      ZnGradient	**grads;
 
       if (*((ZnList *) valp)) {
-	colors = ZnListArray(*((ZnList *) valp));
-	num_colors = ZnListSize(*((ZnList *) valp));
+	grads = ZnListArray(*((ZnList *) valp));
+	num_grads = ZnListSize(*((ZnList *) valp));
 	
-	for (i = 0; i < num_colors; i++) {
-	  if (colors[i].alpha != 100) {
-	    sprintf(buffer, "%s:%d",
-		    ZnNameOfColor(colors[i].shades[0]),
-		    colors[i].alpha);
-	    o = NewStringObj(buffer);
-	  }
-	  else {
-	    o = NewStringObj(ZnNameOfColor(colors[i].shades[0]));
-	  }
+	for (i = 0; i < num_grads; i++) {
+	  o = NewStringObj(ZnNameOfGradient(grads[i]));
 	  Tcl_ListObjAppendElement(wi->interp, result, o);
 	}
       }
     }
     break;
-  case ZN_CONFIG_GRADIENT:
-    if (*((ZnGradient **) valp)) {
-      str = ZnNameOfGradient(*((ZnGradient **) valp));
-      Tcl_SetStringObj(result, str, strlen(str));
-    }
-    break;
   case ZN_CONFIG_BOOL:
     Tcl_SetBooleanObj(result, ISSET(*((char *) valp), desc->bool_bit)?1:0);
     break;
@@ -3853,9 +3824,9 @@ InitFields(FieldSet	field_set)
     field = &field_set->fields[i];
 
     field->field_set = field_set;
-    field->color = ZnGetColorByValue(wi->win, wi->fore_color);
+    field->color = ZnGetGradientByValue(wi->fore_gradient);
     field->fill_color = ZnGetGradient(wi->interp, wi->win, ZnNameOfColor(wi->back_color));
-    field->border_color = ZnGetColorByValue(wi->win, wi->fore_color);
+    field->border_color = ZnGetGradientByValue(wi->fore_gradient);
     SET(field->flags, FIELD_VISIBLE_BIT);
     SET(field->flags, FIELD_SENSITIVE_BIT);
     CLEAR(field->flags, FILLED_BIT);
@@ -3938,9 +3909,9 @@ CloneFields(FieldSet	field_set)
 					 Tk_NameOfBitmap(wi->dpy, field->fill_pattern));
     }
     field->font = Tk_GetFont(wi->interp, wi->win, Tk_NameOfFont(field->font));
-    field->color = ZnGetColorByValue(wi->win, field->color);
+    field->color = ZnGetGradientByValue(field->color);
     field->fill_color = ZnGetGradientByValue(field->fill_color);
-    field->border_color = ZnGetColorByValue(wi->win, field->border_color);
+    field->border_color = ZnGetGradientByValue(field->border_color);
 
     if (strlen(field->text) != 0) {
       text = (char *) ZnMalloc((strlen(field->text) + 1) * sizeof(char));
@@ -3994,8 +3965,7 @@ ConfigureField(FieldSet		field_set,
   }
   if ((field_ptr->relief != RELIEF_FLAT) && !field_ptr->gradient) {
     field_ptr->gradient = ZnGetReliefGradient(wi->interp, wi->win,
-					      ZnNameOfColor(ZnGetGradientColor(wi->win,
-									       field_ptr->fill_color,
+					      ZnNameOfColor(ZnGetGradientColor(field_ptr->fill_color,
 									       50.0, NULL)));
     if (field_ptr->gradient == NULL) {
       return ZN_ERROR;      
@@ -4142,9 +4112,9 @@ FreeFields(FieldSet	field_set)
     }
     /*printf("freeing a font\n");*/
     Tk_FreeFont(field->font);
-    ZnFreeColor(field->color);
+    ZnFreeGradient(field->color);
     ZnFreeGradient(field->fill_color);
-    ZnFreeColor(field->border_color);
+    ZnFreeGradient(field->border_color);
   }
   if (num_fields) {
     ZnFree(field_set->fields);
@@ -4333,7 +4303,7 @@ DrawField(WidgetInfo	*wi,
    * Draw the background.
    */
   if (ISSET(field_ptr->flags, FILLED_BIT)) {
-    values.foreground = ZnPixel(ZnGetGradientColor(wi->win, field_ptr->fill_color, 0.0, NULL));
+    values.foreground = ZnPixel(ZnGetGradientColor(field_ptr->fill_color, 0.0, NULL));
     
     if (field_ptr->tile != ZnUnspecifiedImage) { /* Fill tiled */
       Pixmap pmap = GetImagePixmap(wi->win, field_ptr->tile_name,
@@ -4388,7 +4358,7 @@ DrawField(WidgetInfo	*wi,
        * Draw the text.
        */
       if (field_ptr->text && strlen(field_ptr->text)) {
-	values.foreground = ZnPixel(field_ptr->color);
+	values.foreground = ZnPixel(ZnGetGradientColor(field_ptr->color, 0, NULL));
 	values.fill_style = FillSolid;
 	values.font = ZnFontId(field_ptr->font);
 	XChangeGC(wi->dpy, wi->gc, GCForeground | GCFillStyle | GCFont, &values);
@@ -4412,7 +4382,7 @@ DrawField(WidgetInfo	*wi,
    * Draw the border line.
    */
   if (field_ptr->border_edges != NO_BORDER) {
-    values.foreground = ZnPixel(field_ptr->border_color);
+    values.foreground = ZnPixel(ZnGetGradientColor(field_ptr->border_color, 0, NULL));
     values.line_width = 0;
     values.line_style = LineSolid;
     values.fill_style = FillSolid;
@@ -4489,18 +4459,18 @@ RenderField(WidgetInfo	*wi,
 #ifdef GLX
   int		j;
   XColor	*color;
-  int		alpha, alpha2;
+  int		alpha;
 
-  alpha2 = 100*wi->alpha*65535/100;
   /*
    * Draw the background.
    */
   if (ISSET(field_ptr->flags, FILLED_BIT)) {
     glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
     if (!ZnGradientFlat(field_ptr->fill_color)) {
+#if 0
       int	type = field_ptr->fill_color->type;
       ZnBool	fast = (type == ZN_AXIAL_GRADIENT) && !field_ptr->grad_geo;
-#if 0
+
       RenderGradient(wi, field_ptr->fill_color,
 		     fast ? NULL : FieldRenderCB,
 		     bbox, fast ? (ZnPoint *) bbox : field_ptr->grad_geo);
@@ -4519,8 +4489,8 @@ RenderField(WidgetInfo	*wi,
 	  glEnable(GL_POLYGON_STIPPLE);
 	  glPolygonStipple(GetBitmapMask(wi->dpy, field_ptr->fill_pattern)->pixels);
 	}
-	color = ZnGetGradientColor(wi->win, field_ptr->fill_color, 0.0, &alpha);
-	alpha = alpha*wi->alpha/100*65535/100;
+	color = ZnGetGradientColor(field_ptr->fill_color, 0.0, &alpha);
+	alpha = ZnComposeAlpha(alpha, wi->alpha);
 	glColor4us(color->red, color->green, color->blue, alpha);
 	FieldRenderCB(clip_bbox);
 	glDisable(GL_POLYGON_STIPPLE);
@@ -4540,7 +4510,7 @@ RenderField(WidgetInfo	*wi,
        */
       if (field_ptr->image != ZnUnspecifiedImage) {
 	RenderImage(wi, GetImageTexture(wi->win, field_ptr->image_name, field_ptr->image),
-		    NULL, 100, &(pm_bbox->orig));
+		    field_ptr->fill_color, &(pm_bbox->orig), False);
       }
     }
     else {
@@ -4555,8 +4525,9 @@ RenderField(WidgetInfo	*wi,
 	  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 	  glEnable(GL_TEXTURE_2D);
 	  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-	  color = field_ptr->color;
-	  glColor4us(color->red, color->green, color->blue, alpha2);
+	  color = ZnGetGradientColor(field_ptr->color, 0, &alpha);
+	  alpha = ZnComposeAlpha(alpha, wi->alpha);
+	  glColor4us(color->red, color->green, color->blue, alpha);
 	  glBindTexture(GL_TEXTURE_2D, field_ptr->txf->texobj);
 	  glPushMatrix();
 	  glTranslatef(text_pos->x, text_pos->y, 0.0);
@@ -4591,8 +4562,8 @@ RenderField(WidgetInfo	*wi,
    * Draw the border line.
    */
   if (field_ptr->border_edges != NO_BORDER) {
-    color = field_ptr->border_color;
-    glColor4us(color->red, color->green, color->blue, alpha2);
+    color = ZnGetGradientColor(field_ptr->border_color, 0, &alpha);
+    glColor4us(color->red, color->green, color->blue, alpha);
     glLineWidth(1);
     SetLineStyle(wi, LINE_SIMPLE);
     glBegin(GL_LINES);