lyx_mirror/src/format.C

/**
 * \file format.C
 * This file is part of LyX, the document processor.
 * Licence details can be found in the file COPYING.
 *
 * \author Dekel Tsur
 *
 * Full author contact details are available in file CREDITS.
 */

#include <config.h>

#include "format.h"
#include "buffer.h"
#include "bufferparams.h"
#include "lyxrc.h"
#include "debug.h"
#include "gettext.h"
#include "lyxsocket.h"

#include "frontends/Alert.h" //to be removed?

#include "support/filetools.h"
#include "support/lstrings.h"
#include "support/os.h"
#include "support/systemcall.h"

#include <boost/filesystem/operations.hpp>

using lyx::support::absolutePath;
using lyx::support::bformat;
using lyx::support::compare_ascii_no_case;
using lyx::support::contains;
using lyx::support::libScriptSearch;
using lyx::support::makeDisplayPath;
using lyx::support::onlyPath;
using lyx::support::quoteName;
using lyx::support::subst;
using lyx::support::Systemcall;
using lyx::support::token;

using std::string;
using std::distance;

namespace fs = boost::filesystem;
namespace os = lyx::support::os;

extern LyXServerSocket * lyxsocket;

namespace {

string const token_from("$$i");
string const token_path("$$p");
string const token_socket("$$a");


class FormatNamesEqual : public std::unary_function<Format, bool> {
public:
	FormatNamesEqual(string const & name)
		: name_(name) {}
	bool operator()(Format const & f) const
	{
		return f.name() == name_;
	}
private:
	string name_;
};


class FormatExtensionsEqual : public std::unary_function<Format, bool> {
public:
	FormatExtensionsEqual(string const & extension)
		: extension_(extension) {}
	bool operator()(Format const & f) const
	{
		return f.extension() == extension_;
	}
private:
	string extension_;
};

} //namespace anon

bool operator<(Format const & a, Format const & b)
{
	// use the compare_ascii_no_case instead of compare_no_case,
	// because in turkish, 'i' is not the lowercase version of 'I',
	// and thus turkish locale breaks parsing of tags.

	return compare_ascii_no_case(a.prettyname(), b.prettyname()) < 0;
}


Format::Format(string const & n, string const & e, string const & p,
	       string const & s, string const & v, string const & ed,
               bool d)
	: name_(n), extension_(e), prettyname_(p), shortcut_(s), viewer_(v),
	  editor_(ed), document_(d)
{}


bool Format::dummy() const
{
	return extension().empty();
}


bool Format::isChildFormat() const
{
	if (name_.empty())
		return false;
	return isdigit(name_[name_.length() - 1]);
}


string const Format::parentFormat() const
{
	return name_.substr(0, name_.length() - 1);
}


// This method should return a reference, and throw an exception
// if the format named name cannot be found (Lgb)
Format const * Formats::getFormat(string const & name) const
{
	FormatList::const_iterator cit =
		find_if(formatlist.begin(), formatlist.end(),
			FormatNamesEqual(name));
	if (cit != formatlist.end())
		return &(*cit);
	else
		return 0;
}


string Formats::getFormatFromFile(string const & filename) const
{
	if (filename.empty())
		return string();

	string const format = lyx::support::getFormatFromContents(filename);
	if (!format.empty())
		return format;

	// try to find a format from the file extension.
	string const ext(lyx::support::getExtension(filename));
	if (!ext.empty()) {
		// this is ambigous if two formats have the same extension,
		// but better than nothing
		Formats::const_iterator cit =
			find_if(formatlist.begin(), formatlist.end(),
				FormatExtensionsEqual(ext));
		if (cit != formats.end()) {
			lyxerr[Debug::GRAPHICS]
				<< "\twill guess format from file extension: "
				<< ext << " -> " << cit->name() << std::endl;
			return cit->name();
		}
	}
	return string();
}

namespace {

string fixCommand(string const & cmd, string const & ext, 
		  os::auto_open_mode mode)
{
	// configure.py says we do not want a viewer/editor
	if (cmd.empty())
		return cmd;

	// Does the OS manage this format?
	if (os::canAutoOpenFile(ext, mode))
		return "auto";

	// if configure.py found nothing, clear the command
	if (token(cmd, ' ', 0) == "auto")
		return string();

	// use the command found by configure.py
	return cmd;
}

}

void Formats::setAutoOpen()
{
	FormatList::iterator fit = formatlist.begin();
	FormatList::iterator const fend = formatlist.end();
	for ( ; fit != fend ; ++fit) {
		fit->setViewer(fixCommand(fit->viewer(), fit->extension(), os::VIEW));
		fit->setEditor(fixCommand(fit->editor(), fit->extension(), os::EDIT));
	}
}


int Formats::getNumber(string const & name) const
{
	FormatList::const_iterator cit =
		find_if(formatlist.begin(), formatlist.end(),
			FormatNamesEqual(name));
	if (cit != formatlist.end())
		return distance(formatlist.begin(), cit);
	else
		return -1;
}


void Formats::add(string const & name)
{
	if (!getFormat(name))
		add(name, name, name, string(), string(), string(), true);
}


void Formats::add(string const & name, string const & extension,
		  string const & prettyname, string const & shortcut,
		  string const & viewer, string const & editor, bool document)
{
	FormatList::iterator it =
		find_if(formatlist.begin(), formatlist.end(),
			FormatNamesEqual(name));
	if (it == formatlist.end())
		formatlist.push_back(Format(name, extension, prettyname,
					    shortcut, viewer, editor,
		                            document));
	else
		*it = Format(name, extension, prettyname, shortcut, viewer,
		             editor, document);
}


void Formats::erase(string const & name)
{
	FormatList::iterator it =
		find_if(formatlist.begin(), formatlist.end(),
			FormatNamesEqual(name));
	if (it != formatlist.end())
		formatlist.erase(it);
}


void Formats::sort()
{
	std::sort(formatlist.begin(), formatlist.end());
}


void Formats::setViewer(string const & name, string const & command)
{
	add(name);
	FormatList::iterator it =
		find_if(formatlist.begin(), formatlist.end(),
			FormatNamesEqual(name));
	if (it != formatlist.end())
		it->setViewer(command);
}


bool Formats::view(Buffer const & buffer, string const & filename,
		   string const & format_name) const
{
	BOOST_ASSERT(absolutePath(filename));
	if (filename.empty() || !fs::exists(filename)) {
		Alert::error(_("Cannot view file"),
			bformat(_("File does not exist: %1$s"),
				filename));
		return false;
	}

	Format const * format = getFormat(format_name);
	if (format && format->viewer().empty() &&
	    format->isChildFormat())
		format = getFormat(format->parentFormat());
	if (!format || format->viewer().empty()) {
// FIXME: I believe this is the wrong place to show alerts, it should be done
// by the caller (this should be "utility" code)
		Alert::error(_("Cannot view file"),
			bformat(_("No information for viewing %1$s"),
				prettyName(format_name)));
		return false;
	}
	// viewer is 'auto'
	if (format->viewer() == "auto") {
		if (os::autoOpenFile(filename, os::VIEW))
			return true;
		else {
			Alert::error(_("Cannot view file"),
				bformat(_("Auto-view file %1$s failed"),
					filename));
			return false;
		}
	}

	string command = libScriptSearch(format->viewer());

	if (format_name == "dvi" &&
	    !lyxrc.view_dvi_paper_option.empty()) {
		command += ' ' + lyxrc.view_dvi_paper_option;
		string paper_size = buffer.params().paperSizeName();
		if (paper_size == "letter")
			paper_size = "us";
		command += ' ' + paper_size;
		if (buffer.params().orientation == ORIENTATION_LANDSCAPE)
			command += 'r';
	}

	if (!contains(command, token_from))
		command += ' ' + token_from;

	command = subst(command, token_from, quoteName(filename));
	command = subst(command, token_path, quoteName(onlyPath(filename)));
	command = subst(command, token_socket, quoteName(lyxsocket->address()));
	lyxerr[Debug::FILES] << "Executing command: " << command << std::endl;
	buffer.message(_("Executing command: ") + command);

	Systemcall one;
	int const res = one.startscript(Systemcall::DontWait, command);

	if (res) {
		Alert::error(_("Cannot view file"),
			     bformat(_("An error occurred whilst running %1$s"),
			       makeDisplayPath(command, 50)));
		return false;
	}
	return true;
}


bool Formats::edit(Buffer const & buffer, string const & filename,
			 string const & format_name) const
{
	BOOST_ASSERT(absolutePath(filename));
	if (filename.empty() || !fs::exists(filename)) {
		Alert::error(_("Cannot edit file"),
			bformat(_("File does not exist: %1$s"),
				filename));
		return false;
	}

	Format const * format = getFormat(format_name);
	if (format && format->editor().empty() &&
	    format->isChildFormat())
		format = getFormat(format->parentFormat());
	if (!format || format->editor().empty()) {
// FIXME: I believe this is the wrong place to show alerts, it should
// be done by the caller (this should be "utility" code)
		Alert::error(_("Cannot edit file"),
			bformat(_("No information for editing %1$s"),
				prettyName(format_name)));
		return false;
	}
	// editor is 'auto'
	if (format->editor() == "auto") {
		if (os::autoOpenFile(filename, os::EDIT))
			return true;
		else {
			Alert::error(_("Cannot edit file"),
				bformat(_("Auto-edit file %1$s failed"),
					filename));
			return false;
		}
	}

	string command = format->editor();

	if (!contains(command, token_from))
		command += ' ' + token_from;

	command = subst(command, token_from, quoteName(filename));
	command = subst(command, token_path, quoteName(onlyPath(filename)));
	command = subst(command, token_socket, quoteName(lyxsocket->address()));
	lyxerr[Debug::FILES] << "Executing command: " << command << std::endl;
	buffer.message(_("Executing command: ") + command);

	Systemcall one;
	int const res = one.startscript(Systemcall::DontWait, command);

	if (res) {
		Alert::error(_("Cannot edit file"),
			     bformat(_("An error occurred whilst running %1$s"),
			       makeDisplayPath(command, 50)));
		return false;
	}
	return true;
}


string const Formats::prettyName(string const & name) const
{
	Format const * format = getFormat(name);
	if (format)
		return format->prettyname();
	else
		return name;
}


string const Formats::extension(string const & name) const
{
	Format const * format = getFormat(name);
	if (format)
		return format->extension();
	else
		return name;
}




Formats formats;

Formats system_formats;