int GrPlotIncludeStart(char *name,int atnum,char **atname,char **atval,
char *buf,int sze,void *data) {
struct GrPlotBlock *blk;
struct GrPlotInclude *ptr;
blk=(struct GrPlotBlock *) data;
if (blk==NULL) return -1;
ptr=(struct GrPlotInclude *) blk->data;
if (ptr==NULL) return -1;
if (strcmp(name,blk->name)==0) {
return 0;
}
if (strcmp(name,"name")==0) {
struct GrPlotString *str;
str=malloc(sizeof(struct GrPlotString));
str->inc=ptr->inc;
str->txt=&ptr->name;
blk=GrPlotSave(blk->xml,"name",str);
XMLSetStart(blk->xml,GrPlotStringStart,blk);
XMLSetText(blk->xml,GrPlotStringText,blk);
XMLSetEnd(blk->xml,GrPlotStringEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"include")==0) {
struct GrPlotInclude *inc;
inc=malloc(sizeof(struct GrPlotInclude));
inc->inc=ptr->inc;
blk=GrPlotSave(blk->xml,name,inc);
XMLSetStart(blk->xml,GrPlotIncludeStart,blk);
XMLSetEnd(blk->xml,GrPlotIncludeEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"ignore")==0) {
blk=GrPlotSave(blk->xml,name,NULL);
XMLSetStart(blk->xml,GrPlotIgnoreStart,blk);
XMLSetText(blk->xml,GrPlotIgnoreText,blk);
XMLSetEnd(blk->xml,GrPlotIgnoreEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
return 0;
}
int main(int argc,char *argv[]) {
FILE *outp=stdout;
char lbuf[256];
char *atname[]={"width","height"};
char *atval[]={"100","200"};
struct XMLdata *xmldata;
xmldata=XMLMake();
XMLSetStart(xmldata,start,outp);
XMLSetEnd(xmldata,end,outp);
XMLSetText(xmldata,text,outp);
sprintf(lbuf,"dummy contents.");
XMLCallStart(xmldata,"table",2,atname,atval,"table",strlen("table"));
XMLDecode(xmldata,lbuf,strlen(lbuf));
XMLCallEnd(xmldata,"table","/table",strlen("/table"));
XMLFree(xmldata);
return 0;
}
int GrPlotTickStart(char *name,int atnum,char **atname,char **atval,
char *buf,int sze,void *data) {
struct GrPlotBlock *blk;
struct GrPlotTick *ptr;
blk=(struct GrPlotBlock *) data;
if (blk==NULL) return -1;
ptr=(struct GrPlotTick *) blk->data;
if (ptr==NULL) return -1;
if (strcmp(name,blk->name)==0) {
return 0;
}
if (strcmp(name,"minor")==0) {
struct GrPlotValue *val;
val=malloc(sizeof(struct GrPlotValue));
val->cnv=ptr->cnv;
val->inc=ptr->inc;
val->val=ptr->minor;
blk=GrPlotSave(blk->xml,"minor",val);
XMLSetStart(blk->xml,GrPlotValueStart,blk);
XMLSetText(blk->xml,GrPlotValueText,blk);
XMLSetEnd(blk->xml,GrPlotValueEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"major")==0) {
struct GrPlotValue *val;
val=malloc(sizeof(struct GrPlotValue));
val->cnv=ptr->cnv;
val->inc=ptr->inc;
val->val=ptr->major;
blk=GrPlotSave(blk->xml,"major",val);
XMLSetStart(blk->xml,GrPlotValueStart,blk);
XMLSetText(blk->xml,GrPlotValueText,blk);
XMLSetEnd(blk->xml,GrPlotValueEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"include")==0) {
struct GrPlotInclude *inc;
inc=malloc(sizeof(struct GrPlotInclude));
inc->inc=ptr->inc;
blk=GrPlotSave(blk->xml,name,inc);
XMLSetStart(blk->xml,GrPlotIncludeStart,blk);
XMLSetEnd(blk->xml,GrPlotIncludeEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"ignore")==0) {
blk=GrPlotSave(blk->xml,name,NULL);
XMLSetStart(blk->xml,GrPlotIgnoreStart,blk);
XMLSetText(blk->xml,GrPlotIgnoreText,blk);
XMLSetEnd(blk->xml,GrPlotIgnoreEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
return 0;
}
int GrPlotBarPlotStart(char *name,int atnum,char **atname,char **atval,
char *buf,int sze,void *data) {
int i;
struct GrPlotBlock *blk;
struct GrPlotBarPlot *ptr;
struct GrPlotData *plt;
blk=(struct GrPlotBlock *) data;
if (blk==NULL) return -1;
ptr=(struct GrPlotBarPlot *) blk->data;
if (ptr==NULL) return -1;
plt=ptr->plt;
if (plt==NULL) return -1;
if (strcmp(name,blk->name)==0) {
unsigned int mask;
char tmp[64];
ptr->color=0;
ptr->mask=0;
ptr->width=0;
ptr->dash=NULL;
ptr->or=0;
ptr->fill=0;
ptr->w=0;
ptr->o=0;
ptr->state=0;
ptr->xdmin=-HUGE_VAL;
ptr->xdmax=HUGE_VAL;
ptr->ydmin=-HUGE_VAL;
ptr->ydmax=HUGE_VAL;
ptr->name=NULL;
ptr->encode=NULL;
ptr->x=NULL;
ptr->y=NULL;
for (i=0;i<atnum;i++) {
if (strcmp(atname[i],"color")==0) {
strcpy(tmp,"0x");
strcat(tmp,atval[i]);
sscanf(tmp,"%x",&ptr->color);
} else if (strcmp(atname[i],"mask")==0) {
strcpy(tmp,"0x");
strcat(tmp,atval[i]);
sscanf(tmp,"%x",&mask);
ptr->mask=mask;
} else if (strcmp(atname[i],"width")==0) ptr->width=atof(atval[i]);
else if (strcmp(atname[i],"fill")==0) ptr->fill=1;
else if (strcmp(atname[i],"dash")==0)
ptr->dash=RplotMakeDashString(atval[i]);
else if (strcmp(atname[i],"or")==0) {
strcpy(tmp,"0x");
strcat(tmp,atval[i]);
sscanf(tmp,"%x",&ptr->or);
}
}
return 0;
}
if (strcmp(name,"extent")==0) {
struct GrPlotExtent *ext;
ext=malloc(sizeof(struct GrPlotExtent));
ext->cnv=&plt->cnv;
ext->inc=&plt->inc;
ext->xmin=&ptr->xmin;
ext->xmax=&ptr->xmax;
ext->ymin=&ptr->ymin;
ext->ymax=&ptr->ymax;
ptr->state=ptr->state | 0x01;
blk=GrPlotSave(blk->xml,"extent",ext);
XMLSetStart(blk->xml,GrPlotExtentStart,blk);
XMLSetEnd(blk->xml,GrPlotExtentEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"range")==0) {
struct GrPlotExtent *ext;
ext=malloc(sizeof(struct GrPlotExtent));
ext->cnv=&plt->cnv;
ext->inc=&plt->inc;
ext->xmin=&ptr->xdmin;
ext->xmax=&ptr->xdmax;
ext->ymin=&ptr->ydmin;
ext->ymax=&ptr->ydmax;
ptr->state=ptr->state | 0x02;
blk=GrPlotSave(blk->xml,"range",ext);
XMLSetStart(blk->xml,GrPlotExtentStart,blk);
XMLSetEnd(blk->xml,GrPlotExtentEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"name")==0) {
struct GrPlotString *str;
str=malloc(sizeof(struct GrPlotString));
str->txt=&ptr->name;
str->inc=&plt->inc;
blk=GrPlotSave(blk->xml,"name",str);
XMLSetStart(blk->xml,GrPlotStringStart,blk);
XMLSetText(blk->xml,GrPlotStringText,blk);
XMLSetEnd(blk->xml,GrPlotStringEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"index")==0) {
struct GrPlotIndex *inx;
inx=malloc(sizeof(struct GrPlotIndex));
inx->inc=&plt->inc;
inx->x=&ptr->x;
inx->y=&ptr->y;
blk=GrPlotSave(blk->xml,"index",inx);
XMLSetStart(blk->xml,GrPlotIndexStart,blk);
XMLSetEnd(blk->xml,GrPlotIndexEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"w")==0) {
struct GrPlotValue *val;
val=malloc(sizeof(struct GrPlotValue));
val->cnv=&plt->cnv;
val->inc=&plt->inc;
val->val=&ptr->w;
ptr->state=ptr->state | 0x04;
blk=GrPlotSave(blk->xml,"w",val);
XMLSetStart(blk->xml,GrPlotValueStart,blk);
XMLSetText(blk->xml,GrPlotValueText,blk);
XMLSetEnd(blk->xml,GrPlotValueEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"o")==0) {
struct GrPlotValue *val;
val=malloc(sizeof(struct GrPlotValue));
val->cnv=&plt->cnv;
val->inc=&plt->inc;
val->val=&ptr->o;
ptr->state=ptr->state | 0x08;
blk=GrPlotSave(blk->xml,"o",val);
XMLSetStart(blk->xml,GrPlotValueStart,blk);
XMLSetText(blk->xml,GrPlotValueText,blk);
XMLSetEnd(blk->xml,GrPlotValueEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"include")==0) {
struct GrPlotInclude *inc;
inc=malloc(sizeof(struct GrPlotInclude));
inc->inc=&plt->inc;
blk=GrPlotSave(blk->xml,name,inc);
XMLSetStart(blk->xml,GrPlotIncludeStart,blk);
XMLSetEnd(blk->xml,GrPlotIncludeEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"ignore")==0) {
blk=GrPlotSave(blk->xml,name,NULL);
XMLSetStart(blk->xml,GrPlotIgnoreStart,blk);
XMLSetText(blk->xml,GrPlotIgnoreText,blk);
XMLSetEnd(blk->xml,GrPlotIgnoreEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
return 0;
}
int GrPlotZeroStart(char *name,int atnum,char **atname,char **atval,
char *buf,int sze,void *data) {
int i;
struct GrPlotBlock *blk;
struct GrPlotZero *ptr;
struct GrPlotData *plt;
blk=(struct GrPlotBlock *) data;
if (blk==NULL) return -1;
ptr=(struct GrPlotZero *) blk->data;
if (ptr==NULL) return -1;
plt=ptr->plt;
if (plt==NULL) return -1;
if (strcmp(name,blk->name)==0) {
unsigned int mask;
char tmp[64];
ptr->color=0;
ptr->mask=0;
ptr->width=0;
ptr->dash=NULL;
ptr->state=0;
for (i=0;i<atnum;i++) {
if (strcmp(atname[i],"color")==0) {
strcpy(tmp,"0x");
strcat(tmp,atval[i]);
sscanf(tmp,"%x",&ptr->color);
} else if (strcmp(atname[i],"mask")==0) {
strcpy(tmp,"0x");
strcat(tmp,atval[i]);
sscanf(tmp,"%x",&mask);
ptr->mask=mask;
} else if (strcmp(atname[i],"width")==0) ptr->width=atof(atval[i]);
else if (strcmp(atname[i],"dash")==0)
ptr->dash=RplotMakeDashString(atval[i]);
}
return 0;
}
if (strcmp(name,"limit")==0) {
struct GrPlotLimit *lmt;
lmt=malloc(sizeof(struct GrPlotLimit));
lmt->cnv=&plt->cnv;
lmt->inc=&plt->inc;
lmt->min=&ptr->min;
lmt->max=&ptr->max;
ptr->state=ptr->state | 0x01;
blk=GrPlotSave(blk->xml,"limit",lmt);
XMLSetStart(blk->xml,GrPlotLimitStart,blk);
XMLSetEnd(blk->xml,GrPlotLimitEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"include")==0) {
struct GrPlotInclude *inc;
inc=malloc(sizeof(struct GrPlotInclude));
inc->inc=&plt->inc;
blk=GrPlotSave(blk->xml,name,inc);
XMLSetStart(blk->xml,GrPlotIncludeStart,blk);
XMLSetEnd(blk->xml,GrPlotIncludeEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"ignore")==0) {
blk=GrPlotSave(blk->xml,name,NULL);
XMLSetStart(blk->xml,GrPlotIgnoreStart,blk);
XMLSetText(blk->xml,GrPlotIgnoreText,blk);
XMLSetEnd(blk->xml,GrPlotIgnoreEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
return 0;
}
int GrPlotImageNameStart(char *name,int atnum,char **atname,char **atval,
char *buf,int sze,void *data) {
int i;
struct GrPlotBlock *blk;
struct GrPlotImageName *ptr;
struct GrPlotData *plt;
struct GrPlotConvert *cnv;
blk=(struct GrPlotBlock *) data;
if (blk==NULL) return -1;
ptr=(struct GrPlotImageName *) blk->data;
if (ptr==NULL) return -1;
plt=ptr->plt;
if (plt==NULL) return -1;
cnv=&plt->cnv;
if (strcmp(name,blk->name)==0) {
int s=0;
unsigned int mask;
char *xvalue=NULL;
char *yvalue=NULL;
char *xtype=NULL;
char *ytype=NULL;
char tmp[64];
ptr->mask=0;
ptr->name=NULL;
ptr->matrix=NULL;
ptr->dx=0;
ptr->dy=0;
ptr->x=0;
ptr->y=0;
for (i=0;i<atnum;i++) {
if (strcmp(atname[i],"mask")==0) {
strcpy(tmp,"0x");
strcat(tmp,atval[i]);
sscanf(tmp,"%x",&mask);
ptr->mask=mask;
} else if (strcmp(atname[i],"matrix")==0)
ptr->matrix=RplotMatrixString(atval[i]);
else if (strcmp(atname[i],"xvalue")==0) xvalue=atval[i];
else if (strcmp(atname[i],"yvalue")==0) yvalue=atval[i];
else if (strcmp(atname[i],"xpos")==0) xvalue=atval[i];
else if (strcmp(atname[i],"ypos")==0) yvalue=atval[i];
else if (strcmp(atname[i],"xtype")==0) xtype=atval[i];
else if (strcmp(atname[i],"ytype")==0) ytype=atval[i];
else if (strcmp(atname[i],"xoffset")==0) ptr->dx=atof(atval[i]);
else if (strcmp(atname[i],"yoffset")==0) ptr->dy=atof(atval[i]);
}
if (xvalue !=NULL) {
if (xtype==NULL) ptr->x=atof(xvalue);
else if (cnv->user !=NULL)
s=(cnv->user)(xtype,xvalue,&ptr->x,cnv->data);
else ptr->x=0;
}
if (yvalue !=NULL) {
if (ytype==NULL) ptr->y=atof(yvalue);
else if (cnv->user !=NULL)
s=(cnv->user)(xtype,yvalue,&ptr->y,cnv->data);
else ptr->y=0;
}
return s;
}
if (strcmp(name,"extent")==0) {
struct GrPlotExtent *ext;
ext=malloc(sizeof(struct GrPlotExtent));
ext->cnv=&plt->cnv;
ext->inc=&plt->inc;
ext->xmin=&ptr->xmin;
ext->xmax=&ptr->xmax;
ext->ymin=&ptr->ymin;
ext->ymax=&ptr->ymax;
ptr->state=ptr->state | 0x01;
blk=GrPlotSave(blk->xml,"extent",ext);
XMLSetStart(blk->xml,GrPlotExtentStart,blk);
XMLSetEnd(blk->xml,GrPlotExtentEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"name")==0) {
struct GrPlotString *str;
str=malloc(sizeof(struct GrPlotString));
str->txt=&ptr->name;
str->inc=&plt->inc;
blk=GrPlotSave(blk->xml,"name",str);
XMLSetStart(blk->xml,GrPlotStringStart,blk);
XMLSetText(blk->xml,GrPlotStringText,blk);
XMLSetEnd(blk->xml,GrPlotStringEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"include")==0) {
struct GrPlotInclude *inc;
inc=malloc(sizeof(struct GrPlotInclude));
inc->inc=&plt->inc;
blk=GrPlotSave(blk->xml,name,inc);
XMLSetStart(blk->xml,GrPlotIncludeStart,blk);
XMLSetEnd(blk->xml,GrPlotIncludeEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
return 0;
}
int GrPlotShapeStart(char *name,int atnum,char **atname,char **atval,
char *buf,int sze,void *data) {
int i;
struct GrPlotBlock *blk;
struct GrPlotShape *ptr;
struct GrPlotData *plt;
struct GrPlotConvert *cnv;
blk=(struct GrPlotBlock *) data;
if (blk==NULL) return -1;
ptr=(struct GrPlotShape *) blk->data;
if (ptr==NULL) return -1;
plt=ptr->plt;
if (plt==NULL) return -1;
cnv=&plt->cnv;
if (strcmp(name,blk->name)==0) {
int s=0;
char *xvalue=NULL;
char *yvalue=NULL;
char *xtype=NULL;
char *ytype=NULL;
unsigned int mask;
char tmp[64];
ptr->color=0;
ptr->mask=0;
ptr->fill=0;
ptr->width=0;
ptr->dash=NULL;
ptr->matrix=NULL;
ptr->x=0;
ptr->y=0;
for (i=0;i<atnum;i++) {
if (strcmp(atname[i],"color")==0) {
strcpy(tmp,"0x");
strcat(tmp,atval[i]);
sscanf(tmp,"%x",&ptr->color);
} else if (strcmp(atname[i],"mask")==0) {
strcpy(tmp,"0x");
strcat(tmp,atval[i]);
sscanf(tmp,"%x",&mask);
ptr->mask=mask;
} else if (strcmp(atname[i],"width")==0) ptr->width=atof(atval[i]);
else if (strcmp(atname[i],"dash")==0)
ptr->dash=RplotMakeDashString(atval[i]);
else if (strcmp(atname[i],"fill")==0) ptr->fill=1;
else if (strcmp(atname[i],"matrix")==0)
ptr->matrix=RplotMatrixString(atval[i]);
else if (strcmp(atname[i],"xvalue")==0) xvalue=atval[i];
else if (strcmp(atname[i],"yvalue")==0) yvalue=atval[i];
else if (strcmp(atname[i],"xpos")==0) xvalue=atval[i];
else if (strcmp(atname[i],"ypot")==0) yvalue=atval[i];
else if (strcmp(atname[i],"xtype")==0) xtype=atval[i];
else if (strcmp(atname[i],"ytype")==0) ytype=atval[i];
}
if (xvalue !=NULL) {
if (xtype==NULL) ptr->x=atof(xvalue);
else if (cnv->user !=NULL)
s=(cnv->user)(xtype,xvalue,&ptr->x,cnv->data);
else ptr->x=0;
}
if (yvalue !=NULL) {
if (ytype==NULL) ptr->y=atof(yvalue);
else if (cnv->user !=NULL)
s=(cnv->user)(xtype,yvalue,&ptr->y,cnv->data);
else ptr->y=0;
}
return s;
}
if (strcmp(name,"extent")==0) {
struct GrPlotExtent *ext;
ext=malloc(sizeof(struct GrPlotExtent));
ext->cnv=&plt->cnv;
ext->inc=&plt->inc;
ext->xmin=&ptr->xmin;
ext->xmax=&ptr->xmax;
ext->ymin=&ptr->ymin;
ext->ymax=&ptr->ymax;
ptr->state=ptr->state | 0x01;
blk=GrPlotSave(blk->xml,"extent",ext);
XMLSetStart(blk->xml,GrPlotExtentStart,blk);
XMLSetEnd(blk->xml,GrPlotExtentEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"s")==0) {
struct GrPlotDimension *dim;
dim=malloc(sizeof(struct GrPlotDimension));
dim->cnv=&plt->cnv;
dim->inc=&plt->inc;
dim->w=&ptr->w;
dim->h=&ptr->h;
ptr->state=ptr->state | 0x02;
blk=GrPlotSave(blk->xml,"d",dim);
XMLSetStart(blk->xml,GrPlotDimensionStart,blk);
XMLSetEnd(blk->xml,GrPlotDimensionEnd,blk);
return 0;
}
if (strcmp(name,"include")==0) {
struct GrPlotInclude *inc;
inc=malloc(sizeof(struct GrPlotInclude));
inc->inc=&plt->inc;
blk=GrPlotSave(blk->xml,name,inc);
XMLSetStart(blk->xml,GrPlotIncludeStart,blk);
XMLSetEnd(blk->xml,GrPlotIncludeEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"ignore")==0) {
blk=GrPlotSave(blk->xml,name,NULL);
XMLSetStart(blk->xml,GrPlotIgnoreStart,blk);
XMLSetText(blk->xml,GrPlotIgnoreText,blk);
XMLSetEnd(blk->xml,GrPlotIgnoreEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
return 0;
}
int GrPlotSymbolDrawStart(char *name,int atnum,char **atname,char **atval,
char *buf,int sze,void *data) {
struct GrPlotBlock *blk;
struct GrPlotSymbolDraw *ptr;
struct GrPlotData *plt;
blk=(struct GrPlotBlock *) data;
if (blk==NULL) return -1;
ptr=(struct GrPlotSymbolDraw *) blk->data;
if (ptr==NULL) return -1;
plt=ptr->plt;
if (plt==NULL) return -1;
if (strcmp(name,blk->name)==0) {
return 0;
}
if (strcmp(name,"line")==0) {
struct GrPlotLine *lne;
lne=malloc(sizeof(struct GrPlotLine));
lne->plt=plt;
lne->off=&ptr->off;
lne->xmin=ptr->xmin;
lne->ymin=ptr->ymin;
lne->xmax=ptr->xmax;
lne->ymax=ptr->ymax;
lne->state=0x01;
blk=GrPlotSave(plt->xml,name,lne);
XMLSetStart(plt->xml,GrPlotLineStart,blk);
XMLSetEnd(plt->xml,GrPlotLineEnd,blk);
return XMLCallStart(plt->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"bezier")==0) {
struct GrPlotBezier *bez;
bez=malloc(sizeof(struct GrPlotBezier));
bez->plt=plt;
bez->off=&ptr->off;
bez->xmin=ptr->xmin;
bez->ymin=ptr->ymin;
bez->xmax=ptr->xmax;
bez->ymax=ptr->ymax;
bez->state=0x01;
blk=GrPlotSave(plt->xml,name,bez);
XMLSetStart(plt->xml,GrPlotBezierStart,blk);
XMLSetEnd(plt->xml,GrPlotBezierEnd,blk);
return XMLCallStart(plt->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"ellipse")==0) {
struct GrPlotShape *shp;
shp=malloc(sizeof(struct GrPlotShape));
shp->plt=plt;
shp->off=&ptr->off;
shp->xmin=ptr->xmin;
shp->ymin=ptr->ymin;
shp->xmax=ptr->xmax;
shp->ymax=ptr->ymax;
shp->state=0x01;
blk=GrPlotSave(plt->xml,name,shp);
XMLSetStart(plt->xml,GrPlotShapeStart,blk);
XMLSetEnd(plt->xml,GrPlotShapeEnd,blk);
return XMLCallStart(plt->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"rectangle")==0) {
struct GrPlotShape *shp;
shp=malloc(sizeof(struct GrPlotShape));
shp->plt=plt;
shp->off=&ptr->off;
shp->xmin=ptr->xmin;
shp->ymin=ptr->ymin;
shp->xmax=ptr->xmax;
shp->ymax=ptr->ymax;
shp->state=0x01;
blk=GrPlotSave(plt->xml,name,shp);
XMLSetStart(plt->xml,GrPlotShapeStart,blk);
XMLSetEnd(plt->xml,GrPlotShapeEnd,blk);
return XMLCallStart(plt->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"polygon")==0) {
struct GrPlotPolygon *pol;
pol=malloc(sizeof(struct GrPlotPolygon));
pol->plt=plt;
pol->off=&ptr->off;
pol->xmin=ptr->xmin;
pol->ymin=ptr->ymin;
pol->xmax=ptr->xmax;
pol->ymax=ptr->ymax;
pol->state=0x01;
blk=GrPlotSave(plt->xml,name,pol);
XMLSetStart(plt->xml,GrPlotPolygonStart,blk);
XMLSetEnd(plt->xml,GrPlotPolygonEnd,blk);
return XMLCallStart(plt->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"text")==0) {
struct GrPlotText *txt;
txt=malloc(sizeof(struct GrPlotText));
txt->plt=plt;
txt->off=&ptr->off;
txt->xmin=ptr->xmin;
txt->ymin=ptr->ymin;
txt->xmax=ptr->xmax;
txt->ymax=ptr->ymax;
txt->state=0x01;
blk=GrPlotSave(plt->xml,name,txt);
XMLSetStart(plt->xml,GrPlotTextStart,blk);
XMLSetEnd(plt->xml,GrPlotTextEnd,blk);
return XMLCallStart(plt->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"image")==0) {
struct GrPlotImage *img;
img=malloc(sizeof(struct GrPlotImage));
img->plt=plt;
img->off=&ptr->off;
img->xmin=ptr->xmin;
img->ymin=ptr->ymin;
img->xmax=ptr->xmax;
img->ymax=ptr->ymax;
img->state=0x01;
blk=GrPlotSave(plt->xml,name,img);
XMLSetStart(plt->xml,GrPlotImageStart,blk);
XMLSetEnd(plt->xml,GrPlotImageEnd,blk);
return XMLCallStart(plt->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"imagen")==0) {
struct GrPlotImageName *img;
img=malloc(sizeof(struct GrPlotImageName));
img->plt=plt;
img->plt=plt;
img->off=&ptr->off;
img->xmin=ptr->xmin;
img->ymin=ptr->ymin;
img->xmax=ptr->xmax;
img->ymax=ptr->ymax;
img->state=0x01;
blk=GrPlotSave(plt->xml,name,img);
XMLSetStart(plt->xml,GrPlotImageNameStart,blk);
XMLSetEnd(plt->xml,GrPlotImageNameEnd,blk);
return XMLCallStart(plt->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"include")==0) {
struct GrPlotInclude *inc;
inc=malloc(sizeof(struct GrPlotInclude));
inc->inc=&plt->inc;
blk=GrPlotSave(blk->xml,name,inc);
XMLSetStart(blk->xml,GrPlotIncludeStart,blk);
XMLSetEnd(blk->xml,GrPlotIncludeEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"ignore")==0) {
blk=GrPlotSave(blk->xml,name,NULL);
XMLSetStart(blk->xml,GrPlotIgnoreStart,blk);
XMLSetText(blk->xml,GrPlotIgnoreText,blk);
XMLSetEnd(blk->xml,GrPlotIgnoreEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
return 0;
}
int RplotInDimensionStart(char *name,int atnum,char **atname,char **atval,
char *buf,int sze,void *data) {
struct RplotInBlock *blk;
struct RplotInDimension *ptr;
blk=(struct RplotInBlock *) data;
if (blk==NULL) return -1;
ptr=(struct RplotInDimension *) blk->data;
if (ptr==NULL) return -1;
if (strcmp(name,blk->name)==0) {
ptr->state=0;
return 0;
}
if (strcmp(name,"w")==0) {
struct RplotInFloat *flt;
flt=malloc(sizeof(struct RplotInFloat));
flt->inc=ptr->inc;
flt->val=ptr->w;
ptr->state=ptr->state | 0x01;
blk=RplotInSave(blk->xml,name,flt);
XMLSetStart(blk->xml,RplotInFloatStart,blk);
XMLSetText(blk->xml,RplotInFloatText,blk);
XMLSetEnd(blk->xml,RplotInFloatEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"h")==0) {
struct RplotInFloat *flt;
flt=malloc(sizeof(struct RplotInFloat));
flt->inc=ptr->inc;
flt->val=ptr->h;
ptr->state=ptr->state | 0x02;
blk=RplotInSave(blk->xml,name,flt);
XMLSetStart(blk->xml,RplotInFloatStart,blk);
XMLSetText(blk->xml,RplotInFloatText,blk);
XMLSetEnd(blk->xml,RplotInFloatEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"include")==0) {
struct RplotInInclude *inc;
inc=malloc(sizeof(struct RplotInInclude));
inc->inc=ptr->inc;
blk=RplotInSave(blk->xml,name,inc);
XMLSetStart(blk->xml,RplotInIncludeStart,blk);
XMLSetEnd(blk->xml,RplotInIncludeEnd,blk);
return XMLCallStart(blk->xml,name,atnum,atname,atval,buf,sze);
}
if (strcmp(name,"ignore")==0) {
blk=RplotInSave(blk->xml,name,NULL);
XMLSetStart(blk->xml,RplotInIgnoreStart,blk);
XMLSetText(blk->xml,RplotInIgnoreText,blk);
XMLSetEnd(blk->xml,RplotInIgnoreEnd,blk);
return 0;
}
return 0;
}
