#include "Buffer.h"
#include "BufferParams.h"
#include "LyXRC.h"
+#include "OutputParams.h"
#include "ServerSocket.h"
#include "frontends/alert.h" //to be removed?
#include "support/Translator.h"
#include <algorithm>
+#include <functional>
#include <map>
#include <ctime>
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_;
-};
-
-
-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
+
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));
+ FormatNameIs(name));
if (cit != formatlist_.end())
return &(*cit);
else
{
FormatList::iterator it =
find_if(formatlist_.begin(), formatlist_.end(),
- [name](Format const & f) { return f.name() == name; });
+ FormatNameIs(name));
if (it != formatlist_.end())
return &(*it);
} 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";
else if (contains(str, " EMF"))
format = "emf";
- else if (contains(str, "PNG"))
- format = "png";
-
else if (contains(str, "%!PS-Adobe")) {
// eps or ps
ifs >> str;
mime != "text/plain") {
Formats::const_iterator cit =
find_if(formatlist_.begin(), formatlist_.end(),
- FormatMimeEqual(mime));
+ [mime](Format const & f){ return f.mime() == mime; });
if (cit != formatlist_.end()) {
LYXERR(Debug::GRAPHICS, "\tgot format from MIME type: "
<< mime << " -> " << cit->name());
// but better than nothing
Formats::const_iterator cit =
find_if(formatlist_.begin(), formatlist_.end(),
- FormatExtensionsEqual(ext));
+ [ext](Format const & f){ return f.hasExtension(ext); });
if (cit != formatlist_.end()) {
LYXERR(Debug::GRAPHICS, "\twill guess format from file extension: "
<< ext << " -> " << cit->name());
{
FormatList::const_iterator cit =
find_if(formatlist_.begin(), formatlist_.end(),
- FormatNamesEqual(name));
- if (cit != formatlist_.end())
- return distance(formatlist_.begin(), cit);
- else
+ FormatNameIs(name));
+ if (cit == formatlist_.end())
return -1;
+
+ return distance(formatlist_.begin(), cit);
}
{
FormatList::iterator it =
find_if(formatlist_.begin(), formatlist_.end(),
- FormatNamesEqual(name));
+ FormatNameIs(name));
if (it != formatlist_.end())
formatlist_.erase(it);
}
// 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'
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;
}
} // 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);
} */
projects / lyx.git / blobdiff