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;
}
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 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;
}
static void
export_svg(DiagramData *data, const gchar *filename,
const gchar *diafilename, void* user_data)
{
DiaSvgRenderer *renderer;
if ((renderer = new_svg_renderer(data, filename))) {
data_render(data, DIA_RENDERER(renderer), NULL, NULL, NULL);
g_object_unref(renderer);
}
}
/* 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;
}
/*!
* \brief Calls data_render() for paginated formats
*
* Call data_render() for every used page in the diagram
*
* \memberof _DiagramData
*/
void
data_render_paginated (DiagramData *data, DiaRenderer *renderer, gpointer user_data)
{
Rectangle *extents;
gdouble width, height;
gdouble x, y, initx, inity;
gint xpos, ypos;
guint nobjs = 0;
/* the usable area of the page */
width = data->paper.width;
height = data->paper.height;
/* get extents, and make them multiples of width / height */
extents = &data->extents;
initx = extents->left;
inity = extents->top;
/* make page boundaries align with origin */
if (!data->paper.fitto) {
initx = floor(initx / width) * width;
inity = floor(inity / height) * height;
}
/* iterate through all the pages in the diagram */
for (y = inity, ypos = 0; y < extents->bottom; y += height, ypos++) {
/* ensure we are not producing pages for epsilon */
if ((extents->bottom - y) < 1e-6)
break;
for (x = initx, xpos = 0; x < extents->right; x += width, xpos++) {
Rectangle page_bounds;
if ((extents->right - x) < 1e-6)
break;
page_bounds.left = x;
page_bounds.right = x + width;
page_bounds.top = y;
page_bounds.bottom = y + height;
data_render (data, renderer, &page_bounds, NULL, user_data);
}
}
}
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;
}
static void
draw_page (GtkPrintOperation *operation,
GtkPrintContext *context,
int page_nr,
PrintData *print_data)
{
Rectangle bounds;
DiagramData *data = print_data->data;
int x, y;
/* the effective sizes - dia already applied is_portrait */
double dp_width = data->paper.width;
double dp_height = data->paper.height;
DiaCairoRenderer *cairo_renderer;
g_return_if_fail (print_data->renderer != NULL);
cairo_renderer = DIA_CAIRO_RENDERER (print_data->renderer);
if (data->paper.fitto) {
x = page_nr % data->paper.fitwidth;
y = page_nr / data->paper.fitwidth;
bounds.left = dp_width * x + data->extents.left;
bounds.top = dp_height * y + data->extents.top;
bounds.right = bounds.left + dp_width;
bounds.bottom = bounds.top + dp_height;
} else {
double dx, dy;
int nx = ceil((data->extents.right - data->extents.left) / dp_width);
x = page_nr % nx;
y = page_nr / nx;
/* Respect the original pagination as shown by the page guides.
* Caclulate the offset between page origin 0,0 and data.extents.topleft.
* For the usual first page this boils down to lefttop=(0,0) but beware
* the origin being negative.
*/
dx = fmod(data->extents.left, dp_width);
if (dx < 0.0)
dx += dp_width;
dy = fmod(data->extents.top, dp_height);
if (dy < 0.0)
dy += dp_height;
bounds.left = dp_width * x + data->extents.left - dx;
bounds.top = dp_height * y + data->extents.top - dy;
bounds.right = bounds.left + dp_width;
bounds.bottom = bounds.top + dp_height;
}
#if 0 /* calls begin/end of the given renderer */
/* count the number of objects in this region */
data_render(data, print_data->renderer, &bounds,
(ObjectRenderer) count_objs, &nobjs);
if (!nobjs)
return; /* not printing empty pages */
#endif
/* setup a clipping rect */
{
GtkPageSetup *setup = gtk_print_context_get_page_setup (context);
double left = gtk_page_setup_get_left_margin (setup, GTK_UNIT_MM);
double top = gtk_page_setup_get_top_margin (setup, GTK_UNIT_MM);
double width = gtk_page_setup_get_paper_width (setup, GTK_UNIT_MM)
- left - gtk_page_setup_get_right_margin (setup, GTK_UNIT_MM);
double height = gtk_page_setup_get_paper_height (setup, GTK_UNIT_MM)
- top - gtk_page_setup_get_bottom_margin (setup, GTK_UNIT_MM);
cairo_save (cairo_renderer->cr);
/* we are still in the gtk-print coordinate system */
#if 1
/* ... but apparently already transalted to top,left */
top = left = 0;
#endif
cairo_rectangle (cairo_renderer->cr, left, top, width, height);
cairo_clip (cairo_renderer->cr);
}
{
Rectangle extents = data->extents;
data->extents = bounds;
/* render only the region, FIXME: better way than modifying DiagramData ? */
data_render(data, print_data->renderer, &bounds, NULL, NULL);
data->extents = extents;
}
cairo_restore (cairo_renderer->cr);
}
void
ddisplay_render_pixmap(DDisplay *ddisp, Rectangle *update)
{
GList *list;
DiaObject *obj;
int i;
DiaInteractiveRendererInterface *renderer;
#ifdef TRACES
GTimer *timer;
#endif
if (ddisp->renderer==NULL) {
printf("ERROR! Renderer was NULL!!\n");
return;
}
renderer = DIA_GET_INTERACTIVE_RENDERER_INTERFACE (ddisp->renderer);
/* Erase background */
g_return_if_fail (renderer->fill_pixel_rect != NULL);
DIA_RENDERER_GET_CLASS(ddisp->renderer)->begin_render(ddisp->renderer, update);
if (update) {
int x0, y0, x1, y1;
ddisplay_transform_coords (ddisp, update->left, update->top, &x0, &y0);
ddisplay_transform_coords (ddisp, update->right, update->bottom, &x1, &y1);
renderer->fill_pixel_rect (ddisp->renderer,
x0, y0, x1-x0, y1-y0,
&ddisp->diagram->data->bg_color);
} else
renderer->fill_pixel_rect (ddisp->renderer,
0, 0,
dia_renderer_get_width_pixels (ddisp->renderer),
dia_renderer_get_height_pixels (ddisp->renderer),
&ddisp->diagram->data->bg_color);
/* Draw grid */
grid_draw(ddisp, update);
pagebreak_draw(ddisp, update);
#ifdef TRACES
timer = g_timer_new();
#endif
data_render(ddisp->diagram->data, ddisp->renderer, update,
ddisplay_obj_render, (gpointer) ddisp);
#ifdef TRACES
g_print ("data_render(%g%%) took %g seconds\n", ddisp->zoom_factor * 5.0, g_timer_elapsed (timer, NULL));
g_timer_destroy (timer);
#endif
/* Draw handles for all selected objects */
list = ddisp->diagram->data->selected;
while (list!=NULL) {
obj = (DiaObject *) list->data;
for (i=0;i<obj->num_handles;i++) {
handle_draw(obj->handles[i], ddisp);
}
list = g_list_next(list);
}
DIA_RENDERER_GET_CLASS(ddisp->renderer)->end_render(ddisp->renderer);
}