add x-verbs support

(bzr r15136.1.1)

6 files changed, 644 insertions, 2 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 9928f9694..6875eaa38 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -221,6 +221,7 @@ set(inkscape_SRC
   line-geometry.cpp
   line-snapper.cpp
   main-cmdlineact.cpp
+  main-cmdlinexact.cpp
   media.cpp
   message-context.cpp
   message-stack.cpp
@@ -337,6 +338,7 @@ set(inkscape_SRC
   line-snapper.h
   macros.h
   main-cmdlineact.h
+  main-cmdlinexact.h
   media.h
   menus-skeleton.h
   message-context.h
diff --git a/src/main-cmdlineact.cpp b/src/main-cmdlineact.cpp
index c1b756ad5..2d0a5cfd6 100644
--- a/src/main-cmdlineact.cpp
+++ b/src/main-cmdlineact.cpp
@@ -14,6 +14,7 @@
 #include <verbs.h>
 #include <inkscape.h>
 #include <document.h>
+#include <file.h>
 
 #include <glibmm/i18n.h>
 
@@ -22,6 +23,7 @@
 namespace Inkscape {
 
 std::list <CmdLineAction *> CmdLineAction::_list;
+bool CmdLineAction::_requestQuit = false;
 
 CmdLineAction::CmdLineAction (bool isVerb, gchar const * arg) : _isVerb(isVerb), _arg(NULL) {
 	if (arg != NULL) {
@@ -39,10 +41,34 @@ CmdLineAction::~CmdLineAction () {
 	}
 }
 
+bool
+CmdLineAction::isExtended() {
+	return false;
+}
+
+void
+CmdLineAction::doItX (ActionContext const & context)
+{
+	(void)context;
+	printf("CmdLineAction::doItX() %s\n", _arg);
+}
+
 void
 CmdLineAction::doIt (ActionContext const & context) {
 	//printf("Doing: %s\n", _arg);
 	if (_isVerb) {
+		if (isExtended()) {
+			//printf("Is extended\n");
+
+			doItX(context);
+			return;
+		}
+
+		static std::string quit_verb_name = "FileQuit";
+		if (quit_verb_name == _arg) {
+			_requestQuit = true;
+			return;
+		}
 		Inkscape::Verb * verb = Inkscape::Verb::getbyid(_arg);
 		if (verb == NULL) {
 			printf(_("Unable to find verb ID '%s' specified on the command line.\n"), _arg);
@@ -69,10 +95,19 @@ CmdLineAction::doIt (ActionContext const & context) {
 bool
 CmdLineAction::doList (ActionContext const & context) {
   bool hasActions = !_list.empty();
+	if (!hasActions && _requestQuit) {
+		sp_file_exit();
+		return true;
+	}
+
 	for (std::list<CmdLineAction *>::iterator i = _list.begin();
 			i != _list.end(); ++i) {
 		CmdLineAction * entry = *i;
 		entry->doIt(context);
+		if (_requestQuit) {
+			sp_file_exit();
+			return true;
+		}
 	}
   return hasActions;
 }
diff --git a/src/main-cmdlineact.h b/src/main-cmdlineact.h
index b8ec4403b..f50e70e5a 100644
--- a/src/main-cmdlineact.h
+++ b/src/main-cmdlineact.h
@@ -21,15 +21,20 @@ class ActionContext;
 
 class CmdLineAction {
     bool _isVerb;
-    char * _arg;
-
     static std::list <CmdLineAction *> _list;
+    static bool _requestQuit;
+
+protected:
+    char * _arg;
 
 public:
     CmdLineAction (bool isVerb, char const * arg);
     virtual ~CmdLineAction ();
+    virtual bool isExtended();
+    virtual void doItX (ActionContext const & context);
 
     void doIt (ActionContext const & context);
+
     /** Return true if any actions were performed */
     static bool doList (ActionContext const & context);
     static bool idle (void);
diff --git a/src/main-cmdlinexact.cpp b/src/main-cmdlinexact.cpp
new file mode 100644
index 000000000..9efbfe8cd
--- /dev/null
+++ b/src/main-cmdlinexact.cpp
@@ -0,0 +1,526 @@
+/*
+ * Authors:
+ *   Dmitry Zhulanov <dmitry.zhulanov@gmail.com>
+ *
+ * Copyright (C) 2016 Authors
+ *
+ * Released under GNU GPL v2, read the file 'COPYING' for more information
+ *
+ * Format of xverbs.yaml
+ * 
+ * verbose: yes # only "verbose: yes" enable logging
+ * run:
+ *  # open document to process
+ *  - xverb-id: XFileOpen, gfx_sources/loading_screen/sandclock_atlas.svg 
+ *  - xverb-id: XUndoLabel, fresh_document # set label for UndoToLabel xverb works
+ *  # note: if something wrong with undo labels use verb EditUndo instead of XUndoLabel and UndoToLabel at all
+ *
+ *  # select element to handle
+ *  - xverb-id: XSelectElement, top_sand
+ *
+ *  # verbs
+ *  - verb-id: EditInvertInAllLayers
+ *  - verb-id: EditDelete
+ *  - verb-id: FitCanvasToDrawing
+ *
+ *  # save element to separated svg document
+ *  - xverb-id: XFileSaveAs, output/thegame/linux/data/gfx/loading_screen/top_sand.svg
+ *
+ *  # also save png preview
+ *  - xverb-id: XFileExportPNG, output/thegame/linux/data/gfx_preview/loading_screen/top_sand.png
+ *
+ *  # return to the fresh_state of document
+ *  - xverb-id: UndoToLabel, fresh_document 
+ *
+ *  # do any other handling
+ *
+ *  # inkscape have a lot of useful verbs
+ *  - verb-id: FileQuit
+ */
+
+#include <ui/view/view.h>
+#include <desktop.h>
+#include <helper/action.h>
+#include <helper/action-context.h>
+#include <selection.h>
+#include <verbs.h>
+#include <inkscape.h>
+
+#include <document.h>
+
+#include <glibmm/i18n.h>
+
+#include "main-cmdlinexact.h"
+#include "yaml.h"
+#include "extension/system.h"
+#include "file.h"
+#include <glib.h>
+#include "sp-root.h"
+#include "document-undo.h"
+#include "util/units.h"
+#include "sp-namedview.h"
+#include "resource-manager.h"
+#include "ui/dialog/font-substitution.h"
+#include "extension/db.h"
+#include "preferences.h"
+#include "helper/png-write.h"
+#include <document-undo.h>
+#include <ui/view/view-widget.h>
+#include <ui/interface.h>
+
+#define DPI_BASE Inkscape::Util::Quantity::convert(1, "in", "px")
+
+namespace
+{
+bool s_verbose = false;
+
+bool createDirForFilename( const std::string &filename )
+{
+    size_t found = filename.find_last_of("/\\");
+    std::string output_directory = filename.substr(0,found);
+    
+    if( output_directory == filename )
+		return true;
+    
+    if (g_mkdir_with_parents(output_directory.c_str(), 0755))
+    {
+		printf("Can't create directory %s\n", output_directory.c_str());
+		fflush(stdout);
+
+		return false;
+	}
+
+    return true;
+}
+
+void xFileOpen( const Glib::ustring &uri )
+{
+	if (s_verbose) {
+		printf("open %s\n", uri.c_str());
+		fflush(stdout);
+	}
+
+    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+    if (desktop) {
+		SPDocument *old_document = desktop->getDocument();
+        desktop->setWaitingCursor();
+        Inkscape::DocumentUndo::clearRedo(old_document);
+    }
+    
+    SPDocument *doc = NULL;
+    Inkscape::Extension::Extension *key = NULL;
+    try {
+        doc = Inkscape::Extension::open(key, uri.c_str());
+    } catch (std::exception &e) {
+        doc = NULL;
+        std::string exeption_mgs = e.what();
+		printf("Error: open %s:%s\n",uri.c_str(), exeption_mgs.c_str() );
+		fflush(stdout);
+    }
+
+	// Set viewBox if it doesn't exist
+	if (!doc->getRoot()->viewBox_set
+	&& (doc->getRoot()->width.unit != SVGLength::PERCENT)
+	&& (doc->getRoot()->height.unit != SVGLength::PERCENT)) {
+		doc->setViewBox(Geom::Rect::from_xywh(0, 0, doc->getWidth().value(doc->getDisplayUnit()), doc->getHeight().value(doc->getDisplayUnit())));
+	}
+
+	desktop->change_document(doc);
+	doc->emitResizedSignal(doc->getWidth().value("px"), doc->getHeight().value("px"));
+	if(desktop)
+		desktop->clearWaitingCursor();
+
+	doc->virgin = FALSE;
+
+	// everyone who cares now has a reference, get rid of our`s
+	doc->doUnref();
+
+	// resize the window to match the document properties
+	sp_namedview_window_from_document(desktop);
+	sp_namedview_update_layers_from_document(desktop);
+
+	if ( INKSCAPE.use_gui() ) {
+		// Perform a fixup pass for hrefs.
+		if ( Inkscape::ResourceManager::getManager().fixupBrokenLinks(doc) ) {
+			Glib::ustring msg = _("Broken links have been changed to point to existing files.");
+			desktop->showInfoDialog(msg);
+		}
+
+		// Check for font substitutions
+		Inkscape::UI::Dialog::FontSubstitution::getInstance().checkFontSubstitutions(doc);
+	}
+}
+
+void xFileSaveAs( Inkscape::ActionContext const & context, const Glib::ustring &uri )
+{
+	SPDocument *doc = context.getDocument();
+	if (s_verbose) {
+		printf("save as %s\n", uri.c_str());
+		fflush(stdout);
+	}
+
+	if( createDirForFilename( uri )) {
+		Inkscape::Extension::save(
+			Inkscape::Extension::db.get("org.inkscape.output.svg.inkscape"), 
+			doc, uri.c_str(), false, false, true, Inkscape::Extension::FILE_SAVE_METHOD_SAVE_AS);
+		if (s_verbose) {
+			printf("save done: %s\n", uri.c_str() );
+			fflush(stdout);
+		}
+	}
+	else
+	{
+		printf("can't create dirs for filename %s\n", uri.c_str() );
+		fflush(stdout);
+	}
+}
+
+void xFileExportPNG( Inkscape::ActionContext const & context, const Glib::ustring &uri )
+{
+	if (s_verbose) {
+		printf("export png %s\n", uri.c_str());
+		fflush(stdout);
+	}
+
+	SPDocument *doc = context.getDocument();
+
+	gdouble dpi = 200.0;
+	SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+
+	Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+	dpi = prefs->getDouble("/dialogs/export/defaultxdpi/value", DPI_BASE);
+	
+	gdouble width = doc->getWidth().value(doc->getDisplayUnit());
+	gdouble height = doc->getHeight().value(doc->getDisplayUnit());
+	
+	gdouble bmwidth = (width) * dpi / DPI_BASE;
+	gdouble bmheight = (height) * dpi / DPI_BASE;
+	
+	int png_width = (int)(0.5 + bmwidth);
+	int png_height = (int)(0.5 + bmheight);
+	
+	SPNamedView *nv = desktop->getNamedView();
+
+	ExportResult status = sp_export_png_file(doc, uri.c_str(),
+		Geom::Rect(Geom::Point(0,0), Geom::Point(width, height)), png_width, png_height, dpi, dpi,
+		nv->pagecolor, 0, 0, TRUE);
+}
+
+void xSelectElement( Inkscape::ActionContext const & context, const Glib::ustring &uri )
+{
+	if (context.getDocument() == NULL || context.getSelection() == NULL) { return; }
+
+	if (s_verbose) {
+		printf("select element: %s\n", uri.c_str());
+		fflush(stdout);
+	}
+
+	SPDocument * doc = context.getDocument();
+	SPObject * obj = doc->getObjectById(uri);
+
+	if (obj == NULL) {
+		printf(_("Unable to find node ID: '%s'\n"), uri.c_str());
+		fflush(stdout);
+		return;
+	}
+
+	Inkscape::Selection * selection = context.getSelection();
+	selection->add(obj);
+
+	if (s_verbose) {
+		printf("select done %s\n", uri.c_str());
+		fflush(stdout);
+	}
+}
+
+} // end of unnamed namespace
+
+namespace Inkscape {
+
+CmdLineXAction::CmdLineXAction (gchar const * arg, xaction_args_values_map_t &values_map):
+	CmdLineAction(true, arg), _values_map(values_map) {
+	this->arg = (char *)arg;
+	return;
+}
+
+bool
+CmdLineXAction::isExtended() {
+	return true;
+}
+
+void
+CmdLineXAction::doItX (ActionContext const & context) {
+	(void)(context);	
+
+	if( arg == "XFileSaveAs")
+		xFileSaveAs( context, _values_map["filename"] );
+	else if (arg == "XFileOpen")
+		xFileOpen( _values_map["filename"] );
+	else if (arg == "XFileExportPNG")
+		xFileExportPNG( context, _values_map["png_filename"] );
+	else if (arg == "XSelectElement")
+		xSelectElement( context, _values_map["element-id"] );
+	else
+	{
+		printf("unknown xverb: %s", arg.c_str());
+		fflush(stdout);
+	}
+
+	return;
+}
+
+enum parser_state_t{ HANDLING_ROOT,
+	HANDLING_VERBOSE, // options
+	HANDLING_RUN, HANDLING_RUN_LIST, HANDLING_RUN_LIST_ENTRY }; // run entries
+
+struct verb_info_t
+{
+	bool xverb;
+	std::vector<std::string> args;
+};
+
+typedef std::list<verb_info_t> verbs_list_t;
+
+static void tokenize(const std::string& str, std::vector<std::string>& tokens, const std::string& delimiters = ",")
+{
+  // Skip delimiters at beginning.
+  std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
+
+  // Find first non-delimiter.
+  std::string::size_type pos = str.find_first_of(delimiters, lastPos);
+
+  while (std::string::npos != pos || std::string::npos != lastPos) {
+    // Found a token, add it to the vector.
+    tokens.push_back(str.substr(lastPos, pos - lastPos));
+
+    // Skip delimiters.
+    lastPos = str.find_first_not_of(delimiters, pos);
+
+    // Find next non-delimiter.
+    pos = str.find_first_of(delimiters, lastPos);
+  }
+}
+
+void
+CmdLineXAction::createActionsFromYAML( gchar const *yaml_filename ) {
+	FILE *fh = fopen(yaml_filename, "r");
+	if(fh == NULL) {
+		printf("Failed to open file!\n");
+		fflush(stdout);
+		return;
+	}
+
+	yaml_parser_t parser;
+	if(!yaml_parser_initialize(&parser)) {
+		printf("Failed to initialize parser!\n");
+		fflush(stdout);
+		return;
+	}
+
+	/* Set input file */
+	yaml_parser_set_input_file(&parser, fh);
+
+	parser_state_t state = HANDLING_ROOT;
+
+
+	bool handling_key = false;
+	bool handling_value = false;
+
+	std::string key;
+	verbs_list_t verbs_list;
+
+	// parse
+	yaml_token_t token;
+	do {
+		yaml_parser_scan(&parser, &token);
+		switch(token.type)
+		{
+		// avoid "warning: enumeration value", "-Wswitch"
+		case YAML_NO_TOKEN: break;
+		case YAML_STREAM_START_TOKEN: break;
+		case YAML_STREAM_END_TOKEN: break;
+		case YAML_VERSION_DIRECTIVE_TOKEN: break;
+		case YAML_TAG_DIRECTIVE_TOKEN: break;
+		case YAML_DOCUMENT_START_TOKEN: break;
+		case YAML_DOCUMENT_END_TOKEN: break;
+		case YAML_FLOW_SEQUENCE_START_TOKEN: break;
+		case YAML_FLOW_SEQUENCE_END_TOKEN: break;
+		case YAML_FLOW_MAPPING_START_TOKEN: break;
+		case YAML_FLOW_MAPPING_END_TOKEN: break;
+		case YAML_FLOW_ENTRY_TOKEN: break;
+		case YAML_ALIAS_TOKEN: break;
+		case YAML_ANCHOR_TOKEN: break;
+		case YAML_TAG_TOKEN: break;
+
+		/* Token types (read before actual token) */
+		case YAML_KEY_TOKEN:
+			handling_key = true;
+			handling_value = false;
+			break;
+		case YAML_VALUE_TOKEN:
+			handling_key = false;
+			handling_value = true;
+			break;
+
+		/* Block delimeters */
+		case YAML_BLOCK_SEQUENCE_START_TOKEN:
+			if( state == HANDLING_ROOT )
+			{
+				if( key == "run" )
+					state = HANDLING_RUN;
+			}	
+			break;
+		case YAML_BLOCK_ENTRY_TOKEN:
+			if( state == HANDLING_RUN )
+				state = HANDLING_RUN_LIST;
+			else if( state == HANDLING_RUN_LIST )
+				state = HANDLING_RUN_LIST_ENTRY;
+			else if( state == HANDLING_VERBOSE )
+				state = HANDLING_ROOT;
+			break;
+		case YAML_BLOCK_END_TOKEN:
+			if( state == HANDLING_RUN_LIST_ENTRY )
+				state = HANDLING_RUN_LIST;
+			else if( state == HANDLING_RUN_LIST )
+				state = HANDLING_RUN;
+			else if( state == HANDLING_VERBOSE )
+				state = HANDLING_ROOT;
+			else if( state == HANDLING_RUN )
+				state = HANDLING_ROOT;
+			break;
+
+		/* Data */
+		case YAML_BLOCK_MAPPING_START_TOKEN:
+			break;
+		case YAML_SCALAR_TOKEN:
+			if( handling_key )
+				key = (char *)token.data.scalar.value;
+			else if ( handling_value )
+			{
+				if(state == HANDLING_RUN_LIST)
+				{
+					if(key == "xverb-id")
+					{
+						verb_info_t verb;
+						verb.xverb = true;
+
+						std::string values = (char *)token.data.scalar.value;
+						tokenize(values, verb.args);
+						for( size_t i = 0; i < verb.args.size(); ++i )
+						{
+							verb.args[i].erase(0, verb.args[i].find_first_not_of(' '));       //prefixing spaces
+							verb.args[i].erase(verb.args[i].find_last_not_of(' ')+1);         //surfixing spaces
+						}
+						verbs_list.push_back(verb);
+					}
+					else if(key == "verb-id")
+					{
+						verb_info_t verb;
+						verb.xverb = false;
+						verb.args.push_back((char *)token.data.scalar.value);
+						verbs_list.push_back(verb);
+					}
+					else
+					{
+						printf("unknown verb type [%s]\n", key.c_str());
+						fflush(stdout);
+					}
+				}
+				else if(state == HANDLING_ROOT)
+				{
+					std::string value = (char *)token.data.scalar.value;
+					if( (key == "verbose") && (value == "yes") )
+						s_verbose = true;
+				}
+			}
+			break;
+		}
+	} while(token.type != YAML_STREAM_END_TOKEN);
+
+	/* Cleanup */
+	yaml_token_delete(&token);
+	yaml_parser_delete(&parser);
+	fclose(fh);
+
+	typedef std::map<std::string,int> undo_labels_map_t;
+	undo_labels_map_t undo_labels_map;
+	int undo_counter = 0;
+
+	verbs_list_t::iterator iter = verbs_list.begin();
+	for( ; iter != verbs_list.end(); ++iter )
+	{
+		verb_info_t &verb = *iter;
+		std::string &verb_word = verb.args[0];
+		if( s_verbose )
+			printf("handle %s and args count is %d\n", verb_word.c_str(), (int)verb.args.size());
+
+		if( verb.args.size() == 2 )
+		{
+			xaction_args_values_map_t values_map;
+			if (verb_word == "XFileSaveAs" || verb_word == "XFileOpen")
+			{
+				std::string &filename = verb.args[1];
+				values_map["filename"] = filename;
+				new CmdLineXAction(verb_word.c_str(), values_map);
+			}
+			else if (verb_word == "XUndoLabel")
+				undo_labels_map[verb.args[1]] = undo_counter;
+			else if (verb_word == "UndoToLabel")
+			{
+				undo_labels_map_t::iterator iter = undo_labels_map.find(verb.args[1]);
+				if(iter != undo_labels_map.end())
+				{
+					int counter = undo_counter - iter->second;
+					if( counter > 0 )
+					{
+						for(int i = 0; i < counter; ++i)
+							new CmdLineAction(true, "EditUndo");
+						undo_counter -= counter;
+					}
+				}
+			}
+			else if (verb_word == "XSelectElement")
+			{
+				++undo_counter;
+				values_map["element-id"] = verb.args[1];
+				new CmdLineXAction(verb_word.c_str(), values_map);
+			}
+			else if (verb_word == "XFileExportPNG")
+			{
+				std::string &png_filename = verb.args[1];
+				values_map["png_filename"] = png_filename;
+				if(createDirForFilename( png_filename )) {
+					new CmdLineXAction(verb_word.c_str(), values_map);
+				}
+			}
+		}
+		else if(!verb.xverb)
+		{
+			++undo_counter;
+			new CmdLineAction(true, verb.args[0].c_str());
+		}
+
+		else
+		{
+			printf("Unhadled verb %s\n", verb.args[0].c_str());
+			fflush(stdout);
+		}
+	}
+
+	fflush(stdout);
+	return;
+}
+
+
+} // Inkscape
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
diff --git a/src/main-cmdlinexact.h b/src/main-cmdlinexact.h
new file mode 100644
index 000000000..1ac630e55
--- /dev/null
+++ b/src/main-cmdlinexact.h
@@ -0,0 +1,52 @@
+
+#ifndef __INK_MAIN_CMD_LINE_XACTIONS_H__
+#define __INK_MAIN_CMD_LINE_XACTIONS_H__
+
+/** \file
+ * Extended actions that can be queued at the yaml file
+ */
+
+/*
+ * Authors:
+ *   Dmitry Zhulanov <dmitry.zhulanov@gmail.com>
+ *
+ * Copyright (C) 2016 Authors
+ *
+ * Released under GNU GPL v2.x, read the file 'COPYING' for more information
+ */
+
+#include "main-cmdlineact.h"
+#include <string>
+
+namespace Inkscape {
+
+typedef std::map<std::string, std::string > xaction_args_values_map_t;
+
+class CmdLineXAction : public CmdLineAction {
+    std::string arg;
+    xaction_args_values_map_t _values_map;
+public:
+    CmdLineXAction (gchar const * arg, xaction_args_values_map_t &values_map);
+
+    virtual void doItX (ActionContext const & context);
+    virtual bool isExtended();
+
+    static void createActionsFromYAML( gchar const *filename );
+};
+
+} // Inkscape
+
+
+
+#endif /* __INK_MAIN_CMD_LINE_XACTIONS_H__ */
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
diff --git a/src/main.cpp b/src/main.cpp
index 004d96191..d9f11ed8b 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -112,6 +112,7 @@
 #endif
 
 #include "main-cmdlineact.h"
+#include "main-cmdlinexact.h"
 #include "widgets/icon.h"
 
 #include <errno.h>
@@ -127,6 +128,7 @@ enum {
     SP_ARG_NOGUI,
     SP_ARG_GUI,
     SP_ARG_FILE,
+    SP_ARG_XVERBS,
     SP_ARG_PRINT,
     SP_ARG_EXPORT_PNG,
     SP_ARG_EXPORT_DPI,
@@ -227,6 +229,9 @@ static gchar *sp_export_png_utf8 = NULL;
 static gchar *sp_export_svg_utf8 = NULL;
 static gchar *sp_global_printer_utf8 = NULL;
 
+static gchar *sp_xverbs_yaml_utf8 = NULL;
+static gchar *sp_xverbs_yaml = NULL;
+
 
 /**
  *  Reset variables to default values.
@@ -301,6 +306,11 @@ struct poptOption options[] = {
      N_("Open specified document(s) (option string may be excluded)"),
      N_("FILENAME")},
 
+     {"xverbs", 'B',
+     POPT_ARG_STRING, &sp_xverbs_yaml, SP_ARG_XVERBS,
+     N_("xverbs command"),
+     N_("XVERBS_FILENAME")},
+
     {"print", 'p',
      POPT_ARG_STRING, &sp_global_printer, SP_ARG_PRINT,
      N_("Print document(s) to specified output file (use '| program' for pipe)"),
@@ -881,6 +891,7 @@ static int sp_common_main( int argc, char const **argv, GSList **flDest )
         fixupSingleFilename( &sp_export_png, &sp_export_png_utf8 );
         fixupSingleFilename( &sp_export_svg, &sp_export_svg_utf8 );
         fixupSingleFilename( &sp_global_printer, &sp_global_printer_utf8 );
+        fixupSingleFilename( &sp_xverbs_yaml, &sp_xverbs_yaml_utf8 );
     }
     else
     {
@@ -890,6 +901,9 @@ static int sp_common_main( int argc, char const **argv, GSList **flDest )
             sp_export_svg_utf8 = g_strdup( sp_export_svg );
         if ( sp_global_printer )
             sp_global_printer_utf8 = g_strdup( sp_global_printer );
+        if ( sp_xverbs_yaml )
+            sp_xverbs_yaml_utf8 = g_strdup( sp_xverbs_yaml );
+
     }
 
 #ifdef WITH_DBUS
@@ -2131,6 +2145,14 @@ sp_process_args(poptContext ctx)
                 }
                 break;
             }
+            case SP_ARG_XVERBS: {
+                gchar const *fn = poptGetOptArg(ctx);
+                if (fn != NULL) {
+                    sp_xverbs_yaml = g_strdup(fn);
+                    Inkscape::CmdLineXAction::createActionsFromYAML((const char *)sp_xverbs_yaml);
+                }
+                break;
+            }
             case SP_ARG_VERSION: {
                 printf("Inkscape %s (%s)\n", Inkscape::version_string, __DATE__);
                 exit(0);