view release on metacpan or  search on metacpan

Curve.c  view on Meta::CPAN

 * Configure --
 *
 **********************************************************************************
 */
static int
Configure(ZnItem        item,
          int           argc,
          Tcl_Obj *CONST argv[],
          int           *flags)
{
  ZnWInfo       *wi = item->wi;
  CurveItem     cv = (CurveItem) item;
  int           status = TCL_OK;
  XColor        *color;
  unsigned short alpha;
  
  status = ZnConfigureAttributes(wi, item, item, cv_attrs, argc, argv, flags);

  if (cv->gradient &&
      (ISSET(*flags, ZN_BORDER_FLAG) || (cv->relief == ZN_RELIEF_FLAT))) {
    ZnFreeGradient(cv->gradient);
    cv->gradient = NULL;
  }
  if ((cv->relief != ZN_RELIEF_FLAT) && !cv->gradient) {
    color = ZnGetGradientColor(cv->line_color, 51.0, &alpha);
    cv->gradient = ZnGetReliefGradient(wi->interp, wi->win,
                                       Tk_NameOfColor(color), alpha);
    if (cv->gradient == NULL) {
      status = TCL_ERROR;
    }
  }

  return status;
}


/*
 **********************************************************************************
 *
 * Query --
 *
 **********************************************************************************
 */
static int
Query(ZnItem            item,
      int               argc,
      Tcl_Obj *CONST    argv[])
{
  if (ZnQueryAttribute(item->wi->interp, item, cv_attrs, argv[0]) == TCL_ERROR) {
    return TCL_ERROR;
  }

  return TCL_OK;
}

static void
UpdateTristrip(CurveItem        cv,
               ZnPoly           *poly,
               ZnBool           revert)
{
  ZnCombineData *cdata, *cnext;
  GLdouble      v[3];
  unsigned int  j, k;
  int           i;

  //printf("UpdateTristrips sur %d\n", ((ZnItem) cv)->id);
  gluTessProperty(ZnTesselator.tess, GLU_TESS_WINDING_RULE, (GLdouble) cv->fill_rule);

  if (cv->tristrip.num_strips == 0) {
    gluTessProperty(ZnTesselator.tess, GLU_TESS_BOUNDARY_ONLY, (GLdouble) GL_FALSE);
    gluTessBeginPolygon(ZnTesselator.tess, &cv->tristrip);
    /*
     * We need to take care of the final (after transformation) winding
     * direction of the polygon in order to have the right tesselation
     * taking place.
     */
    if (!revert) {
      for (j = 0; j < poly->num_contours; j++){
        gluTessBeginContour(ZnTesselator.tess);
        //printf("Début contour %d num_points %d\n", j, poly->contours[j].num_points);
        for (k = 0; k < poly->contours[j].num_points; k++) {
          /*printf("%g@%g ", poly->contours[j].points[k].x, poly->contours[j].points[k].y);*/
          v[0] = poly->contours[j].points[k].x;
          v[1] = poly->contours[j].points[k].y;
          v[2] = 0;
          gluTessVertex(ZnTesselator.tess, v, &poly->contours[j].points[k]);
        }
        //printf("\n");
        gluTessEndContour(ZnTesselator.tess);
      }
    }
    else {
      for (j = 0; j < poly->num_contours; j++){
        gluTessBeginContour(ZnTesselator.tess);
        //printf("revert Début contour %d num_points %d\n", j, poly->contours[j].num_points);
        for (i = (int) (poly->contours[j].num_points-1); i >= 0; i--) {
          /*printf("%g@%g ", poly->contours[j].points[i].x, poly->contours[j].points[i].y);*/
          v[0] = poly->contours[j].points[i].x;
          v[1] = poly->contours[j].points[i].y;
          v[2] = 0;
          gluTessVertex(ZnTesselator.tess, v, &poly->contours[j].points[i]);
        }
        //printf("\n");
        gluTessEndContour(ZnTesselator.tess);
      }
    }
    gluTessEndPolygon(ZnTesselator.tess);
    cdata = ZnTesselator.combine_list;
                //printf("Combine length: %d\n", ZnTesselator.combine_length);
    while (cdata) {
                        ZnTesselator.combine_length--;
      cnext = cdata->next;
      ZnFree(cdata);
      cdata = cnext;
    }
    ZnTesselator.combine_list = NULL;
  }
  //printf("Fin UpdateTristrips sur %d\n", ((ZnItem) cv)->id);
}

static void
UpdateOutlines(CurveItem        cv,
               ZnPoly           *poly,
               ZnBool           revert)
{
  ZnCombineData *cdata, *cnext;
  GLdouble      v[3];
  unsigned int  j, k;
  int           i;

  //printf("UpdateOutlines sur %d\n", ((ZnItem) cv)->id);
  gluTessProperty(ZnTesselator.tess, GLU_TESS_WINDING_RULE, (GLdouble) cv->fill_rule);

  if (cv->outlines.num_contours == 0) {
    gluTessProperty(ZnTesselator.tess, GLU_TESS_BOUNDARY_ONLY, (GLdouble) GL_TRUE);
    gluTessBeginPolygon(ZnTesselator.tess, &cv->outlines);

    /*
     * We need to take care of the final (after transformation) winding
     * direction of the polygon in order to have the right tesselation
     * taking place.
     */
    if (!revert) {
      for (j = 0; j < poly->num_contours; j++){
        gluTessBeginContour(ZnTesselator.tess);
        for (k = 0; k < poly->contours[j].num_points; k++) {
          v[0] = poly->contours[j].points[k].x;
          v[1] = poly->contours[j].points[k].y;
          v[2] = 0;
          gluTessVertex(ZnTesselator.tess, v, &poly->contours[j].points[k]);
        }
        gluTessEndContour(ZnTesselator.tess);
      }
    }
    else {
      for (j = 0; j < poly->num_contours; j++){
        gluTessBeginContour(ZnTesselator.tess);
        for (i = (int) (poly->contours[j].num_points-1); i >= 0; i--) {
          v[0] = poly->contours[j].points[i].x;
          v[1] = poly->contours[j].points[i].y;
          v[2] = 0;
          gluTessVertex(ZnTesselator.tess, v, &poly->contours[j].points[i]);
        }
        gluTessEndContour(ZnTesselator.tess);
      }
    }
    gluTessEndPolygon(ZnTesselator.tess);
    cdata = ZnTesselator.combine_list;
    while (cdata) {
                        ZnTesselator.combine_length--;
      cnext = cdata->next;
      ZnFree(cdata);
      cdata = cnext;
    }
    ZnTesselator.combine_list = NULL;
  }
  //printf("Fin UpdateOutlines sur %d\n", ((ZnItem) cv)->id);
}


/*
 **********************************************************************************
 *
 * ComputeCoordinates --
 *
 **********************************************************************************
 */
static void
ComputeCoordinates(ZnItem       item,
                   ZnBool       force)
{
  ZnWInfo       *wi = item->wi;
  CurveItem     cv = (CurveItem) item;
  unsigned int  i, j;
  ZnPoint       end_points[ZN_LINE_END_POINTS];
  ZnPoint       *points;
  unsigned int  num_points, num_contours, segment_start;
  ZnBBox        bbox;
  ZnDim         lw;
  ZnContour     *c1, *c2;
  ZnPoly        dev;
  ZnBool        revert;

  ZnResetBBox(&item->item_bounding_box);

  /*printf("Curve CC: flags %x\n", cv->flags);*/
  SetRenderFlags(cv);

  num_contours = cv->shape.num_contours;
  if (num_contours == 0) {
    return;
  }

  if (cv->tristrip.num_strips) {
    ZnTriFree(&cv->tristrip);
  }
  if (cv->outlines.num_contours) {
    ZnPolyFree(&cv->outlines);
  };

  ZnPolyInit(&dev);
  if (num_contours != 1) {
    dev.contours = ZnMalloc(num_contours * sizeof(ZnContour));
    dev.num_contours = num_contours;
  }
  else {
    dev.contours = &dev.contour1;
    dev.num_contours = 1;
  }

  for (c1 = cv->shape.contours, c2 = dev.contours, i = 0;
       i < cv->shape.num_contours; i++, c1++, c2++) {
    c2->num_points = c1->num_points;