222 lines
6.3 KiB
C++
222 lines
6.3 KiB
C++
/**
|
|
* @file llexternaleditor.cpp
|
|
* @brief A convenient class to run external editor.
|
|
*
|
|
* $LicenseInfo:firstyear=2010&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2010, Linden Research, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation;
|
|
* version 2.1 of the License only.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
#include "llviewerprecompiledheaders.h"
|
|
#include "llexternaleditor.h"
|
|
|
|
#include "lltrans.h"
|
|
#include "llui.h"
|
|
#include "llprocess.h"
|
|
#include "llsdutil.h"
|
|
#include <boost/foreach.hpp>
|
|
|
|
// static
|
|
const std::string LLExternalEditor::sFilenameMarker = "%s";
|
|
|
|
// static
|
|
const std::string LLExternalEditor::sSetting = "ExternalEditor";
|
|
|
|
LLExternalEditor::EErrorCode LLExternalEditor::setCommand(const std::string& env_var, const std::string& override)
|
|
{
|
|
std::string cmd = findCommand(env_var, override);
|
|
if (cmd.empty())
|
|
{
|
|
LL_WARNS() << "Editor command is empty or not set" << LL_ENDL;
|
|
// <FS:CR> FIRE-10320 If no editor is set, fallback on the system open handler
|
|
//return EC_NOT_SPECIFIED;
|
|
LL_WARNS() << "Falling back on generic open handler" << LL_ENDL;
|
|
#if LL_WINDOWS
|
|
std::string comspec(getenv("COMSPEC"));
|
|
comspec.append(" /C START \"%s\"");
|
|
cmd = findCommand("", comspec);
|
|
#elif LL_DARWIN
|
|
cmd = findCommand("", "/usr/bin/open \"%s\"");
|
|
#elif LL_LINUX
|
|
// xdg-open might not actually be installed, but it's out best shot
|
|
cmd = findCommand("", "/usr/bin/xdg-open \"%s\"");
|
|
#endif
|
|
if (cmd.empty())
|
|
{
|
|
LL_WARNS() << "Failed to find generic open handler: " << cmd << LL_ENDL;
|
|
return EC_NOT_SPECIFIED;
|
|
}
|
|
// </FS:CR>
|
|
}
|
|
|
|
string_vec_t tokens;
|
|
tokenize(tokens, cmd);
|
|
|
|
// Check executable for existence.
|
|
std::string bin_path = tokens[0];
|
|
if (!LLFile::isfile(bin_path))
|
|
{
|
|
LL_WARNS() << "Editor binary [" << bin_path << "] not found" << LL_ENDL;
|
|
return EC_BINARY_NOT_FOUND;
|
|
}
|
|
|
|
// Save command.
|
|
mProcessParams = LLProcess::Params();
|
|
mProcessParams.executable = bin_path;
|
|
for (size_t i = 1; i < tokens.size(); ++i)
|
|
{
|
|
mProcessParams.args.add(tokens[i]);
|
|
}
|
|
|
|
// Add the filename marker if missing.
|
|
if (cmd.find(sFilenameMarker) == std::string::npos)
|
|
{
|
|
mProcessParams.args.add(sFilenameMarker);
|
|
LL_INFOS() << "Adding the filename marker (" << sFilenameMarker << ")" << LL_ENDL;
|
|
}
|
|
|
|
LL_INFOS() << "Setting command [" << mProcessParams << "]" << LL_ENDL;
|
|
|
|
return EC_SUCCESS;
|
|
}
|
|
|
|
LLExternalEditor::EErrorCode LLExternalEditor::run(const std::string& file_path)
|
|
{
|
|
if (std::string(mProcessParams.executable).empty() || mProcessParams.args.empty())
|
|
{
|
|
LL_WARNS() << "Editor command not set" << LL_ENDL;
|
|
return EC_NOT_SPECIFIED;
|
|
}
|
|
|
|
// Copy params block so we can replace sFilenameMarker
|
|
LLProcess::Params params;
|
|
params.executable = mProcessParams.executable;
|
|
|
|
// Substitute the filename marker in the command with the actual passed file name.
|
|
BOOST_FOREACH(const std::string& arg, mProcessParams.args)
|
|
{
|
|
std::string fixed(arg);
|
|
LLStringUtil::replaceString(fixed, sFilenameMarker, file_path);
|
|
params.args.add(fixed);
|
|
}
|
|
|
|
// Run the editor. Prevent killing the process in destructor.
|
|
params.autokill = false;
|
|
return LLProcess::create(params) ? EC_SUCCESS : EC_FAILED_TO_RUN;
|
|
}
|
|
|
|
// static
|
|
std::string LLExternalEditor::getErrorMessage(EErrorCode code)
|
|
{
|
|
switch (code)
|
|
{
|
|
case EC_SUCCESS: return LLTrans::getString("ok");
|
|
case EC_NOT_SPECIFIED: return LLTrans::getString("ExternalEditorNotSet");
|
|
case EC_PARSE_ERROR: return LLTrans::getString("ExternalEditorCommandParseError");
|
|
case EC_BINARY_NOT_FOUND: return LLTrans::getString("ExternalEditorNotFound");
|
|
case EC_FAILED_TO_RUN: return LLTrans::getString("ExternalEditorFailedToRun");
|
|
}
|
|
|
|
return LLTrans::getString("Unknown");
|
|
}
|
|
|
|
// TODO:
|
|
// - Unit-test this with tests like LLStringUtil::getTokens() (the
|
|
// command-line overload that supports quoted tokens)
|
|
// - Unless there are significant semantic differences, eliminate this method
|
|
// and use LLStringUtil::getTokens() instead.
|
|
|
|
// static
|
|
size_t LLExternalEditor::tokenize(string_vec_t& tokens, const std::string& str)
|
|
{
|
|
tokens.clear();
|
|
|
|
// Split the argument string into separate strings for each argument
|
|
typedef boost::tokenizer< boost::char_separator<char> > tokenizer;
|
|
boost::char_separator<char> sep("", "\" ", boost::drop_empty_tokens);
|
|
|
|
tokenizer tokens_list(str, sep);
|
|
tokenizer::iterator token_iter;
|
|
BOOL inside_quotes = FALSE;
|
|
BOOL last_was_space = FALSE;
|
|
for (token_iter = tokens_list.begin(); token_iter != tokens_list.end(); ++token_iter)
|
|
{
|
|
if (!strncmp("\"",(*token_iter).c_str(),2))
|
|
{
|
|
inside_quotes = !inside_quotes;
|
|
}
|
|
else if (!strncmp(" ",(*token_iter).c_str(),2))
|
|
{
|
|
if(inside_quotes)
|
|
{
|
|
tokens.back().append(std::string(" "));
|
|
last_was_space = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
std::string to_push = *token_iter;
|
|
if (last_was_space)
|
|
{
|
|
tokens.back().append(to_push);
|
|
last_was_space = FALSE;
|
|
}
|
|
else
|
|
{
|
|
tokens.push_back(to_push);
|
|
}
|
|
}
|
|
}
|
|
|
|
return tokens.size();
|
|
}
|
|
|
|
// static
|
|
std::string LLExternalEditor::findCommand(
|
|
const std::string& env_var,
|
|
const std::string& override)
|
|
{
|
|
std::string cmd;
|
|
|
|
// Get executable path.
|
|
if (!override.empty()) // try the supplied override first
|
|
{
|
|
cmd = override;
|
|
LL_INFOS() << "Using override" << LL_ENDL;
|
|
}
|
|
else if (!LLUI::sSettingGroups["config"]->getString(sSetting).empty())
|
|
{
|
|
cmd = LLUI::sSettingGroups["config"]->getString(sSetting);
|
|
LL_INFOS() << "Using setting" << LL_ENDL;
|
|
}
|
|
else // otherwise use the path specified by the environment variable
|
|
{
|
|
char* env_var_val = getenv(env_var.c_str());
|
|
if (env_var_val)
|
|
{
|
|
cmd = env_var_val;
|
|
LL_INFOS() << "Using env var " << env_var << LL_ENDL;
|
|
}
|
|
}
|
|
|
|
LL_INFOS() << "Found command [" << cmd << "]" << LL_ENDL;
|
|
return cmd;
|
|
}
|