gboolean PyDia_export_data(DiagramData *data, DiaContext *ctx, const gchar *filename, const gchar *diafilename, void* user_data) { DiaPyRenderer *renderer; { FILE *file; file = g_fopen(filename, "w"); /* "wb" for binary! */ if (file == NULL) { dia_context_add_message_with_errno(ctx, errno, _("Couldn't open '%s' for writing.\n"), dia_context_get_filename(ctx)); return FALSE; } else fclose (file); } renderer = g_object_new (DIA_TYPE_PY_RENDERER, NULL); renderer->filename = g_strdup (filename); renderer->diagram_data = PyDiaDiagramData_New(data); /* The Python Renderer object was created at PyDia_Register */ renderer->self = (PyObject*)user_data; /* this will call the required callback functions above */ data_render(data, DIA_RENDERER(renderer), NULL, NULL, NULL); g_object_unref(renderer); return TRUE; }
/* dia export funtion */ static gboolean export_data(DiagramData *data, DiaContext *ctx, const gchar *filename, const gchar *diafilename, void* user_data) { WpgRenderer *renderer; FILE *file; Rectangle *extent; real width, height; file = g_fopen(filename, "wb"); /* "wb" for binary! */ if (file == NULL) { dia_context_add_message_with_errno (ctx, errno, _("Can't open output file %s"), dia_context_get_filename(ctx)); return FALSE; } renderer = g_object_new (WPG_TYPE_RENDERER, NULL); renderer->file = file; renderer->ctx = ctx; extent = &data->extents; /* use extents */ DIAG_NOTE(g_message("export_data extents %f,%f -> %f,%f", extent->left, extent->top, extent->right, extent->bottom)); width = extent->right - extent->left; height = extent->bottom - extent->top; #if 0 /* extend to use full range */ renderer->Scale = 0.001; if (width > height) while (renderer->Scale * width < 3276.7) renderer->Scale *= 10.0; else while (renderer->Scale * height < 3276.7) renderer->Scale *= 10.0; #else /* scale from Dia's cm to WPU (1/1200 inch) */ renderer->Scale = WPU_PER_DCM; /* avoid int16 overflow */ if (width > height) while (renderer->Scale * width > 32767) renderer->Scale /= 10.0; else while (renderer->Scale * height > 32767) renderer->Scale /= 10.0; renderer->XOffset = - extent->left; renderer->YOffset = extent->bottom; #endif renderer->Box.Width = width * renderer->Scale; renderer->Box.Height = height * renderer->Scale; renderer->Box.Flag = 0; renderer->Box.Version = 0; data_render(data, DIA_RENDERER(renderer), NULL, NULL, NULL); g_object_unref(renderer); return TRUE; }
static gboolean export_render_eps(DiaPsRenderer *renderer, DiagramData *data, DiaContext *ctx, const gchar *filename, const gchar *diafilename, void* user_data) { FILE *outfile; outfile = g_fopen(filename, "w"); if (outfile == NULL) { dia_context_add_message_with_errno (ctx, errno, _("Can't open output file %s"), dia_context_get_filename(ctx)); return FALSE; } renderer->file = outfile; renderer->scale = 28.346 * data->paper.scaling; renderer->extent = data->extents; renderer->pstype = (guint)user_data; if (renderer->pstype & PSTYPE_EPSI) { /* Must store the diagram for making a preview */ renderer->diagram = data; } if (renderer->file) { renderer->title = g_strdup (diafilename); data_render(data, DIA_RENDERER(renderer), NULL, NULL, NULL); } fclose(outfile); return TRUE; }
static void end_render(DiaRenderer *self) { WmfRenderer *renderer = WMF_RENDERER (self); W32::HENHMETAFILE hEmf; W32::UINT nSize; W32::BYTE* pData = NULL; FILE* f; DIAG_NOTE(renderer, "end_render\n"); hEmf = W32::CloseEnhMetaFile(renderer->hFileDC); #if !defined DIRECT_WMF && defined G_OS_WIN32 /* the later offers both */ /* Don't do it when printing */ if (renderer->sFileName && strlen (renderer->sFileName)) { W32::HDC hdc = W32::GetDC(NULL); f = g_fopen(renderer->sFileName, "wb"); if (renderer->target_emf) { nSize = W32::GetEnhMetaFileBits (hEmf, 0, NULL); pData = g_new(W32::BYTE, nSize); nSize = W32::GetEnhMetaFileBits (hEmf, nSize, pData); } else { /* write the placeable header */ fwrite(&renderer->pmh, 1, 22 /* NOT: sizeof(PLACEABLEMETAHEADER) */, f); /* get size */ nSize = W32::GetWinMetaFileBits(hEmf, 0, NULL, MM_ANISOTROPIC, hdc); pData = g_new(W32::BYTE, nSize); /* get data */ nSize = W32::GetWinMetaFileBits(hEmf, nSize, pData, MM_ANISOTROPIC, hdc); } /* write file */ if (fwrite(pData,1,nSize,f) != nSize) dia_context_add_message_with_errno(renderer->ctx, errno, _("Couldn't write file %s\n%s"), dia_context_get_filename (renderer->ctx)); fclose(f); g_free(pData); W32::ReleaseDC(NULL, hdc); } else { W32::PlayEnhMetaFile (renderer->hPrintDC, hEmf, &renderer->margins); } #endif g_free(renderer->sFileName); if (hEmf) W32::DeleteEnhMetaFile(hEmf); if (renderer->hFont) W32::DeleteObject(renderer->hFont); if (renderer->pango_context) g_object_unref (renderer->pango_context); }
/* plug-in interface : export function */ static gboolean export_data(DiagramData *data, DiaContext *ctx, const gchar *filename, const gchar *diafilename, void* user_data) { HpglRenderer *renderer; FILE *file; Rectangle *extent; real width, height; file = g_fopen(filename, "w"); /* "wb" for binary! */ if (!file) { dia_context_add_message_with_errno(ctx, errno, _("Can't open output file %s."), dia_context_get_filename(ctx)); return FALSE; } renderer = g_object_new(HPGL_TYPE_RENDERER, NULL); renderer->file = file; extent = &data->extents; /* use extents */ DIAG_NOTE(g_message("export_data extents %f,%f -> %f,%f", extent->left, extent->top, extent->right, extent->bottom)); width = extent->right - extent->left; height = extent->bottom - extent->top; renderer->scale = 0.001; if (width > height) while (renderer->scale * width < 3276.7) renderer->scale *= 10.0; else while (renderer->scale * height < 3276.7) renderer->scale *= 10.0; renderer->offset = 0.0; /* just to have one */ renderer->size.x = width * renderer->scale; renderer->size.y = height * renderer->scale; #if 0 /* OR: set page size and scale */ fprintf(renderer->file, "PS0;SC%d,%d,%d,%d;\n", hpgl_scale(renderer, extent->left), hpgl_scale(renderer, extent->right), hpgl_scale(renderer, extent->bottom), hpgl_scale(renderer, extent->top)); #endif data_render(data, DIA_RENDERER(renderer), NULL, NULL, NULL); g_object_unref(renderer); return TRUE; }
static gboolean import_data (const gchar *filename, DiagramData *data, DiaContext *ctx, void* user_data) { DiaObjectType *otype = object_get_type("Standard - Image"); gint width, height; if (!otype) /* this would be really broken */ return FALSE; if (!user_data) { dia_context_add_message(ctx, _("Calling error, missing user_data.")); return FALSE; } if (gdk_pixbuf_get_file_info (filename, &width, &height)) { DiaObject *obj; Handle *h1, *h2; Point point; point.x = point.y = 0.0; obj = otype->ops->create(&point, otype->default_user_data, &h1, &h2); if (obj) { GPtrArray *plist = g_ptr_array_new (); prop_list_add_filename (plist, "image_file", filename); prop_list_add_real (plist, "elem_width", width / 20.0); prop_list_add_real (plist, "elem_height", height / 20.0); obj->ops->set_props(obj, plist); prop_list_free (plist); layer_add_object(data->active_layer, obj); return TRUE; } } else { dia_context_add_message(ctx, _("Pixbuf[%s] can't load:\n%s"), (gchar*)user_data, dia_context_get_filename(ctx)); } return FALSE; }
gboolean import_pdf(const gchar *filename, DiagramData *dia, DiaContext *ctx, void* user_data) { PDFDoc *doc; GooString *fileName = new GooString(filename); // no passwords yet GooString *ownerPW = NULL; GooString *userPW = NULL; gboolean ret = FALSE; // without this we will get strange crashes (at least with /O2 build) globalParams = new GlobalParams(); doc = PDFDocFactory().createPDFDoc(*fileName, ownerPW, userPW); if (!doc->isOk()) { dia_context_add_message (ctx, _("PDF document not OK.\n%s"), dia_context_get_filename (ctx)); } else { DiaOutputDev *diaOut = new DiaOutputDev(dia, doc->getNumPages()); for (int pg = 1; pg <= doc->getNumPages(); ++pg) { Page *page = doc->getPage (pg); if (!page || !page->isOk()) continue; doc->displayPage(diaOut, pg, 72.0, 72.0, /* DPI, scaling elsewhere */ 0, /* rotate */ gTrue, /* useMediaBox */ gTrue, /* Crop */ gFalse /* printing */ ); } delete diaOut; ret = TRUE; } delete doc; delete globalParams; delete fileName; return ret; }
static DiaObject * _dae_load (ObjectNode obj_node, int version, DiaContext *ctx) { DiaObject *obj; DiagramAsElement *dae; obj = object_load_using_properties (&diagram_as_element_type, obj_node, version, ctx); /* filename de-normalization */ dae = (DiagramAsElement*)obj; if (strlen(dae->filename) && !g_path_is_absolute (dae->filename)) { gchar *dirname = g_path_get_dirname (dia_context_get_filename(ctx)); gchar *fname = g_build_filename (dirname, dae->filename, NULL); g_free (dae->filename); dae->filename = fname; g_free (dirname); /* need to update again with new filenames */ _dae_update_data(dae); } return obj; }
static void _dae_save (DiaObject *obj, ObjectNode obj_node, DiaContext *ctx) { DiagramAsElement *dae; /* filename normalization */ gchar *saved_path = NULL; dae = (DiagramAsElement*)obj; if (strlen(dae->filename) && g_path_is_absolute (dae->filename)) { gchar *dirname = g_path_get_dirname (dia_context_get_filename (ctx)); if (strstr (dae->filename, dirname) == dae->filename) { saved_path = dae->filename; dae->filename += (strlen (dirname) + g_str_has_suffix (dirname, G_DIR_SEPARATOR_S) ? 0 : 1); } g_free (dirname); } object_save_using_properties (obj, obj_node, ctx); if (saved_path) { dae->filename = saved_path; } }
static gboolean export_data(DiagramData *data, DiaContext *ctx, const gchar *filename, const gchar *diafilename, void* user_data) { DiaCairoRenderer *renderer; GdkColor color; int width, height; GdkPixbuf* pixbuf = NULL; GError* error = NULL; Rectangle rect; real zoom = 1.0; cairo_t *cctx; const char* format = (const char*)user_data; rect.left = data->extents.left; rect.top = data->extents.top; rect.right = data->extents.right; rect.bottom = data->extents.bottom; /* quite arbitrary */ zoom = 20.0 * data->paper.scaling; /* Adding a bit of padding to account for rounding errors. Better to * pad than to clip. See bug #413275 */ width = ceil((rect.right - rect.left) * zoom) + 1; height = ceil((rect.bottom - rect.top) * zoom) + 1; renderer = g_object_new (dia_cairo_renderer_get_type(), NULL); renderer->scale = zoom; renderer->surface = cairo_surface_reference (cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height)); cctx = cairo_create (renderer->surface); /* draw background */ color_convert (&data->bg_color, &color); gdk_cairo_set_source_color (cctx, &color); cairo_rectangle (cctx, 0, 0, width, height); cairo_fill (cctx); data_render (data, DIA_RENDERER (renderer), NULL, NULL, NULL); #if GTK_CHECK_VERSION(3,0,0) pixbuf = gdk_pixbuf_get_from_surface (renderer->surface, 0, 0, width, height); #else { GdkPixmap *pixmap; cairo_t *cr; pixmap = gdk_pixmap_new (NULL, width, height, 24); cr = gdk_cairo_create (pixmap); cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); cairo_set_source_surface (cr, renderer->surface, 0, 0); cairo_paint (cr); pixbuf = gdk_pixbuf_get_from_drawable (NULL, pixmap, gdk_colormap_get_system (), 0, 0, 0, 0, width, height); } #endif if (pixbuf) { gdk_pixbuf_save (pixbuf, filename, format, &error, NULL); g_object_unref (pixbuf); } else { dia_context_add_message(ctx, _("Failed to create pixbuf from drawable.")); } if (error) { dia_context_add_message(ctx, _("Could not save file:\n%s\n%s"), dia_context_get_filename(ctx), error->message); g_error_free (error); } g_object_unref (renderer); return TRUE; }
/* imports the given fig-file, returns TRUE if successful */ static gboolean import_fig(const gchar *filename, DiagramData *dia, DiaContext *ctx, void* user_data) { FILE *figfile; char buf[BUFLEN]; int figmajor, figminor; int i; for (i = 0; i < FIG_MAX_USER_COLORS; i++) { fig_colors[i] = color_black; } for (i = 0; i < FIG_MAX_DEPTHS; i++) { depths[i] = NULL; } figfile = g_fopen(filename,"r"); if (figfile == NULL) { dia_context_add_message_with_errno(ctx, errno, _("Couldn't open: '%s' for reading.\n"), dia_context_get_filename(ctx)); return FALSE; } /* First check magic bytes */ if (fgets(buf, BUFLEN, figfile) == NULL || sscanf(buf, "#FIG %d.%d\n", &figmajor, &figminor) != 2) { dia_context_add_message_with_errno(ctx, errno, _("Doesn't look like a Fig file")); fclose(figfile); return FALSE; } if (figmajor != 3 || figminor != 2) { dia_context_add_message(ctx, _("This is a Fig version %d.%d file.\n It may not be importable."), figmajor, figminor); } figversion = figmajor*100+figminor; if (!skip_comments(figfile)) { if (!feof(figfile)) { dia_context_add_message_with_errno(ctx, errno, _("Error reading Fig file.")); } else { dia_context_add_message(ctx, _("Premature end of Fig file")); } fclose(figfile); return FALSE; } if (!fig_read_meta_data(figfile, dia, ctx)) { fclose(figfile); return FALSE; } compound_stack = NULL; do { if (!skip_comments(figfile)) { if (!feof(figfile)) { dia_context_add_message_with_errno(ctx, errno, _("Error reading Fig file.")); } else { break; } } if (! fig_read_object(figfile, ctx)) { fclose(figfile); break; } } while (TRUE); /* Now we can reorder for the depth fields */ for (i = 0; i < FIG_MAX_DEPTHS; i++) { if (depths[i] != NULL) layer_add_objects_first(dia->active_layer, depths[i]); } return TRUE; }
static DiaObject * image_load(ObjectNode obj_node, int version, DiaContext *ctx) { Image *image; Element *elem; DiaObject *obj; int i; AttributeNode attr; char *diafile_dir; image = g_malloc0(sizeof(Image)); elem = &image->element; obj = &elem->object; obj->type = &image_type; obj->ops = &image_ops; element_load(elem, obj_node, ctx); image->border_width = 0.1; attr = object_find_attribute(obj_node, "border_width"); if (attr != NULL) image->border_width = data_real(attribute_first_data(attr), ctx); image->border_color = color_black; attr = object_find_attribute(obj_node, "border_color"); if (attr != NULL) data_color(attribute_first_data(attr), &image->border_color, ctx); image->line_style = LINESTYLE_SOLID; attr = object_find_attribute(obj_node, "line_style"); if (attr != NULL) image->line_style = data_enum(attribute_first_data(attr), ctx); image->dashlength = DEFAULT_LINESTYLE_DASHLEN; attr = object_find_attribute(obj_node, "dashlength"); if (attr != NULL) image->dashlength = data_real(attribute_first_data(attr), ctx); image->draw_border = TRUE; attr = object_find_attribute(obj_node, "draw_border"); if (attr != NULL) image->draw_border = data_boolean(attribute_first_data(attr), ctx); image->keep_aspect = TRUE; attr = object_find_attribute(obj_node, "keep_aspect"); if (attr != NULL) image->keep_aspect = data_boolean(attribute_first_data(attr), ctx); attr = object_find_attribute(obj_node, "file"); if (attr != NULL) { image->file = data_filename(attribute_first_data(attr), ctx); } else { image->file = g_strdup(""); } element_init(elem, 8, NUM_CONNECTIONS); for (i=0;i<NUM_CONNECTIONS;i++) { obj->connections[i] = &image->connections[i]; image->connections[i].object = obj; image->connections[i].connected = NULL; } image->connections[8].flags = CP_FLAGS_MAIN; image->image = NULL; if (strcmp(image->file, "")!=0) { diafile_dir = get_directory(dia_context_get_filename(ctx)); if (g_path_is_absolute(image->file)) { /* Absolute pathname */ image->image = dia_image_load(image->file); if (image->image == NULL) { /* Not found as abs path, try in same dir as diagram. */ char *temp_string; const char *image_file_name = image->file; const char *psep; psep = strrchr(image->file, G_DIR_SEPARATOR); /* try the other G_OS as well */ if (!psep) psep = strrchr(image->file, G_DIR_SEPARATOR == '/' ? '\\' : '/'); if (psep) image_file_name = psep + 1; temp_string = g_build_filename(diafile_dir, image_file_name, NULL); image->image = dia_image_load(temp_string); if (image->image != NULL) { /* Found file in same dir as diagram. */ message_warning(_("The image file '%s' was not found in the specified directory.\n" "Using the file '%s' instead.\n"), image->file, temp_string); g_free(image->file); image->file = temp_string; } else { g_free(temp_string); image->image = dia_image_load((char *)image_file_name); if (image->image != NULL) { char *tmp; /* Found file in current dir. */ message_warning(_("The image file '%s' was not found in the specified directory.\n" "Using the file '%s' instead.\n"), image->file, image_file_name); tmp = image->file; image->file = g_strdup(image_file_name); g_free(tmp); } else { message_warning(_("The image file '%s' was not found.\n"), image_file_name); } } } } else { /* Relative pathname: */ char *temp_string; temp_string = g_build_filename (diafile_dir, image->file, NULL); image->image = dia_image_load(temp_string); if (image->image != NULL) { /* Found file in same dir as diagram. */ g_free(image->file); image->file = temp_string; } else { g_free(temp_string); image->image = dia_image_load(image->file); if (image->image == NULL) { /* Didn't find file in current dir. */ message_warning(_("The image file '%s' was not found.\n"), image->file); } } } g_free(diafile_dir); } /* if we don't have an image yet try to recover it from inlined data */ if (!image->image) { attr = object_find_attribute(obj_node, "pixbuf"); if (attr != NULL) { GdkPixbuf *pixbuf = data_pixbuf (attribute_first_data(attr)); if (pixbuf) { image->image = dia_image_new_from_pixbuf (pixbuf); image->inline_data = TRUE; /* avoid loosing it */ /* FIXME: should we reset the filename? */ g_object_unref (pixbuf); } } } /* update mtime */ { struct stat st; if (g_stat (image->file, &st) != 0) st.st_mtime = 0; image->mtime = st.st_mtime; } image_update_data(image); return &image->element.object; }
/*! * \brief Fallback implementation for not well-formed diagram files * * If all files produced by dia were good XML files, we wouldn't have to do * this little gymnastic. Alas, during the libxml1 days, we were outputting * files with no encoding specification (which means UTF-8 if we're in an * asciish encoding) and strings encoded in local charset (so, we wrote * broken files). * * The following logic finds if we have a broken file, and attempts to fix * it if it's possible. If the file is correct or is unrecognisable, we pass * it untouched to libxml2. * @param filename The name of the file to check. * @param default_enc The default encoding to use if none is given. * @param ctx The context in which this function is called * @return The filename given if it seems ok, or the name of a new file * with fixed contents, or NULL if we couldn't read the file. The * caller should free this string and unlink the file if it is not * the same as `filename'. * @bug The many gzclose-g_free-return sequences should be refactored into * an "exception handle" (goto+label). At least for people who think goto is * better than this. I dont. --hb * \ingroup DiagramXmlIo */ static const gchar * xml_file_check_encoding(const gchar *filename, const gchar *default_enc, DiaContext *ctx) { int fd = g_open (filename, O_RDONLY, 0); /* If the next call exits the program (without any message) check if * you are loading an incompatible version of zlib*.dll, e.g. one * built against a newer version of msvcrt*.dll */ gzFile zf = gzdopen(fd,"rb"); gchar *buf; gchar *p,*pmax; int len; gchar *tmp,*res; int uf; gboolean well_formed_utf8; int write_ok; static char magic_xml[] = {0x3c,0x3f,0x78,0x6d,0x6c,0x00}; /* "<?xml" in ASCII */ if (!zf) { dia_log_message("%s can not be opened for encoding check (%s)", filename, fd > 0 ? "gzdopen" : "g_open"); /* XXX perhaps we can just chicken out to libxml ? -- CC */ return filename; } p = buf = g_malloc0(BUFLEN); len = gzread(zf,buf,BUFLEN); pmax = p + len; /* first, we expect the magic <?xml string */ if ((0 != strncmp(p,magic_xml,5)) || (len < 5)) { gzclose(zf); g_free(buf); return filename; /* let libxml figure out what this is. */ } /* now, we're sure we have some asciish XML file. */ p += 5; while (((*p == 0x20)||(*p == 0x09)||(*p == 0x0d)||(*p == 0x0a)) && (p<pmax)) p++; if (p>=pmax) { /* whoops ? */ gzclose(zf); g_free(buf); return filename; } if (0 != strncmp(p,"version=\"",9)) { gzclose(zf); /* chicken out. */ g_free(buf); return filename; } p += 9; /* The header is rather well formed. */ if (p>=pmax) { /* whoops ? */ gzclose(zf); g_free(buf); return filename; } while ((*p != '"') && (p < pmax)) p++; p++; while (((*p == 0x20)||(*p == 0x09)||(*p == 0x0d)||(*p == 0x0a)) && (p<pmax)) p++; if (p>=pmax) { /* whoops ? */ gzclose(zf); g_free(buf); return filename; } if (0 == strncmp(p,"encoding=\"",10)) { gzclose(zf); /* this file has an encoding string. Good. */ g_free(buf); return filename; } /* now let's read the whole file, to see if there are offending bits. * We can call it well formed UTF-8 if the highest isn't used */ well_formed_utf8 = TRUE; do { int i; for (i = 0; i < len; i++) if (buf[i] & 0x80 || buf[i] == '&') well_formed_utf8 = FALSE; len = gzread(zf,buf,BUFLEN); } while (len > 0 && well_formed_utf8); if (well_formed_utf8) { gzclose(zf); /* this file is utf-8 compatible */ g_free(buf); return filename; } else { gzclose(zf); /* poor man's fseek */ fd = g_open (filename, O_RDONLY, 0); zf = gzdopen(fd,"rb"); len = gzread(zf,buf,BUFLEN); } if (0 != strcmp(default_enc,"UTF-8")) { dia_context_add_message (ctx, _("The file %s has no encoding specification;\n" "assuming it is encoded in %s"), dia_context_get_filename(ctx), default_enc); } else { gzclose(zf); /* we apply the standard here. */ g_free(buf); return filename; } tmp = getenv("TMP"); if (!tmp) tmp = getenv("TEMP"); if (!tmp) tmp = "/tmp"; res = g_strconcat(tmp,G_DIR_SEPARATOR_S,"dia-xml-fix-encodingXXXXXX",NULL); uf = g_mkstemp(res); write_ok = (uf > 0); write_ok = write_ok && (write(uf,buf,p-buf) > 0); write_ok = write_ok && (write(uf," encoding=\"",11) > 0); write_ok = write_ok && (write(uf,default_enc,strlen(default_enc)) > 0); write_ok = write_ok && (write(uf,"\" ",2) > 0); write_ok = write_ok && (write(uf,p,pmax - p) > 0); while (write_ok) { len = gzread(zf,buf,BUFLEN); if (len <= 0) break; write_ok = write_ok && (write(uf,buf,len) > 0); } gzclose(zf); if (uf > 0) close(uf); g_free(buf); if (!write_ok) { g_free(res); res = NULL; } return res; /* caller frees the name and unlinks the file. */ }
static gboolean export_dxf(DiagramData *data, DiaContext *ctx, const gchar *filename, const gchar *diafilename, void* user_data) { DxfRenderer *renderer; FILE *file; int i; Layer *layer; gchar buf[G_ASCII_DTOSTR_BUF_SIZE]; gchar buf2[G_ASCII_DTOSTR_BUF_SIZE]; file = g_fopen(filename, "w"); if (file == NULL) { dia_context_add_message_with_errno (ctx, errno, _("Can't open output file %s"), dia_context_get_filename(ctx)); return FALSE; } renderer = g_object_new(DXF_TYPE_RENDERER, NULL); renderer->file = file; /* drawing limits */ fprintf(file, " 0\nSECTION\n 2\nHEADER\n"); fprintf(file, " 9\n$EXTMIN\n 10\n%s\n 20\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", data->extents.left), g_ascii_formatd (buf2, sizeof(buf2), "%g", -data->extents.bottom)); fprintf(file, " 9\n$EXTMAX\n 10\n%s\n 20\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", data->extents.right), g_ascii_formatd (buf2, sizeof(buf2), "%g", -data->extents.top)); fprintf(file, " 0\nENDSEC\n"); /* write layer description */ fprintf(file," 0\nSECTION\n 2\nTABLES\n 0\nTABLE\n"); /* some dummy entry to make it work for more DXF viewers */ fprintf(file," 2\nLAYER\n 70\n255\n"); for (i=0; i<data->layers->len; i++) { layer = (Layer *) g_ptr_array_index(data->layers, i); fprintf(file," 0\nLAYER\n 2\n%s\n",layer->name); if(layer->visible) fprintf(file," 62\n%d\n",i+1); else fprintf(file," 62\n%d\n",(-1)*(i+1)); } fprintf(file, " 0\nENDTAB\n 0\nENDSEC\n"); /* write graphics */ fprintf(file," 0\nSECTION\n 2\nENTITIES\n"); init_attributes(renderer); DIA_RENDERER_GET_CLASS(renderer)->begin_render(DIA_RENDERER(renderer), NULL); for (i=0; i<data->layers->len; i++) { layer = (Layer *) g_ptr_array_index(data->layers, i); renderer->layername = layer->name; layer_render(layer, DIA_RENDERER(renderer), NULL, NULL, data, 0); } DIA_RENDERER_GET_CLASS(renderer)->end_render(DIA_RENDERER(renderer)); g_object_unref(renderer); return TRUE; }
/* imports the given dxf-file, returns TRUE if successful */ static gboolean import_dxf(const gchar *filename, DiagramData *dia, DiaContext *ctx, void* user_data) { FILE *filedxf; DxfData *data; filedxf = g_fopen(filename,"r"); if(filedxf == NULL){ dia_context_add_message(ctx, _("Couldn't open: '%s' for reading.\n"), dia_context_get_filename (ctx)); return FALSE; } data = g_new(DxfData, 1); do { if(read_dxf_codes(filedxf, data) == FALSE) { g_free(data); dia_context_add_message(ctx, _("read_dxf_codes failed on '%s'"), dia_context_get_filename(ctx) ); return FALSE; } else { if (0 == data->code && strstr(data->codeline, "AutoCAD Binary DXF")) { g_free(data); dia_context_add_message(ctx, _("Binary DXF from '%s' not supported"), dia_context_get_filename(ctx)); return FALSE; } if (0 == data->code) { if(strcmp(data->value, "SECTION") == 0) { /* don't think we need to do anything */ } else if(strcmp(data->value, "ENDSEC") == 0) { /* don't think we need to do anything */ } else if(strcmp(data->value, "EOF") == 0) { /* handled below */ } else { g_print ("DXF 0:%s not handled\n", data->value); } } else if(data->code == 2) { if(strcmp(data->value, "ENTITIES") == 0) { /*printf( "reading section entities\n" );*/ read_section_entities_dxf(filedxf, data, dia); } else if(strcmp(data->value, "BLOCKS") == 0) { /*printf( "reading section BLOCKS\n" );*/ read_section_blocks_dxf(filedxf, data, dia); } else if(strcmp(data->value, "CLASSES") == 0) { /*printf( "reading section CLASSES\n" );*/ read_section_classes_dxf(filedxf, data, dia); } else if(strcmp(data->value, "HEADER") == 0) { /*printf( "reading section HEADER\n" );*/ read_section_header_dxf(filedxf, data, dia); } else if(strcmp(data->value, "TABLES") == 0) { /*printf( "reading section tables\n" );*/ read_section_tables_dxf(filedxf, data, dia); } else if(strcmp(data->value, "OBJECTS") == 0) { /*printf( "reading section objects\n" );*/ read_section_entities_dxf(filedxf, data, dia); } } else if(data->code == 999) { /* Don't complain on comments, but silently ignore */ } else g_warning("Unknown dxf code %d", data->code); } }while((data->code != 0) || (strcmp(data->value, "EOF") != 0)); g_free(data); if (_color_by_layer_ht) { g_hash_table_destroy (_color_by_layer_ht); _color_by_layer_ht = NULL; } return TRUE; }