script.cpp revision 6b15695578f07a3f72c4c9475c1a261a3021472a
/** \file
* Code for handling extensions (i.e.\ scripts).
*/
/*
* Authors:
* Bryce Harrington <bryce@osdl.org>
* Ted Gould <ted@gould.cx>
*
* Copyright (C) 2002-2005 Authors
*
* Released under GNU GPL, read the file 'COPYING' for more information
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <unistd.h>
#include <errno.h>
#include <gtkmm/textview.h>
#include <gtkmm/scrolledwindow.h>
#include "desktop-handles.h"
#include "selection.h"
#include "sp-namedview.h"
#include "prefs-utils.h"
#include "../system.h"
#include "script.h"
#include "util/glib-list-iterators.h"
#ifdef WIN32
#include <windows.h>
#endif
/** This is the command buffer that gets allocated from the stack */
#define BUFSIZE (255)
/* Namespaces */
namespace Inkscape {
namespace Extension {
namespace Implementation {
/* Real functions */
/**
\return A script object
\brief This function creates a script object and sets up the
variables.
This function just sets the command to NULL. It should get built
officially in the load function. This allows for less allocation
of memory in the unloaded state.
*/
{
}
/**
\return A string with the complete string with the relative directory expanded
\brief This function takes in a Repr that contains a reldir entry
and returns that data with the relative directory expanded.
Mostly it is here so that relative directories all get used
the same way.
\param reprin The Inkscape::XML::Node with the reldir in it.
Basically this function looks at an attribute of the Repr, and makes
a decision based on that. Currently, it is only working with the
'extensions' relative directory, but there will be more of them.
One thing to notice is that this function always returns an allocated
string. This means that the caller of this function can always
free what they are given (and should do it too!).
*/
gchar *
}
gchar * filename = g_build_filename(Inkscape::Extension::Extension::search_path[i], sp_repr_children(reprin)->content(), NULL);
return filename;
}
}
} else {
}
return NULL;
}
/**
\return Whether the command given exists, including in the path
\brief This function is used to find out if something exists for
the check command. It can look in the path if required.
\param command The command or file that should be looked for
The first thing that this function does is check to see if the
incoming file name has a directory delimiter in it. This would
mean that it wants to control the directories, and should be
used directly.
If not, the path is used. Each entry in the path is stepped through,
attached to the string, and then tested. If the file is found
then a TRUE is returned. If we get all the way through the path
then a FALSE is returned, the command could not be found.
*/
bool
{
if (*command == '\0') {
/* We check the simple case first. */
return FALSE;
}
/* Don't search when it contains a slash. */
return TRUE;
else
return FALSE;
}
/* There is no `PATH' in the environment.
The default search path is the current directory */
}
break;
}
/* Not sure whether this is UTF8 happy, but it would seem
like it considering that I'm searching (and finding)
the ':' character */
path[0] = '\0';
path++;
} else {
}
if (local_path == '\0') {
} else {
}
return TRUE;
}
}
return FALSE;
}
/**
\return none
\brief This function 'loads' an extention, basically it determines
the full command for the extention and stores that.
\param module The extention to be loaded.
The most difficult part about this function is finding the actual
command through all of the Reprs. Basically it is hidden down a
couple of layers, and so the code has to move down too. When
the command is actually found, it has its relative directory
solved.
At that point all of the loops are exited, and there is an
if statement to make sure they didn't exit because of not finding
the command. If that's the case, the extention doesn't get loaded
and should error out at a higher level.
*/
bool
{
return TRUE;
}
/* This should probably check to find the executable... */
while (child_repr != NULL) {
while (child_repr != NULL) {
if (interpretstr != NULL) {
struct interpreter_t {
gchar * prefstring;
gchar * defaultval;
};
const interpreter_t interpreterlst[] = {
{"perl", "perl-interpreter", "perl"},
{"python", "python-interpreter", "python"},
{"ruby", "ruby-interpreter", "ruby"},
{"shell", "shell-interpreter", "sh"}
}; /* Change count below if you change structure */
for (unsigned int i = 0; i < 4; i++) {
#ifdef _WIN32
else {
char szCurrentDir[MAX_PATH];
}
#endif
break;
}
}
}
}
}
}
break;
}
}
return TRUE;
}
/**
\return None.
\brief Unload this puppy!
\param module Extension to be unloaded.
This function just sets the module to unloaded. It free's the
command if it has been allocated.
*/
void
{
}
if (helper_extension != NULL) {
}
return;
}
/**
\return Whether the check passed or not
\brief Check every dependency that was given to make sure we should keep this extension
\param module The Extension in question
*/
bool
{
while (child_repr != NULL) {
while (child_repr != NULL) {
if (command_text != NULL) {
/* I've got the command */
bool existance;
if (!existance)
return FALSE;
}
}
return FALSE;
}
}
}
break;
}
}
return TRUE;
}
/**
\return A dialog for preferences
\brief A stub funtion right now
\param module Module who's preferences need getting
\param filename Hey, the file you're getting might be important
This function should really do something, right now it doesn't.
*/
{
/*return module->autogui(); */
return NULL;
}
/**
\return A dialog for preferences
\brief A stub funtion right now
\param module Module whose preferences need getting
This function should really do something, right now it doesn't.
*/
{
/*return module->autogui();*/
return NULL;
}
/**
\return A dialog for preferences
\brief A stub funtion right now
\param module Module who's preferences need getting
This function should really do something, right now it doesn't.
*/
{
}
/**
\return A new document that has been opened
\brief This function uses a filename that is put in, and calls
the extension's command to create an SVG file which is
returned.
\param module Extension to use.
\param filename File to open.
First things first, this function needs a temporary file name. To
create on of those the function g_file_open_tmp is used with
the header of ink_ext_.
The extension is then executed using the 'execute' function
with the filname coming in, and the temporary filename. After
That executing, the SVG should be in the temporary file.
Finally, the temporary file is opened using the SVG input module and
a document is returned. That document has its filename set to
the incoming filename (so that it's not the temporary filename).
That document is then returned from this function.
*/
{
int data_read = 0;
// FIXME: process the GError instead of passing NULL
/* Error, couldn't create temporary filename */
/* The last six characters of template were not XXXXXX. Now template is unchanged. */
perror("Extension::Script: template for filenames is misconfigured.\n");
exit(-1);
/* Now the contents of template are undefined. */
perror("Extension::Script: Could not create a unique temporary filename\n");
return NULL;
} else {
perror("Extension::Script: Unknown error creating temporary filename\n");
exit(-1);
}
}
gsize bytesWritten = 0;
if (data_read > 10) {
if (helper_extension == NULL) {
mydoc = Inkscape::Extension::open(Inkscape::Extension::db.get(SP_MODULE_KEY_INPUT_SVG), tempfilename_out);
} else {
}
}
// make sure we don't leak file descriptors from g_file_open_tmp
// FIXME: convert to utf8 (from "filename encoding") and unlink_utf8name
return mydoc;
}
/**
\return none
\brief This function uses an extention to save a document. It first
creates an SVG file of the document, and then runs it through
the script.
\param module Extention to be used
\param doc Document to be saved
\param filename The name to save the final file as
Well, at some point people need to save - it is really what makes
the entire application useful. And, it is possible that someone
would want to use an extetion for this, so we need a function to
do that eh?
First things first, the document is saved to a temporary file that
is an SVG file. To get the temporary filename g_file_open_tmp is used with
ink_ext_ as a prefix. Don't worry, this file gets deleted at the
end of the function.
After we have the SVG file, then extention_execute is called with
the temporary file name and the final output filename. This should
put the output of the script into the final output file. We then
delete the temporary file.
*/
void
{
// FIXME: process the GError instead of passing NULL
/* Error, couldn't create temporary filename */
/* The last six characters of template were not XXXXXX. Now template is unchanged. */
perror("Extension::Script: template for filenames is misconfigured.\n");
exit(-1);
/* Now the contents of template are undefined. */
perror("Extension::Script: Could not create a unique temporary filename\n");
return;
} else {
perror("Extension::Script: Unknown error creating temporary filename\n");
exit(-1);
}
}
if (helper_extension == NULL) {
Inkscape::Extension::save(Inkscape::Extension::db.get(SP_MODULE_KEY_OUTPUT_SVG_INKSCAPE), doc, tempfilename_in, FALSE, FALSE, FALSE);
} else {
Inkscape::Extension::save(Inkscape::Extension::db.get(helper_extension), doc, tempfilename_in, FALSE, FALSE, FALSE);
}
gsize bytesWritten = 0;
// make sure we don't leak file descriptors from g_file_open_tmp
// FIXME: convert to utf8 (from "filename encoding") and unlink_utf8name
}
/**
\return none
\brief This function uses an extention as a effect on a document.
\param module Extention to effect with.
\param doc Document to run through the effect.
This function is a little bit trickier than the previous two. It
needs two temporary files to get it's work done. Both of these
files have random names created for them using the g_file_open_temp function
with the sp_ext_ prefix in the temporary directory. Like the other
functions, the temporary files are deleted at the end.
modules for SVG load and save are used. They are both used through
the module system function by passing their keys into the functions.
The command itself is built a little bit differently than in other
functions because the effect support selections. So on the command
line a list of all the ids that are selected is included. Currently,
this only works for a single selected object, but there will be more.
The command string is filled with the data, and then after the execution
it is freed.
The execute function is used at the core of this function
to execute the Script on the two SVG documents (actually only one
exists at the time, the other is created by that script). At that
point both should be full, and the second one is loaded.
*/
void
{
int data_read = 0;
// FIXME: process the GError instead of passing NULL
/* Error, couldn't create temporary filename */
/* The last six characters of template were not XXXXXX. Now template is unchanged. */
perror("Extension::Script: template for filenames is misconfigured.\n");
exit(-1);
/* Now the contents of template are undefined. */
perror("Extension::Script: Could not create a unique temporary filename\n");
return;
} else {
perror("Extension::Script: Unknown error creating temporary filename\n");
exit(-1);
}
}
// FIXME: process the GError instead of passing NULL
/* Error, couldn't create temporary filename */
/* The last six characters of template were not XXXXXX. Now template is unchanged. */
perror("Extension::Script: template for filenames is misconfigured.\n");
exit(-1);
/* Now the contents of template are undefined. */
perror("Extension::Script: Could not create a unique temporary filename\n");
return;
} else {
perror("Extension::Script: Unknown error creating temporary filename\n");
exit(-1);
}
}
/* fixme: Should be some sort of checking here. Don't know how to do this with structs instead
* of classes. */
local_command += " --id=";
++selected;
}
}
local_command += *paramString;
delete paramString;
// std::cout << local_command << std::endl;
if (data_read > 10)
mydoc = Inkscape::Extension::open(Inkscape::Extension::db.get(SP_MODULE_KEY_INPUT_SVG), tempfilename_out);
// make sure we don't leak file descriptors from g_file_open_tmp
// FIXME: convert to utf8 (from "filename encoding") and unlink_utf8name
/* Do something with mydoc.... */
}
}
/**
\brief A function to take all the svg elements from one document
and put them in another.
\param oldroot The root node of the document to be replaced
\param newroot The root node of the document to replace it with
This function first deletes all of the data in the old document. It
does this by creating a list of what needs to be deleted, and then
goes through the list. This two pass approach removes issues with
the list being change while parsing through it. Lots of nasty bugs.
Then, it goes through the new document, duplicating all of the
elements and putting them into the old document. The copy
is then complete.
*/
void
{
continue;
continue;
}
for (unsigned int i = 0; i < delete_list.size(); i++)
continue;
continue;
}
/** \todo Restore correct layer */
/** \todo Restore correct selection */
}
/* Helper class used by Script::execute */
class pipe_t {
public:
/* These functions set errno if they return false.
I'm not sure whether that's a good idea or not, but it should be reasonably
straightforward to change it if needed. */
bool close();
enum {
mode_read = 1 << 0,
};
private:
#ifdef WIN32
/* This is used to translate win32 errors into errno errors.
It only recognizes a few win32 errors for the moment though. */
#else
#endif
};
/**
\return none
\brief This is the core of the extension file as it actually does
the execution of the extension.
\param in_command The command to be executed
\param filein Filename coming in
\param fileout Filename of the out file
\return Number of bytes that were read into the output file.
The first thing that this function does is build the command to be
executed. This consists of the first string (in_command) and then
the filename for input (filein). This file is put on the command
line.
The next thing is that this function does is open a pipe to the
command and get the file handle in the ppipe variable. It then
opens the output file with the output file handle. Both of these
operations are checked extensively for errors.
After both are opened, then the data is copied from the output
of the pipe into the file out using fread and fwrite. These two
functions are used because of their primitive nature they make
no assumptions about the data. A buffer is used in the transfer,
but the output of fread is stored so the exact number of bytes
is handled gracefully.
At the very end (after the data has been copied) both of the files
are closed, and we return to what we were doing.
*/
int
{
// printf("Executing: %s\n", in_command);
if (errorFileNum != 0) {
} else {
}
// std::cout << "Command to run: " << command << std::endl;
/* Run script */
if (!open_success) {
/* Error - could not open pipe - check errno */
perror("Extension::Script: Invalid mode argument in popen\n");
perror("Extension::Script: Cannot obtain child extension status in popen\n");
} else {
perror("Extension::Script: Unknown error for popen\n");
}
return 0;
}
/* Error - could not open file */
perror("Extension::Script: The mode provided to fopen was invalid\n");
} else {
perror("Extension::Script: Unknown error attempting to open temporary file\n");
}
return 0;
}
/* Copy pipe output to a temporary file */
int amount_read = 0;
int num_read;
amount_read += num_read;
}
/* Close file */
perror("Extension::Script: The filedescriptor for the temporary file is invalid\n");
return 0;
} else {
perror("Extension::Script: Unknown error closing temporary file\n");
}
}
/* Close pipe */
perror("Extension::Script: Invalid mode set for pclose\n");
perror("Extension::Script: Could not obtain child status for pclose\n");
} else {
_("Inkscape has received an error from the script that it called. "
"The text returned with the error is included below. "
"Inkscape will continue working, but the action you requested has been cancelled."));
} else {
perror("Extension::Script: Unknown error for pclose\n");
}
}
/* Could be a lie, but if there is an error, we don't want
* to count on what was read being good */
amount_read = 0;
} else {
_("Inkscape has received additional data from the script executed. "
"The script did not return an error, but this may indicate the results will not be as expected."));
}
}
}
return amount_read;
}
/** \brief This function checks the stderr file, and if it has data,
shows it in a warning dialog to the user
\param filename Filename of the stderr file
*/
void
{
// magic win32 crlf->lf conversion means the file length is not the same as
// the text length, but luckily gtk will accept crlf in textviews so we can
// just use binary mode
if (0 == length) return;
warning.set_resizable(true);
/* Gtk::TextView * textview = new Gtk::TextView(Gtk::TextBuffer::create()); */
textview->set_editable(false);
delete buffer;
scrollwindow->show();
return;
}
#ifdef WIN32
// Create pipe
{
HANDLE t_pipe_read = 0;
return false;
}
// This duplicate handle makes the read pipe uninheritable
if ( !DuplicateHandle(GetCurrentProcess(), t_pipe_read, GetCurrentProcess(), &hpipe, 0, FALSE, DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS) ) {
return false;
}
}
// Open stderr file
HANDLE hStdErrFile = CreateFile(errorFile, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, NULL);
DuplicateHandle(GetCurrentProcess(), hStdErrFile, GetCurrentProcess(), &hInheritableStdErr, 0, TRUE, DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS);
// Create process
{
//startupinfo.lpReserved = 0;
//startupinfo.lpDesktop = 0;
//startupinfo.lpTitle = 0;
return false;
}
}
// Close our copy of the write handle
return true;
}
if ( !retval ) {
}
}
DWORD bytes_read = 0;
return bytes_read;
}
DWORD bytes_written = 0;
return bytes_written;
}
switch (err) {
case ERROR_FILE_NOT_FOUND:
return ENOENT;
case ERROR_INVALID_HANDLE:
case ERROR_INVALID_PARAMETER:
return EINVAL;
default:
return 0;
}
}
#else // Win32
char popen_mode[4] = {0,0,0,0};
char *popen_mode_cur = popen_mode;
*popen_mode_cur++ = 'r';
}
if ( (mode_p & mode_write) != 0 ) {
*popen_mode_cur++ = 'w';
}
/* Get the commandline to be run */
char * temp;
} else
}
}
}
}
#endif // (Non-)Win32
} /* Inkscape */
} /* module */
} /* Implementation */
/*
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:encoding=utf-8:textwidth=99 :