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;
}
