#include "Buffer.h"
#include "BufferParams.h"
#include "LyXRC.h"
+#include "OutputParams.h"
#include "ServerSocket.h"
#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/docstream.h"
#include "support/os.h"
#include "support/PathChanger.h"
#include "support/Systemcall.h"
#include "support/Translator.h"
#include <algorithm>
+#include <functional>
#include <map>
#include <ctime>
#include "support/linkback/LinkBackProxy.h"
#endif
-#ifdef HAVE_MAGIC_H
-#include <magic.h>
-#endif
-
using namespace std;
using namespace lyx::support;
string const token_path_format("$$p");
string const token_socket_format("$$a");
-
-class FormatNamesEqual : public unary_function<Format, bool> {
-public:
- FormatNamesEqual(string const & name)
- : name_(name)
- {}
- bool operator()(Format const & f) const
- {
- return f.name() == name_;
- }
-private:
- string name_;
-};
+} // namespace
-class FormatExtensionsEqual : public unary_function<Format, bool> {
-public:
- FormatExtensionsEqual(string const & extension)
- : extension_(extension)
- {}
- bool operator()(Format const & f) const
- {
- return f.hasExtension(extension_);
- }
-private:
- string extension_;
-};
-
-
-class FormatMimeEqual : public unary_function<Format, bool> {
-public:
- FormatMimeEqual(string const & mime)
- : mime_(mime)
- {}
- bool operator()(Format const & f) const
- {
- // The test for empty mime strings is needed since we allow
- // formats with empty mime types.
- return f.mime() == mime_ && !mime_.empty();
- }
-private:
- string mime_;
-};
-
-
-} //namespace anon
-
bool Format::formatSorter(Format const * lhs, Format const * rhs)
{
return compare_locale(translateIfPossible(lhs->prettyname()),
}
-bool Format::hasExtension(string const & e) const
+bool Format::hasExtension(string const & ext) const
{
- return (find(extension_list_.begin(), extension_list_.end(), e)
+ return (find(extension_list_.begin(), extension_list_.end(), ext)
!= extension_list_.end());
}
}
+namespace {
+
+std::function<bool (Format const &)> FormatNameIs(string const & name)
+{
+ return [name](Format const & f){ return f.name() == name; };
+}
+
+}
+
// 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())
+ find_if(formatlist_.begin(), formatlist_.end(),
+ FormatNameIs(name));
+ if (cit != formatlist_.end())
return &(*cit);
else
- return 0;
+ return nullptr;
+}
+
+
+Format * Formats::getFormat(string const & name)
+{
+ FormatList::iterator it =
+ find_if(formatlist_.begin(), formatlist_.end(),
+ FormatNameIs(name));
+
+ if (it != formatlist_.end())
+ return &(*it);
+
+ return nullptr;
}
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";
} else if (stamp == "\377\330") {
format = "jpg";
+ } else if (prefixIs(str, "\x89PNG")) {
+ format = "png";
+
} else if (stamp == "\001\332") {
format = "sgi";
+
} else if (prefixIs(str, binEPSStamp)) {
format = "eps";
// autodetect pdf format for graphics inclusion
format = "pdf6";
- else if (contains(str, "PNG"))
- format = "png";
+ else if (contains(str, " EMF"))
+ format = "emf";
else if (contains(str, "%!PS-Adobe")) {
// eps or ps
return string();
}
-}
+} // namespace
string Formats::getFormatFromFile(FileName const & filename) const
string psformat;
string format;
-#ifdef HAVE_MAGIC_H
if (filename.exists()) {
- magic_t magic_cookie = magic_open(MAGIC_MIME);
- if (magic_cookie) {
- if (magic_load(magic_cookie, NULL) != 0) {
- LYXERR(Debug::GRAPHICS, "Formats::getFormatFromFile\n"
- << "\tCouldn't load magic database - "
- << magic_error(magic_cookie));
- } else {
- char const * result = magic_file(magic_cookie,
- filename.toFilesystemEncoding().c_str());
- string mime;
- if (result)
- mime = token(result, ';', 0);
- else {
- LYXERR(Debug::GRAPHICS, "Formats::getFormatFromFile\n"
- << "\tCouldn't query magic database - "
- << magic_error(magic_cookie));
- }
- // 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();
- }
- }
+ // 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(),
+ [mime](Format const & f){ return f.mime() == 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);
- // 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;
}
+
+ // 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 ext = getExtension(filename.absFileName());
if (format.empty()) {
}
if (isZippedFileFormat(format) && !ext.empty()) {
- string const & fmt_name = formats.getFormatFromExtension(ext);
+ string const & fmt_name = getFormatFromExtension(ext);
if (!fmt_name.empty()) {
- Format const * p_format = formats.getFormat(fmt_name);
+ Format const * p_format = getFormat(fmt_name);
if (p_format && p_format->zippedNative())
return p_format->name();
}
// 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()) {
+ find_if(formatlist_.begin(), formatlist_.end(),
+ [ext](Format const & f){ return f.hasExtension(ext); });
+ if (cit != formatlist_.end()) {
LYXERR(Debug::GRAPHICS, "\twill guess format from file extension: "
<< ext << " -> " << cit->name());
return cit->name();
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(),
- FormatNamesEqual(name));
- if (cit != formatlist.end())
- return distance(formatlist.begin(), cit);
- else
+ find_if(formatlist_.begin(), formatlist_.end(),
+ FormatNameIs(name));
+ if (cit == formatlist_.end())
return -1;
+
+ return distance(formatlist_.begin(), cit);
}
string const & viewer, string const & editor,
string const & mime, int flags)
{
- FormatList::iterator it =
- find_if(formatlist.begin(), formatlist.end(),
- FormatNamesEqual(name));
- if (it == formatlist.end())
- formatlist.push_back(Format(name, extensions, prettyname,
- shortcut, viewer, editor, mime, flags));
+ Format * format = getFormat(name);
+ if (format)
+ *format = Format(name, extensions, prettyname, shortcut, viewer,
+ editor, mime, flags);
else
- *it = Format(name, extensions, prettyname, shortcut, viewer,
- editor, mime, flags);
+ formatlist_.push_back(Format(name, extensions, prettyname,
+ shortcut, viewer, editor, mime, flags));
}
void Formats::erase(string const & name)
{
FormatList::iterator it =
- find_if(formatlist.begin(), formatlist.end(),
- FormatNamesEqual(name));
- if (it != formatlist.end())
- formatlist.erase(it);
+ find_if(formatlist_.begin(), formatlist_.end(),
+ FormatNameIs(name));
+ if (it != formatlist_.end())
+ formatlist_.erase(it);
}
void Formats::sort()
{
- std::sort(formatlist.begin(), formatlist.end());
+ 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);
+ Format * format = getFormat(name);
+ if (format)
+ format->setViewer(command);
+ else
+ LYXERR0("Unable to set viewer for non-existent format: " << name);
}
void Formats::setEditor(string const & name, string const & command)
{
add(name);
- FormatList::iterator it =
- find_if(formatlist.begin(), formatlist.end(),
- FormatNamesEqual(name));
- if (it != formatlist.end())
- it->setEditor(command);
+ Format * format = getFormat(name);
+ if (format)
+ format->setEditor(command);
+ else
+ LYXERR0("Unable to set editor for non-existent format: " << name);
}
// by the caller (this should be "utility" code)
Alert::error(_("Cannot view file"),
bformat(_("No information for viewing %1$s"),
- prettyName(format_name)));
+ translateIfPossible(prettyName(format_name))));
return false;
}
// viewer is 'auto'
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()) {
string paper_size = buffer.params().paperSizeName(BufferParams::XDVI);
bool Formats::edit(Buffer const & buffer, FileName const & filename,
string const & format_name) const
{
- if (filename.empty() || !filename.exists()) {
- Alert::error(_("Cannot edit file"),
- bformat(_("File does not exist: %1$s"),
- from_utf8(filename.absFileName())));
+ if (filename.empty()) {
+ Alert::error(_("No Filename"),
+ _("No filename was provided!"));
return false;
}
// 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)));
+ translateIfPossible(prettyName(format_name))));
return false;
}
namespace {
-typedef Translator<OutputParams::FLAVOR, string> FlavorTranslator;
+typedef Translator<Flavor, string> FlavorTranslator;
FlavorTranslator initFlavorTranslator()
{
- FlavorTranslator f(OutputParams::LATEX, "latex");
- f.addPair(OutputParams::DVILUATEX, "dviluatex");
- f.addPair(OutputParams::LUATEX, "luatex");
- f.addPair(OutputParams::PDFLATEX, "pdflatex");
- f.addPair(OutputParams::XETEX, "xetex");
- f.addPair(OutputParams::XML, "docbook-xml");
- f.addPair(OutputParams::HTML, "xhtml");
- f.addPair(OutputParams::TEXT, "text");
- f.addPair(OutputParams::LYX, "lyx");
+ FlavorTranslator f(Flavor::LaTeX, "latex");
+ f.addPair(Flavor::DviLuaTeX, "dviluatex");
+ f.addPair(Flavor::LuaTeX, "luatex");
+ f.addPair(Flavor::PdfLaTeX, "pdflatex");
+ f.addPair(Flavor::XeTeX, "xetex");
+ f.addPair(Flavor::DocBook5, "docbook-xml");
+ f.addPair(Flavor::Html, "xhtml");
+ f.addPair(Flavor::Text, "text");
+ f.addPair(Flavor::LyX, "lyx");
return f;
}
return translator;
}
-}
+} // namespace
-std::string flavor2format(OutputParams::FLAVOR flavor)
+std::string flavor2format(Flavor flavor)
{
return flavorTranslator().find(flavor);
}
/* Not currently needed, but I'll leave the code in case it is.
-OutputParams::FLAVOR format2flavor(std::string fmt)
+Flavor format2flavor(std::string fmt)
{
return flavorTranslator().find(fmt);
} */
-Formats formats;
-
-Formats system_formats;
-
-
} // namespace lyx
projects / lyx.git / blobdiff