AssistantBase::~AssistantBase()
{
gtk_widget_destroy (assistant);
gtk_widget_destroy (signal_button);
if (process_id) {
unix_kill(process_id);
}
}
void GwSpawn::run()
{
describe();
// Working directory.
const gchar *workingdirectory = NULL;
if (!myworkingdirectory.empty())
workingdirectory = myworkingdirectory.c_str();
// Store arguments in argv.
char *argv[myarguments.size() + 2];
// I know these casts are ugly. To do: figure out a better way.
argv[0] = (char *)myprogram.c_str();
for (unsigned int i = 0; i < myarguments.size(); i++) {
argv[i + 1] = (char *)myarguments[i].c_str();
}
// Terminate argv.
argv[myarguments.size() + 1] = NULL;
// Spawn flags.
int flags = G_SPAWN_SEARCH_PATH;
if (mydevnull) {
flags |= (G_SPAWN_STDOUT_TO_DEV_NULL | G_SPAWN_STDERR_TO_DEV_NULL);
}
// Possible pipes.
gint standard_input_filedescriptor = 0;
gint standard_output_filedescriptor;
gint standard_error_filedescriptor;
gint *standard_input_filedescriptor_pointer = NULL;
gint *standard_output_filedescriptor_pointer = NULL;
gint *standard_error_filedescriptor_pointer = NULL;
gchar *standard_output = NULL;
gchar *standard_error = NULL;
gchar **standard_output_pointer = NULL;
gchar **standard_error_pointer = NULL;
if (myread) {
standard_output_filedescriptor_pointer = &standard_output_filedescriptor;
standard_error_filedescriptor_pointer = &standard_error_filedescriptor;
standard_output_pointer = &standard_output;
standard_error_pointer = &standard_error;
}
if (!mywrite.empty()) {
standard_input_filedescriptor_pointer = &standard_input_filedescriptor;
}
// Spawn process.
if (myasync) {
result = g_spawn_async_with_pipes(workingdirectory, argv, NULL, (GSpawnFlags) flags, NULL, NULL, &pid, standard_input_filedescriptor_pointer, standard_output_filedescriptor_pointer, standard_error_filedescriptor_pointer, NULL);
// Handle writing to stdin.
if (standard_input_filedescriptor) {
tiny_spawn_write(standard_input_filedescriptor, mywrite);
close(standard_input_filedescriptor);
}
} else {
result = g_spawn_sync(workingdirectory, argv, NULL, (GSpawnFlags) flags, NULL, NULL, standard_output_pointer, standard_error_pointer, &exitstatus, NULL);
}
// Handle case we didn't spawn the process.
if (!result) {
exitstatus = -1;
ustring message = myprogram;
message.append(_(" didn't spawn"));
gw_critical(message);
return;
}
// Handle progress function.
if (myprogress || standard_input_filedescriptor) {
ProgressWindow *progresswindow = NULL;
if (myprogress)
progresswindow = new ProgressWindow(mytext, myallowcancel);
ustring filename = gw_build_filename("/proc", convert_to_string(pid));
while (g_file_test(filename.c_str(), G_FILE_TEST_EXISTS)) {
if (progresswindow) {
progresswindow->pulse();
if (progresswindow->cancel) {
unix_kill(pid);
cancelled = true;
}
}
g_usleep(500000);
}
// Close pid.
g_spawn_close_pid(pid);
if (progresswindow) { delete progresswindow; }
}
// Handle reading the output.
if (myread) {
// In async mode we've got file descriptors, and in sync mode we have
// gchar * output.
// If async mode, read the output and close the descriptors.
if (myasync) {
GIOChannel *channel_out = g_io_channel_unix_new(standard_output_filedescriptor);
g_io_channel_read_to_end(channel_out, &standard_output, NULL, NULL);
g_io_channel_shutdown(channel_out, false, NULL);
GIOChannel *channel_err = g_io_channel_unix_new(standard_error_filedescriptor);
g_io_channel_read_to_end(channel_err, &standard_error, NULL, NULL);
g_io_channel_shutdown(channel_err, false, NULL);
}
ParseLine parse_out(standard_output);
standardout = parse_out.lines;
ParseLine parse_err(standard_error);
standarderr = parse_err.lines;
// Free data.
if (standard_output)
g_free(standard_output);
if (standard_error)
g_free(standard_error);
}
}
