Import upstream version 5.3.

[mup] / mup / mupmate / utils.C

/* Copyright (c) 2006 by Arkkra Enterprises */
/* All rights reserved */

// This file contains code for miscellaneous things that don't seem to really
// belong with any particular menu.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "globals.H"
#include "utils.H"
#include <FL/fl_ask.H>
#include <FL/filename.H>
#ifdef OS_LIKE_WIN32
#include <windef.h>
#include <winbase.h>
#include <winreg.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/stat.h>
#endif


// The FLTK Fl_Int_Input is almost what we want, but it allows
// octal and hex input via leading 0 and 0x respectively.
// So the Int_Input derived class intercepts the input and throws away
// characters from the set [xX] and leading zeros.
// Sometimes we also want to restrict to positive numbers,
// so the Positive_Int_Input class discards the - character as well.

Int_Input::Int_Input(int x, int y, int w, int h, const char * label)
        : Fl_Int_Input(x, y, w, h, label)
{
        allow_negative = true;
}


Positive_Int_Input::Positive_Int_Input(int x, int y, int w, int h, const char * label)
        : Int_Input(x, y, w, h, label)
{
        allow_negative = false;
}

int
Int_Input::handle(int event)
{
        if (event == FL_KEYBOARD) {
                int key = Fl::event_key();
                if (key == 'x' || key == 'X') {
                        return(1);
                }
                if (key == '0' && position() == 0) {
                        return(1);
                }
                if (key == '-' && ! allow_negative) {
                        return(1);
                }
        }
        return(Fl_Int_Input::handle(event));
}



// Character used to separate items in $PATH and to separate directory names
#ifdef OS_LIKE_WIN32
        static const char path_sep = ';';
        static const char dir_sep = '\\';
#else
        static const char path_sep = ':';
        static const char dir_sep = '/';
#endif


// Return the native OS's directory separator character

char
dir_separator(void)
{
        return(dir_sep);
}

// Return the native OS's path separator character
char
path_separator(void)
{
        return(path_sep);
}

// Set the value of $MUPPATH. We "new" space for it and save a static
// pointer to that space.
// If it had been set before, we delete the old space.

void
set_muppath(const char * new_muppath)
{
        static char * muppath = 0;

        if (muppath != 0) {
                // The +8 is to skip past the MUPPATH= part
                if (strcmp(muppath + 8, new_muppath) == 0) {
                        // Setting to existing value, so nothing to do
                        return;
                }
                delete muppath;
        }
        muppath = new char [strlen(new_muppath) + 9];
        (void) sprintf(muppath, "MUPPATH=%s", new_muppath);
        (void) putenv(muppath);
}



// Given a path to a file in "location", and the length of that path,
// and a suffix, see if the location with the suffix added is an
// executable file. If so, return true, with the suffixed name left
// in location. Otherwise return false with location as it came in.
// Could also return false if path would be longer than FL_PATH_MAX,
// and therefore will not fit. (Better to fail than core dump.)

static bool
access_with_suffix(char * location, int length, const char * suffix)
{
        if (length + strlen(suffix) + 1 > FL_PATH_MAX) {
                // Too long to store
                return(false);
        }

        // Add suffix and see if it is an executable file
        (void) strcpy(location + length, suffix);
        if(access(location, X_OK) == 0) {
                return(true);
        }
        else {
                // This suffix didn't work. Remove it before returning
                location[length] = '\0';
                return(false);
        }
}


// Given a file location, see if it exists as an executable file,
// taking into account the DOS/Windows strangeness of implicit suffixes.

static bool
check_access(char * location)
{
        int len = strlen(location);
#ifdef __WIN32
        // If doesn't have a suffix, try with .com, .exe, and .bat suffix
        if (len < 5 || strchr(location + len - 4, '.') == 0) {
                // This is the precedence order for executable suffixes
                if (access_with_suffix(location, len, ".com")) {
                        return(true);
                }
                if (access_with_suffix(location, len, ".exe")) {
                        return(true);
                }
                if (access_with_suffix(location, len, ".bat")) {
                        return(true);
                }
                return(false);
        }
        // If did have a suffix, go ahead and try name as is
#endif
        return access_with_suffix(location, len, "");
}


// Find the value of PATH. First try in third arg of main()
// since that seems more reliable on some OSs. Failing that, try getenv().

// We cache the value so we only have to search for it one time.
// This also rescues us in case env_p becomes invalid due to setting
// new environment variable values.

static const char * Path = 0;

void
get_path(const char ** const env_p)
{
        if (Path != 0) {
                // Already did it before
                return;
        }

        if (env_p != 0) {
                // Find $PATH in the environment variable list
                int e;
                for (e = 0; env_p[e] != 0; e++) {
                        if (strncmp(env_p[e], "PATH=", 5) == 0) {
                                Path = strdup(env_p[e] + 5);
                                break;
                        }
                }
        }
        if (Path == 0) {
                // Not found in the arge, so try looking up directly
                Path = getenv("PATH");
        }
}


// Return true if given path is an absoluate path

bool
is_absolute(const char * const path)
{
#ifdef OS_LIKE_WIN32
        if ((path[0] != '\0' && path[1] == ':') || path[0] == dir_sep) {
#else
        if (path[0] == dir_sep) {
#endif
                return(true);
        }
        return(false);
}


// Given the name of a executable program, find the directory from
// which it comes, and put the full path into "location,"
// which is expected to be at least FL_PATH_MAX bytes long.
// The incoming pgm_name is expected to be no more than FL_PATH_MAX long.
// It uses the components of PATH to try to find the executable.
// For Windows, if the program name doesn't have a suffix,
// it tries to find a .com, .exe, or .bat file with the pgm_name.
// It returns true on success. On failure, it returns false,
// and the contents of location are not defined.

bool
find_executable(const char * const pgm_name, char * location)
{
        // If pgm_name is already absolute path,
        // just check if it exists and is executable
        if (is_absolute(pgm_name)) {
                (void) strcpy(location, pgm_name);
                return (check_access(location));
        }

        if (Path == 0) {
                // Should have already looked up $PATH,
                // but make another attempt, just in case...
                get_path(0);
                if (Path == 0) {
                        return(false);
                }
        }

        // We'll try the program name added to each PATH component
        // until we find it or have to give up.
#ifdef OS_LIKE_WIN32
        // DOS/Windows implicitly adds current working directory first
        bool add_implicit_cwd = true;
#else
        bool add_implicit_cwd = false;
#endif
        const char * component;         // current component of PATH
        const char * next_component;    // next component of PATH
        const char * sep_p;             // location of PATH separator
        int len;                        // length of component
        for (component = Path; *component != '\0'; component = next_component) {
                if (add_implicit_cwd) {
                        // DOS/Windows implicitly adds current directory
                        // as first PATH component.
                        len = 0;
                        next_component = component;
                        add_implicit_cwd = false;
                }

                else if ((sep_p = strchr(component, path_sep)) != 0) {
                        // Not the last component in the PATH
                        len = sep_p - component;
                        next_component = sep_p + 1;
                }
                else {
                        // Is the last component in the PATH
                        len = strlen(component);
                        next_component = component + len;
                }

                if (len == 0) {
                        // Empty path component means current directory.
                        // Allow enough room for directory separator,
                        // pgm_name, suffix, and null terminator
                        if (getcwd(location, FL_PATH_MAX
                                        - strlen(pgm_name) - 6) == 0) {
                                // Current directory unobtainable or too long
                                return(false);
                        }
                        len = strlen(location);
                }
                else {
                        strncpy(location, component, len);
                }

                // If PATH component didn't already add a directory
                // separator, we add one. In some OSs it doesn't hurt
                // to add another, but no reason to use an extra byte.
                if (location[len-1] != dir_sep) {
                        location[len++] = dir_sep;
                }

                // Now add the progam name itself and see if it exists.
                // The check_access() will add implied suffix if necessary.
                (void) strcpy(location + len, pgm_name);
                if (check_access(location)) {
                        return(true);
                }
        }
        return(false);
}


// Returns location of magic file that lets us know user agreed
// to the license. The value is saved so subsequent calls can just return
// the saved value. If something goes wrong, a null string is returned.

#ifdef OS_LIKE_WIN32
  #define MAGIC_FILE_NAME "mup.ok"
#else
  #if defined(OS_LIKE_UNIX) || defined(VMS) || defined(AMIGA) || defined(EMX)
    #define MAGIC_FILE_NAME ".mup"
  #else
    #ifdef Mac_BBEdit
      #define MAGIC_FILE_NAME (char *)(MupRegFileName + 1)
    #endif
  #endif
#endif

#ifndef MAGIC_FILE_NAME
#error OS not supported
#endif

const char *
magic_file(const char * pname, const char ** env_p)
{
        char * home;
        char * fname = MAGIC_FILE_NAME;
        static char * magicpath = 0;    // Path is saved here

        if (magicpath != 0) {
                // Must have figured it out on previous call
                return(magicpath);
        }

        // First check current directory. This will only work
        // for the case where user has already created the file,
        // and is of somewhat questionable use, since if the user
        // changes directories to somewhere without the magic file,
        // Mup will print the watermark.
        if (access(fname, F_OK) == 0) {
                magicpath = new char[strlen(fname) + 1];
                strcpy(magicpath, fname);
                return(magicpath);
        }

#ifdef OS_LIKE_WIN32
        // Construct pathname to magic file in the directory where
        // mup.exe came from
        if (pname == 0) {
                // Shouldn't happen; We should get called once with valid
                // pname, and return cached value after that
                fl_alert("Unable to determine magic file name.");
                return("");
        }
        char location[FL_PATH_MAX];
        if (find_executable(pname, location)) {
                int baselength = strlen(location)
                                        - strlen(fl_filename_name(location));
                magicpath = new char[baselength + strlen(fname) + 1];
                // Copy pname up to last backslash
                (void) strncpy(magicpath, location, baselength);
                // add magic file name
                (void) strcpy(magicpath + baselength, fname);
        }
#else
        // Construct pathname to magic file if it is in $HOME
        if ((home = getenv("HOME")) != (char *) 0) {
                magicpath = new char[strlen(home) + strlen(fname) + 2];
#ifdef VMS
                (void) sprintf(magicpath, "%s%s", home, fname);
#else
                (void) sprintf(magicpath, "%s/%s", home, fname);
#endif
        }

#endif
#ifdef Mac_BBEdit
#pragma unused(pname)
        // Check for file in Preferences folder inside System folder
        magicpath = 0;
        home = 0;
        {
                short vRefNum;
                long dirID;
                FSSpec fsSpec;
                
                if (FindFolder(kOnSystemDisk, kPreferencesFolderType, false,
                                                &vRefNum, &dirID) == noErr) {
                        // Preferences folder exists
                        if (FSMakeFSSpec(vRefNum, dirID,
                                        (StringPtr) MupRegFileName, &fsSpec)
                                        == noErr) {
                                // File exists
                                short old_vRefNum;
                                long old_dirID;
                                if (HGetVol((StringPtr) 0, &old_vRefNum,
                                                        &old_dirID) != noErr) {
                                         return;
                                }

                                if (HSetVol((StringPtr) 0, vRefNum, dirID)
                                                                != noErr) {
                                         return;
                                }
                                HSetVol((StringPtr) 0, old_vRefNum, old_dirID);
                                magicpath = new char[strlen(MAGIC_FILE_NAME) + 1];
                                (void) sprintf(magicpath, MAGIC_FILE_NAME);
                        }
                }
        }
#endif

        if (magicpath == 0) {
                // Not sure what to really do here... Punt.
                fl_alert("Unable to find magic file path.");
                magicpath = "";
        }

        return(magicpath);
}


#ifdef OS_LIKE_WIN32

// On Windows, we read the registry to try to determine the proper
// program to use for a given file type, like .mid or .ps files.
// This function will return the path to the appropriate file,
// if found, in a static area that may get overwritten on next call,
// so caller needs to make its own copy. If program is not found,
// returns null.


char *
lookup_pgm_for_file_suffix(const char * file_suffix)
{
        static char data[512];
        char name[512]; 
        long len = sizeof(data);
        // First find entry for file suffix mapping to a class
        (void) sprintf(name, "Software\\Classes\\%s", file_suffix);
        HRESULT result = RegQueryValue(HKEY_LOCAL_MACHINE, name, data, &len);
        if (result != ERROR_SUCCESS) {
                return(0);
        }

        // Next look up the program associated with that class
        (void) sprintf(name, "Software\\Classes\\%s\\shell\\open\\command", data);
        len = sizeof(data);
        result = RegQueryValue(HKEY_LOCAL_MACHINE, name, data, &len);
        if (result != ERROR_SUCCESS) {
                return(0);
        }

        // We might get multiple strings back,
        // giving the program itself plus arguments.
        // We only want the program itself. So if the first string is quoted,
        // strip the quotes and anything after it.
        char * d;
        if (*data == '"') {
                for (d = data + 1; *d != '\0'; d++) {
                        if (*d == '"') {
                                *(d-1) = '\0';
                                break;
                        }
                        *(d-1) = *d;
                }
        }
        if (access(data, X_OK) == 0) {
                return(data);
        }
        return(0);
}


// Look up the given name in the CURRENT_USER area of registry
// and if found, fill in the data and return true, except return false.

static bool
reg_dir_found(char * name, char * data, DWORD len)
{
        HRESULT result = RegQueryValueEx(HKEY_CURRENT_USER, name, 0, 0,
                                        (LPBYTE)data, &len);
        if (result == ERROR_SUCCESS) {
                struct stat info;
                if (stat(data, &info) == 0 && (info.st_mode & S_IFDIR)) {
                        return(true);
                }
        }
        return(false);
}


// Look for likely default folder for Mup files.
// Use the current user's "My Music" folder if there is one,
// otherwise try their "Personal" folder.
// Returns path in static area or null on failure.

char *
find_music_folder(void)
{
        static char best_value[FL_PATH_MAX];

        // Get the registry info about folders
        HKEY key = 0;
        // Win'98 uses "User Shell Folders" but newer versions use just
        // "Shell Folders," so we check for both, newer first, since that
        // is probably more likely to work.
        if ((RegOpenKeyEx(HKEY_CURRENT_USER,
                        "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders",
                        0, KEY_READ, &key) == ERROR_SUCCESS) ||
                        (RegOpenKeyEx(HKEY_CURRENT_USER,
                        "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders",
                        0, KEY_READ, &key) == ERROR_SUCCESS)) {
                DWORD max_key_length;
                DWORD count;
                DWORD max_name_length;
                DWORD max_value_length;
                // Find out how many subkeys there are, and max lengths.
                if (RegQueryInfoKey(key, 0, 0, 0, 0, &max_key_length, 0, &count,
                                &max_name_length, &max_value_length, 0, 0)
                                == ERROR_SUCCESS) {
                        TCHAR name[max_name_length + 1];
                        DWORD name_length;
                        DWORD value_type;
                        BYTE value[max_value_length + 1];
                        DWORD value_length;
                        int i;
                        best_value[0] = '\0';
                        // Look for "My Music" and "Personal" subkeys.
                        // There's probably a better way to query for specific
                        // subkey than linear search, but this works...
                        for (i = 0; i < count; i++) {
                                name_length = sizeof(name);
                                value_length = sizeof(value);
                                if (RegEnumValue(key, i, name, &name_length, 0,
                                                &value_type, value,
                                                &value_length)
                                                == ERROR_SUCCESS) {
                                        if (value_type != REG_SZ) {
                                                continue;
                                        }
                                        if (strcasecmp(name, "My Music") == 0) {
                                                // Found the ones we want.
                                                strcpy(best_value, (char *) value);
                                                break;
                                        }
                                        if (strcasecmp(name, "Personal") == 0) {
                                                // This is our second choice.
                                                // Save as best so far.
                                                strcpy(best_value, (char *) value);
                                        }
                                }
                        }
                }
        }
        if (key != 0) {
                RegCloseKey(key);
        }
        return(best_value[0] == '\0' ? 0 : best_value);
}

#endif