static void _dae_draw(DiagramAsElement *dae, DiaRenderer *renderer) { DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer); Element *elem = &dae->element; if (!dae->data) { /* just draw the box */ Point lower_right = { elem->corner.x + elem->width, elem->corner.y + elem->height }; renderer_ops->draw_rect(renderer,&elem->corner, &lower_right, &dae->border_color); } else { if (FALSE) { /* if the renderer supports transformations ... */ /* temporary messing with it (not enough) */ dae->data->paper.scaling *= dae->scale; data_render (dae->data, DIA_RENDERER (renderer), NULL, NULL, NULL); dae->data->paper.scaling /= dae->scale; } else { /* we have to render to an image and draw that */ if (!dae->image) { /* lazy creation */ gchar *imgfname = NULL; gint fd = g_file_open_tmp ("diagram-as-elementXXXXXX.png", &imgfname, NULL); if (fd != -1) { DiaExportFilter *ef = filter_export_get_by_name ("cairo-alpha-png"); if (!ef) /* prefer cairo with alpha, but don't require it */ ef = filter_guess_export_filter (imgfname); close(fd); if (ef) { DiaContext *ctx = dia_context_new ("Diagram as Object"); dia_context_set_filename (ctx, imgfname); if (ef->export_func (dae->data, ctx, imgfname, dae->filename, ef->user_data)) { DiaImage *tmp_image = dia_image_load (imgfname); /* some extra gymnastics to create an image w/o filename */ if (tmp_image) { dae->image = dia_image_new_from_pixbuf ((GdkPixbuf *)dia_image_pixbuf (tmp_image)); g_object_unref (tmp_image); } /* FIXME: where to put the message in case of an error? */ dia_context_release (ctx); } } /* found a filter */ g_unlink (imgfname); g_free (imgfname); } /* temporary file created*/ } /* only if we have no image yet */ if (dae->image) renderer_ops->draw_image (renderer, &elem->corner, elem->width, elem->height, dae->image); } } }
static gboolean export_shape(DiagramData *data, DiaContext *ctx, const gchar *filename, const gchar *diafilename, void* user_data) { DiaSvgRenderer *renderer; int i; gchar *point; gchar *png_filename = NULL; DiaExportFilter *exportfilter; gfloat old_scaling; Rectangle *ext = &data->extents; gfloat scaling_x, scaling_y; /* create the png preview shown in the toolbox */ point = strrchr(filename, '.'); if (point == NULL || strcmp(point, ".shape") != 0) { dia_context_add_message(ctx, _("Shape files must end in .shape, or they cannot be loaded by Dia")); return FALSE; } i = (int)(point-filename); point = g_strndup(filename, i); png_filename = g_strdup_printf("%s.png",point); g_free(point); /* we are especially requesting the libart/png cause it is the only one with the size-hack */ exportfilter = filter_export_get_by_name ("png-libart"); /* ... but the code below does not use the size-hack anymore ... */ if (!exportfilter) exportfilter = filter_guess_export_filter(png_filename); if (!exportfilter) { dia_context_add_message(ctx, _("Can't export PNG icon without export plugin!")); } else { /* get the scaling right */ old_scaling = data->paper.scaling; scaling_x = 22/((ext->right - ext->left) * 20); scaling_y = 22/((ext->bottom - ext->top) * 20); data->paper.scaling = MIN(scaling_x, scaling_y); exportfilter->export_func(data, ctx, png_filename, diafilename, exportfilter->user_data); data->paper.scaling = old_scaling; } g_free(png_filename); /* create the shape */ if((renderer = new_shape_renderer(data, filename))) { data_render(data, DIA_RENDERER(renderer), NULL, NULL, NULL); g_object_unref (renderer); return TRUE; } /* Create a sheet entry if applicable (../../sheets exists) */ return FALSE; }
/* Guess the filter for a given filename. * Returns the first filter found that matches the extension on the filename, * or NULL if none such are found. * If there are multiple filters registered for the same extension some are * excluded from being returned here by the hint FILTER_DONT_GUESS. */ DiaExportFilter * filter_guess_export_filter(const gchar *filename) { GList *tmp; gchar *ext; gint no_guess = 0; DiaExportFilter *dont_guess = NULL; const gchar *unique_name; ext = strrchr(filename, '.'); if (ext) ext++; else ext = ""; /* maybe ther is no need to guess? */ unique_name = _favored_hash ? g_hash_table_lookup(_favored_hash, ext) : NULL; if (unique_name) { DiaExportFilter *ef = filter_export_get_by_name(unique_name); if (ef) return ef; } for (tmp = export_filters; tmp != NULL; tmp = tmp->next) { DiaExportFilter *ef = tmp->data; gint i; for (i = 0; ef->extensions[i] != NULL; i++) { if (!g_ascii_strcasecmp(ef->extensions[i], ext)) { if (ef->hints & FILTER_DONT_GUESS) { dont_guess = ef; ++no_guess; continue; } return ef; } } } return (no_guess == 1) ? dont_guess : NULL; }
/** Handle loading of diagrams given on command line, including conversions. * Returns TRUE if any automatic conversions were performed. * Note to future hackers: 'size' is currently the only argument that can be * sent to exporters. If more arguments are desired, please don't just add * even more arguments, but create a more general system. */ static gboolean handle_initial_diagram(const char *in_file_name, const char *out_file_name, const char *export_file_format, const char *size, char* show_layers, const char *outdir) { Diagram *diagram = NULL; gboolean made_conversions = FALSE; if (export_file_format) { char *export_file_name = NULL; DiaExportFilter *ef = NULL; /* First try guessing based on extension */ export_file_name = build_output_file_name(in_file_name, export_file_format, outdir); /* to make the --size hack even uglier but work again for the only filter supporting it */ if ( size && strcmp(export_file_format, "png") == 0) ef = filter_export_get_by_name ("png-libart"); if (!ef) ef = filter_guess_export_filter(export_file_name); if (ef == NULL) { ef = filter_export_get_by_name(export_file_format); if (ef == NULL) { g_critical(_("Can't find output format/filter %s\n"), export_file_format); return FALSE; } g_free (export_file_name); export_file_name = build_output_file_name(in_file_name, ef->extensions[0], outdir); } made_conversions |= do_convert(in_file_name, (out_file_name != NULL?out_file_name:export_file_name), ef, size, show_layers); g_free(export_file_name); } else if (out_file_name) { DiaExportFilter *ef = NULL; /* if this looks like an ugly hack to you, agreed ;) */ if (size && strstr(out_file_name, ".png")) ef = filter_export_get_by_name ("png-libart"); made_conversions |= do_convert(in_file_name, out_file_name, ef, size, show_layers); } else { if (g_file_test(in_file_name, G_FILE_TEST_EXISTS)) { diagram = diagram_load (in_file_name, NULL); } else { diagram = new_diagram (in_file_name); } if (diagram != NULL) { diagram_update_extents(diagram); if (app_is_interactive()) { layer_dialog_set_diagram(diagram); /* the display initial diagram holds two references */ new_display(diagram); } else { g_object_unref(diagram); } } } return made_conversions; }
/** Convert infname to outfname, using input filter inf and export filter * ef. If either is null, try to guess them. * size might be NULL. */ static gboolean do_convert(const char *infname, const char *outfname, DiaExportFilter *ef, const char *size, char *show_layers) { DiaImportFilter *inf; DiagramData *diagdata = NULL; DiaContext *ctx; inf = filter_guess_import_filter(infname); if (!inf) inf = &dia_import_filter; if (ef == NULL) { ef = filter_guess_export_filter(outfname); if (!ef) { g_critical(_("%s error: don't know how to export into %s\n"), argv0,outfname); exit(1); } } dia_is_interactive = FALSE; if (0==strcmp(infname,outfname)) { g_critical(_("%s error: input and output filenames are identical: %s"), argv0, infname); exit(1); } diagdata = g_object_new (DIA_TYPE_DIAGRAM_DATA, NULL); ctx = dia_context_new(_("Import")); if (!inf->import_func(infname, diagdata, ctx, inf->user_data)) { g_critical(_("%s error: need valid input file %s\n"), argv0, infname); exit(1); } /* Apply --show-layers */ if (show_layers) handle_show_layers(diagdata, show_layers); /* recalculate before export */ data_update_extents(diagdata); /* Do our best in providing the size to the filter, but don't abuse user_data * too much for it. It _must not_ be changed after initialization and there * are quite some filter selecting their output format by it. --hb */ if (size) { if (ef == filter_export_get_by_name ("png-libart")) /* the warning we get is appropriate, don't cast */ ef->export_func(diagdata, ctx, outfname, infname, size); else { g_warning ("--size parameter unsupported for %s filter", ef->unique_name ? ef->unique_name : "selected"); ef->export_func(diagdata, ctx, outfname, infname, ef->user_data); } } else ef->export_func(diagdata, ctx, outfname, infname, ef->user_data); /* if (!quiet) */ fprintf(stdout, _("%s --> %s\n"), infname,outfname); g_object_unref(diagdata); dia_context_release(ctx); return TRUE; }