1549N/A

1549N/A

1549N/A#ifdef HAVE_CONFIG_H

1549N/A# include "config.h"

1549N/A#endif

1549N/A

1549N/A#include <png.h>

1549N/A

1549N/A#include "ui/widget/panel.h" // This has to be the first to include <glib.h> because of Glibmm's dependence on a deprecated feature...

1549N/A

1549N/A#include "path-prefix.h"

1549N/A

1549N/A#ifdef HAVE_IEEEFP_H

1549N/A#include <ieeefp.h>

1549N/A#endif

1549N/A#include <cstring>

1549N/A#include <string>

1549N/A#include <locale.h>

1549N/A#include <stdlib.h>

1549N/A

1549N/A#include <popt.h>

1549N/A#ifndef POPT_TABLEEND

1549N/A#define POPT_TABLEEND { NULL, '\0', 0, 0, 0, NULL, NULL }

1549N/A#endif /* Not def: POPT_TABLEEND */

1549N/A

1549N/A#include <libxml/tree.h>

1549N/A#include <glib/gprintf.h>

1549N/A#include <glib-object.h>

1549N/A#include <gtk/gtk.h>

1549N/A

1549N/A#include "gc-core.h"

1549N/A

1549N/A#ifdef AND

#undef AND

#endif

#include "macros.h"

#include "file.h"

#include "document.h"

#include "layer-model.h"

#include "selection.h"

#include "sp-object.h"

#include "ui/interface.h"

#include "print.h"

#include "color.h"

#include "sp-item.h"

#include "sp-root.h"

#include "svg/svg.h"

#include "svg/svg-color.h"

#include "svg/stringstream.h"

#include "inkscape.h"

#include "inkscape-version.h"

#include "sp-namedview.h"

#include "sp-guide.h"

#include "xml/repr.h"

#include "io/sys.h"

#include "debug/logger.h"

#include "debug/log-display-config.h"

#include "helper/action-context.h"

#include "helper/png-write.h"

#include "helper/geom.h"

#include <extension/extension.h>

#include <extension/system.h>

#include <extension/db.h>

#include <extension/output.h>

#include <extension/input.h>

#ifdef WIN32

#include <windows.h>

#include "registrytool.h"

#endif // WIN32

#include "extension/init.h"

#ifdef WITH_DBUS

#include "extension/dbus/dbus-init.h"

#endif // WITH_DBUS

#include <glibmm/i18n.h>

#include <glibmm/main.h>

#include <glibmm/miscutils.h>

#include <gtkmm/main.h>

#ifndef HAVE_BIND_TEXTDOMAIN_CODESET

#define bind_textdomain_codeset(p,c)

#endif

#include "main-cmdlineact.h"

#include "widgets/icon.h"

#include <errno.h>

#include "verbs.h"

#include <gdk/gdkkeysyms.h>

#include "path-chemistry.h"

#include "sp-text.h"

#include "sp-flowtext.h"

#include "text-editing.h"

enum {

SP_ARG_NONE,

SP_ARG_NOGUI,

SP_ARG_GUI,

SP_ARG_FILE,

SP_ARG_PRINT,

SP_ARG_EXPORT_PNG,

SP_ARG_EXPORT_DPI,

SP_ARG_EXPORT_AREA,

SP_ARG_EXPORT_AREA_DRAWING,

SP_ARG_EXPORT_AREA_PAGE,

SP_ARG_EXPORT_MARGIN,

SP_ARG_EXPORT_AREA_SNAP,

SP_ARG_EXPORT_WIDTH,

SP_ARG_EXPORT_HEIGHT,

SP_ARG_EXPORT_ID,

SP_ARG_EXPORT_ID_ONLY,

SP_ARG_EXPORT_USE_HINTS,

SP_ARG_EXPORT_BACKGROUND,

SP_ARG_EXPORT_BACKGROUND_OPACITY,

SP_ARG_EXPORT_SVG,

SP_ARG_EXPORT_PS,

SP_ARG_EXPORT_EPS,

SP_ARG_EXPORT_PS_LEVEL,

SP_ARG_EXPORT_PDF,

SP_ARG_EXPORT_PDF_VERSION,

SP_ARG_EXPORT_LATEX,

SP_ARG_EXPORT_EMF,

SP_ARG_EXPORT_WMF,

SP_ARG_EXPORT_TEXT_TO_PATH,

SP_ARG_EXPORT_IGNORE_FILTERS,

SP_ARG_EXTENSIONDIR,

SP_ARG_QUERY_X,

SP_ARG_QUERY_Y,

SP_ARG_QUERY_WIDTH,

SP_ARG_QUERY_HEIGHT,

SP_ARG_QUERY_ALL,

SP_ARG_QUERY_ID,

SP_ARG_SHELL,

SP_ARG_VERSION,

SP_ARG_VACUUM_DEFS,

#ifdef WITH_DBUS

SP_ARG_DBUS_LISTEN,

SP_ARG_DBUS_NAME,

#endif // WITH_DBUS

SP_ARG_VERB_LIST,

SP_ARG_VERB,

SP_ARG_SELECT,

SP_ARG_LAST

};

int sp_main_gui(int argc, char const **argv);

int sp_main_console(int argc, char const **argv);

static int sp_do_export_png(SPDocument *doc);

static int do_export_ps_pdf(SPDocument* doc, gchar const* uri, char const *mime);

static int do_export_emf(SPDocument* doc, gchar const* uri, char const *mime);

static int do_export_wmf(SPDocument* doc, gchar const* uri, char const *mime);

static int do_export_win_metafile_common(SPDocument* doc, gchar const* uri, char const *mime);

static void do_query_dimension (SPDocument *doc, bool extent, Geom::Dim2 const axis, const gchar *id);

static void do_query_all (SPDocument *doc);

static void do_query_all_recurse (SPObject *o);

static gchar *sp_global_printer = NULL;

static gchar *sp_export_png = NULL;

static gchar *sp_export_dpi = NULL;

static gchar *sp_export_area = NULL;

static gboolean sp_export_area_drawing = FALSE;

static gboolean sp_export_area_page = FALSE;

static gchar *sp_export_margin = NULL;

static gboolean sp_export_latex = FALSE;

static gchar *sp_export_width = NULL;

static gchar *sp_export_height = NULL;

static gchar *sp_export_id = NULL;

static gchar *sp_export_background = NULL;

static gchar *sp_export_background_opacity = NULL;

static gboolean sp_export_area_snap = FALSE;

static gboolean sp_export_use_hints = FALSE;

static gboolean sp_export_id_only = FALSE;

static gchar *sp_export_svg = NULL;

static gchar *sp_export_ps = NULL;

static gchar *sp_export_eps = NULL;

static gint sp_export_ps_level = 2;

static gchar *sp_export_pdf = NULL;

static gchar *sp_export_pdf_version = NULL;

static gchar *sp_export_emf = NULL;

static gchar *sp_export_wmf = NULL;

static gboolean sp_export_text_to_path = FALSE;

static gboolean sp_export_ignore_filters = FALSE;

static gboolean sp_export_font = FALSE;

static gboolean sp_query_x = FALSE;

static gboolean sp_query_y = FALSE;

static gboolean sp_query_width = FALSE;

static gboolean sp_query_height = FALSE;

static gboolean sp_query_all = FALSE;

static gchar *sp_query_id = NULL;

static gboolean sp_shell = FALSE;

static gboolean sp_vacuum_defs = FALSE;

#ifdef WITH_DBUS

static gboolean sp_dbus_listen = FALSE;

static gchar *sp_dbus_name = NULL;

#endif // WITH_DBUS

static gchar *sp_export_png_utf8 = NULL;

static gchar *sp_export_svg_utf8 = NULL;

static gchar *sp_global_printer_utf8 = NULL;

static void resetCommandlineGlobals() {

sp_global_printer = NULL;

sp_export_png = NULL;

sp_export_dpi = NULL;

sp_export_area = NULL;

sp_export_area_drawing = FALSE;

sp_export_area_page = FALSE;

sp_export_margin = NULL;

sp_export_latex = FALSE;

sp_export_width = NULL;

sp_export_height = NULL;

sp_export_id = NULL;

sp_export_background = NULL;

sp_export_background_opacity = NULL;

sp_export_area_snap = FALSE;

sp_export_use_hints = FALSE;

sp_export_id_only = FALSE;

sp_export_svg = NULL;

sp_export_ps = NULL;

sp_export_eps = NULL;

sp_export_ps_level = 2;

sp_export_pdf = NULL;

sp_export_pdf_version = NULL;

sp_export_emf = NULL;

sp_export_wmf = NULL;

sp_export_text_to_path = FALSE;

sp_export_ignore_filters = FALSE;

sp_export_font = FALSE;

sp_query_x = FALSE;

sp_query_y = FALSE;

sp_query_width = FALSE;

sp_query_height = FALSE;

sp_query_all = FALSE;

sp_query_id = NULL;

sp_vacuum_defs = FALSE;

#ifdef WITH_DBUS

sp_dbus_listen = FALSE;

sp_dbus_name = NULL;

#endif // WITH_DBUS

sp_export_png_utf8 = NULL;

sp_export_svg_utf8 = NULL;

sp_global_printer_utf8 = NULL;

}

#ifdef WIN32

static bool replaceArgs( int& argc, char**& argv );

#endif

static GSList *sp_process_args(poptContext ctx);

struct poptOption options[] = {

{"version", 'V',

POPT_ARG_NONE, NULL, SP_ARG_VERSION,

N_("Print the Inkscape version number"),

NULL},

{"without-gui", 'z',

POPT_ARG_NONE, NULL, SP_ARG_NOGUI,

N_("Do not use X server (only process files from console)"),

NULL},

{"with-gui", 'g',

POPT_ARG_NONE, NULL, SP_ARG_GUI,

N_("Try to use X server (even if $DISPLAY is not set)"),

NULL},

{"file", 'f',

POPT_ARG_STRING, NULL, SP_ARG_FILE,

N_("Open specified document(s) (option string may be excluded)"),

N_("FILENAME")},

{"print", 'p',

POPT_ARG_STRING, &sp_global_printer, SP_ARG_PRINT,

N_("Print document(s) to specified output file (use '| program' for pipe)"),

N_("FILENAME")},

{"export-png", 'e',

POPT_ARG_STRING, &sp_export_png, SP_ARG_EXPORT_PNG,

N_("Export document to a PNG file"),

N_("FILENAME")},

{"export-dpi", 'd',

POPT_ARG_STRING, &sp_export_dpi, SP_ARG_EXPORT_DPI,

N_("Resolution for exporting to bitmap and for rasterization of filters in PS/EPS/PDF (default 96)"),

N_("DPI")},

{"export-area", 'a',

POPT_ARG_STRING, &sp_export_area, SP_ARG_EXPORT_AREA,

N_("Exported area in SVG user units (default is the page; 0,0 is lower-left corner)"),

N_("x0:y0:x1:y1")},

{"export-area-drawing", 'D',

POPT_ARG_NONE, &sp_export_area_drawing, SP_ARG_EXPORT_AREA_DRAWING,

N_("Exported area is the entire drawing (not page)"),

NULL},

{"export-area-page", 'C',

POPT_ARG_NONE, &sp_export_area_page, SP_ARG_EXPORT_AREA_PAGE,

N_("Exported area is the entire page"),

NULL},

{"export-margin", 0,

POPT_ARG_STRING, &sp_export_margin, SP_ARG_EXPORT_MARGIN,

N_("Only for PS/EPS/PDF, sets margin in mm around exported area (default 0)"),

N_("VALUE")},

{"export-area-snap", 0,

POPT_ARG_NONE, &sp_export_area_snap, SP_ARG_EXPORT_AREA_SNAP,

N_("Snap the bitmap export area outwards to the nearest integer values (in SVG user units)"),

NULL},

{"export-width", 'w',

POPT_ARG_STRING, &sp_export_width, SP_ARG_EXPORT_WIDTH,

N_("The width of exported bitmap in pixels (overrides export-dpi)"),

N_("WIDTH")},

{"export-height", 'h',

POPT_ARG_STRING, &sp_export_height, SP_ARG_EXPORT_HEIGHT,

N_("The height of exported bitmap in pixels (overrides export-dpi)"),

N_("HEIGHT")},

{"export-id", 'i',

POPT_ARG_STRING, &sp_export_id, SP_ARG_EXPORT_ID,

N_("The ID of the object to export"),

N_("ID")},

{"export-id-only", 'j',

POPT_ARG_NONE, &sp_export_id_only, SP_ARG_EXPORT_ID_ONLY,

// TRANSLATORS: this means: "Only export the object whose id is given in --export-id".

// See "man inkscape" for details.

N_("Export just the object with export-id, hide all others (only with export-id)"),

NULL},

{"export-use-hints", 't',

POPT_ARG_NONE, &sp_export_use_hints, SP_ARG_EXPORT_USE_HINTS,

N_("Use stored filename and DPI hints when exporting (only with export-id)"),

NULL},

{"export-background", 'b',

POPT_ARG_STRING, &sp_export_background, SP_ARG_EXPORT_BACKGROUND,

N_("Background color of exported bitmap (any SVG-supported color string)"),

N_("COLOR")},

{"export-background-opacity", 'y',

POPT_ARG_STRING, &sp_export_background_opacity, SP_ARG_EXPORT_BACKGROUND_OPACITY,

N_("Background opacity of exported bitmap (either 0.0 to 1.0, or 1 to 255)"),

N_("VALUE")},

{"export-plain-svg", 'l',

POPT_ARG_STRING, &sp_export_svg, SP_ARG_EXPORT_SVG,

N_("Export document to plain SVG file (no sodipodi or inkscape namespaces)"),

N_("FILENAME")},

{"export-ps", 'P',

POPT_ARG_STRING, &sp_export_ps, SP_ARG_EXPORT_PS,

N_("Export document to a PS file"),

N_("FILENAME")},

{"export-eps", 'E',

POPT_ARG_STRING, &sp_export_eps, SP_ARG_EXPORT_EPS,

N_("Export document to an EPS file"),

N_("FILENAME")},

{"export-ps-level", 0,

POPT_ARG_INT, &sp_export_ps_level, SP_ARG_EXPORT_PS_LEVEL,

N_("Choose the PostScript Level used to export. Possible choices are"

" 2 (the default) and 3"),

N_("PS Level")},

{"export-pdf", 'A',

POPT_ARG_STRING, &sp_export_pdf, SP_ARG_EXPORT_PDF,

N_("Export document to a PDF file"),

N_("FILENAME")},

{"export-pdf-version", 0,

POPT_ARG_STRING, &sp_export_pdf_version, SP_ARG_EXPORT_PDF_VERSION,

// TRANSLATORS: "--export-pdf-version" is an Inkscape command line option; see "inkscape --help"

N_("Export PDF to given version. (hint: make sure to input the exact string found in the PDF export dialog, e.g. \"PDF 1.4\" which is PDF-a conformant)"),

N_("PDF_VERSION")},

{"export-latex", 0,

POPT_ARG_NONE, &sp_export_latex, SP_ARG_EXPORT_LATEX,

N_("Export PDF/PS/EPS without text. Besides the PDF/PS/EPS, a LaTeX file is exported, putting the text on top of the PDF/PS/EPS file. Include the result in LaTeX like: \\input{latexfile.tex}"),

NULL},

{"export-emf", 'M',

POPT_ARG_STRING, &sp_export_emf, SP_ARG_EXPORT_EMF,

N_("Export document to an Enhanced Metafile (EMF) File"),

N_("FILENAME")},

{"export-wmf", 'm',

POPT_ARG_STRING, &sp_export_wmf, SP_ARG_EXPORT_WMF,

N_("Export document to a Windows Metafile (WMF) File"),

N_("FILENAME")},

{"export-text-to-path", 'T',

POPT_ARG_NONE, &sp_export_text_to_path, SP_ARG_EXPORT_TEXT_TO_PATH,

N_("Convert text object to paths on export (PS, EPS, PDF, SVG)"),

NULL},

{"export-ignore-filters", 0,

POPT_ARG_NONE, &sp_export_ignore_filters, SP_ARG_EXPORT_IGNORE_FILTERS,

N_("Render filtered objects without filters, instead of rasterizing (PS, EPS, PDF)"),

NULL},

{"query-x", 'X',

POPT_ARG_NONE, &sp_query_x, SP_ARG_QUERY_X,

// TRANSLATORS: "--query-id" is an Inkscape command line option; see "inkscape --help"

N_("Query the X coordinate of the drawing or, if specified, of the object with --query-id"),

NULL},

{"query-y", 'Y',

POPT_ARG_NONE, &sp_query_y, SP_ARG_QUERY_Y,

// TRANSLATORS: "--query-id" is an Inkscape command line option; see "inkscape --help"

N_("Query the Y coordinate of the drawing or, if specified, of the object with --query-id"),

NULL},

{"query-width", 'W',

POPT_ARG_NONE, &sp_query_width, SP_ARG_QUERY_WIDTH,

// TRANSLATORS: "--query-id" is an Inkscape command line option; see "inkscape --help"

N_("Query the width of the drawing or, if specified, of the object with --query-id"),

NULL},

{"query-height", 'H',

POPT_ARG_NONE, &sp_query_height, SP_ARG_QUERY_HEIGHT,

// TRANSLATORS: "--query-id" is an Inkscape command line option; see "inkscape --help"

N_("Query the height of the drawing or, if specified, of the object with --query-id"),

NULL},

{"query-all", 'S',

POPT_ARG_NONE, &sp_query_all, SP_ARG_QUERY_ALL,

N_("List id,x,y,w,h for all objects"),

NULL},

{"query-id", 'I',

POPT_ARG_STRING, &sp_query_id, SP_ARG_QUERY_ID,

N_("The ID of the object whose dimensions are queried"),

N_("ID")},

{"extension-directory", 'x',

POPT_ARG_NONE, NULL, SP_ARG_EXTENSIONDIR,

// TRANSLATORS: this option makes Inkscape print the name (path) of the extension directory

N_("Print out the extension directory and exit"),

NULL},

{"vacuum-defs", 0,

POPT_ARG_NONE, &sp_vacuum_defs, SP_ARG_VACUUM_DEFS,

N_("Remove unused definitions from the defs section(s) of the document"),

NULL},

#ifdef WITH_DBUS

{"dbus-listen", 0,

POPT_ARG_NONE, &sp_dbus_listen, SP_ARG_DBUS_LISTEN,

N_("Enter a listening loop for D-Bus messages in console mode"),

NULL},

{"dbus-name", 0,

POPT_ARG_STRING, &sp_dbus_name, SP_ARG_DBUS_NAME,

N_("Specify the D-Bus bus name to listen for messages on (default is org.inkscape)"),

N_("BUS-NAME")},

#endif // WITH_DBUS

{"verb-list", 0,

POPT_ARG_NONE, NULL, SP_ARG_VERB_LIST,

N_("List the IDs of all the verbs in Inkscape"),

NULL},

{"verb", 0,

POPT_ARG_STRING, NULL, SP_ARG_VERB,

N_("Verb to call when Inkscape opens."),

N_("VERB-ID")},

{"select", 0,

POPT_ARG_STRING, NULL, SP_ARG_SELECT,

N_("Object ID to select when Inkscape opens."),

N_("OBJECT-ID")},

{"shell", 0,

POPT_ARG_NONE, &sp_shell, SP_ARG_SHELL,

N_("Start Inkscape in interactive shell mode."),

NULL},

POPT_AUTOHELP POPT_TABLEEND

};

static bool needToRecodeParams = true;

gchar * blankParam = g_strdup("");

#ifdef WIN32

static void _win32_set_inkscape_env(gchar const *exe)

{

gchar const *path = g_getenv("PATH");

gchar const *pythonpath = g_getenv("PYTHONPATH");

gchar *python = g_build_filename(exe, "python", NULL);

gchar *scripts = g_build_filename(exe, "python", "Scripts", NULL);

gchar *perl = g_build_filename(exe, "python", NULL);

gchar *pythonlib = g_build_filename(exe, "python", "Lib", NULL);

gchar *pythondll = g_build_filename(exe, "python", "DLLs", NULL);

// Python 2.x needs short paths in PYTHONPATH.

// Otherwise it doesn't work when Inkscape is installed in Unicode directories.

// g_win32_locale_filename_from_utf8 is the GLib wrapper for GetShortPathName.

// Remove this once we move to Python 3.0.

gchar *python_s = g_win32_locale_filename_from_utf8(python);

gchar *pythonlib_s = g_win32_locale_filename_from_utf8(pythonlib);

gchar *pythondll_s = g_win32_locale_filename_from_utf8(pythondll);

gchar *new_path;

gchar *new_pythonpath;

if (path) {

new_path = g_strdup_printf("%s;%s;%s;%s;%s", exe, python, scripts, perl, path);

} else {

new_path = g_strdup_printf("%s;%s;%s;%s", exe, python, scripts, perl);

}

if (pythonpath) {

new_pythonpath = g_strdup_printf("%s;%s;%s;%s",

python_s, pythonlib_s, pythondll_s, pythonpath);

} else {

new_pythonpath = g_strdup_printf("%s;%s;%s",

python_s, pythonlib_s, pythondll_s);

}

g_setenv("PATH", new_path, TRUE);

g_setenv("PYTHONPATH", new_pythonpath, TRUE);

/*

// INKSCAPE_LOCALEDIR is needed by Python/Gettext

gchar *localepath = g_build_filename(exe, PACKAGE_LOCALE_DIR, NULL);

g_setenv("INKSCAPE_LOCALEDIR", localepath, TRUE);

// prevent "please insert disk" messages. fixes bug #950781

SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);

g_free(python);

g_free(scripts);

g_free(perl);

g_free(pythonlib);

g_free(pythondll);

g_free(python_s);

g_free(pythonlib_s);

g_free(pythondll_s);

g_free(new_path);

g_free(new_pythonpath);

g_free(localepath);

}

#endif

static void set_extensions_env()

{

gchar const *pythonpath = g_getenv("PYTHONPATH");

gchar *extdir;

gchar *new_pythonpath;

#ifdef WIN32

extdir = g_win32_locale_filename_from_utf8(INKSCAPE_EXTENSIONDIR);

#else

extdir = g_strdup(INKSCAPE_EXTENSIONDIR);

#endif

// On some platforms, INKSCAPE_EXTENSIONDIR is not absolute,

// but relative to the directory that contains the Inkscape executable.

// Since we spawn Python chdir'ed into the script's directory,

// we need to obtain the absolute path here.

if (!g_path_is_absolute(extdir)) {

gchar *curdir = g_get_current_dir();

gchar *extdir_new = g_build_filename(curdir, extdir, NULL);

g_free(extdir);

g_free(curdir);

extdir = extdir_new;

}

if (pythonpath) {

new_pythonpath = g_strdup_printf("%s" G_SEARCHPATH_SEPARATOR_S "%s",

extdir, pythonpath);

g_free(extdir);

} else {

new_pythonpath = extdir;

}

g_setenv("PYTHONPATH", new_pythonpath, TRUE);

g_free(new_pythonpath);

//printf("PYTHONPATH = %s\n", g_getenv("PYTHONPATH"));

}

main(int argc, char **argv)

{

#ifdef HAVE_FPSETMASK

/* This is inherited from Sodipodi code, where it was in #ifdef __FreeBSD__. It's probably

fpsetmask(fpgetmask() & ~(FP_X_DZ | FP_X_INV));

#endif

#ifdef WIN32

gchar *exedir = g_strdup(win32_getExePath().data());

_win32_set_inkscape_env(exedir);

# ifdef ENABLE_NLS

// obtain short path to executable dir and pass it

// to bindtextdomain (it doesn't understand UTF-8)

gchar *shortexedir = g_win32_locale_filename_from_utf8(exedir);

gchar *localepath = g_build_filename(shortexedir, PACKAGE_LOCALE_DIR, NULL);

bindtextdomain(GETTEXT_PACKAGE, localepath);

g_free(shortexedir);

g_free(localepath);

# endif

g_free(exedir);

// Don't touch the registry (works fine without it) for Inkscape Portable

gchar const *val = g_getenv("INKSCAPE_PORTABLE_PROFILE_DIR");

if (!val) {

RegistryTool rt;

rt.setPathInfo();

}

#elif defined(ENABLE_NLS)

# ifdef ENABLE_BINRELOC

bindtextdomain(GETTEXT_PACKAGE, BR_LOCALEDIR(""));

# else

bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);

// needed by Python/Gettext

g_setenv("PACKAGE_LOCALE_DIR", PACKAGE_LOCALE_DIR, TRUE);

# endif

#endif

// the bit below compiles regardless of platform

#ifdef ENABLE_NLS

// Allow the user to override the locale directory by setting

// the environment variable INKSCAPE_LOCALEDIR.

char const *inkscape_localedir = g_getenv("INKSCAPE_LOCALEDIR");

if (inkscape_localedir != NULL) {

bindtextdomain(GETTEXT_PACKAGE, inkscape_localedir);

}

// common setup

bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");

textdomain(GETTEXT_PACKAGE);

#endif

set_extensions_env();

// Prevents errors like "Unable to wrap GdkPixbuf..." (in nr-filter-image.cpp for example)

Gtk::Main::init_gtkmm_internals();

LIBXML_TEST_VERSION

Inkscape::GC::init();

Inkscape::Debug::Logger::init();

gboolean use_gui;

#if !defined(WIN32) && !defined(GDK_WINDOWING_QUARTZ)

use_gui = (g_getenv("DISPLAY") != NULL);

#else

use_gui = TRUE;

#endif

/* Test whether with/without GUI is forced */

for (int i = 1; i < argc; i++) {

if (!strcmp(argv[i], "-z")

|| !strcmp(argv[i], "--without-gui")

|| !strcmp(argv[i], "-p")

|| !strncmp(argv[i], "--print", 7)

|| !strcmp(argv[i], "-e")

|| !strncmp(argv[i], "--export-png", 12)

|| !strcmp(argv[i], "-l")

|| !strncmp(argv[i], "--export-plain-svg", 18)

|| !strcmp(argv[i], "-i")

|| !strncmp(argv[i], "--export-area-drawing", 21)

|| !strcmp(argv[i], "-D")

|| !strncmp(argv[i], "--export-area-page", 18)

|| !strcmp(argv[i], "-C")

|| !strncmp(argv[i], "--export-id", 11)

|| !strcmp(argv[i], "-P")

|| !strncmp(argv[i], "--export-ps", 11)

|| !strcmp(argv[i], "-E")

|| !strncmp(argv[i], "--export-eps", 12)

|| !strcmp(argv[i], "-A")

|| !strncmp(argv[i], "--export-pdf", 12)

|| !strncmp(argv[i], "--export-latex", 14)

|| !strcmp(argv[i], "-M")

|| !strncmp(argv[i], "--export-emf", 12)

|| !strcmp(argv[i], "-m")

|| !strncmp(argv[i], "--export-wmf", 12)

|| !strcmp(argv[i], "-W")

|| !strncmp(argv[i], "--query-width", 13)

|| !strcmp(argv[i], "-H")

|| !strncmp(argv[i], "--query-height", 14)

|| !strcmp(argv[i], "-S")

|| !strncmp(argv[i], "--query-all", 11)

|| !strcmp(argv[i], "-X")

|| !strncmp(argv[i], "--query-x", 9)

|| !strcmp(argv[i], "-Y")

|| !strncmp(argv[i], "--query-y", 9)

|| !strcmp(argv[i], "--vacuum-defs")

#ifdef WITH_DBUS

|| !strcmp(argv[i], "--dbus-listen")

#endif // WITH_DBUS

|| !strcmp(argv[i], "--shell")

)

{

/* main_console handles any exports -- not the gui */

use_gui = FALSE;

break;

} else if (!strcmp(argv[i], "-g") || !strcmp(argv[i], "--with-gui")) {

use_gui = TRUE;

break;

}

}

#ifdef WIN32

{

// If the call fails, we'll need to convert charsets

needToRecodeParams = !replaceArgs( argc, argv );

}

#endif // WIN32

int retcode;

if (use_gui) {

retcode = sp_main_gui(argc, (const char **) argv);

} else {

retcode = sp_main_console(argc, (const char **) argv);

}

return retcode;

}

static void fixupSingleFilename( gchar **orig, gchar **spare )

{

if ( orig && *orig && **orig ) {

GError *error = NULL;

gchar *newFileName = Inkscape::IO::locale_to_utf8_fallback(*orig, -1, NULL, NULL, &error);

if ( newFileName )

{

*orig = newFileName;

if ( spare ) {

*spare = newFileName;

}

}

}

}

static GSList *fixupFilenameEncoding( GSList* fl )

{

GSList *newFl = NULL;

while ( fl ) {

gchar *fn = static_cast<gchar*>(fl->data);

fl = g_slist_remove( fl, fl->data );

gchar *newFileName = Inkscape::IO::locale_to_utf8_fallback(fn, -1, NULL, NULL, NULL);

if ( newFileName ) {

if ( 0 )

{

gchar *safeFn = Inkscape::IO::sanitizeString(fn);

gchar *safeNewFn = Inkscape::IO::sanitizeString(newFileName);

GtkWidget *w = gtk_message_dialog_new( NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,

"Note: Converted '%s' to '%s'", safeFn, safeNewFn );

gtk_dialog_run (GTK_DIALOG (w));

gtk_widget_destroy (w);

g_free(safeNewFn);

g_free(safeFn);

}

g_free( fn );

fn = newFileName;

newFileName = 0;

}

else

if ( 0 )

{

gchar *safeFn = Inkscape::IO::sanitizeString(fn);

GtkWidget *w = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, "Error: Unable to convert '%s'", safeFn );

gtk_dialog_run (GTK_DIALOG (w));

gtk_widget_destroy (w);

g_free(safeFn);

}

newFl = g_slist_append( newFl, fn );

}

return newFl;

}

static int sp_common_main( int argc, char const **argv, GSList **flDest )

{

/// \todo fixme: Move these to some centralized location (Lauris)

//sp_object_type_register("sodipodi:namedview", SP_TYPE_NAMEDVIEW);

//sp_object_type_register("sodipodi:guide", SP_TYPE_GUIDE);

// temporarily switch gettext encoding to locale, so that help messages can be output properly

gchar const *charset;

g_get_charset(&charset);

bind_textdomain_codeset(GETTEXT_PACKAGE, charset);

poptContext ctx = poptGetContext(NULL, argc, argv, options, 0);

poptSetOtherOptionHelp(ctx, _("[OPTIONS...] [FILE...]\n\nAvailable options:"));

g_return_val_if_fail(ctx != NULL, 1);

/* Collect own arguments */

GSList *fl = sp_process_args(ctx);

poptFreeContext(ctx);

// now switch gettext back to UTF-8 (for GUI)

bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");

// Now let's see if the file list still holds up

if ( needToRecodeParams )

{

fl = fixupFilenameEncoding( fl );

}

// Check the globals for filename-fixup

if ( needToRecodeParams )

{

fixupSingleFilename( &sp_export_png, &sp_export_png_utf8 );

fixupSingleFilename( &sp_export_svg, &sp_export_svg_utf8 );

fixupSingleFilename( &sp_global_printer, &sp_global_printer_utf8 );

}

else

{

if ( sp_export_png )

sp_export_png_utf8 = g_strdup( sp_export_png );

if ( sp_export_svg )

sp_export_svg_utf8 = g_strdup( sp_export_svg );

if ( sp_global_printer )

sp_global_printer_utf8 = g_strdup( sp_global_printer );

}

#ifdef WITH_DBUS

// Before initializing extensions, we must set the DBus bus name if required

if (sp_dbus_name != NULL) {

Inkscape::Extension::Dbus::dbus_set_bus_name(sp_dbus_name);

}

#endif

// Return the list if wanted, else free it up.

if ( flDest ) {

*flDest = fl;

fl = 0;

} else {

while ( fl ) {

g_free( fl->data );

fl = g_slist_remove( fl, fl->data );

}

}

return 0;

}

namespace Inkscape {

namespace UI {

namespace Tools {

guint get_group0_keyval(GdkEventKey const* event);

}

}

}

static void

snooper(GdkEvent *event, gpointer /*data*/) {

if (INKSCAPE.mapalt()) /* returns the map of the keyboard modifier to map to Alt, zero if no mapping */

{

GdkModifierType mapping=(GdkModifierType)INKSCAPE.mapalt();

switch (event->type) {

case GDK_MOTION_NOTIFY:

if(event->motion.state & mapping) {

event->motion.state|=GDK_MOD1_MASK;

}

break;

case GDK_BUTTON_PRESS:

if(event->button.state & mapping) {

event->button.state|=GDK_MOD1_MASK;

}

break;

case GDK_KEY_PRESS:

if(event->key.state & mapping) {

event->key.state|=GDK_MOD1_MASK;

}

break;

default:

break;

}

}

if (INKSCAPE.trackalt()) {

// MacOS X with X11 has some problem with the default

// xmodmapping. A ~/.xmodmap solution does not work reliably due

// to the way we package our executable in a .app that can launch

// X11 or use an already-running X11. The same problem has been

// reported on Linux but there is no .app/X11 to get in the way

// of ~/.xmodmap fixes. So we make this a preference.

//

// For some reason, Gdk senses changes in Alt (Mod1) state for

// many message types, but not for keystrokes! So this ugly hack

// tracks what the state of Alt-pressing is, and ensures

// GDK_MOD1_MASK is in the event->key.state as appropriate.

//

static gboolean altL_pressed = FALSE;

static gboolean altR_pressed = FALSE;

static gboolean alt_pressed = FALSE;

guint keyval = 0;

switch (event->type) {

case GDK_MOTION_NOTIFY:

alt_pressed = TRUE && (event->motion.state & GDK_MOD1_MASK);

break;

case GDK_BUTTON_PRESS:

alt_pressed = TRUE && (event->button.state & GDK_MOD1_MASK);

break;

case GDK_KEY_PRESS:

keyval = Inkscape::UI::Tools::get_group0_keyval(&event->key);

if (keyval == GDK_KEY_Alt_L) altL_pressed = TRUE;

if (keyval == GDK_KEY_Alt_R) altR_pressed = TRUE;

alt_pressed = alt_pressed || altL_pressed || altR_pressed;

alt_pressed = alt_pressed || (event->button.state & GDK_MOD1_MASK);

if (alt_pressed)

event->key.state |= GDK_MOD1_MASK;

else

event->key.state &= ~GDK_MOD1_MASK;

break;

case GDK_KEY_RELEASE:

keyval = Inkscape::UI::Tools::get_group0_keyval(&event->key);

if (keyval == GDK_KEY_Alt_L) altL_pressed = FALSE;

if (keyval == GDK_KEY_Alt_R) altR_pressed = FALSE;

if (!altL_pressed && !altR_pressed)

alt_pressed = FALSE;

break;

default:

break;

}

//printf("alt_pressed: %s\n", alt_pressed? "+" : "-");

}

gtk_main_do_event (event);

}

static std::vector<Glib::ustring> getDirectorySet(const gchar* userDir, const gchar* const * systemDirs) {

std::vector<Glib::ustring> listing;

listing.push_back(userDir);

for ( const char* const* cur = systemDirs; *cur; cur++ )

{

listing.push_back(*cur);

}

return listing;

}

sp_main_gui(int argc, char const **argv)

{

Gtk::Main main_instance (&argc, const_cast<char ***>(&argv));

GSList *fl = NULL;

int retVal = sp_common_main( argc, argv, &fl );

g_return_val_if_fail(retVal == 0, 1);

// Add possible icon entry directories

std::vector<Glib::ustring> dataDirs = getDirectorySet( g_get_user_data_dir(),

g_get_system_data_dirs() );

for (std::vector<Glib::ustring>::iterator it = dataDirs.begin(); it != dataDirs.end(); ++it)

{

std::vector<Glib::ustring> listing;

listing.push_back(*it);

listing.push_back("inkscape");

listing.push_back("icons");

Glib::ustring dir = Glib::build_filename(listing);

gtk_icon_theme_append_search_path(gtk_icon_theme_get_default(), dir.c_str());

}

// Add our icon directory to the search path for icon theme lookups.

gchar *usericondir = Inkscape::Application::profile_path("icons");

gtk_icon_theme_append_search_path(gtk_icon_theme_get_default(), usericondir);

gtk_icon_theme_append_search_path(gtk_icon_theme_get_default(), INKSCAPE_PIXMAPDIR);

g_free(usericondir);

gdk_event_handler_set((GdkEventFunc)snooper, NULL, NULL);

Inkscape::Debug::log_display_config();

// Set default window icon. Obeys the theme.

gtk_window_set_default_icon_name("inkscape");

// Do things that were previously in inkscape_gtk_stock_init().

sp_icon_get_phys_size(GTK_ICON_SIZE_MENU);

Inkscape::UI::Widget::Panel::prep();

gboolean create_new = TRUE;

/// \todo FIXME BROKEN - non-UTF-8 sneaks in here.

Inkscape::Application::create(argv[0], true);

while (fl) {

if (sp_file_open((gchar *)fl->data,NULL)) {

create_new=FALSE;

}

fl = g_slist_remove(fl, fl->data);

}

if (create_new) {

sp_file_new_default();

}

Glib::signal_idle().connect(sigc::ptr_fun(&Inkscape::CmdLineAction::idle));

main_instance.run();

#ifdef WIN32

//We might not need anything here

//sp_win32_finish(); <-- this is a NOP func

#endif

return 0;

}

static int sp_process_file_list(GSList *fl)

{

int retVal = 0;

#ifdef WITH_DBUS

if (!fl) {

// If we've been asked to listen for D-Bus messages, enter a main loop here

// The main loop may be exited by calling "exit" on the D-Bus application interface.

if (sp_dbus_listen) {

Gtk::Main main_dbus_loop(0, NULL);

main_dbus_loop.run();

}

}

#endif // WITH_DBUS

while (fl) {

const gchar *filename = (gchar *)fl->data;

SPDocument *doc = NULL;

try {

doc = Inkscape::Extension::open(NULL, filename);

} catch (Inkscape::Extension::Input::no_extension_found &e) {

doc = NULL;

} catch (Inkscape::Extension::Input::open_failed &e) {

doc = NULL;

}

if (doc == NULL) {

try {

doc = Inkscape::Extension::open(Inkscape::Extension::db.get(SP_MODULE_KEY_INPUT_SVG), filename);

} catch (Inkscape::Extension::Input::no_extension_found &e) {

doc = NULL;

} catch (Inkscape::Extension::Input::open_failed &e) {

doc = NULL;

}

}

if (doc == NULL) {

g_warning("Specified document %s cannot be opened (does not exist or not a valid SVG file)", filename);

retVal++;

} else {

INKSCAPE.add_document(doc);

if (sp_vacuum_defs) {

doc->vacuumDocument();

}

// Execute command-line actions (selections and verbs) using our local models

bool has_performed_actions = Inkscape::CmdLineAction::doList(INKSCAPE.active_action_context());

#ifdef WITH_DBUS

// If we've been asked to listen for D-Bus messages, enter a main loop here

// The main loop may be exited by calling "exit" on the D-Bus application interface.

if (sp_dbus_listen) {

Gtk::Main main_dbus_loop(0, NULL);

main_dbus_loop.run();

}

#endif // WITH_DBUS

if (!sp_export_svg && (sp_vacuum_defs || has_performed_actions)) {

// save under the name given in the command line

Inkscape::Extension::save(Inkscape::Extension::db.get("org.inkscape.output.svg.inkscape"), doc, filename, false,

false, false, Inkscape::Extension::FILE_SAVE_METHOD_INKSCAPE_SVG);

}

if (sp_global_printer) {

sp_print_document_to_file(doc, sp_global_printer);

}

if (sp_export_png || (sp_export_id && sp_export_use_hints)) {

retVal |= sp_do_export_png(doc);

}

if (sp_export_svg) {

if (sp_export_text_to_path) {

std::vector<SPItem*> items;

SPRoot *root = doc->getRoot();

doc->ensureUpToDate();

for ( SPObject *iter = root->firstChild(); iter ; iter = iter->getNext()) {

SPItem* item = (SPItem*) iter;

if (! (SP_IS_TEXT(item) || SP_IS_FLOWTEXT(item) || SP_IS_GROUP(item))) {

continue;

}

te_update_layout_now_recursive(item);

items.push_back(item);

}

std::vector<SPItem*> selected;

std::vector<Inkscape::XML::Node*> to_select;

sp_item_list_to_curves(items, selected, to_select);

}

if(sp_export_id) {

doc->ensureUpToDate();

// "crop" the document to the specified object, cleaning as we go.

SPObject *obj = doc->getObjectById(sp_export_id);

Geom::OptRect const bbox(SP_ITEM(obj)->visualBounds());

if (bbox) {

doc->fitToRect(*bbox, false);

}

if (sp_export_id_only) {

// If -j then remove all other objects to complete the "crop"

doc->getRoot()->cropToObject(obj);

}

}

Inkscape::Extension::save(Inkscape::Extension::db.get("org.inkscape.output.svg.plain"), doc, sp_export_svg, false,

false, false, Inkscape::Extension::FILE_SAVE_METHOD_SAVE_COPY);

}

if (sp_export_ps) {

retVal |= do_export_ps_pdf(doc, sp_export_ps, "image/x-postscript");

}

if (sp_export_eps) {

retVal |= do_export_ps_pdf(doc, sp_export_eps, "image/x-e-postscript");

}

if (sp_export_pdf) {

retVal |= do_export_ps_pdf(doc, sp_export_pdf, "application/pdf");

}

if (sp_export_emf) {

retVal |= do_export_emf(doc, sp_export_emf, "image/x-emf");

}

if (sp_export_wmf) {

retVal |= do_export_wmf(doc, sp_export_wmf, "image/x-wmf");

}

if (sp_query_all) {

do_query_all (doc);

} else if (sp_query_width || sp_query_height) {

do_query_dimension (doc, true, sp_query_width? Geom::X : Geom::Y, sp_query_id);

} else if (sp_query_x || sp_query_y) {

do_query_dimension (doc, false, sp_query_x? Geom::X : Geom::Y, sp_query_id);

}

INKSCAPE.remove_document(doc);

delete doc;

}

fl = g_slist_remove(fl, fl->data);

}

return retVal;

}

static int sp_main_shell(char const* command_name)

{

int retval = 0;

const unsigned int buffer_size = 4096;

gchar *command_line = g_strnfill(buffer_size, 0);

g_strlcpy(command_line, command_name, buffer_size);

gsize offset = g_strlcat(command_line, " ", buffer_size);

gsize sizeLeft = buffer_size - offset;

gchar *useme = command_line + offset;

fprintf(stdout, "Inkscape %s interactive shell mode. Type 'quit' to quit.\n", Inkscape::version_string);

fflush(stdout);

char* linedata = 0;

do {

fprintf(stdout, ">");

fflush(stdout);

if ((linedata = fgets(useme, sizeLeft, stdin))) {

size_t len = strlen(useme);

if ( (len >= sizeLeft - 1) || (useme[len - 1] != '\n') ) {

fprintf(stdout, "ERROR: Command line too long\n");

// Consume rest of line

retval = -1; // If the while loop completes, this remains -1

while (fgets(useme, sizeLeft, stdin) && retval) {

len = strlen(command_line);

if ( (len < buffer_size) && (command_line[len-1] == '\n') ) {

retval = 0;

}

}

} else {

useme[--len] = '\0'; // Strip newline

if (useme[len - 1] == '\r') {

useme[--len] = '\0';

}

if ( strcmp(useme, "quit") == 0 ) {

// Time to quit

fflush(stdout);

linedata = 0; // mark for exit

} else if ( len < 1 ) {

// blank string. Do nothing.

} else {

GError* parseError = 0;

gchar** argv = 0;

gint argc = 0;

if ( g_shell_parse_argv(command_line, &argc, &argv, &parseError) ) {

poptContext ctx = poptGetContext(NULL, argc, const_cast<const gchar**>(argv), options, 0);

poptSetOtherOptionHelp(ctx, _("[OPTIONS...] [FILE...]\n\nAvailable options:"));

if ( ctx ) {

GSList *fl = sp_process_args(ctx);

if (sp_process_file_list(fl)) {

retval = -1;

}

poptFreeContext(ctx);

} else {

retval = 1; // not sure why. But this was the previous return value

}

resetCommandlineGlobals();

g_strfreev(argv);

} else {

g_warning("Cannot parse commandline: %s", useme);

retval = -1;

}

}

}

} // if (linedata...

} while (linedata && (retval == 0));