--- /dev/null
+/* Copyright (c) 2006 by Arkkra Enterprises */
+/* All rights reserved */
+
+// This file includes methods related to the "Run" menu on the main toolbar.
+
+#include "Run.H"
+#include "Preferences.H"
+#include "globals.H"
+#include "Config.H"
+#include "defines.h"
+#include <FL/fl_ask.H>
+#include <FL/filename.H>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <sys/stat.h>
+#ifdef OS_LIKE_UNIX
+#include <sys/wait.h>
+#include <errno.h>
+#endif
+
+// Message for when Mup fails, but we can't figure out why.
+const char * Unknown_Mup_failure = "Mup failed. Reason unknown.";
+
+// Describe use of numbers passed to -x option
+#define EXTRACT_NUM_DESCRIPTION "0 is used for pickup measure.\n" \
+ "Negative numbers are used to specify\n" \
+ "number of measures from the end.\n"
+
+// Tooltip is the same for all macro entries
+const char * macro_definition_tip =
+ "Your Mup input can use macros to vary characteristics\n"
+ "of the output for different runs.\n"
+ "Enter the name of a macro you want to define,\n"
+ "optionally followed by an equals sign and macro definition.\n"
+ "Macro names must consist of upper case letters,\n"
+ "numbers, and underscores, starting with an upper case letter.";
+
+//------ Class for user to set parameters to pass to Mup
+
+Run_parameters_dialog::Run_parameters_dialog(void)
+ : Fl_Double_Window(0, 0, 700, 350, "Mup Options")
+{
+ enable_combine_p = new Fl_Check_Button(20, 20, 165, 30,
+ "Enable Auto Multirest");
+ enable_combine_p->tooltip("Set whether to automatically combine\n"
+ "consecutive measures of rests into a multirest.");
+ enable_combine_p->callback(combine_cb, this);
+ enable_combine_p->when(FL_WHEN_CHANGED);
+
+ rest_combine_p = new Positive_Int_Input(370, 20, 40, 30,
+ "Min Measures to Combine");
+ rest_combine_p->tooltip("Minimum number of consecutive measures\n"
+ "of rest that will be combined into a multirest.");
+ // Only becomes active if auto-multirest combine becomes active
+ rest_combine_p->deactivate();
+
+ // -p firstpage
+ first_page_p = new Positive_Int_Input(300, 60, 50, 30, "First Page's Page Number");
+ first_page_p->tooltip("Set the page number to use\n"
+ "for the first page of music output.");
+
+ // -o pagelist
+ pages_p = new Fl_Group(30, 100, 380, 70, "Pages to Display");
+ pages_p->box(FL_ENGRAVED_BOX);
+ pages_p->align(FL_ALIGN_TOP_LEFT | FL_ALIGN_INSIDE);
+
+ all_p = new Fl_Check_Button(170, 105, 55, 20, "All");
+ all_p->type(FL_RADIO_BUTTON);
+ all_p->tooltip("You can restrict to displaying only a subset\n"
+ "of the pages of music, but this shows all pages.");
+ all_p->callback(selected_pages_cb, this);
+ all_p->when(FL_WHEN_CHANGED);
+
+ odd_p = new Fl_Check_Button(245, 105, 60, 20, "Odd");
+ odd_p->type(FL_RADIO_BUTTON);
+ odd_p->tooltip("This restricts to displaying only\n"
+ "odd numbered pages. This is generally\n"
+ "most useful for printing to a\n"
+ "single-sided printer.");
+ odd_p->callback(selected_pages_cb, this);
+ odd_p->when(FL_WHEN_CHANGED);
+
+ even_p = new Fl_Check_Button(320, 105, 70, 20, "Even");
+ even_p->type(FL_RADIO_BUTTON);
+ even_p->tooltip("This restricts to displaying only\n"
+ "even numbered pages. This is generally\n"
+ "most useful for printing to a\n"
+ "single-sided printer.");
+ even_p->callback(selected_pages_cb, this);
+ even_p->when(FL_WHEN_CHANGED);
+
+ selected_p = new Fl_Check_Button(50, 135, 85, 20, "Selected:");
+ selected_p->tooltip("This restricts to displaying only\n"
+ "the pages you list in the blank to the right.");
+ selected_p->type(FL_RADIO_BUTTON);
+ selected_p->callback(selected_pages_cb, this);
+ selected_p->when(FL_WHEN_CHANGED);
+
+ page_list_p = new Fl_Input(150, 130, 230, 30, "");
+ page_list_p->tooltip("List the specific pages you want displayed.\n"
+ "You can list individual pages separated by commas,\n"
+ "and/or ranges of pages separated by dashes.\n"
+ "Pages may be listed more than once and in any order.");
+ page_list_p->deactivate();
+ saved_page_list = 0;
+ pages_p->end();
+
+ // -s stafflist
+ staff_list_p = new Fl_Input(150, 180, 260, 30, "Staffs to Display/Play");
+ staff_list_p->tooltip("If you wish to display or play only a subset\n"
+ "of the staffs, or voices on a staff, list them here.\n"
+ "Staffs are specified by comma-separated numbers\n"
+ "or ranges, like 1,4 or 1-3,5-6. Staff numbers can be\n"
+ "followed by v1, v2, or v3 to limit to a single voice.\n");
+ saved_staff_list = 0;
+
+ // -x extract list
+ extract_begin_p = new Int_Input(150, 220, 95, 30, "Extract Measures");
+ extract_begin_p->tooltip("If you wish to display or play only selected\n"
+ "measures, enter the starting measure here.\n"
+ EXTRACT_NUM_DESCRIPTION);
+ extract_begin_p->callback(extract_cb, this);
+ extract_begin_p->when(FL_WHEN_CHANGED);
+ extract_end_p = new Int_Input(315, 220, 95, 30, "through");
+ extract_end_p->tooltip("If you wish to display or play only selected\n"
+ "measures, enter the ending measure here.\n"
+ EXTRACT_NUM_DESCRIPTION);
+ extract_end_p->deactivate();
+
+ // Macros
+ macros_group_p = new Fl_Group(430, 20, 250, 40 + MAX_MACROS * 40, "Macro Definitions");
+ macros_group_p->box(FL_ENGRAVED_BOX);
+ macros_group_p->align(FL_ALIGN_TOP | FL_ALIGN_INSIDE);
+ int m;
+ for (m = 0; m < MAX_MACROS; m++) {
+
+ macro_definitions_p[m] = new Fl_Input(450, 50 + m * 40, 210, 30, "");
+ macro_definitions_p[m]->tooltip(macro_definition_tip);
+
+ saved_macro_definitions[m] = 0;
+ }
+ macros_group_p->end();
+
+ save_p = new Fl_Return_Button(100, h() - 50, 80, 30, "Save");
+ save_p->callback(Save_cb, this);
+ save_p->when(FL_WHEN_RELEASE);
+
+ clear_form_p = new Fl_Button((w() - 150) / 2, h() - 50, 150, 30,
+ "Clear Options");
+ clear_form_p->callback(clear_form_cb, this);
+ clear_form_p->when(FL_WHEN_RELEASE);
+
+ cancel_p = new Fl_Button(w() - 180, h() - 50, 80, 30, "Cancel");
+ cancel_p->shortcut(FL_Escape);
+ cancel_p->callback(Cancel_cb, this);
+ cancel_p->when(FL_WHEN_RELEASE);
+
+ // Set everything to default values
+ clear_form();
+
+ // Arrange to clean up all the new-ed widgets in destructor.
+ end();
+
+ // Arrange for window manager closes to do Cancel.
+ callback(Cancel_cb, this);
+ when(FL_WHEN_NEVER);
+}
+
+
+Run_parameters_dialog::~Run_parameters_dialog(void)
+{
+ int m;
+ for (m = 0; m < MAX_MACROS; m++) {
+ if (saved_macro_definitions[m] != 0) {
+ delete saved_macro_definitions[m];
+ }
+ }
+}
+
+
+//---- Callback for when user changes enablement of rest combining,
+// to gray or ungray the field for how many measures to combine.
+
+CALL_BACK(Run_parameters_dialog, combine)
+{
+ if (enable_combine_p->value()) {
+ rest_combine_p->activate();
+ }
+ else {
+ rest_combine_p->value("");
+ rest_combine_p->deactivate();
+ }
+}
+
+
+//---- Callback for when user changes setting of start of measure extraction,
+// to gray or ungray the field for ending measure of extraction.
+
+CALL_BACK(Run_parameters_dialog, extract)
+{
+ if (extract_begin_p->size() > 0) {
+ extract_end_p->activate();
+ }
+ else {
+ extract_end_p->value("");
+ extract_end_p->deactivate();
+ }
+}
+
+//---- Callback for when user changes setting of page selection,
+// to gray or ungray the field for listing the specific pages to display
+
+CALL_BACK(Run_parameters_dialog, selected_pages)
+{
+ page_list_p->value("");
+ if (selected_p->value() == 1) {
+ page_list_p->activate();
+ }
+ else {
+ page_list_p->deactivate();
+ }
+}
+
+
+//----Callback for button for clearing the form
+
+CALL_BACK(Run_parameters_dialog, clear_form)
+{
+ // Set everything to default values
+ saved_enable_combine = false;
+ enable_combine_p->value(saved_enable_combine);
+
+ (void) sprintf(saved_combine_measures, "");
+ rest_combine_p->value(saved_combine_measures);
+
+ (void) sprintf(saved_first_page, "%d", MINFIRSTPAGE);
+ first_page_p->value(saved_first_page);
+
+ if (saved_page_list != 0) {
+ delete saved_page_list;
+ }
+ saved_page_list = new char[1];
+ saved_page_list[0] = '\0';
+ page_list_p->value(saved_page_list);
+ all_p->value(1);
+ saved_pages = ALL_PAGES;
+
+ if (saved_staff_list != 0) {
+ delete saved_staff_list;
+ }
+ saved_staff_list = new char[1];
+ saved_staff_list[0] = '\0';
+ staff_list_p->value(saved_staff_list);
+
+ saved_extract_begin[0] = '\0';
+ extract_begin_p->value(saved_extract_begin);
+ saved_extract_end[0] = '\0';
+ extract_end_p->value(saved_extract_end);
+
+ int m;
+ for (m = 0; m < MAX_MACROS; m++) {
+ macro_definitions_p[m]->value("");
+ if (saved_macro_definitions[m] != 0) {
+ delete saved_macro_definitions[m];
+ saved_macro_definitions[m] = 0;
+ }
+ }
+}
+
+
+//---- callback for when user clicks "Save" on Set Options form
+
+CALL_BACK(Run_parameters_dialog, Save)
+{
+ // -c rest combine option
+ bool error = false;
+ saved_enable_combine = enable_combine_p->value();
+ int num_meas = (int) atoi(rest_combine_p->value());
+ if (saved_enable_combine && (num_meas < MINRESTCOMBINE || num_meas > MAXRESTCOMBINE)) {
+ fl_alert("\"Min Measures to Combine\" must be between\n"
+ "%d and %d.", MINRESTCOMBINE, MAXRESTCOMBINE);
+ error = true;
+ }
+ else {
+ (void) strcpy(saved_combine_measures, rest_combine_p->value());
+ }
+
+ // -p first page option
+ int page_num = (int) atoi(first_page_p->value());
+ if (page_num < MINFIRSTPAGE || page_num > MAXFIRSTPAGE) {
+ fl_alert("\"First Page\" number must be between\n"
+ "%d and %d.", MINFIRSTPAGE, MAXFIRSTPAGE);
+ error = true;
+ }
+ else {
+ (void) strcpy(saved_first_page, first_page_p->value());
+ }
+
+ // We don't really fully parse and error check the -o argument,
+ // but make sure it at least is made up of only valid characters.
+ if (page_list_p->size() > 0) {
+ if (strspn(page_list_p->value(), "0123456789,- \t")
+ != page_list_p->size()) {
+ fl_alert("\"Pages to Display\" value is not valid.");
+ error = true;
+ }
+ else {
+ // Free existing, if any, and save new value.
+ if (saved_page_list != 0) {
+ delete saved_page_list;
+ }
+ saved_page_list = new char[page_list_p->size() + 1];
+ strcpy(saved_page_list, page_list_p->value());
+ }
+ }
+ else if (saved_page_list[0] != '\0') {
+ // Had a list before but not anymore.
+ // Null out the existing list.
+ delete saved_page_list;
+ saved_page_list = new char[1];
+ saved_page_list[0] = '\0';
+ }
+ if (all_p->value() == 1) {
+ saved_pages = ALL_PAGES;
+ }
+ if (odd_p->value() == 1) {
+ saved_pages = ODD_PAGES;
+ }
+ if (even_p->value() == 1) {
+ saved_pages = EVEN_PAGES;
+ }
+ if (selected_p->value() == 1) {
+ saved_pages = SELECTED_PAGES;
+ }
+ if (saved_pages == SELECTED_PAGES && page_list_p->size() == 0) {
+ fl_alert("You did not list which selected pages you want.");
+ error = true;
+ }
+
+ // Similar for staff list (-s option)
+ if (staff_list_p->size() > 0) {
+ if (strspn(staff_list_p->value(), "0123456789,-v \t")
+ != staff_list_p->size()) {
+ fl_alert("\"Staffs to Display/Play\" is not valid");
+ error = true;
+ }
+ else {
+ if (saved_staff_list != 0) {
+ delete saved_staff_list;
+ }
+ saved_staff_list = new char[staff_list_p->size() + 1];
+ strcpy(saved_staff_list, staff_list_p->value());
+ }
+ }
+ else if (saved_staff_list[0] != '\0') {
+ delete saved_staff_list;
+ saved_staff_list = new char[1];
+ saved_staff_list[0] = '\0';
+ }
+
+ // We can't really error check -x option values.
+ // Widget will have already constrained to integer,
+ // and we have no way to know what range is valid,
+ // since we don't know how many measures the song has.
+ // However, to keep things simple, we have fixed-size array of 8 bytes
+ // for saving value, so can only allow up to 6 digits plus sign.
+ if (abs(atoi(extract_begin_p->value())) >= 1000000) {
+ fl_alert("\"Extract Measures\" start value is out of range.");
+ error = true;
+ }
+ else {
+ (void) strcpy(saved_extract_begin, extract_begin_p->value());
+ }
+ if (abs(atoi(extract_end_p->value())) >= 1000000) {
+ fl_alert("\"Extract Measures\" end value is out of range.");
+ error = true;
+ }
+ else {
+ (void) strcpy(saved_extract_end, extract_end_p->value());
+ }
+
+ // Macros
+ int m;
+ int macsize;
+ bool changed;
+ for (m = 0; m < MAX_MACROS; m++) {
+ changed = false;
+ if ((macsize = macro_definitions_p[m]->size()) > 0) {
+ if (macro_error(macro_definitions_p[m]->value())) {
+ fl_alert("Macro %d has invalid format.", m + 1);
+ error = true;
+ }
+ else if (saved_macro_definitions[m] == 0) {
+ // no macro before, but is one now
+ changed = true;
+ }
+ else if (strcmp(macro_definitions_p[m]->value(),
+ saved_macro_definitions[m]) != 0) {
+ // A different macro value than before
+ delete saved_macro_definitions[m];
+ changed = true;
+ }
+ if (changed) {
+ saved_macro_definitions[m] = new char[macsize + 1];
+ (void) strcpy(saved_macro_definitions[m],
+ macro_definitions_p[m]->value());
+ }
+ }
+ else if (macsize == 0 && saved_macro_definitions[m] != 0) {
+ // Used to be a macro value, but not anymore
+ delete saved_macro_definitions[m];
+ saved_macro_definitions[m] = 0;
+ }
+ }
+
+
+ // If there were user errors, we leave the window up for user to
+ // correct the errors. User can, of course, cancel without correcting,
+ // in which case if they try to run, Mup will complain about the
+ // bad arguments.
+ if ( ! error ) {
+ hide();
+ }
+}
+
+
+//---- Callback for when user clicks "Cancel" on Set Options form
+
+CALL_BACK(Run_parameters_dialog, Cancel)
+{
+ // Put back all the previous values
+ enable_combine_p->value(saved_enable_combine);
+ rest_combine_p->value(saved_combine_measures);
+ first_page_p->value(saved_first_page);
+
+ // It seems setting a radio button via value(1) doesn't reset the
+ // others, so clear all, then set the one we want
+ all_p->value(0);
+ odd_p->value(0);
+ even_p->value(0);
+ selected_p->value(0);
+ switch (saved_pages) {
+ default: // default should be impossible
+ case ALL_PAGES:
+ all_p->value(1);
+ break;
+ case ODD_PAGES:
+ odd_p->value(1);
+ break;
+ case EVEN_PAGES:
+ even_p->value(1);
+ break;
+ case SELECTED_PAGES:
+ selected_p->value(1);
+ break;
+ }
+ page_list_p->value(saved_page_list);
+ staff_list_p->value(saved_staff_list);
+ extract_begin_p->value(saved_extract_begin);
+ extract_end_p->value(saved_extract_end);
+
+ int m;
+ for (m = 0; m < MAX_MACROS; m++) {
+ macro_definitions_p[m]->value( saved_macro_definitions[m] == 0
+ ? "" : saved_macro_definitions[m]);
+ }
+ hide();
+}
+
+// Return true if check of macro finds an error.
+
+bool
+Run_parameters_dialog::macro_error(const char * macro)
+{
+ // First character must be an upper case letter.
+ if ( ! isupper(macro[0])) {
+ return(true);
+ }
+ // Everything up to = or end of string, whichever comes first,
+ // must be upper case letter, digit, or underscore.
+ const char * m_p;
+ for (m_p = macro; *m_p != '\0' && *m_p != '='; m_p++) {
+ if ( ! isupper(*m_p) && ! isdigit(*m_p) && *m_p != '_') {
+ return(true);
+ }
+ }
+ return(false);
+}
+
+
+//--------class for Run menu -----------------------------------------------
+
+Run::Run()
+{
+ parameters_p = 0;
+ report_p = 0;
+#ifdef OS_LIKE_WIN32
+ display_child.hProcess = 0;
+ display_child.dwProcessId = 0;
+ MIDI_child.hProcess = 0;
+ MIDI_child.dwProcessId = 0;
+#else
+ display_child = 0;
+ MIDI_child = 0;
+#endif
+}
+
+Run::~Run()
+{
+ if (parameters_p != 0) {
+ delete parameters_p;
+ parameters_p = 0;
+ }
+ if (report_p != 0) {
+ delete report_p;
+ report_p = 0;
+ }
+ // Kill off any child processes
+ clean_up();
+}
+
+
+
+//------------callback for Display menu item
+
+CALL_BACK(Run, Display)
+{
+ Run_Mup(false, true);
+}
+
+
+//-----Callback for menu item to play MIDI file
+
+CALL_BACK(Run, Play)
+{
+ Run_Mup(true, true);
+}
+
+
+//---------callback for menu item for writing PostScript output
+
+CALL_BACK(Run, WritePostScript)
+{
+ Run_Mup(false, false);
+}
+
+//---------callback for menu item for writing MIDI output
+
+CALL_BACK(Run, WriteMIDI)
+{
+ Run_Mup(true, false);
+}
+
+//---- callback for menu item to collect Mup command line parameters from user
+
+CALL_BACK(Run, Options)
+{
+ if (parameters_p == 0) {
+ parameters_p = new Run_parameters_dialog();
+ }
+ parameters_p->show();
+}
+
+
+//--------- This lets Run class know the file name and editor buffer,
+// which it needs access to, so it can run Mup on its contents.
+
+void
+Run::set_file(File * file_info_p)
+{
+ file_p = file_info_p;
+}
+
+
+// Run Mup commands with user's parameters on the current file
+
+void
+Run::Run_Mup(bool midi, bool show_or_play)
+{
+
+ const char * mup_input = file_p->effective_filename();
+ // Make sure file has been written.
+ // The fiilename == 0 will be hit in the case where
+ // user did New From Template but made no changes.
+ if (file_p->unsaved_changes || file_p->filename == 0) {
+ int auto_save;
+ (void) Preferences_p->get(Auto_save_preference, auto_save,
+ Default_auto_save);
+ if (auto_save) {
+ file_p->Save(false);
+ if (file_p->unsaved_changes || file_p->filename == 0) {
+ // User probably canceled a Save that got
+ // turned into a SaveAs,
+ // or maybe Save failed. If not properly
+ // saved, we shouldn't try to process it.
+ return;
+ }
+ }
+ else {
+ bool hide_the_No;
+ const char * extra_text;
+ // If there is a previous version of the file,
+ // allow user to select "No," which means use that
+ // previous version rather than writing out current.
+ if (access(mup_input, F_OK) == 0) {
+ hide_the_No = false;
+ extra_text = "(If you select \"No,\" "
+ "the most recently saved version "
+ "of the Mup input file will be used.)";
+ }
+ else {
+ // No previous version
+ hide_the_No = true;
+ extra_text = "";
+ }
+ switch (file_p->save_changes_check(extra_text, hide_the_No)) {
+ default: // default case should be impossible
+ case Save_confirm_dialog::Cancel:
+ return;
+ case Save_confirm_dialog::No:
+ break;
+ case Save_confirm_dialog::Yes:
+ file_p->Save(false);
+ if (file_p->unsaved_changes
+ || file_p->filename == 0) {
+ // User probably canceled the Save,
+ // or maybe it failed. If not properly
+ // saved, we shouldn't try to process it.
+ return;
+ }
+ break;
+ }
+ }
+ // If was "Untitled" before, it is now saved under a good
+ // name, so get what that is.
+ mup_input = file_p->effective_filename();
+ }
+
+ // Get length of file name without the extension
+ int base_length = strlen(mup_input)
+ - strlen(fl_filename_ext(mup_input));
+
+ // Create output file name
+ char mup_output[base_length + (midi ? 5 : 4)];
+ strncpy(mup_output, mup_input, base_length);
+ strcpy(mup_output + base_length, (midi ? ".mid" : ".ps"));
+
+ // Create error file name
+ char mup_error[base_length + 5];
+ strncpy(mup_error, mup_input, base_length);
+ strcpy(mup_error + base_length, ".err");
+
+ // Get Mup command to use.
+ char * mup_command;
+ (void) Preferences_p->get(Mup_program_location, mup_command,
+ Default_Mup_program_location);
+ char full_location[FL_PATH_MAX];
+ if ( ! find_executable(mup_command, full_location)) {
+ fl_alert("Mup command not found.\n"
+ "Check Config > File Locations setting.");
+ return;
+ }
+
+ if (parameters_p == 0) {
+ // User hasn't set any parameters, so we will use all
+ // defaults. Creating the instance lets us deference it
+ // below, so we don't have to care whether user ever
+ // went to the Set Options page or not.
+ parameters_p = new Run_parameters_dialog();
+ }
+
+ // Build up list of arguments.
+ // array slots needed for args:
+ // 1 for Mup command itself
+ // 2 for -e and arg
+ // 2 for -f or -m and arg
+ // 2 for -c and arg
+ // 2 for -p and arg
+ // 2 for -o and arg
+ // 2 for -s and arg
+ // 2 for -x and arg
+ // 1 for Mup input file name
+ // 2 for each -D and its macro definition arg
+ // 1 for null terminator
+ const char * command[17 + 2 * MAX_MACROS];
+ command[0] = full_location;
+ command[1] = "-e";
+ command[2] = mup_error;
+ command[3] = (midi ? "-m" : "-f");
+ command[4] = mup_output;
+ int arg_offset = 5;
+
+ // rest combine
+ if (parameters_p->enable_combine_p->value() &&
+ parameters_p->rest_combine_p->size() > 0) {
+ command[arg_offset++] = "-c";
+ command[arg_offset++] = parameters_p->rest_combine_p->value();
+ }
+
+ // first page
+ if (parameters_p->first_page_p->size() > 0) {
+ command[arg_offset++] = "-p";
+ command[arg_offset++] = parameters_p->first_page_p->value();
+ }
+
+ // page list
+ switch (parameters_p->saved_pages) {
+ default: // default should be impossible
+ case Run_parameters_dialog::ALL_PAGES:
+ break;
+ case Run_parameters_dialog::ODD_PAGES:
+ command[arg_offset++] = "-o";
+ command[arg_offset++] = "odd";
+ break;
+ case Run_parameters_dialog::EVEN_PAGES:
+ command[arg_offset++] = "-o";
+ command[arg_offset++] = "even";
+ case Run_parameters_dialog::SELECTED_PAGES:
+ if (parameters_p->page_list_p->size() > 0) {
+ command[arg_offset++] = "-o";
+ command[arg_offset++] = parameters_p->page_list_p->value();
+ }
+ // Else they said selected, but then didn't list
+ // any particular pages. We treat like ALL_PAGES,
+ // since no pages is useless.
+ // We would have already given error message,
+ // but they must have ignored it.
+ break;
+ }
+
+ // staff list
+ if (parameters_p->staff_list_p->size() > 0) {
+ command[arg_offset++] = "-s";
+ command[arg_offset++] = parameters_p->staff_list_p->value();
+ }
+
+ // extract list
+ char xoption[parameters_p->extract_begin_p->size()
+ + parameters_p->extract_end_p->size() + 2];
+ if (parameters_p->extract_begin_p->size() > 0) {
+ command[arg_offset++] = "-x";
+ (void) strcpy(xoption, parameters_p->extract_begin_p->value());
+ if (parameters_p->extract_end_p->size() > 0) {
+ (void) strcat(xoption, ",");
+ (void) strcat(xoption, parameters_p->extract_end_p->value());
+ }
+ command[arg_offset++] = xoption;
+ }
+
+ // -D options
+ int m;
+ for (m = 0; m < MAX_MACROS; m++) {
+ if (parameters_p->saved_macro_definitions[m] != 0) {
+ command[arg_offset++] = "-D";
+ command[arg_offset++] = parameters_p->saved_macro_definitions[m];
+ }
+ }
+
+ // Mup input file name and null terminator
+ command[arg_offset++] = mup_input;
+ command[arg_offset++] = 0;
+
+ static bool set_mupquiet = false;
+ if ( ! set_mupquiet ) {
+ putenv("MUPQUIET=1");
+ set_mupquiet = true;
+ }
+
+ // Look up the right (dis)player program to use.
+ // On Windows we need this even if we are only writing the file,
+ // not actually (dis)playing. To keep the code simpler,
+ // we just always look it up.
+ char * player_command;
+ if (midi) {
+ (void) Preferences_p->get(MIDI_player_location,
+ player_command,
+ Default_MIDI_player_location);
+ }
+ else {
+ (void) Preferences_p->get(Viewer_location,
+ player_command,
+ Default_viewer_location);
+ }
+#ifdef OS_LIKE_WIN32
+ // Media player locks the file it plays, so if we had
+ // run it before, we have to make it release the lock
+ // before we run Mup. Also, if it was playing a different file
+ // before, it doesn't seem to want to play ours.
+ // So if the MIDI player of choice is the media player,
+ // we first try to make it close somewhat gracefully,
+ // and wait a second for that to complete.
+ // In any case we try to kill off any child MIDI players we
+ // know of. If the graceful close already worked,
+ // it should find the child already dead.
+ // If they are using some other MIDI player,
+ // we don't know what to do, so we'll just kill any child
+ // MIDI player we know spawned previously, if any.
+ // Would be nice to be able to do something less drastic than
+ // kill the process, but we're not sure what else would be effective.
+ if (midi) {
+ if (is_mplayer(player_command)) {
+ HWND window_handle;
+ if ((window_handle = FindWindow(0, "Windows Media Player")) != 0) {
+ SendMessage(window_handle, WM_CLOSE, 0, 0);
+ }
+ _sleep(1000);
+ }
+ if (has_MIDI_child()) {
+ kill_process(&MIDI_child, "MIDI player");
+ }
+ }
+ // Somewhat similarly, we kill off any prior displayer, unless
+ // the displayer is GSview, which we know we can pass -e argument
+ // to make it reuse existing instance, if any.
+ else if ( ! is_gsview(player_command) && has_display_child()) {
+ kill_process(&display_child, "display");
+ }
+#endif
+
+ // Run the command.
+ int ret = execute_command(command, 0, true);
+
+ // Report the errors, if any.
+ struct stat info;
+ if (stat(mup_error, &info) == 0) {
+ if (info.st_size > 0) {
+ if (report_p == 0) {
+ report_p = new Error_report();
+ }
+ report_p->loadfile(mup_error);
+ report_p->show();
+ }
+ unlink(mup_error);
+ }
+ else if (ret != 0) {
+ // Exited with error, but left no error file.
+ // Must have died badly (core dumped, execvp failed, etc)
+#if defined(WIFEXITED) && defined(WIFSIGNALED)
+ if (WIFEXITED(ret)) {
+ // Did exit(), so most likely exec failed
+ // due to bad path to Mup program,
+ // although we should have caught that above.
+ fl_alert("Mup exited with return code %d but no error output.\n"
+ "Check Config > File Locations setting.",
+ WEXITSTATUS(ret));
+ }
+ else if (WIFSIGNALED(ret)) {
+ // Probably core dump :-(
+ fl_alert("Mup exited due to signal %d.", WTERMSIG(ret));
+ } else {
+ fl_alert(Unknown_Mup_failure);
+ }
+#else // WIF... macros not defined
+ if (ret == -1) {
+#ifdef OS_LIKE_WIN32
+ // Look up the error reason to include in message.
+ DWORD format_retval;
+ LPVOID error_string = 0;
+ if (FormatMessage(
+ FORMAT_MESSAGE_ALLOCATE_BUFFER
+ | FORMAT_MESSAGE_FROM_SYSTEM
+ | FORMAT_MESSAGE_ARGUMENT_ARRAY,
+ 0, GetLastError(),
+ LANG_NEUTRAL, (LPTSTR)&error_string,
+ 0, 0)) {
+ fl_alert("Failed to execute Mup program:\n%s"
+ "Check settings in Config > File Locations.",
+ (char *) error_string);
+ LocalFree((HLOCAL)error_string);
+ }
+ else {
+ fl_alert(Unknown_Mup_failure);
+ }
+ }
+#else // not Windows
+ fl_alert(Unknown_Mup_failure);
+ }
+#endif
+ else {
+ fl_alert(Unknown_Mup_failure);
+ }
+#endif // WIF... macros
+ }
+
+ if (ret != 0) {
+ // Something went wrong. We should not go on to
+ // display/play even if user had asked for that.
+ return;
+ }
+
+ // We wrote the output file successfully.
+ // Hide any previous error window and
+ // check if we need to (dis)play the results.
+ if (report_p != 0) {
+ report_p->hide();
+ }
+ if ( ! show_or_play ) {
+ // User just asked to generate a file, not (dis)play it.
+ fl_message("%s output file\n\n %s\n\n"
+ "has been successfully created.",
+ (midi ? "MIDI" : "PostScript"), mup_output);
+ return;
+ }
+
+
+ if ( ! find_executable(player_command, full_location)) {
+ fl_alert("Unable to run %s command.\n"
+ "Check Config > File Locations setting.",
+ player_command);
+ return;
+ }
+
+#ifdef OS_LIKE_UNIX
+ // For MIDI, we try to kill the previous player
+ // if any, since we'll probably need the same
+ // sound card. Note that for Windows, we did this
+ // even before running Mup, since the player may lock
+ // the file so Mup would be unable to write it.
+ if (midi) {
+ kill_process(&MIDI_child, "MIDI player");
+ }
+
+ // If using gv as displayer and one already running on
+ // this file, it would be nice to get send it SIGHUP
+ // to make it re-read the file
+ // rather than starting a new one.
+ // But for other displayers, we don't know what signal
+ // might work, if any. And even with gv, if we send
+ // the signal, we have no way of knowing whether it
+ // actually worked. And there are lots of cases to
+ // consider. Suppose the displayer was gv,
+ // and they brought up an instance,
+ // then they changed to some other displayer,
+ // and then back to gv. Should we have killed off
+ // the first gv when bringing up the other viewer,
+ // of should we keep it up and reuse it after they
+ // change back? What if they kill the current
+ // instance just after we decided to re-use it?
+ // So just keep things simple for now. Always
+ // kill off any existing viewer we know of and
+ // start up a new one.
+ else { // displaying
+ kill_process(&display_child, "display");
+ }
+#endif
+
+ // Fill in the argv array for displayer/player
+ command[0] = full_location;
+#ifdef OS_LIKE_WIN32
+ // Media player appears to ignore its argument
+ // if it isn't a full path name, including drive.
+ // So ensure we have everything.
+ char fullpath[FL_PATH_MAX];
+ if (mup_output[1] != ':' ) {
+ // We don't have complete path.
+ // Get current directory including drive.
+ if (getcwd(fullpath, sizeof(fullpath)) == 0) {
+ fl_alert("Unable to determine current folder.");
+ return;
+ }
+ if (mup_output[0] != dir_separator()) {
+ // Relative path
+ (void) sprintf(fullpath + strlen(fullpath),
+ "%c%s", dir_separator(),
+ mup_output);
+ }
+ else {
+ // Was full path except for drive.
+ (void) strcpy(fullpath + 2, mup_output);
+ }
+ }
+ else {
+ // Can use existing path as is.
+ (void) strcpy(fullpath, mup_output);
+ }
+
+ if ( ! midi && is_gsview(player_command)) {
+ // For gsview, use -e to make it use
+ // existing instance if any.
+ command[1] = "-e";
+ command[2] = fullpath;
+ command[3] = '\0';
+ }
+ else {
+ command[1] = fullpath;
+ command[2] = '\0';
+
+ }
+#else
+ command[1] = mup_output;
+ command[2] = '\0';
+#endif
+
+ if (execute_command(command,
+ (midi ? &MIDI_child : &display_child)) != 0) {
+ fl_alert("Unable to run %s command.\n"
+ "Check settings under Config > File Locations.",
+ command[0]);
+ }
+}
+
+
+// Execute given command with the given argv.
+// If proc_info_p is zero, wait for the process to complete,
+// otherwise save information about the spawned process in what it points to,
+// so that the caller can keep track of it while it runs independently.
+// The hide_window parameter is only used for Windows and causes the
+// spawned process to be created with flags to not create a window,
+// This lets us use a console mode version of Mup, so traditional users
+// can continue to run Mup in a console without mupmate, but we can
+// run the same .exe without the annoyance of a console popping up.
+// Returns 0 on success, -1 on failure to create process,
+// or what the process returned if it had non-zero exit code,
+// and was waited for.
+
+int
+Run::execute_command(const char ** argv, Proc_Info *proc_info_p, bool hide_window)
+{
+ int ret = -1;
+
+#ifdef OS_LIKE_UNIX
+ pid_t child;
+ switch (child = fork()) {
+ case 0:
+ execvp(argv[0], (char * const *)argv);
+ // If here, the exec failed. Child must die.
+ exit(1);
+ case -1:
+ // failed
+ if (proc_info_p != 0) {
+ *proc_info_p = 0;
+ }
+ break;
+ default:
+ if (proc_info_p == 0) {
+ // wait for child to complete
+ if (waitpid(child, &ret, 0) < 0) {
+ ret = -1;
+ }
+ }
+ else {
+ *proc_info_p = child;
+ ret = 0;
+ }
+ break;
+ }
+#else
+
+#ifdef OS_LIKE_WIN32
+
+ // Convert the argv array into a string with each argument quoted.
+ // First calculate how much space is needed.
+ int a;
+ int length = 0;
+ bool has_quote = false; // to optimize normal case
+ for (a = 0; argv[a] != 0; a++) {
+ length += strlen(argv[a]);
+ // A quoted argv[0] won't work; just quote the other args.
+ if (a > 0) {
+ // Add space before the arg and quotes on each end.
+ length += 3;
+ const char * s;
+ // If embedded quote, add space for escaping it
+ for (s = argv[a]; *s != '\0'; s++) {
+ if (*s == '"') {
+ length++;
+ has_quote = true;
+ }
+ }
+ }
+ }
+
+ // Get space and fill in all the arguments, properly quoted.
+ char command[length + 1];
+ (void) strcpy(command, argv[0]);
+ char * dest = command + strlen(command);
+ for (a = 1; argv[a] != 0; a++) {
+ *dest++ = ' ';
+ *dest++ = '"';
+ if (has_quote) {
+ int i;
+ for (i = 0; argv[a][i] != '\0'; i++) {
+ if (argv[a][i] == '"') {
+ *dest++ = '\\';
+ }
+ *dest++ = argv[a][i];
+ }
+ }
+ else {
+ (void) strcpy(dest, argv[a]);
+ dest += strlen(dest);
+ }
+ *dest++ = '"';
+ }
+ *dest = '\0';
+
+ // Fill in information for starting up the process
+ PROCESS_INFORMATION process_info;
+ STARTUPINFO startup_info;
+ memset( &startup_info, 0, sizeof(startup_info));
+ startup_info.cb = sizeof(startup_info);
+ DWORD create_flags; // flags to control creation aspects
+ if (hide_window) {
+ startup_info.dwFlags = STARTF_USESHOWWINDOW;
+ startup_info.wShowWindow = SW_HIDE;
+ create_flags = CREATE_NO_WINDOW;
+ }
+ else {
+ create_flags = 0;
+ }
+
+ // Run the process
+ BOOL proc = CreateProcess(NULL, command, NULL, NULL,
+ TRUE, create_flags, NULL, NULL,
+ &startup_info, &process_info);
+
+ if (proc) {
+ // It was successfully created.
+ if (proc_info_p == 0) {
+ // wait for child to complete
+ DWORD result = WaitForSingleObject(
+ process_info.hProcess, INFINITE);
+ switch (result) {
+ case WAIT_FAILED:
+ case WAIT_ABANDONED:
+ case WAIT_TIMEOUT:
+ ret = -1;
+ break;
+ default:
+ GetExitCodeProcess(process_info.hProcess, &result);
+ ret = (int) result;
+ }
+ }
+ else {
+ *proc_info_p = process_info;
+ ret = 0;
+ }
+ }
+ else {
+ proc_info_p->hProcess = 0;
+ proc_info_p->dwProcessId = 0;
+ ret = -1;
+ }
+
+#else
+ fl_alert("Process execution only implemented\n"
+ "for Linux (and similar) and Windows so far...");
+ ret = -1;
+#endif
+
+#endif
+ return(ret);
+}
+
+
+// Kill the specified process, if it exists.
+// The description is used in error messages
+
+void
+Run::kill_process(const Proc_Info * const proc_info_p, const char * const description)
+{
+#ifdef OS_LIKE_UNIX
+ int exitstatus;
+ if (*proc_info_p == 0 || waitpid(*proc_info_p, &exitstatus, WNOHANG)
+ == *proc_info_p) {
+ // No process spawned or the one we had already died
+ return;
+ }
+ // Not clear how hard to try to kill process.
+ // SIGTERM should usually work, and is preferable if it works.
+ // We wait a little while and try SIGKILL if it hasn't died yet.
+ // We don't check for errors, because the
+ // only errors that should be possible are bad signal (should be
+ // impossible, since we hard-code SIGTERM), process doesn't exist
+ // (already dead, so no need to kill it), or bad permission (we
+ // spawned it ourself, so ought to have permission to kill it).
+ (void) kill(*proc_info_p, SIGTERM);
+ // Wait for up to 3 seconds for it to die
+ int w;
+ int ret;
+ for (w = 0; w < 3; w++) {
+ if ((ret = waitpid(*proc_info_p, &exitstatus, WNOHANG))
+ == *proc_info_p) {
+ // It died.
+ // *** Especially in the case of MIDI, there is a
+ // chance the player has already written stuff out
+ // to the device driver that it won't clear out when
+ // it dies, so that if we try to start a new one,
+ // the device will still be busy. But we have no way
+ // to know how long to wait, if at all, and don't
+ // want to always sleep a long time just to cover
+ // the case of trying to play again while in the middle
+ // of playing.
+ return;
+ }
+ if (ret == -1 && errno == ECHILD) {
+ // Child doesn't exist, so nothing to kill
+ return;
+ }
+ sleep(1);
+ }
+ // Okay. Resort to SIGKILL and wait 1 more second to let it die.
+ kill(*proc_info_p, SIGKILL);
+ sleep(1);
+#endif
+#ifdef OS_LIKE_WIN32
+ if (proc_info_p->hProcess == 0 || WaitForSingleObject(
+ proc_info_p->hProcess, 0) != WAIT_TIMEOUT) {
+ // No process spawned or the one we had must have already died.
+ return;
+ }
+ HANDLE handle;
+ if ( (handle = OpenProcess(PROCESS_TERMINATE,
+ FALSE, proc_info_p->dwProcessId)) == 0 ||
+ TerminateProcess(handle, 0) == 0) {
+ // Warn user we were unable to kill the old child.
+ DWORD format_retval;
+ LPVOID error_string = 0;
+ if (FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER
+ | FORMAT_MESSAGE_FROM_SYSTEM
+ | FORMAT_MESSAGE_ARGUMENT_ARRAY,
+ 0, GetLastError(),
+ LANG_NEUTRAL, (LPTSTR)&error_string,
+ 0, 0)) {
+ fl_alert("Unable to terminate %s process.\n%s",
+ description, (char *) error_string);
+ LocalFree((HLOCAL)error_string);
+ }
+ }
+ if (handle != 0) {
+ CloseHandle(handle);
+ }
+#endif
+}
+
+
+#ifdef OS_LIKE_WIN32
+// Return true if the given command is for Windows Media Player.
+
+bool
+Run::is_mplayer(const char * command)
+{
+ int length = strlen(command);
+ if (strcasecmp(command + length - 12, "wmplayer.exe") == 0 ||
+ strcasecmp(command + length - 11, "mplayer.exe") == 0 ||
+ strcasecmp(command + length - 8, "wmplayer") == 0 ||
+ strcasecmp(command + length - 7, "mplayer") == 0) {
+ return(true);
+ }
+ return(false);
+}
+
+
+// Return true if the given command is for GSview.
+
+bool
+Run::is_gsview(const char * command)
+{
+ int length = strlen(command);
+ if (strcasecmp(command + length - 12, "gsview32.exe") == 0 ||
+ strcasecmp(command + length - 10, "gsview.exe") == 0 ||
+ strcasecmp(command + length - 8, "gsview32") == 0 ||
+ strcasecmp(command + length - 6, "gsview") == 0) {
+ return(true);
+ }
+ return(false);
+}
+#endif
+
+
+// Called when user begins a new file, or when exiting,
+// to kill off child proceses that were spawned.
+// We start new processes for new file,
+// even if one already up for current file.
+// Not sure if that's what user wants, but...
+
+void
+Run::clean_up(void)
+{
+ kill_process(&display_child, "display");
+ kill_process(&MIDI_child, "MIDI player");
+}
+
+
+// Report whether we spawned a display child and think it is still alive.
+
+bool
+Run::has_display_child(void)
+{
+#ifdef OS_LIKE_WIN32
+ return(display_child.hProcess != 0);
+#else
+ return(display_child != 0);
+#endif
+}
+
+
+// Report whether we spawned a MIDI child and think it is still alive.
+
+bool
+Run::has_MIDI_child(void)
+{
+#ifdef OS_LIKE_WIN32
+ return(MIDI_child.hProcess != 0);
+#else
+ return(MIDI_child != 0);
+#endif
+}
+
+
+//------------ Class for displaying errors from Mup
+
+Error_report::Error_report(void)
+ : Fl_Double_Window(Default_width, Default_height, "Error report")
+{
+ text_p = new Fl_Text_Display(20, 20, w() - 40, h() - 90);
+ resizable((Fl_Widget *) text_p);
+ text_p->buffer( new Fl_Text_Buffer() );
+
+ // Set font/size and arrange to get notified of changes in them
+ font_change_reg_p = new Font_change_registration(
+ font_change_cb, (void *) this);
+
+ ok_p = new Fl_Return_Button(w() / 2 - 40, h() - 50, 80, 30, "OK");
+ ok_p->callback(OK_cb, this);
+ show();
+
+ // Arrange to clean up new-ed widgets in destructor.
+ end();
+}
+
+Error_report::~Error_report()
+{
+}
+
+
+// Load the error file (from -e of Mup) into window to show user.
+
+int
+Error_report::loadfile(const char * filename)
+{
+ return text_p->buffer()->loadfile(filename);
+}
+
+
+// Callback for when user clicks OK after reading Mup error report
+
+CALL_BACK(Error_report, OK)
+{
+ hide();
+}
+
+
+// Callback for change in font/size
+
+void
+Error_report::font_change_cb(void * data, Fl_Font font, unsigned char size)
+{
+ ((Error_report *)data)->font_change(font, size);
+}
+
+void
+Error_report::font_change(Fl_Font font, unsigned char size)
+{
+ text_p->textfont(font);
+ text_p->textsize(size);
+ text_p->redisplay_range(0, text_p->buffer()->length());
+}
~mdw / mup / blobdiff