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; }
/** 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; }
/** * A button hit in the Export Dialog */ static void file_export_response_callback(GtkWidget *fs, gint response, gpointer user_data) { char *filename; Diagram *dia; DiaExportFilter *ef; struct stat statbuf; dia = g_object_get_data (G_OBJECT (fs), "user_data"); g_assert (dia); if (response == GTK_RESPONSE_ACCEPT) { gint index; diagram_update_extents(dia); filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fs)); if (g_stat(filename, &statbuf) == 0) { GtkWidget *dialog = NULL; dialog = gtk_message_dialog_new (GTK_WINDOW(fs), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, _("File already exists")); gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog), _("The file '%s' already exists.\n" "Do you want to overwrite it?"), dia_message_filename(filename)); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES); if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_YES) { /* if not overwrite allow to select another filename */ gtk_widget_destroy(dialog); g_free (filename); return; } gtk_widget_destroy(dialog); } index = gtk_combo_box_get_active (GTK_COMBO_BOX(user_data)); if (index >= 0) persistence_set_integer ("export-filter", index); ef = efilter_by_index (index - 1, NULL); if (!ef) ef = filter_guess_export_filter(filename); if (ef) { DiaContext *ctx = dia_context_new (_("Export")); g_object_ref(dia->data); dia_context_set_filename (ctx, filename); ef->export_func(dia->data, ctx, filename, dia->filename, ef->user_data); g_object_unref(dia->data); dia_context_release (ctx); } else message_error(_("Could not determine which export filter\n" "to use to save '%s'"), dia_message_filename(filename)); g_free (filename); } g_object_unref (dia); /* drop our diagram reference */ gtk_widget_destroy(exportdlg); }