diff --git a/src/actions.c b/src/actions.c index ad68be28..f8cbaf52 100644 --- a/src/actions.c +++ b/src/actions.c @@ -490,8 +490,8 @@ void remove_symbol(int j) { int i,c; xSymbol save; - dbg(1, "remove_symbol(): removing symbol %d\n", j); + dbg(1,"clearing symbol %s\n", xctx->sym[j].name); my_free(666, &xctx->sym[j].prop_ptr); my_free(667, &xctx->sym[j].templ); my_free(668, &xctx->sym[j].type); @@ -529,6 +529,7 @@ void remove_symbol(int j) if(xctx->sym[j].rect[c][i].prop_ptr != NULL) { my_free(678, &xctx->sym[j].rect[c][i].prop_ptr); } + set_rect_extraptr(0, &xctx->sym[j].rect[c][i]); } my_free(679, &xctx->sym[j].rect[c]); xctx->sym[j].rects[c] = 0; @@ -589,30 +590,18 @@ int set_rect_flags(xRect *r) else if(strstr(flags, "graph")) f |= 1; } r->flags = f; + dbg(1, "set_rect_flags(): flags=%d\n", f); return f; } /* what: - * 2: copy: drptr->extraptr <- srptr->extraptr * 1: create * 0: clear */ -int set_rect_extraptr(int what, xRect *drptr, xRect *srptr) +int set_rect_extraptr(int what, xRect *drptr) { #if HAS_CAIRO==1 - if(what==2) { /* copy */ - if(drptr->flags & 1024) { /* embedded image */ - xEmb_image *d, *s; - s = srptr->extraptr; - if(s) { - d = my_malloc(1478, sizeof(xEmb_image)); - d->image = NULL; - drptr->extraptr = d; - } else { - drptr->extraptr = NULL; - } - } - } else if(what==1) { /* create */ + if(what==1) { /* create */ if(drptr->flags & 1024) { /* embedded image */ if(!drptr->extraptr) { xEmb_image *d; @@ -676,7 +665,7 @@ void clear_drawing(void) for(j=0;jrects[i];j++) { my_free(700, &xctx->rect[i][j].prop_ptr); - set_rect_extraptr(0, &xctx->rect[i][j], NULL); + set_rect_extraptr(0, &xctx->rect[i][j]); } for(j=0;jarcs[i];j++) { diff --git a/src/draw.c b/src/draw.c index eaf64e2e..bec22731 100644 --- a/src/draw.c +++ b/src/draw.c @@ -351,10 +351,10 @@ void draw_symbol(int what,int c, int n,int layer,short tmp_flip, short rot, double x0,y0,x1,y1,x2,y2; double *x, *y; /* polygon point arrays */ short flip; - xLine line; - xRect rect; - xArc arc; - xPoly polygon; + xLine *line; + xRect *rect; + xArc *arc; + xPoly *polygon; xText text; register xSymbol *symptr; double angle; @@ -421,42 +421,42 @@ void draw_symbol(int what,int c, int n,int layer,short tmp_flip, short rot, if(!hide) { for(j=0;j< symptr->lines[layer];j++) { - line = (symptr->line[layer])[j]; - ROTATION(rot, flip, 0.0,0.0,line.x1,line.y1,x1,y1); - ROTATION(rot, flip, 0.0,0.0,line.x2,line.y2,x2,y2); + line = &(symptr->line[layer])[j]; + ROTATION(rot, flip, 0.0,0.0,line->x1,line->y1,x1,y1); + ROTATION(rot, flip, 0.0,0.0,line->x2,line->y2,x2,y2); ORDER(x1,y1,x2,y2); - if(line.bus) - drawline(c,THICK, x0+x1, y0+y1, x0+x2, y0+y2, line.dash); + if(line->bus) + drawline(c,THICK, x0+x1, y0+y1, x0+x2, y0+y2, line->dash); else - drawline(c,what, x0+x1, y0+y1, x0+x2, y0+y2, line.dash); + drawline(c,what, x0+x1, y0+y1, x0+x2, y0+y2, line->dash); } for(j=0;j< symptr->polygons[layer];j++) { - polygon = (symptr->poly[layer])[j]; - x = my_malloc(34, sizeof(double) * polygon.points); - y = my_malloc(35, sizeof(double) * polygon.points); - for(k=0;kpoly[layer])[j]; + x = my_malloc(34, sizeof(double) * polygon->points); + y = my_malloc(35, sizeof(double) * polygon->points); + for(k=0;kpoints;k++) { + ROTATION(rot, flip, 0.0,0.0,polygon->x[k],polygon->y[k],x[k],y[k]); x[k]+= x0; y[k] += y0; } - drawpolygon(c, NOW, x, y, polygon.points, polygon.fill, polygon.dash); /* added fill */ + drawpolygon(c, NOW, x, y, polygon->points, polygon->fill, polygon->dash); /* added fill */ my_free(718, &x); my_free(719, &y); } for(j=0;j< symptr->arcs[layer];j++) { - arc = (symptr->arc[layer])[j]; + arc = &(symptr->arc[layer])[j]; if(flip) { - angle = 270.*rot+180.-arc.b-arc.a; + angle = 270.*rot+180.-arc->b-arc->a; } else { - angle = arc.a+rot*270.; + angle = arc->a+rot*270.; } angle = fmod(angle, 360.); if(angle<0.) angle+=360.; - ROTATION(rot, flip, 0.0,0.0,arc.x,arc.y,x1,y1); - drawarc(c,what, x0+x1, y0+y1, arc.r, angle, arc.b, arc.fill, arc.dash); + ROTATION(rot, flip, 0.0,0.0,arc->x,arc->y,x1,y1); + drawarc(c,what, x0+x1, y0+y1, arc->r, angle, arc->b, arc->fill, arc->dash); } } /* if(!hide) */ @@ -464,12 +464,23 @@ void draw_symbol(int what,int c, int n,int layer,short tmp_flip, short rot, (hide && layer == PINLAYER && xctx->enable_layer[layer]) ) { for(j=0;j< symptr->rects[layer];j++) { - rect = (symptr->rect[layer])[j]; - ROTATION(rot, flip, 0.0,0.0,rect.x1,rect.y1,x1,y1); - ROTATION(rot, flip, 0.0,0.0,rect.x2,rect.y2,x2,y2); - RECTORDER(x1,y1,x2,y2); - drawrect(c,what, x0+x1, y0+y1, x0+x2, y0+y2, rect.dash); - filledrect(c,what, x0+x1, y0+y1, x0+x2, y0+y2); + rect = &(symptr->rect[layer])[j]; + ROTATION(rot, flip, 0.0,0.0,rect->x1,rect->y1,x1,y1); + ROTATION(rot, flip, 0.0,0.0,rect->x2,rect->y2,x2,y2); + #if HAS_CAIRO == 1 + if(layer == GRIDLAYER && rect->flags & 1024) { + double xx1 = x0 + x1; + double yy1 = y0 + y1; + double xx2 = x0 + x2; + double yy2 = y0 + y2; + draw_image(1, rect, &xx1, &yy1, &xx2, &yy2, rot, flip); + } else + #endif + { + RECTORDER(x1,y1,x2,y2); + drawrect(c,what, x0+x1, y0+y1, x0+x2, y0+y2, rect->dash); + filledrect(c,what, x0+x1, y0+y1, x0+x2, y0+y2); + } } } if( (layer==TEXTWIRELAYER && !(xctx->inst[n].flags&2) ) || @@ -535,10 +546,10 @@ void draw_temp_symbol(int what, GC gc, int n,int layer,short tmp_flip, short rot int j; double x0,y0,x1,y1,x2,y2; short flip; - xLine line; - xPoly polygon; - xRect rect; - xArc arc; + xLine *line; + xPoly *polygon; + xRect *rect; + xArc *arc; xText text; register xSymbol *symptr; double angle; @@ -582,29 +593,29 @@ void draw_temp_symbol(int what, GC gc, int n,int layer,short tmp_flip, short rot symptr = (xctx->inst[n].ptr+ xctx->sym); for(j=0;j< symptr->lines[layer];j++) { - line = (symptr->line[layer])[j]; - ROTATION(rot, flip, 0.0,0.0,line.x1,line.y1,x1,y1); - ROTATION(rot, flip, 0.0,0.0,line.x2,line.y2,x2,y2); + line = &(symptr->line[layer])[j]; + ROTATION(rot, flip, 0.0,0.0,line->x1,line->y1,x1,y1); + ROTATION(rot, flip, 0.0,0.0,line->x2,line->y2,x2,y2); ORDER(x1,y1,x2,y2); - if(line.bus) + if(line->bus) drawtempline(gc,THICK, x0+x1, y0+y1, x0+x2, y0+y2); else drawtempline(gc,what, x0+x1, y0+y1, x0+x2, y0+y2); } for(j=0;j< symptr->polygons[layer];j++) { - polygon = (symptr->poly[layer])[j]; + polygon = &(symptr->poly[layer])[j]; { /* scope block so we declare some auxiliary arrays for coord transforms. 20171115 */ int k; - double *x = my_malloc(36, sizeof(double) * polygon.points); - double *y = my_malloc(37, sizeof(double) * polygon.points); - for(k=0;kpoints); + double *y = my_malloc(37, sizeof(double) * polygon->points); + for(k=0;kpoints;k++) { + ROTATION(rot, flip, 0.0,0.0,polygon->x[k],polygon->y[k],x[k],y[k]); x[k] += x0; y[k] += y0; } - drawtemppolygon(gc, NOW, x, y, polygon.points); + drawtemppolygon(gc, NOW, x, y, polygon->points); my_free(720, &x); my_free(721, &y); } @@ -612,24 +623,24 @@ void draw_temp_symbol(int what, GC gc, int n,int layer,short tmp_flip, short rot for(j=0;j< symptr->rects[layer];j++) { - rect = (symptr->rect[layer])[j]; - ROTATION(rot, flip, 0.0,0.0,rect.x1,rect.y1,x1,y1); - ROTATION(rot, flip, 0.0,0.0,rect.x2,rect.y2,x2,y2); + rect = &(symptr->rect[layer])[j]; + ROTATION(rot, flip, 0.0,0.0,rect->x1,rect->y1,x1,y1); + ROTATION(rot, flip, 0.0,0.0,rect->x2,rect->y2,x2,y2); RECTORDER(x1,y1,x2,y2); drawtemprect(gc,what, x0+x1, y0+y1, x0+x2, y0+y2); } for(j=0;j< symptr->arcs[layer];j++) { - arc = (symptr->arc[layer])[j]; + arc = &(symptr->arc[layer])[j]; if(flip) { - angle = 270.*rot+180.-arc.b-arc.a; + angle = 270.*rot+180.-arc->b-arc->a; } else { - angle = arc.a+rot*270.; + angle = arc->a+rot*270.; } angle = fmod(angle, 360.); if(angle<0.) angle+=360.; - ROTATION(rot, flip, 0.0,0.0,arc.x,arc.y,x1,y1); - drawtemparc(gc, what, x0+x1, y0+y1, arc.r, angle, arc.b); + ROTATION(rot, flip, 0.0,0.0,arc->x,arc->y,x1,y1); + drawtemparc(gc, what, x0+x1, y0+y1, arc->r, angle, arc->b); } if(layer==PROPERTYLAYER && xctx->sym_txt) @@ -2413,161 +2424,177 @@ static cairo_status_t png_writer(void *in_closure, const unsigned char *in_data, } #endif -int draw_images_all(void) + +/* rot and flip for rotated / flipped symbols + * draw: 1 draw image + * 0 only load image and build base64 + */ +void draw_image(int draw, xRect *r, double *x1, double *y1, double *x2, double *y2, int rot, int flip) { - #if HAS_CAIRO==1 - int ret = 0, i, w, h; + #if HAS_CAIRO == 1 + const char *ptr; + int w,h; double x, y, rw, rh; double sx1, sy1, sx2, sy2, alpha; - const char *ptr; char filename[PATH_MAX]; + struct stat buf; + const char *attr ; + char *filter = NULL; + double xx1, yy1, scalex, scaley; + png_to_byte_closure_t closure; + xEmb_image *emb_ptr; + xx1 = *x1; yy1 = *y1; /* image anchor point */ + RECTORDER(*x1, *y1, *x2, *y2); + + /* screen position */ + sx1=X_TO_SCREEN(*x1); + sy1=Y_TO_SCREEN(*y1); + sx2=X_TO_SCREEN(*x2); + sy2=Y_TO_SCREEN(*y2); + if(RECT_OUTSIDE(sx1, sy1, sx2, sy2, + xctx->areax1,xctx->areay1,xctx->areax2,xctx->areay2)) return; + set_rect_extraptr(1, r); /* create r->extraptr pointing to a xEmb_image struct */ + emb_ptr = r->extraptr; + if(draw) { + cairo_save(xctx->cairo_ctx); + cairo_save(xctx->cairo_save_ctx); + } + my_strncpy(filename, get_tok_value(r->prop_ptr, "image", 0), S(filename)); + my_strdup(1484, &filter, get_tok_value(r->prop_ptr, "filter", 0)); + + /* read PNG from in-memory buffer ... */ + if(emb_ptr && emb_ptr->image) { + ; /* nothing to do, image is already created */ + /* ... or read PNG from image_data attribute */ + } else if( (attr = get_tok_value(r->prop_ptr, "image_data", 0))[0] ) { + size_t data_size; + if(filter) { + size_t filtersize = 0; + char *filterdata = NULL; + closure.buffer = NULL; + filterdata = (char *)base64_decode(attr, strlen(attr), &filtersize); + filter_data(filterdata, filtersize, (char **)&closure.buffer, &data_size, filter); + my_free(1488, &filterdata); + my_free(1485, &filter); + } else { + closure.buffer = base64_decode(attr, strlen(attr), &data_size); + } + closure.pos = 0; + closure.size = data_size; /* should not be necessary */ + emb_ptr->image = cairo_image_surface_create_from_png_stream(png_reader, &closure); + if(closure.buffer == NULL) dbg(0, "draw_images_all(): image creation failed\n"); + my_free(1467, &closure.buffer); + dbg(1, "draw_images_all(): length2 = %d\n", closure.pos); + /* ... or read PNG from file (image attribute) */ + } else if(filename[0] && !stat(filename, &buf)) { + char *image_data = NULL; + size_t olength; + if(filter) { + size_t filtersize = 0; + char *filterdata = NULL; + size_t pngsize = 0; + char *pngdata = NULL; + FILE *fd; + filtersize = buf.st_size; + if(filtersize) { + fd = fopen(filename, "r"); + if(fd) { + filterdata = my_malloc(1490, filtersize); + fread(filterdata, filtersize, 1, fd); + fclose(fd); + } + } + filter_data(filterdata, filtersize, &pngdata, &pngsize, filter); + closure.buffer = (unsigned char *)pngdata; + closure.size = pngsize; + closure.pos = 0; + emb_ptr->image = cairo_image_surface_create_from_png_stream(png_reader, &closure); + image_data = base64_encode((unsigned char *)filterdata, filtersize, &olength, 0); + my_free(1489, &filterdata); + my_free(1487, &filter); + } else { + closure.buffer = NULL; + closure.size = 0; + closure.pos = 0; + emb_ptr->image = cairo_image_surface_create_from_png(filename); + /* write PNG to in-memory buffer */ + cairo_surface_write_to_png_stream(emb_ptr->image, png_writer, &closure); + image_data = base64_encode(closure.buffer, closure.pos, &olength, 0); + my_free(1468, &closure.buffer); + } + /* put base64 encoded data to rect image_data attrinute */ + my_strdup2(1473, &r->prop_ptr, subst_token(r->prop_ptr, "image_data", image_data)); + my_free(1474, &image_data); + if(cairo_surface_status(emb_ptr->image) != CAIRO_STATUS_SUCCESS) return; + dbg(1, "draw_image(): length3 = %d\n", closure.pos); + } else return; + if(cairo_surface_status(emb_ptr->image) != CAIRO_STATUS_SUCCESS) return; + ptr = get_tok_value(r->prop_ptr, "alpha", 0); + alpha = 1.0; + if(ptr[0]) alpha = atof(ptr); + w = cairo_image_surface_get_width (emb_ptr->image); + h = cairo_image_surface_get_height (emb_ptr->image); + dbg(1, "draw_image() w=%d, h=%d\n", w, h); + x = X_TO_SCREEN(xx1); + y = Y_TO_SCREEN(yy1); + if(r->flags & 2048) { /* resize container rectangle to fit image */ + *x2 = *x1 + w; + *y2 = *y1 + h; + scalex = xctx->mooz; + scaley = xctx->mooz; + } else { /* resize image to fit in rectangle */ + rw = abs(*x2 - *x1); + rh = abs(*y2 - *y1); + scalex = rw/w * xctx->mooz; + scaley = rh/h * xctx->mooz; + } + if(draw && xctx->draw_pixmap) { + cairo_translate(xctx->cairo_save_ctx, x, y); + if(flip && (rot == 0 || rot == 2)) cairo_scale(xctx->cairo_save_ctx, -scalex, scaley); + else if(flip && (rot == 1 || rot == 3)) cairo_scale(xctx->cairo_save_ctx, scalex, -scaley); + else cairo_scale(xctx->cairo_save_ctx, scalex, scaley); + cairo_rotate(xctx->cairo_save_ctx, rot * XSCH_PI * 0.5); + cairo_set_source_surface(xctx->cairo_save_ctx, emb_ptr->image, 0. , 0.); + cairo_rectangle(xctx->cairo_save_ctx, 0, 0, w , h ); + /* cairo_fill(xctx->cairo_save_ctx); + * cairo_stroke(xctx->cairo_save_ctx); */ + cairo_clip(xctx->cairo_save_ctx); + cairo_paint_with_alpha(xctx->cairo_save_ctx, alpha); + } + if(draw && xctx->draw_window) { + cairo_translate(xctx->cairo_ctx, x, y); + if(flip && (rot == 0 || rot == 2)) cairo_scale(xctx->cairo_ctx, -scalex, scaley); + else if(flip && (rot == 1 || rot == 3)) cairo_scale(xctx->cairo_ctx, scalex, -scaley); + else cairo_scale(xctx->cairo_ctx, scalex, scaley); + cairo_rotate(xctx->cairo_ctx, rot * XSCH_PI * 0.5); + cairo_set_source_surface(xctx->cairo_ctx, emb_ptr->image, 0. , 0.); + cairo_rectangle(xctx->cairo_ctx, 0, 0, w , h ); + /* cairo_fill(xctx->cairo_ctx); + * cairo_stroke(xctx->cairo_ctx); */ + cairo_clip(xctx->cairo_ctx); + cairo_paint_with_alpha(xctx->cairo_ctx, alpha); + } + if(draw) { + cairo_restore(xctx->cairo_ctx); + cairo_restore(xctx->cairo_save_ctx); + } + #endif +} + +static void draw_images_all(void) +{ + #if HAS_CAIRO==1 + int i; if(xctx->draw_single_layer==-1 || GRIDLAYER == xctx->draw_single_layer) { if(xctx->enable_layer[GRIDLAYER]) for(i = 0; i < xctx->rects[GRIDLAYER]; i++) { xRect *r = &xctx->rect[GRIDLAYER][i]; if(r->flags & 1024) { - struct stat buf; - const char *attr; - double scalex, scaley; - char *filter = NULL; - png_to_byte_closure_t closure; - xEmb_image *emb_ptr; - - my_strncpy(filename, get_tok_value(r->prop_ptr, "image", 0), S(filename)); - my_strdup(1484, &filter, get_tok_value(r->prop_ptr, "filter", 0)); - /* screen position */ - sx1=X_TO_SCREEN(r->x1); - sy1=Y_TO_SCREEN(r->y1); - sx2=X_TO_SCREEN(r->x2); - sy2=Y_TO_SCREEN(r->y2); - if(RECT_OUTSIDE(sx1, sy1, sx2, sy2, - xctx->areax1,xctx->areay1,xctx->areax2,xctx->areay2)) continue; - if(!r->extraptr) { - set_rect_extraptr(1, r, NULL); - } - emb_ptr = r->extraptr; - cairo_save(xctx->cairo_ctx); - cairo_save(xctx->cairo_save_ctx); - - /* read PNG from in-memory buffer ... */ - if(emb_ptr && emb_ptr->image) { - ; /* nothing to do, image is already created */ - /* ... or read PNG from image_data attribute */ - } else if( (attr = get_tok_value(r->prop_ptr, "image_data", 0))[0] ) { - size_t data_size; - if(filter) { - size_t filtersize = 0; - char *filterdata = NULL; - closure.buffer = NULL; - filterdata = (char *)base64_decode(attr, strlen(attr), &filtersize); - filter_data(filterdata, filtersize, (char **)&closure.buffer, &data_size, filter); - my_free(1488, &filterdata); - } else { - closure.buffer = base64_decode(attr, strlen(attr), &data_size); - } - closure.pos = 0; - closure.size = data_size; /* should not be necessary */ - emb_ptr->image = cairo_image_surface_create_from_png_stream(png_reader, &closure); - if(closure.buffer == NULL) dbg(0, "draw_images_all(): image creation failed, n=%d\n", i); - my_free(1467, &closure.buffer); - dbg(1, "draw_images_all(): length2 = %d\n", closure.pos); - /* ... or read PNG from file (image attribute) */ - } else if(filename[0] && !stat(filename, &buf)) { - char *image_data = NULL; - size_t olength; - if(filter) { - size_t filtersize = 0; - char *filterdata = NULL; - size_t pngsize = 0; - char *pngdata = NULL; - struct stat st; - if(stat(filename, &st) == 0 /* && ( (st.st_mode & S_IFMT) == S_IFREG)*/ ) { - FILE *fd; - filtersize = st.st_size; - if(filtersize) { - fd = fopen(filename, "r"); - if(fd) { - filterdata = my_malloc(1490, filtersize); - fread(filterdata, filtersize, 1, fd); - fclose(fd); - } - } - } - filter_data(filterdata, filtersize, &pngdata, &pngsize, filter); - closure.buffer = (unsigned char *)pngdata; - closure.size = pngsize; - closure.pos = 0; - emb_ptr->image = cairo_image_surface_create_from_png_stream(png_reader, &closure); - image_data = base64_encode((unsigned char *)filterdata, filtersize, &olength, 0); - my_free(1489, &filterdata); - } else { - closure.buffer = NULL; - closure.size = 0; - closure.pos = 0; - emb_ptr->image = cairo_image_surface_create_from_png(filename); - /* write PNG to in-memory buffer */ - cairo_surface_write_to_png_stream(emb_ptr->image, png_writer, &closure); - image_data = base64_encode(closure.buffer, closure.pos, &olength, 0); - } - my_free(1468, &closure.buffer); - /* put base64 encoded data to rect image_data attrinute */ - my_strdup2(1473, &r->prop_ptr, subst_token(r->prop_ptr, "image_data", image_data)); - my_free(1474, &image_data); - - - if(cairo_surface_status(emb_ptr->image) != CAIRO_STATUS_SUCCESS) {ret = 1; continue;} - dbg(1, "draw_images_all(): length3 = %d\n", closure.pos); - } else { - {ret = 1; continue;} - } - if(cairo_surface_status(emb_ptr->image) != CAIRO_STATUS_SUCCESS) {ret = 1; continue;} - ptr = get_tok_value(r->prop_ptr, "alpha", 0); - alpha = 1.0; - if(ptr[0]) alpha = atof(ptr); - w = cairo_image_surface_get_width (emb_ptr->image); - h = cairo_image_surface_get_height (emb_ptr->image); - dbg(1, "draw_images_all() w=%d, h=%d\n", w, h); - x = X_TO_SCREEN(r->x1); - y = Y_TO_SCREEN(r->y1); - if(r->flags & 2048) { /* resize container rectangle to fit image */ - r->x2 = r->x1 + w; - r->y2 = r->y1 + h; - scalex = xctx->mooz; - scaley = xctx->mooz; - } else { /* resize image to fit in rectangle */ - rw = abs(r->x2 - r->x1); - rh = abs(r->y2 - r->y1); - scalex = rw/w * xctx->mooz; - scaley = rh/h * xctx->mooz; - } - if(xctx->draw_pixmap) { - cairo_translate(xctx->cairo_save_ctx, x, y); - cairo_scale(xctx->cairo_save_ctx, scalex, scaley); - cairo_set_source_surface(xctx->cairo_save_ctx, emb_ptr->image, 0. , 0.); - cairo_rectangle(xctx->cairo_save_ctx, 0, 0, w , h ); - /* cairo_fill(xctx->cairo_save_ctx); - * cairo_stroke(xctx->cairo_save_ctx); */ - cairo_clip(xctx->cairo_save_ctx); - cairo_paint_with_alpha(xctx->cairo_save_ctx, alpha); - } - if(xctx->draw_window) { - cairo_translate(xctx->cairo_ctx, x, y); - cairo_scale(xctx->cairo_ctx, scalex, scaley); - cairo_set_source_surface(xctx->cairo_ctx, emb_ptr->image, 0. , 0.); - cairo_rectangle(xctx->cairo_ctx, 0, 0, w , h ); - /* cairo_fill(xctx->cairo_ctx); - * cairo_stroke(xctx->cairo_ctx); */ - cairo_clip(xctx->cairo_ctx); - cairo_paint_with_alpha(xctx->cairo_ctx, alpha); - } - cairo_restore(xctx->cairo_ctx); - cairo_restore(xctx->cairo_save_ctx); - my_free(1486, &filter); + draw_image(1, r, &r->x1, &r->y1, &r->x2, &r->y2, 0, 0); } } } #endif - return ret; } void draw(void) diff --git a/src/editprop.c b/src/editprop.c index ef5fff6f..0f0b890d 100644 --- a/src/editprop.c +++ b/src/editprop.c @@ -293,7 +293,8 @@ void *my_calloc(int id, size_t nmemb, size_t size) void *ptr; if(size*nmemb > 0) { ptr=calloc(nmemb, size); - if(ptr == NULL) fprintf(errfp,"my_calloc(%d,): allocation failure\n", id); + if(ptr == NULL) + fprintf(errfp,"my_calloc(%d,): allocation failure %ld * %ld bytes\n", id, nmemb, size); dbg(3, "\nmy_calloc(%d,): allocating %p , %lu bytes\n", id, ptr, (unsigned long) (size*nmemb)); } @@ -306,7 +307,7 @@ void *my_malloc(int id, size_t size) void *ptr; if(size>0) { ptr=malloc(size); - if(ptr == NULL) fprintf(errfp,"my_malloc(%d,): allocation failure\n", id); + if(ptr == NULL) fprintf(errfp,"my_malloc(%d,): allocation failure for %ld bytes\n", id, size); dbg(3, "\nmy_malloc(%d,): allocating %p , %lu bytes\n", id, ptr, (unsigned long) size); } else ptr=NULL; @@ -323,7 +324,7 @@ void my_realloc(int id, void *ptr,size_t size) *(void **)ptr=NULL; } else { *(void **)ptr=realloc(*(void **)ptr,size); - if(*(void **)ptr == NULL) fprintf(errfp,"my_realloc(%d,): allocation failure\n", id); + if(*(void **)ptr == NULL) fprintf(errfp,"my_realloc(%d,): allocation failure for %ld bytes\n", id, size); dbg(3, "\nmy_realloc(%d,): reallocating %p --> %p to %lu bytes\n", id, a, *(void **)ptr,(unsigned long) size); } @@ -404,9 +405,6 @@ static void edit_rect_property(int x) } else { tclsetvar("retval",""); } - - - if(x==0) { xctx->semaphore++; tcleval("text_line {Input property:} 0 normal"); @@ -435,9 +433,7 @@ static void edit_rect_property(int x) } set_rect_flags(&xctx->rect[c][n]); /* set cached .flags bitmask from on attributes */ - if(xctx->rect[c][n].extraptr) { /* used for images, clear so will be recreated from image attr */ - set_rect_extraptr(0, &xctx->rect[c][n], NULL); - } + set_rect_extraptr(0, &xctx->rect[c][n]); dash = get_tok_value(xctx->rect[c][n].prop_ptr,"dash",0); if( strcmp(dash, "") ) { int d = atoi(dash); @@ -450,6 +446,8 @@ static void edit_rect_property(int x) bbox(START,0.0,0.0,0.0,0.0); drw = 1; } + draw_image(0, &xctx->rect[c][n], + &xctx->rect[c][n].x1, &xctx->rect[c][n].y1, &xctx->rect[c][n].x2, &xctx->rect[c][n].y2, 0, 0); bbox(ADD, xctx->rect[c][n].x1, xctx->rect[c][n].y1, xctx->rect[c][n].x2, xctx->rect[c][n].y2); } } diff --git a/src/in_memory_undo.c b/src/in_memory_undo.c index dd15ecbb..408ca983 100644 --- a/src/in_memory_undo.c +++ b/src/in_memory_undo.c @@ -306,10 +306,8 @@ void mem_push_undo(void) for(i = 0;irects[c];i++) { xctx->uslot[slot].bptr[c][i] = xctx->rect[c][i]; xctx->uslot[slot].bptr[c][i].prop_ptr = NULL; + xctx->uslot[slot].bptr[c][i].extraptr = NULL; my_strdup(185, &xctx->uslot[slot].bptr[c][i].prop_ptr, xctx->rect[c][i].prop_ptr); - if(xctx->rect[c][i].extraptr) { - set_rect_extraptr(2, &xctx->uslot[slot].bptr[c][i], &xctx->rect[c][i]); - } } /* arcs */ for(i = 0;iarcs[c];i++) { @@ -385,6 +383,7 @@ void mem_push_undo(void) for(j = 0; j < xctx->sym[i].rects[c]; j++) { sym->rect[c][j] = xctx->sym[i].rect[c][j]; sym->rect[c][j].prop_ptr = NULL; + sym->rect[c][j].extraptr = NULL; my_strdup(1362, &sym->rect[c][j].prop_ptr, xctx->sym[i].rect[c][j].prop_ptr); } /* symbol arcs */ @@ -531,10 +530,8 @@ void mem_pop_undo(int redo, int set_modify_status) for(i = 0;irects[c];i++) { xctx->rect[c][i] = xctx->uslot[slot].bptr[c][i]; xctx->rect[c][i].prop_ptr = NULL; + xctx->rect[c][i].extraptr = NULL; my_strdup(205, &xctx->rect[c][i].prop_ptr, xctx->uslot[slot].bptr[c][i].prop_ptr); - if(xctx->uslot[slot].bptr[c][i].extraptr) { - set_rect_extraptr(2, &xctx->rect[c][i], &xctx->uslot[slot].bptr[c][i]); - } } /* arcs */ xctx->maxa[c] = xctx->arcs[c] = xctx->uslot[slot].arcs[c]; @@ -621,6 +618,7 @@ void mem_pop_undo(int redo, int set_modify_status) for(j = 0; j < xctx->sym[i].rects[c]; j++) { xctx->sym[i].rect[c][j] = sym->rect[c][j]; xctx->sym[i].rect[c][j].prop_ptr = NULL; + xctx->sym[i].rect[c][j].extraptr = NULL; my_strdup(1369, & xctx->sym[i].rect[c][j].prop_ptr, sym->rect[c][j].prop_ptr); } /* symbol arcs */ diff --git a/src/move.c b/src/move.c index ebbb5b4b..0e03b7b9 100644 --- a/src/move.c +++ b/src/move.c @@ -145,7 +145,7 @@ void check_collapsing_objects() if(xctx->rect[c][i].x1==xctx->rect[c][i].x2 || xctx->rect[c][i].y1 == xctx->rect[c][i].y2) { my_free(815, &xctx->rect[c][i].prop_ptr); - set_rect_extraptr(0, &xctx->rect[c][i], NULL); + set_rect_extraptr(0, &xctx->rect[c][i]); found=1; j++; continue; @@ -870,12 +870,10 @@ void copy_objects(int what) RECTORDER(xctx->rx1,xctx->ry1,xctx->rx2,xctx->ry2); xctx->rect[c][n].sel=0; xctx->sel_array[i].n=xctx->rects[c]; + /* following also clears extraptr */ storeobject(-1, xctx->rx1+xctx->deltax, xctx->ry1+xctx->deltay, xctx->rx2+xctx->deltax, xctx->ry2+xctx->deltay,xRECT, c, SELECTED, xctx->rect[c][n].prop_ptr); l = xctx->rects[c] - 1; - if(xctx->rect[c][n].extraptr) { - set_rect_extraptr(2, &xctx->rect[c][l], &xctx->rect[c][n]); - } bbox(ADD, xctx->rect[c][l].x1, xctx->rect[c][l].y1, xctx->rect[c][l].x2, xctx->rect[c][l].y2); break; diff --git a/src/save.c b/src/save.c index 417fd892..96e61e66 100644 --- a/src/save.c +++ b/src/save.c @@ -37,13 +37,15 @@ int filter_data(const char *din, const size_t ilen, int p2[2]; /* child -> parent, 0: read, 1: write */ int ret = 0; pid_t pid; - size_t bufsize = 1024, oalloc = 0, n = 0; + size_t bufsize = 32768, oalloc = 0, n = 0; if(!din || !ilen || !cmd) { /* basic check */ *dout = NULL; *olen = 0; return 1; } + + dbg(1, "filter_data(): ilen=%ld, cmd=%s\n", ilen, cmd); pipe(p1); pipe(p2); signal(SIGPIPE, SIG_IGN); /* so attempting write/read a broken pipe won't kill program */ @@ -73,22 +75,19 @@ int filter_data(const char *din, const size_t ilen, } close(p1[1]); if(!ret) { - if((*dout = my_malloc(1480, bufsize))) { - oalloc = bufsize + 1; /* add extra space for final '\0' */ - *olen = 0; - while( (n = read(p2[0], *dout + *olen, bufsize)) > 0) { - *olen += n; - if(*olen + bufsize + 1 >= oalloc) { /* allocate for next read */ - bufsize = (((bufsize << 2) + bufsize) >> 2); /* bufsize *= 1.25 */ - oalloc = *olen + bufsize + 1; /* add extra space for final '\0' */ - my_realloc(1482, dout, oalloc); - } + oalloc = bufsize + 1; /* add extra space for final '\0' */ + *dout = my_malloc(1480, oalloc); + *olen = 0; + while( (n = read(p2[0], *dout + *olen, bufsize)) > 0) { + *olen += n; + if(*olen + bufsize + 1 >= oalloc) { /* allocate for next read */ + oalloc = *olen + bufsize + 1; /* add extra space for final '\0' */ + oalloc = ((oalloc << 2) + oalloc) >> 2; /* size up 1.25x */ + dbg(1, "filter_data() read %ld bytes, reallocate dout to %ld bytes, bufsize=%ld\n", n, oalloc, bufsize); + my_realloc(1482, dout, oalloc); } - if(*olen) (*dout)[*olen] = '\0'; /* so (if ascii) it can be used as a string */ - } else { - fprintf(stderr, "filter_data(): malloc error for read buffer\n"); - ret = 1; } + if(*olen) (*dout)[*olen] = '\0'; /* so (if ascii) it can be used as a string */ } close(p2[0]); if(n < 0 || !*olen) { @@ -1992,6 +1991,8 @@ static void add_pinlayer_boxes(int *lastr, xRect **bb, my_snprintf(pin_label, save, "name=%s dir=inout ", label); } my_strdup(463, &bb[PINLAYER][i].prop_ptr, pin_label); + bb[PINLAYER][i].flags = 0; + bb[PINLAYER][i].extraptr = 0; bb[PINLAYER][i].dash = 0; bb[PINLAYER][i].sel = 0; /* add to symbol pins remaining attributes from schematic pins, except name= and lab= */ @@ -2416,6 +2417,8 @@ int load_sym_def(const char *name, FILE *embed_fd) } else bb[c][i].dash = 0; bb[c][i].sel = 0; + bb[c][i].extraptr = NULL; + set_rect_flags(&bb[c][i]); lastr[c]++; break; case 'T': diff --git a/src/select.c b/src/select.c index 1e3fbd6f..02ebe8c9 100644 --- a/src/select.c +++ b/src/select.c @@ -218,7 +218,7 @@ static void del_rect_line_arc_poly(void) j++; bbox(ADD, xctx->rect[c][i].x1, xctx->rect[c][i].y1, xctx->rect[c][i].x2, xctx->rect[c][i].y2); my_free(928, &xctx->rect[c][i].prop_ptr); - set_rect_extraptr(0, &xctx->rect[c][i], NULL); + set_rect_extraptr(0, &xctx->rect[c][i]); set_modify(1); continue; } diff --git a/src/xschem.h b/src/xschem.h index 4cd7bd95..d596aa05 100644 --- a/src/xschem.h +++ b/src/xschem.h @@ -1000,6 +1000,7 @@ extern int cli_opt_load_initfile; extern Xschem_ctx *xctx; /* FUNCTIONS */ +extern void draw_image(int draw, xRect *r, double *x1, double *y1, double *x2, double *y2, int rot, int flip); extern int filter_data(const char *din, const size_t ilen, char **dout, size_t *olen, const char *cmd); extern int embed_rawfile(const char *rawfile); @@ -1007,7 +1008,7 @@ extern int read_rawfile_from_attr(const char *b64s, size_t length); extern int read_embedded_rawfile(void); extern char *base64_from_file(const char *f, size_t *length); extern int set_rect_flags(xRect *r); -extern int set_rect_extraptr(int what, xRect *drptr, xRect *srptr); +extern int set_rect_extraptr(int what, xRect *drptr); extern unsigned char *base64_decode(const char *data, const size_t input_length, size_t *output_length); extern char *base64_encode(const unsigned char *data, const size_t input_length, size_t *output_length, int brk); extern int get_raw_index(const char *node); @@ -1017,7 +1018,6 @@ extern double get_raw_value(int dataset, int idx, int point); extern int schematic_waves_loaded(void); extern void draw_graph(int i, int flags, Graph_ctx *gr); extern void draw_graph_all(int flags); -extern int draw_images_all(void); extern void setup_graph_data(int i, const int flags, int skip, Graph_ctx *gr); extern double timer(int start); extern void enable_layers(void); diff --git a/xschem_library/examples/0_examples_top.sch b/xschem_library/examples/0_examples_top.sch index 12bd956d..d6abec5c 100644 --- a/xschem_library/examples/0_examples_top.sch +++ b/xschem_library/examples/0_examples_top.sch @@ -13,7 +13,7 @@ L 16 860 -650 910 -670 {} B 2 1220 -770 1470 -591 {flags=image,unscaled alpha=0.7 image=/home/schippes/x/4.png -image_data=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} +image_data=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} B 2 1200 -560 1490 -410 {flags=graph y1 = -0.038 y2 = 20 diff --git a/xschem_library/examples/bus_keeper.sch b/xschem_library/examples/bus_keeper.sch index e003036b..38261809 100644 --- a/xschem_library/examples/bus_keeper.sch +++ b/xschem_library/examples/bus_keeper.sch @@ -1,4 +1,4 @@ -v {xschem version=2.9.8 file_version=1.2} +v {xschem version=3.0.0 file_version=1.2 } G {} K {type=subcircuit format="@name @pinlist @symname WN_FB=@WN_FB WP_FB=@WP_FB" diff --git a/xschem_library/examples/test_ne555.sch b/xschem_library/examples/test_ne555.sch index 494b01dc..325b51b8 100644 --- a/xschem_library/examples/test_ne555.sch +++ b/xschem_library/examples/test_ne555.sch @@ -1,5 +1,6 @@ -v {xschem version=2.9.5_RC5 file_version=1.1} +v {xschem version=3.0.0 file_version=1.2 } G {} +K {} V {} S {} E {} diff --git a/xschem_library/examples/test_ne555.sym b/xschem_library/examples/test_ne555.sym index 9e1aeffd..b2acb6c9 100644 --- a/xschem_library/examples/test_ne555.sym +++ b/xschem_library/examples/test_ne555.sym @@ -1,16 +1,14 @@ -v {xschem version=2.9.5_RC5 file_version=1.1} +v {xschem version=3.0.0 file_version=1.2} G {type=subcircuit format="@name @pinlist @symname" verilog_stop=true template="name=x1" } -V {} -S {} -E {} + +T {@symname} -63 -6 0 0 0.3 0.3 {} +T {@name} 135 -22 0 0 0.2 0.2 {} L 4 -130 -10 130 -10 {} L 4 -130 10 130 10 {} L 4 -130 -10 -130 10 {} L 4 130 -10 130 10 {} -T {@symname} -58.5 -6 0 0 0.3 0.3 {} -T {@name} 135 -22 0 0 0.2 0.2 {}