2002-10-08 02:45:37 +00:00
|
|
|
/* The GIMP -- an image manipulation program
|
|
|
|
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
|
2003-03-24 16:09:12 +00:00
|
|
|
/* SVG loading file filter for the GIMP
|
2003-09-20 00:49:39 +00:00
|
|
|
* (C) Copyright 2003 Dom Lachowicz <cinamod@hotmail.com>
|
2003-03-18 16:21:30 +00:00
|
|
|
*
|
2003-09-20 00:49:39 +00:00
|
|
|
* Largely rewritten by Sven Neumann <sven@gimp.org>
|
2002-10-08 02:45:37 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
2003-09-20 00:49:39 +00:00
|
|
|
#include <stdlib.h>
|
2002-10-08 02:45:37 +00:00
|
|
|
#include <string.h>
|
2003-09-18 01:42:04 +00:00
|
|
|
|
|
|
|
#include <librsvg/rsvg.h>
|
2002-10-08 02:45:37 +00:00
|
|
|
|
2003-03-24 16:09:12 +00:00
|
|
|
#include <gtk/gtk.h>
|
2003-09-18 01:42:04 +00:00
|
|
|
|
2003-09-20 00:49:39 +00:00
|
|
|
#include "libgimp/gimp.h"
|
|
|
|
#include "libgimp/gimpui.h"
|
2003-03-24 16:09:12 +00:00
|
|
|
|
2003-09-18 01:42:04 +00:00
|
|
|
#include "libgimp/stdplugins-intl.h"
|
|
|
|
|
|
|
|
|
2003-09-20 00:49:39 +00:00
|
|
|
#define SVG_VERSION "2.5.0"
|
|
|
|
#define SVG_BUFFER_SIZE (8 * 1024)
|
|
|
|
|
2003-09-18 01:42:04 +00:00
|
|
|
|
2003-03-24 16:09:12 +00:00
|
|
|
typedef struct
|
|
|
|
{
|
2003-09-20 00:49:39 +00:00
|
|
|
gdouble resolution;
|
|
|
|
gint width;
|
|
|
|
gint height;
|
2003-03-24 16:09:12 +00:00
|
|
|
} SvgLoadVals;
|
|
|
|
|
|
|
|
static SvgLoadVals load_vals =
|
|
|
|
{
|
2003-09-20 00:49:39 +00:00
|
|
|
72.0, /* resolution */
|
2003-09-21 15:24:36 +00:00
|
|
|
0, /* width */
|
|
|
|
0 /* height */
|
2003-03-24 16:09:12 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
2003-09-20 00:49:39 +00:00
|
|
|
gboolean run;
|
2003-03-24 16:09:12 +00:00
|
|
|
} SvgLoadInterface;
|
|
|
|
|
|
|
|
static SvgLoadInterface load_interface =
|
|
|
|
{
|
2003-09-21 15:24:36 +00:00
|
|
|
FALSE /* run */
|
2003-03-24 16:09:12 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2003-09-20 00:49:39 +00:00
|
|
|
static void query (void);
|
|
|
|
static void run (const gchar *name,
|
|
|
|
gint nparams,
|
|
|
|
const GimpParam *param,
|
|
|
|
gint *nreturn_vals,
|
|
|
|
GimpParam **return_vals);
|
|
|
|
|
|
|
|
static gint32 load_image (const gchar *filename);
|
|
|
|
static GdkPixbuf * load_rsvg_pixbuf (const gchar *filename,
|
|
|
|
SvgLoadVals *vals,
|
|
|
|
GError **error);
|
|
|
|
static gboolean load_dialog (const gchar *filename);
|
2003-03-24 16:09:12 +00:00
|
|
|
|
|
|
|
|
2003-09-18 13:47:23 +00:00
|
|
|
GimpPlugInInfo PLUG_IN_INFO =
|
2003-03-24 16:09:12 +00:00
|
|
|
{
|
2003-09-21 15:24:36 +00:00
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
query,
|
|
|
|
run,
|
2003-09-18 13:47:23 +00:00
|
|
|
};
|
2003-03-24 16:09:12 +00:00
|
|
|
|
2003-09-18 13:47:23 +00:00
|
|
|
MAIN ()
|
2003-03-24 16:09:12 +00:00
|
|
|
|
|
|
|
|
2002-10-08 02:45:37 +00:00
|
|
|
static void
|
|
|
|
query (void)
|
|
|
|
{
|
|
|
|
static GimpParamDef load_args[] =
|
|
|
|
{
|
2003-09-20 00:49:39 +00:00
|
|
|
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
|
|
|
|
{ GIMP_PDB_STRING, "filename", "The name of the file to load" },
|
|
|
|
{ GIMP_PDB_STRING, "raw_filename", "The name of the file to load" },
|
|
|
|
{ GIMP_PDB_FLOAT, "resolution",
|
|
|
|
"Resolution to use for rendering the SVG (defaults to 72 dpi" },
|
2003-09-21 15:24:36 +00:00
|
|
|
{ GIMP_PDB_INT32, "width",
|
2003-09-20 00:49:39 +00:00
|
|
|
"Width (in pixels) to load the SVG in."
|
|
|
|
"(0 for original width, a negative width to specify a maximum width)" },
|
2003-09-21 15:24:36 +00:00
|
|
|
{ GIMP_PDB_INT32, "height",
|
2003-09-20 00:49:39 +00:00
|
|
|
"Height (in pixels) to load the SVG in."
|
|
|
|
"(0 for original height, a negative width to specify a maximum height)"}
|
2002-10-08 02:45:37 +00:00
|
|
|
};
|
|
|
|
static GimpParamDef load_return_vals[] =
|
|
|
|
{
|
2003-09-20 00:49:39 +00:00
|
|
|
{ GIMP_PDB_IMAGE, "image", "Output image" }
|
2003-03-24 16:09:12 +00:00
|
|
|
};
|
|
|
|
|
2002-10-08 02:45:37 +00:00
|
|
|
gimp_install_procedure ("file_svg_load",
|
2003-03-18 00:26:49 +00:00
|
|
|
"Loads files in the SVG file format",
|
2003-09-20 00:49:39 +00:00
|
|
|
"Renders SVG files to raster graphics using librsvg.",
|
|
|
|
"Dom Lachowicz, Sven Neumann",
|
2003-03-18 00:26:49 +00:00
|
|
|
"Dom Lachowicz <cinamod@hotmail.com>",
|
2003-09-20 00:49:39 +00:00
|
|
|
SVG_VERSION,
|
2002-10-08 02:45:37 +00:00
|
|
|
"<Load>/SVG",
|
|
|
|
NULL,
|
|
|
|
GIMP_PLUGIN,
|
|
|
|
G_N_ELEMENTS (load_args),
|
|
|
|
G_N_ELEMENTS (load_return_vals),
|
|
|
|
load_args, load_return_vals);
|
|
|
|
|
|
|
|
gimp_register_magic_load_handler ("file_svg_load",
|
2003-03-18 00:26:49 +00:00
|
|
|
"svg", "",
|
2002-10-08 02:45:37 +00:00
|
|
|
"0,string,<?xml,0,string,<svg");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2003-08-02 13:45:47 +00:00
|
|
|
run (const gchar *name,
|
2003-08-02 13:45:47 +00:00
|
|
|
gint nparams,
|
2003-08-02 13:45:47 +00:00
|
|
|
const GimpParam *param,
|
2003-08-02 13:45:47 +00:00
|
|
|
gint *nreturn_vals,
|
|
|
|
GimpParam **return_vals)
|
2002-10-08 02:45:37 +00:00
|
|
|
{
|
2003-09-20 00:49:39 +00:00
|
|
|
static GimpParam values[2];
|
|
|
|
GimpRunMode run_mode;
|
|
|
|
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
|
|
|
|
gint32 image_ID;
|
2002-10-08 02:45:37 +00:00
|
|
|
|
|
|
|
run_mode = param[0].data.d_int32;
|
|
|
|
|
|
|
|
*nreturn_vals = 1;
|
|
|
|
*return_vals = values;
|
|
|
|
|
|
|
|
values[0].type = GIMP_PDB_STATUS;
|
|
|
|
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
|
|
|
|
|
2003-03-18 00:26:49 +00:00
|
|
|
/* MUST call this before any RSVG funcs */
|
|
|
|
g_type_init ();
|
|
|
|
|
2002-10-08 02:45:37 +00:00
|
|
|
if (strcmp (name, "file_svg_load") == 0)
|
|
|
|
{
|
2003-09-20 00:49:39 +00:00
|
|
|
gimp_get_data ("file_svg_load", &load_vals);
|
2002-10-08 02:45:37 +00:00
|
|
|
|
2003-09-21 15:24:36 +00:00
|
|
|
switch (run_mode)
|
|
|
|
{
|
|
|
|
case GIMP_RUN_NONINTERACTIVE:
|
|
|
|
if (nparams > 2) load_vals.resolution = param[3].data.d_float;
|
|
|
|
if (nparams > 3) load_vals.width = param[4].data.d_int32;
|
|
|
|
if (nparams > 4) load_vals.height = param[5].data.d_int32;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GIMP_RUN_INTERACTIVE:
|
|
|
|
gimp_get_data ("file_svg_load", &load_vals);
|
2003-03-24 16:09:12 +00:00
|
|
|
if (!load_dialog (param[1].data.d_string))
|
|
|
|
status = GIMP_PDB_CANCEL;
|
2003-09-21 15:24:36 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case GIMP_RUN_WITH_LAST_VALS:
|
|
|
|
gimp_get_data ("file_svg_load", &load_vals);
|
|
|
|
break;
|
2003-03-24 16:09:12 +00:00
|
|
|
}
|
2002-10-08 02:45:37 +00:00
|
|
|
|
2003-03-24 16:09:12 +00:00
|
|
|
if (status == GIMP_PDB_SUCCESS)
|
|
|
|
{
|
2003-09-18 13:47:23 +00:00
|
|
|
image_ID = load_image (param[1].data.d_string);
|
2003-09-20 00:49:39 +00:00
|
|
|
|
2003-03-24 16:09:12 +00:00
|
|
|
gimp_set_data ("file_svg_load", &load_vals, sizeof (load_vals));
|
2002-10-08 02:45:37 +00:00
|
|
|
|
2003-03-24 16:09:12 +00:00
|
|
|
if (image_ID != -1)
|
|
|
|
{
|
|
|
|
*nreturn_vals = 2;
|
|
|
|
values[1].type = GIMP_PDB_IMAGE;
|
|
|
|
values[1].data.d_image = image_ID;
|
|
|
|
}
|
|
|
|
else
|
2003-09-20 00:49:39 +00:00
|
|
|
{
|
|
|
|
status = GIMP_PDB_EXECUTION_ERROR;
|
|
|
|
}
|
|
|
|
}
|
2003-03-18 00:26:49 +00:00
|
|
|
}
|
2003-03-24 16:09:12 +00:00
|
|
|
else
|
2003-09-18 13:47:23 +00:00
|
|
|
{
|
|
|
|
status = GIMP_PDB_CALLING_ERROR;
|
|
|
|
}
|
2003-03-18 00:26:49 +00:00
|
|
|
|
2003-03-24 16:09:12 +00:00
|
|
|
values[0].data.d_status = status;
|
2002-10-08 02:45:37 +00:00
|
|
|
}
|
2003-09-18 13:47:23 +00:00
|
|
|
|
|
|
|
static gint32
|
|
|
|
load_image (const gchar *filename)
|
|
|
|
{
|
|
|
|
gint32 image;
|
|
|
|
gint32 layer;
|
|
|
|
GimpDrawable *drawable;
|
|
|
|
GimpPixelRgn rgn;
|
|
|
|
GdkPixbuf *pixbuf;
|
|
|
|
gchar *status;
|
|
|
|
gchar *pixels;
|
|
|
|
gint width;
|
|
|
|
gint height;
|
|
|
|
gint rowstride;
|
|
|
|
gint bpp;
|
|
|
|
gpointer pr;
|
|
|
|
GError *error = NULL;
|
|
|
|
|
2003-09-20 00:49:39 +00:00
|
|
|
pixbuf = load_rsvg_pixbuf (filename, &load_vals, &error);
|
2003-09-18 13:47:23 +00:00
|
|
|
if (!pixbuf)
|
|
|
|
{
|
2003-09-19 16:13:33 +00:00
|
|
|
/* Do not rely on librsvg setting GError on failure! */
|
2003-09-18 13:47:23 +00:00
|
|
|
g_message (_("Can't open '%s':\n"
|
2003-09-19 16:13:33 +00:00
|
|
|
"%s"),
|
|
|
|
filename, error ? error->message : "unknown reason");
|
2003-09-18 13:47:23 +00:00
|
|
|
gimp_quit ();
|
|
|
|
}
|
|
|
|
|
|
|
|
status = g_strdup_printf (_("Loading %s:"), filename);
|
|
|
|
gimp_progress_init (status);
|
|
|
|
g_free (status);
|
|
|
|
|
|
|
|
width = gdk_pixbuf_get_width (pixbuf);
|
|
|
|
height = gdk_pixbuf_get_height (pixbuf);
|
|
|
|
|
|
|
|
image = gimp_image_new (width, height, GIMP_RGB);
|
|
|
|
gimp_image_set_filename (image, filename);
|
2003-09-20 00:49:39 +00:00
|
|
|
gimp_image_set_resolution (image,
|
|
|
|
load_vals.resolution, load_vals.resolution);
|
2003-09-18 13:47:23 +00:00
|
|
|
|
|
|
|
layer = gimp_layer_new (image, _("Rendered SVG"), width, height,
|
|
|
|
GIMP_RGBA_IMAGE, 100, GIMP_NORMAL_MODE);
|
|
|
|
|
|
|
|
drawable = gimp_drawable_get (layer);
|
|
|
|
|
|
|
|
gimp_pixel_rgn_init (&rgn, drawable, 0, 0, width, height, TRUE, FALSE);
|
|
|
|
|
|
|
|
rowstride = gdk_pixbuf_get_rowstride (pixbuf);
|
|
|
|
bpp = gdk_pixbuf_get_n_channels (pixbuf);
|
|
|
|
pixels = gdk_pixbuf_get_pixels (pixbuf);
|
|
|
|
|
|
|
|
g_assert (bpp == rgn.bpp);
|
|
|
|
|
|
|
|
for (pr = gimp_pixel_rgns_register (1, &rgn);
|
|
|
|
pr != NULL;
|
|
|
|
pr = gimp_pixel_rgns_process (pr))
|
|
|
|
{
|
|
|
|
const guchar *src;
|
|
|
|
guchar *dest;
|
|
|
|
gint y;
|
|
|
|
|
|
|
|
src = pixels + rgn.y * rowstride + rgn.x * bpp;
|
|
|
|
dest = rgn.data;
|
|
|
|
|
|
|
|
for (y = 0; y < rgn.h; y++)
|
|
|
|
{
|
|
|
|
memcpy (dest, src, rgn.w * rgn.bpp);
|
|
|
|
|
|
|
|
src += rowstride;
|
|
|
|
dest += rgn.rowstride;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
gimp_drawable_detach (drawable);
|
|
|
|
g_object_unref (pixbuf);
|
|
|
|
|
|
|
|
gimp_progress_update (1.0);
|
|
|
|
|
|
|
|
gimp_image_add_layer (image, layer, 0);
|
|
|
|
|
|
|
|
return image;
|
|
|
|
}
|
|
|
|
|
2003-09-20 00:49:39 +00:00
|
|
|
static void
|
|
|
|
load_size_callback (gint *width,
|
|
|
|
gint *height,
|
|
|
|
gpointer data)
|
|
|
|
{
|
|
|
|
SvgLoadVals *vals = data;
|
2003-09-21 15:24:36 +00:00
|
|
|
gint owidth;
|
|
|
|
gint oheight;
|
2003-09-20 00:49:39 +00:00
|
|
|
|
|
|
|
g_return_if_fail (*width > 0 && *height > 0);
|
|
|
|
|
2003-09-21 15:24:36 +00:00
|
|
|
owidth = *width;
|
|
|
|
oheight = *height;
|
|
|
|
|
2003-09-20 00:49:39 +00:00
|
|
|
if (!vals->width || !vals->height)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* either both arguments negative or none */
|
|
|
|
if ((vals->width * vals->height) < 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (vals->width > 0)
|
|
|
|
{
|
|
|
|
*width = vals->width;
|
|
|
|
*height = vals->height;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
gdouble w = *width;
|
|
|
|
gdouble h = *height;
|
|
|
|
gdouble aspect = (gdouble) vals->width / (gdouble) vals->height;
|
|
|
|
|
|
|
|
if (aspect > (w / h))
|
|
|
|
{
|
|
|
|
*height = abs (vals->height);
|
|
|
|
*width = (gdouble) abs (vals->width) / (w / h) + 0.5;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
*width = abs (vals->width);
|
|
|
|
*height = (gdouble) abs (vals->height) / (w / h) + 0.5;
|
|
|
|
}
|
|
|
|
|
|
|
|
vals->width = *width;
|
|
|
|
vals->height = *height;
|
|
|
|
}
|
2003-09-21 15:24:36 +00:00
|
|
|
|
|
|
|
load_vals.width = owidth;
|
|
|
|
load_vals.height = oheight;
|
2003-09-20 00:49:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static GdkPixbuf *
|
|
|
|
load_rsvg_pixbuf (const gchar *filename,
|
|
|
|
SvgLoadVals *vals,
|
|
|
|
GError **error)
|
|
|
|
{
|
|
|
|
GdkPixbuf *pixbuf = NULL;
|
|
|
|
RsvgHandle *handle;
|
|
|
|
GIOChannel *io;
|
|
|
|
GIOStatus status = G_IO_STATUS_NORMAL;
|
|
|
|
gboolean success = TRUE;
|
|
|
|
|
|
|
|
io = g_io_channel_new_file (filename, "r", error);
|
|
|
|
if (!io)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
g_io_channel_set_encoding (io, NULL, NULL);
|
|
|
|
|
|
|
|
handle = rsvg_handle_new ();
|
|
|
|
|
|
|
|
rsvg_handle_set_dpi (handle, vals->resolution);
|
|
|
|
rsvg_handle_set_size_callback (handle, load_size_callback, vals, NULL);
|
|
|
|
|
|
|
|
while (success && status != G_IO_STATUS_EOF)
|
|
|
|
{
|
|
|
|
guchar buf[SVG_BUFFER_SIZE];
|
|
|
|
gsize len;
|
|
|
|
|
|
|
|
status = g_io_channel_read_chars (io, buf, sizeof (buf), &len, error);
|
|
|
|
|
|
|
|
switch (status)
|
|
|
|
{
|
|
|
|
case G_IO_STATUS_ERROR:
|
|
|
|
success = FALSE;
|
|
|
|
break;
|
|
|
|
case G_IO_STATUS_EOF:
|
|
|
|
success = rsvg_handle_close (handle, error);
|
|
|
|
break;
|
|
|
|
case G_IO_STATUS_NORMAL:
|
|
|
|
success = rsvg_handle_write (handle, buf, len, error);
|
|
|
|
break;
|
|
|
|
case G_IO_STATUS_AGAIN:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
g_io_channel_unref (io);
|
|
|
|
|
|
|
|
if (success)
|
|
|
|
pixbuf = rsvg_handle_get_pixbuf (handle);
|
|
|
|
|
|
|
|
rsvg_handle_free (handle);
|
|
|
|
|
|
|
|
return pixbuf;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-09-18 13:47:23 +00:00
|
|
|
static void
|
|
|
|
load_ok_callback (GtkWidget *widget,
|
|
|
|
gpointer data)
|
|
|
|
|
|
|
|
{
|
2003-09-20 00:49:39 +00:00
|
|
|
GimpSizeEntry *size = g_object_get_data (G_OBJECT (data), "size-entry");
|
|
|
|
|
2003-09-21 15:24:36 +00:00
|
|
|
load_vals.width = ROUND (gimp_size_entry_get_refval (size, 0));
|
|
|
|
load_vals.height = ROUND (gimp_size_entry_get_refval (size, 1));
|
2003-09-20 00:49:39 +00:00
|
|
|
|
2003-09-18 13:47:23 +00:00
|
|
|
load_interface.run = TRUE;
|
2003-09-20 00:49:39 +00:00
|
|
|
|
2003-09-18 13:47:23 +00:00
|
|
|
gtk_widget_destroy (GTK_WIDGET (data));
|
|
|
|
}
|
|
|
|
|
2003-09-21 15:24:36 +00:00
|
|
|
static void
|
|
|
|
load_resolution_callback (GimpSizeEntry *res,
|
|
|
|
GimpSizeEntry *size)
|
|
|
|
{
|
|
|
|
gdouble width, height, factor;
|
|
|
|
|
|
|
|
width = gimp_size_entry_get_refval (size, 0);
|
|
|
|
height = gimp_size_entry_get_refval (size, 1);
|
|
|
|
|
|
|
|
if (load_vals.resolution > 0.0)
|
|
|
|
{
|
|
|
|
factor = gimp_size_entry_get_refval (res, 0) / load_vals.resolution;
|
|
|
|
|
|
|
|
gimp_size_entry_set_refval (size, 0, factor * width);
|
|
|
|
gimp_size_entry_set_refval (size, 1, factor * height);
|
|
|
|
|
|
|
|
load_vals.resolution = gimp_size_entry_get_refval (res, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-09-18 13:47:23 +00:00
|
|
|
static gboolean
|
|
|
|
load_dialog (const gchar *filename)
|
|
|
|
{
|
|
|
|
GtkWidget *dialog;
|
|
|
|
GtkWidget *frame;
|
2003-09-20 00:49:39 +00:00
|
|
|
GtkWidget *hbox;
|
2003-09-18 13:47:23 +00:00
|
|
|
GtkWidget *table;
|
2003-09-20 00:49:39 +00:00
|
|
|
GtkWidget *abox;
|
|
|
|
GtkWidget *size;
|
2003-09-21 15:24:36 +00:00
|
|
|
GtkWidget *res;
|
2003-09-20 00:49:39 +00:00
|
|
|
GtkWidget *label;
|
|
|
|
GtkWidget *spinbutton;
|
|
|
|
GtkWidget *image;
|
|
|
|
GdkPixbuf *preview;
|
2003-09-18 13:47:23 +00:00
|
|
|
GtkObject *adj;
|
2003-09-20 00:49:39 +00:00
|
|
|
GError *error = NULL;
|
|
|
|
|
|
|
|
SvgLoadVals preview_vals = { 72.0, -128, -128 };
|
|
|
|
|
2003-09-21 15:24:36 +00:00
|
|
|
preview_vals.resolution = load_vals.resolution;
|
|
|
|
|
2003-09-20 00:49:39 +00:00
|
|
|
preview = load_rsvg_pixbuf (filename, &preview_vals, &error);
|
|
|
|
|
|
|
|
if (!preview)
|
|
|
|
{
|
|
|
|
/* Do not rely on librsvg setting GError on failure! */
|
|
|
|
g_message (_("Can't open '%s':\n"
|
|
|
|
"%s"),
|
|
|
|
filename, error ? error->message : "unknown reason");
|
|
|
|
return FALSE;
|
|
|
|
}
|
2003-09-18 13:47:23 +00:00
|
|
|
|
|
|
|
gimp_ui_init ("svg", FALSE);
|
|
|
|
|
2003-09-21 15:24:36 +00:00
|
|
|
dialog = gimp_dialog_new (_("Open SVG"), "svg",
|
2003-09-18 13:47:23 +00:00
|
|
|
NULL, NULL,
|
|
|
|
GTK_WIN_POS_MOUSE,
|
|
|
|
FALSE, TRUE, FALSE,
|
|
|
|
|
|
|
|
GTK_STOCK_CANCEL, gtk_widget_destroy,
|
|
|
|
NULL, 1, NULL, FALSE, TRUE,
|
|
|
|
|
|
|
|
GTK_STOCK_OK, load_ok_callback,
|
|
|
|
NULL, NULL, NULL, TRUE, FALSE,
|
|
|
|
|
|
|
|
NULL);
|
|
|
|
|
|
|
|
g_signal_connect (dialog, "destroy",
|
|
|
|
G_CALLBACK (gtk_main_quit),
|
|
|
|
NULL);
|
|
|
|
|
2003-09-20 00:49:39 +00:00
|
|
|
/* Scalable Vector Graphics is SVG, should perhaps not be translated */
|
|
|
|
frame = gtk_frame_new (_("Render Scalable Vector Graphics"));
|
2003-09-18 13:47:23 +00:00
|
|
|
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
|
|
|
|
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
|
|
|
|
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), frame,
|
|
|
|
TRUE, TRUE, 0);
|
2003-09-20 00:49:39 +00:00
|
|
|
gtk_widget_show (frame);
|
|
|
|
|
|
|
|
hbox = gtk_hbox_new (FALSE, 8);
|
|
|
|
gtk_container_set_border_width (GTK_CONTAINER (hbox), 4);
|
|
|
|
gtk_container_add (GTK_CONTAINER (frame), hbox);
|
|
|
|
gtk_widget_show (hbox);
|
|
|
|
|
|
|
|
frame = gtk_frame_new (NULL);
|
|
|
|
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
|
|
|
|
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
|
|
|
|
gtk_widget_show (frame);
|
2003-09-18 13:47:23 +00:00
|
|
|
|
2003-09-20 00:49:39 +00:00
|
|
|
image = gtk_image_new_from_pixbuf (preview);
|
|
|
|
gtk_container_add (GTK_CONTAINER (frame), image);
|
|
|
|
gtk_widget_show (image);
|
2003-09-18 13:47:23 +00:00
|
|
|
|
2003-09-21 15:24:36 +00:00
|
|
|
table = gtk_table_new (3, 3, FALSE);
|
2003-09-20 00:49:39 +00:00
|
|
|
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 4);
|
2003-09-18 13:47:23 +00:00
|
|
|
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
|
2003-09-20 00:49:39 +00:00
|
|
|
gtk_table_set_row_spacing (GTK_TABLE (table), 1, 4);
|
|
|
|
gtk_box_pack_start (GTK_BOX (hbox), table, TRUE, TRUE, 0);
|
2003-09-18 13:47:23 +00:00
|
|
|
gtk_widget_show (table);
|
|
|
|
|
2003-09-20 00:49:39 +00:00
|
|
|
label = gtk_label_new (_("Width:"));
|
|
|
|
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
|
2003-09-18 13:47:23 +00:00
|
|
|
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
|
2003-09-20 00:49:39 +00:00
|
|
|
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
|
2003-09-18 13:47:23 +00:00
|
|
|
gtk_widget_show (label);
|
|
|
|
|
2003-09-20 00:49:39 +00:00
|
|
|
label = gtk_label_new (_("Height:"));
|
|
|
|
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
|
|
|
|
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
|
|
|
|
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
|
|
|
|
gtk_widget_show (label);
|
2003-09-18 13:47:23 +00:00
|
|
|
|
2003-09-20 00:49:39 +00:00
|
|
|
abox = gtk_alignment_new (0.0, 0.5, 0.0, 1.0);
|
|
|
|
gtk_table_attach (GTK_TABLE (table), abox, 1, 2, 0, 1,
|
|
|
|
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
|
|
|
|
gtk_widget_show (abox);
|
2003-09-18 13:47:23 +00:00
|
|
|
|
2003-09-20 00:49:39 +00:00
|
|
|
spinbutton = gimp_spin_button_new (&adj, 1, 1, 1, 1, 10, 1, 1, 2);
|
|
|
|
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10);
|
|
|
|
gtk_container_add (GTK_CONTAINER (abox), spinbutton);
|
|
|
|
gtk_widget_show (spinbutton);
|
|
|
|
|
|
|
|
abox = gtk_alignment_new (0.0, 0.5, 0.0, 1.0);
|
|
|
|
gtk_table_attach (GTK_TABLE (table), abox, 1, 2, 1, 2,
|
|
|
|
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
|
|
|
|
gtk_widget_show (abox);
|
|
|
|
|
|
|
|
size = gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a",
|
|
|
|
TRUE, FALSE, FALSE, 10,
|
|
|
|
GIMP_SIZE_ENTRY_UPDATE_SIZE);
|
2003-09-21 15:24:36 +00:00
|
|
|
gtk_table_set_col_spacing (GTK_TABLE (size), 1, 4);
|
2003-09-20 00:49:39 +00:00
|
|
|
|
|
|
|
g_object_set_data (G_OBJECT (dialog), "size-entry", size);
|
|
|
|
|
|
|
|
gimp_size_entry_add_field (GIMP_SIZE_ENTRY (size),
|
|
|
|
GTK_SPIN_BUTTON (spinbutton), NULL);
|
|
|
|
|
|
|
|
gtk_container_add (GTK_CONTAINER (abox), size);
|
|
|
|
gtk_widget_show (size);
|
|
|
|
|
2003-09-21 15:24:36 +00:00
|
|
|
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (size), 0,
|
|
|
|
GIMP_MIN_IMAGE_SIZE,
|
|
|
|
GIMP_MAX_IMAGE_SIZE);
|
|
|
|
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (size), 1,
|
|
|
|
GIMP_MIN_IMAGE_SIZE,
|
|
|
|
GIMP_MAX_IMAGE_SIZE);
|
|
|
|
|
|
|
|
gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (size), 0, load_vals.width);
|
|
|
|
gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (size), 1, load_vals.height);
|
2003-09-20 00:49:39 +00:00
|
|
|
|
|
|
|
gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (size), 0,
|
|
|
|
load_vals.resolution, FALSE);
|
|
|
|
gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (size), 1,
|
|
|
|
load_vals.resolution, FALSE);
|
2003-09-18 13:47:23 +00:00
|
|
|
|
2003-09-21 15:24:36 +00:00
|
|
|
label = gtk_label_new (_("Resolution:"));
|
|
|
|
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
|
|
|
|
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
|
|
|
|
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
|
|
|
|
gtk_widget_show (label);
|
|
|
|
|
|
|
|
abox = gtk_alignment_new (0.0, 0.5, 0.0, 1.0);
|
|
|
|
gtk_table_attach (GTK_TABLE (table), abox, 1, 2, 2, 3,
|
|
|
|
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
|
|
|
|
gtk_widget_show (abox);
|
|
|
|
|
|
|
|
res = gimp_size_entry_new (1, GIMP_UNIT_INCH, _("pixels/%a"),
|
|
|
|
FALSE, FALSE, FALSE, 10,
|
|
|
|
GIMP_SIZE_ENTRY_UPDATE_RESOLUTION);
|
|
|
|
gtk_table_set_col_spacing (GTK_TABLE (res), 1, 4);
|
|
|
|
|
|
|
|
gtk_table_attach (GTK_TABLE (table), res, 1, 2, 2, 3,
|
|
|
|
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
|
|
|
|
gtk_widget_show (res);
|
|
|
|
|
|
|
|
gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (res), 0,
|
|
|
|
GIMP_MIN_RESOLUTION,
|
|
|
|
GIMP_MAX_RESOLUTION);
|
|
|
|
gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (res), 0, load_vals.resolution);
|
|
|
|
|
|
|
|
g_signal_connect (res, "value-changed",
|
|
|
|
G_CALLBACK (load_resolution_callback),
|
|
|
|
size);
|
|
|
|
|
2003-09-18 13:47:23 +00:00
|
|
|
gtk_widget_show (dialog);
|
|
|
|
|
|
|
|
gtk_main ();
|
|
|
|
|
|
|
|
return load_interface.run;
|
|
|
|
}
|