#include "frontends/alert.h" //to be removed?
#include "support/debug.h"
+#include "support/docstream.h"
#include "support/filetools.h"
#include "support/gettext.h"
#include "support/lstrings.h"
+#include "support/lyxmagic.h"
+#include "support/mutex.h"
#include "support/os.h"
#include "support/PathChanger.h"
#include "support/Systemcall.h"
#include <map>
#include <ctime>
-// FIXME: Q_WS_MACX is not available, it's in Qt
+// FIXME: Q_OS_MAC is not available, it's in Qt
#ifdef USE_MACOSX_PACKAGING
#include "support/linkback/LinkBackProxy.h"
#endif
-#ifdef HAVE_MAGIC_H
-#include <magic.h>
-#endif
-
using namespace std;
using namespace lyx::support;
};
-class FormatPrettyNameEqual : public unary_function<Format, bool> {
-public:
- FormatPrettyNameEqual(string const & prettyname)
- : prettyname_(prettyname)
- {}
- bool operator()(Format const & f) const
- {
- return f.prettyname() == prettyname_;
- }
-private:
- string prettyname_;
-};
-
-} //namespace anon
+} // namespace
bool Format::formatSorter(Format const * lhs, Format const * rhs)
{
- return _(lhs->prettyname()) < _(rhs->prettyname());
+ return compare_locale(translateIfPossible(lhs->prettyname()),
+ translateIfPossible(rhs->prettyname())) < 0;
}
bool operator<(Format const & a, Format const & b)
{
- return _(a.prettyname()) < _(b.prettyname());
+ return compare_locale(translateIfPossible(a.prettyname()),
+ translateIfPossible(b.prettyname())) < 0;
}
-Format::Format(string const & n, string const & e, string const & p,
+Format::Format(string const & n, string const & e, docstring const & p,
string const & s, string const & v, string const & ed,
string const & m, int flags)
: name_(n), prettyname_(p), shortcut_(s), viewer_(v),
Format const * Formats::getFormat(string const & name) const
{
FormatList::const_iterator cit =
- find_if(formatlist.begin(), formatlist.end(),
+ find_if(formatlist_.begin(), formatlist_.end(),
FormatNamesEqual(name));
- if (cit != formatlist.end())
+ if (cit != formatlist_.end())
return &(*cit);
else
return 0;
// FIG #FIG...
// FITS ...BITPIX...
// GIF GIF...
- // JPG JFIF
+ // JPG \377\330... (0xFFD8)
// PDF %PDF-...
// PNG .PNG...
// PBM P1... or P4 (B/W)
static string const zipStamp = "PK";
// ZIP containers (koffice, openoffice.org etc).
- static string const nonzipStamp = "\008\0\0\0mimetypeapplication/";
+ static string const nonzipStamp = "\010\0\0\0mimetypeapplication/";
// compress
static string const compressStamp = "\037\235";
+ // DOS binary EPS according to Adobe TN-5002
+ static string const binEPSStamp = "\xC5\xD0\xD3\xC6";
+
+
// Maximum strings to read
int const max_count = 50;
int count = 0;
string format;
bool firstLine = true;
bool backslash = false;
+ bool maybelatex = false;
int dollars = 0;
- while ((count++ < max_count) && format.empty()) {
+ while ((count++ < max_count) && format.empty() && !maybelatex) {
if (ifs.eof())
break;
} else if (stamp == "BM") {
format = "bmp";
+ } else if (stamp == "\377\330") {
+ format = "jpg";
+
} else if (stamp == "\001\332") {
format = "sgi";
+ } else if (prefixIs(str, binEPSStamp)) {
+ format = "eps";
// PBM family
// Don't need to use str.at(0), str.at(1) because
else if (contains(str, "Grace"))
format = "agr";
- else if (contains(str, "JFIF"))
- format = "jpg";
-
else if (contains(str, "%PDF"))
// autodetect pdf format for graphics inclusion
format = "pdf6";
+ else if (contains(str, " EMF"))
+ format = "emf";
+
else if (contains(str, "PNG"))
format = "png";
contains(str, "$$") ||
contains(str, "\\[") ||
contains(str, "\\]"))
- format = "latex";
+ maybelatex = true;
else {
if (contains(str, '\\'))
backslash = true;
dollars += count_char(str, '$');
+ if (backslash && dollars > 1)
+ // inline equation
+ maybelatex = true;
}
}
- if (format.empty() && backslash && dollars > 1)
- // inline equation
+ if (format.empty() && maybelatex && !isBinaryFile(fn))
format = "latex";
if (format.empty()) {
return string();
}
-}
+} // namespace
string Formats::getFormatFromFile(FileName const & filename) const
if (filename.empty())
return string();
-#ifdef HAVE_MAGIC_H
+ string psformat;
+ string format;
if (filename.exists()) {
- magic_t magic_cookie = magic_open(MAGIC_MIME);
- if (magic_cookie) {
- string format;
- if (magic_load(magic_cookie, NULL) != 0) {
- LYXERR(Debug::GRAPHICS, "Formats::getFormatFromFile\n"
- << "\tCouldn't load magic database - "
- << magic_error(magic_cookie));
- } else {
- string mime = magic_file(magic_cookie,
- filename.toFilesystemEncoding().c_str());
- mime = token(mime, ';', 0);
- // we need our own ps/eps detection
- if ((mime != "application/postscript") && (mime != "text/plain")) {
- Formats::const_iterator cit =
- find_if(formatlist.begin(), formatlist.end(),
- FormatMimeEqual(mime));
- if (cit != formats.end()) {
- LYXERR(Debug::GRAPHICS, "\tgot format from MIME type: "
- << mime << " -> " << cit->name());
- format = cit->name();
- }
- }
+ // one instance of Magic that will be reused for next calls
+ // This avoids to read the magic file everytime
+ // If libmagic is not available, Magic::file returns an empty string.
+ static Magic magic;
+ string const result = magic.file(filename.toFilesystemEncoding());
+ string const mime = token(result, ';', 0);
+ // our own detection is better for binary files (can be anything)
+ // and different plain text formats
+ if (!mime.empty() && mime != "application/octet-stream" &&
+ mime != "text/plain") {
+ Formats::const_iterator cit =
+ find_if(formatlist_.begin(), formatlist_.end(),
+ FormatMimeEqual(mime));
+ if (cit != formatlist_.end()) {
+ LYXERR(Debug::GRAPHICS, "\tgot format from MIME type: "
+ << mime << " -> " << cit->name());
+ // See special eps/ps handling below
+ if (mime == "application/postscript")
+ psformat = cit->name();
+ else
+ format = cit->name();
}
- magic_close(magic_cookie);
- if (!format.empty())
- return format;
}
+
+ // libmagic recognizes as latex also some formats of ours
+ // such as pstex and pdftex. Therefore we have to perform
+ // additional checks in this case (bug 9244).
+ if (!format.empty() && format != "latex")
+ return format;
}
-#endif
- string const format = guessFormatFromContents(filename);
string const ext = getExtension(filename.absFileName());
- if (isZippedFileFormat(format) && !ext.empty()) {
- string const & fmt_name = formats.getFormatFromExtension(ext);
- if (!fmt_name.empty()) {
- Format const * p_format = formats.getFormat(fmt_name);
- if (p_format && p_format->zippedNative())
- return p_format->name();
+ if (format.empty()) {
+ // libmagic does not distinguish eps and ps.
+ // Therefore we need to use our own detection here, but only if it
+ // recognizes either ps or eps. Otherwise the libmagic guess will
+ // be better (bug 9146).
+ format = guessFormatFromContents(filename);
+ if (!psformat.empty()) {
+ if (isPostScriptFileFormat(format))
+ return format;
+ else
+ return psformat;
}
+
+ if (isZippedFileFormat(format) && !ext.empty()) {
+ string const & fmt_name = getFormatFromExtension(ext);
+ if (!fmt_name.empty()) {
+ Format const * p_format = getFormat(fmt_name);
+ if (p_format && p_format->zippedNative())
+ return p_format->name();
+ }
+ }
+ // Don't simply return latex (bug 9244).
+ if (!format.empty() && format != "latex")
+ return format;
+ }
+
+ // Both libmagic and our guessing from contents may return as latex
+ // also lyx files and our pstex and pdftex formats. In this case we
+ // give precedence to the format determined by the extension.
+ if (format == "latex") {
+ format = getFormatFromExtension(ext);
+ return format.empty() ? "latex" : format;
}
- if (!format.empty())
- return format;
// try to find a format from the file extension.
return getFormatFromExtension(ext);
// this is ambigous if two formats have the same extension,
// but better than nothing
Formats::const_iterator cit =
- find_if(formatlist.begin(), formatlist.end(),
+ find_if(formatlist_.begin(), formatlist_.end(),
FormatExtensionsEqual(ext));
- if (cit != formats.end()) {
+ if (cit != formatlist_.end()) {
LYXERR(Debug::GRAPHICS, "\twill guess format from file extension: "
<< ext << " -> " << cit->name());
return cit->name();
}
-string Formats::getFormatFromPrettyName(string const & prettyname) const
-{
- if (!prettyname.empty()) {
- Formats::const_iterator cit =
- find_if(formatlist.begin(), formatlist.end(),
- FormatPrettyNameEqual(prettyname));
- if (cit != formats.end())
- return cit->name();
- }
- return string();
-}
-
-
/// Used to store last timestamp of file and whether it is (was) zipped
struct ZippedInfo {
bool zipped;
/// Mapping absolute pathnames of files to their ZippedInfo metadata.
static std::map<std::string, ZippedInfo> zipped_;
+static Mutex zipped_mutex;
bool Formats::isZippedFile(support::FileName const & filename) const {
string const & fname = filename.absFileName();
time_t timestamp = filename.lastModified();
+ Mutex::Locker lock(&zipped_mutex);
map<string, ZippedInfo>::iterator it = zipped_.find(fname);
if (it != zipped_.end() && it->second.timestamp == timestamp)
return it->second.zipped;
+ // FIXME perf: This very expensive function is called on startup on each
+ // file whic is going to be parsed, and also on svgz icons. Maybe there is a
+ // quicker way to check whether a file is zipped? I.e. for icons we
+ // probably just need to check the extension (svgz vs svg).
string const & format = getFormatFromFile(filename);
bool zipped = (format == "gzip" || format == "zip");
zipped_.insert(make_pair(fname, ZippedInfo(zipped, timestamp)));
void Formats::setAutoOpen()
{
- FormatList::iterator fit = formatlist.begin();
- FormatList::iterator const fend = formatlist.end();
+ 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(),
+ find_if(formatlist_.begin(), formatlist_.end(),
FormatNamesEqual(name));
- if (cit != formatlist.end())
- return distance(formatlist.begin(), cit);
+ 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(),
+ add(name, name, from_utf8(name), string(), string(), string(),
string(), Format::document);
}
void Formats::add(string const & name, string const & extensions,
- string const & prettyname, string const & shortcut,
+ docstring const & prettyname, string const & shortcut,
string const & viewer, string const & editor,
string const & mime, int flags)
{
FormatList::iterator it =
- find_if(formatlist.begin(), formatlist.end(),
+ find_if(formatlist_.begin(), formatlist_.end(),
FormatNamesEqual(name));
- if (it == formatlist.end())
- formatlist.push_back(Format(name, extensions, prettyname,
+ if (it == formatlist_.end())
+ formatlist_.push_back(Format(name, extensions, prettyname,
shortcut, viewer, editor, mime, flags));
else
*it = Format(name, extensions, prettyname, shortcut, viewer,
void Formats::erase(string const & name)
{
FormatList::iterator it =
- find_if(formatlist.begin(), formatlist.end(),
+ find_if(formatlist_.begin(), formatlist_.end(),
FormatNamesEqual(name));
- if (it != formatlist.end())
- formatlist.erase(it);
+ if (it != formatlist_.end())
+ formatlist_.erase(it);
}
void Formats::sort()
{
- std::sort(formatlist.begin(), formatlist.end());
+ std::sort(formatlist_.begin(), formatlist_.end());
}
{
add(name);
FormatList::iterator it =
- find_if(formatlist.begin(), formatlist.end(),
+ find_if(formatlist_.begin(), formatlist_.end(),
FormatNamesEqual(name));
- if (it != formatlist.end())
+ if (it != formatlist_.end())
it->setViewer(command);
}
{
add(name);
FormatList::iterator it =
- find_if(formatlist.begin(), formatlist.end(),
+ find_if(formatlist_.begin(), formatlist_.end(),
FormatNamesEqual(name));
- if (it != formatlist.end())
+ if (it != formatlist_.end())
it->setEditor(command);
}
}
}
- string command = libScriptSearch(format->viewer());
+ string command = format->viewer();
+
+ // Escape backslashes if not already in double or single quotes.
+ // We cannot simply quote the whole command as there may be arguments.
+ if (contains(command, '\\')) {
+ bool inquote1 = false;
+ bool inquote2 = false;
+ string::iterator cit = command.begin();
+ for (; cit != command.end(); ++cit) {
+ switch (*cit) {
+ case '"':
+ inquote1 = !inquote1;
+ break;
+ case '\'':
+ inquote2 = !inquote2;
+ break;
+ case '\\':
+ if (!inquote1 && !inquote2)
+ cit = ++command.insert(cit, '\\');
+ break;
+ }
+ }
+ }
if (format_name == "dvi" &&
!lyxrc.view_dvi_paper_option.empty()) {
if (!contains(command, token_from_format))
command += ' ' + token_from_format;
- command = subst(command, token_from_format, quoteName(onlyFileName(filename.toFilesystemEncoding())));
- command = subst(command, token_path_format, quoteName(onlyPath(filename.toFilesystemEncoding())));
+ command = subst(command, token_from_format,
+ quoteName(onlyFileName(filename.toFilesystemEncoding()), quote_shell_filename));
+ command = subst(command, token_path_format,
+ quoteName(onlyPath(filename.toFilesystemEncoding()), quote_shell_filename));
command = subst(command, token_socket_format, quoteName(theServerSocket().address()));
LYXERR(Debug::FILES, "Executing command: " << command);
// FIXME UNICODE utf8 can be wrong for files
PathChanger p(filename.onlyPath());
Systemcall one;
- one.startscript(Systemcall::DontWait, command, buffer.filePath());
+ one.startscript(Systemcall::DontWait, command,
+ buffer.filePath(), buffer.layoutPos());
// we can't report any sort of error, since we aren't waiting
return true;
if (!contains(command, token_from_format))
command += ' ' + token_from_format;
- command = subst(command, token_from_format, quoteName(filename.toFilesystemEncoding()));
- command = subst(command, token_path_format, quoteName(onlyPath(filename.toFilesystemEncoding())));
+ command = subst(command, token_from_format,
+ quoteName(filename.toFilesystemEncoding(), quote_shell_filename));
+ command = subst(command, token_path_format,
+ quoteName(onlyPath(filename.toFilesystemEncoding()), quote_shell_filename));
command = subst(command, token_socket_format, quoteName(theServerSocket().address()));
LYXERR(Debug::FILES, "Executing command: " << command);
// FIXME UNICODE utf8 can be wrong for files
buffer.message(_("Executing command: ") + from_utf8(command));
Systemcall one;
- one.startscript(Systemcall::DontWait, command, buffer.filePath());
+ one.startscript(Systemcall::DontWait, command,
+ buffer.filePath(), buffer.layoutPos());
// we can't report any sort of error, since we aren't waiting
return true;
{
Format const * format = getFormat(name);
if (format)
- return from_utf8(format->prettyname());
+ return format->prettyname();
else
return from_utf8(name);
}
f.addPair(OutputParams::XML, "docbook-xml");
f.addPair(OutputParams::HTML, "xhtml");
f.addPair(OutputParams::TEXT, "text");
+ f.addPair(OutputParams::LYX, "lyx");
return f;
}
FlavorTranslator const & flavorTranslator()
{
- static FlavorTranslator translator = initFlavorTranslator();
+ static FlavorTranslator const translator = initFlavorTranslator();
return translator;
}
-}
+} // namespace
std::string flavor2format(OutputParams::FLAVOR flavor)
return flavorTranslator().find(fmt);
} */
-Formats formats;
-
-Formats system_formats;
-
-
} // namespace lyx