The way this was done here is inconsistent with how it is done

[features.git] / src / BufferParams.cpp

diff --git a/src/BufferParams.cpp b/src/BufferParams.cpp
index a12a2860dc037d4c7d87a068b998180c278e5ded..269c74c45e9d114b1d3de64a581f89a57d13d9a9 100644 (file)
--- a/src/BufferParams.cpp
+++ b/src/BufferParams.cpp
@@ -20,6 +20,7 @@
 #include "Author.h"
 #include "LayoutFile.h"
 #include "BranchList.h"
+#include "Buffer.h"
 #include "buffer_funcs.h"
 #include "Bullet.h"
 #include "Color.h"
@@ -53,6 +54,7 @@
 #include "support/gettext.h"
 #include "support/Messages.h"
 #include "support/mutex.h"
+#include "support/Package.h"
 #include "support/Translator.h"
 #include "support/lstrings.h"
 
@@ -601,6 +603,8 @@ void BufferParams::setDefSkip(VSpace const & vs)
 string BufferParams::readToken(Lexer & lex, string const & token,
        FileName const & filepath)
 {
+       string result;
+
        if (token == "\\textclass") {
                lex.next();
                string const classname = lex.getString();
@@ -609,13 +613,31 @@ string BufferParams::readToken(Lexer & lex, string const & token,
                // be available.
                string tcp;
                LayoutFileList & bcl = LayoutFileList::get();
-               if (!filepath.empty())
-                       tcp = bcl.addLocalLayout(classname, filepath.absFileName());
+               if (!filepath.empty()) {
+                       // If classname is an absolute path, the document is
+                       // using a local layout file which could not be accessed
+                       // by a relative path. In this case the path is correct
+                       // even if the document was moved to a different
+                       // location. However, we will have a problem if the
+                       // document was generated on a different platform.
+                       bool isabsolute = FileName::isAbsolute(classname);
+                       string const classpath = onlyPath(classname);
+                       string const path = isabsolute ? classpath
+                               : FileName(addPath(filepath.absFileName(),
+                                               classpath)).realPath();
+                       string const oldpath = isabsolute ? string()
+                               : FileName(addPath(origin, classpath)).realPath();
+                       tcp = bcl.addLocalLayout(onlyFileName(classname), path, oldpath);
+               }
                // that returns non-empty if a "local" layout file is found.
-               if (!tcp.empty())
-                       setBaseClass(tcp);
-               else
-                       setBaseClass(classname);
+               if (!tcp.empty()) {
+                       result = to_utf8(makeRelPath(from_utf8(onlyPath(tcp)),
+                                               from_utf8(filepath.absFileName())));
+                       if (result.empty())
+                               result = ".";
+                       setBaseClass(onlyFileName(tcp));
+               } else
+                       setBaseClass(onlyFileName(classname));
                // We assume that a tex class exists for local or unknown
                // layouts so this warning, will only be given for system layouts.
                if (!baseClass()->isTeXClassAvailable()) {
@@ -636,6 +658,14 @@ string BufferParams::readToken(Lexer & lex, string const & token,
                        frontend::Alert::warning(_("Document class not available"),
                                       msg, true);
                }
+       } else if (token == "\\origin") {
+               lex.eatLine();
+               origin = lex.getString();
+               string const sysdirprefix = "/systemlyxdir/";
+               if (prefixIs(origin, sysdirprefix)) {
+                       origin.replace(0, sysdirprefix.length() - 1,
+                               package().system_support().absFileName());
+               }
        } else if (token == "\\begin_preamble") {
                readPreamble(lex);
        } else if (token == "\\begin_local_layout") {
@@ -658,6 +688,19 @@ string BufferParams::readToken(Lexer & lex, string const & token,
        } else if (token == "\\master") {
                lex.eatLine();
                master = lex.getString();
+               if (!filepath.empty() && FileName::isAbsolute(origin)) {
+                       bool const isabs = FileName::isAbsolute(master);
+                       FileName const abspath(isabs ? master : origin + master);
+                       bool const moved = filepath != FileName(origin);
+                       if (moved && abspath.exists()) {
+                               docstring const path = isabs
+                                       ? from_utf8(master)
+                                       : from_utf8(abspath.realPath());
+                               docstring const refpath =
+                                       from_utf8(filepath.absFileName());
+                               master = to_utf8(makeRelPath(path, refpath));
+                       }
+               }
        } else if (token == "\\suppress_date") {
                lex >> suppress_date;
        } else if (token == "\\justification") {
@@ -936,17 +979,28 @@ string BufferParams::readToken(Lexer & lex, string const & token,
                return token;
        }
 
-       return string();
+       return result;
 }
 
 
-void BufferParams::writeFile(ostream & os) const
+void BufferParams::writeFile(ostream & os, Buffer const * buf) const
 {
        // The top of the file is written by the buffer.
        // Prints out the buffer info into the .lyx file given by file
 
+       // the document directory
+       string filepath = buf->filePath();
+       string const sysdir = package().system_support().absFileName();
+       if (prefixIs(filepath, sysdir))
+               filepath.replace(0, sysdir.length(), "/systemlyxdir/");
+       else if (!lyxrc.save_origin)
+               filepath = "unavailable";
+       os << "\\origin " << filepath << '\n';
+
        // the textclass
-       os << "\\textclass " << baseClass()->name() << '\n';
+       os << "\\textclass " << buf->includedFilePath(addName(buf->layoutPos(),
+                                               baseClass()->name()), "layout")
+          << '\n';
 
        // then the preamble
        if (!preamble.empty()) {
@@ -1302,7 +1356,8 @@ void BufferParams::validate(LaTeXFeatures & features) const
        }
 
        // some languages are only available via polyglossia
-       if (features.runparams().flavor == OutputParams::XETEX
+       if ((features.runparams().flavor == OutputParams::XETEX
+            || features.runparams().flavor == OutputParams::LUATEX)
            && (features.hasPolyglossiaExclusiveLanguages()
                || useNonTeXFonts))
                features.require("polyglossia");
@@ -2303,7 +2358,7 @@ OutputParams::FLAVOR BufferParams::getOutputFlavor(string const & format) const
        else if (dformat == "lyx")
                result = OutputParams::LYX;
        else if (dformat == "pdflatex")
-               result = OutputParams::PDFLATEX;
+               result = OutputParams::PDFLATEX;
        else if (dformat == "xetex")
                result = OutputParams::XETEX;
        else if (dformat == "luatex")