]> git.lyx.org Git - lyx.git/blobdiff - src/buffer.C
Set layout informations on newly created paragraphs and don't resize InsetTexts
[lyx.git] / src / buffer.C
index 331c336463b27a1f5c9c5f04851d2deaad42d4b3..1afe9c8d78cca04a004ed8fb34e7d1c301ad3eb3 100644 (file)
@@ -145,7 +145,7 @@ extern int tex_code_break_column;
 
 
 Buffer::Buffer(string const & file, bool ronly)
-       : paragraph(0), lyx_clean(true), bak_clean(true),
+       : paragraph(0), niceFile(true), lyx_clean(true), bak_clean(true),
          unnamed(false), dep_clean(0), read_only(ronly),
          filename_(file), users(0)
 {
@@ -333,6 +333,7 @@ bool Buffer::readLyXformat2(LyXLex & lex, Paragraph * par)
 
        if (!par) {
                par = new Paragraph;
+               par->layout(textclasslist[params.textclass].defaultLayoutName());
        } else {
                // We are inserting into an existing document
                users->text->breakParagraph(users);
@@ -405,7 +406,8 @@ void Buffer::insertErtContents(Paragraph * par, int & pos, bool set_inactive)
        if (!ert_comp.contents.empty()) {
                lyxerr[Debug::INSETS] << "ERT contents:\n'"
                                      << ert_comp.contents << "'" << endl;
-               Inset * inset = new InsetERT(params.language, ert_comp.contents, true);
+               Inset * inset = new InsetERT(params, params.language,
+                                            ert_comp.contents, true);
                par->insertInset(pos++, inset, ert_comp.font);
                ert_comp.contents.erase();
        }
@@ -432,7 +434,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
        static int call_depth;
        ++call_depth;
        bool checkminipage = false;
-       static Paragraph * minipar;
+       static Paragraph * minipar = 0;
        static Paragraph * parBeforeMinipage;
 #endif
 #endif
@@ -462,11 +464,23 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
                insertErtContents(par, pos);
 #endif
                lex.eatLine();
-               string const layoutname = lex.getString();
-               //lyxerr << "Looking for layout '"
-               // << layoutname << "'!" << endl;
+               string layoutname = lex.getString();
+               
+               LyXTextClass const & tclass = textclasslist[params.textclass];
 
-               //lyxerr << "Result: " << pp.first << "/" << pp.second << endl;
+               if (layoutname.empty()) {
+                       layoutname = tclass.defaultLayoutName();
+               }
+               
+               bool hasLayout = tclass.hasLayout(layoutname);
+               if (!hasLayout) {
+                       lyxerr << "Layout '" << layoutname << "' does not"
+                              << " exist in textclass '" << tclass.name()
+                              << "'." << endl;
+                       lyxerr << "Trying to use default layout instead."
+                              << endl;
+                       layoutname = tclass.defaultLayoutName();
+               }
                
 #ifndef NO_COMPABILITY
                if (compare_no_case(layoutname, "latex") == 0) {
@@ -531,6 +545,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
                                first_par = par;
                        else {
                                par = new Paragraph(par);
+                               par->layout(textclasslist[params.textclass].defaultLayoutName());
                        }
                        pos = 0;
                        par->layout(layoutname);
@@ -565,28 +580,28 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
                stringstream old_float;
                
                if (tmptok == "footnote") {
-                       inset = new InsetFoot;
+                       inset = new InsetFoot(params);
                        old_float << "collapsed true\n";
                } else if (tmptok == "margin") {
-                       inset = new InsetMarginal;
+                       inset = new InsetMarginal(params);
                        old_float << "collapsed true\n";
                } else if (tmptok == "fig") {
-                       inset = new InsetFloat("figure");
+                       inset = new InsetFloat(params, "figure");
                        old_float << "placement htbp\n"
                                  << "wide false\n"
                                  << "collapsed false\n";
                } else if (tmptok == "tab") {
-                       inset = new InsetFloat("table");
+                       inset = new InsetFloat(params, "table");
                        old_float << "placement htbp\n"
                                  << "wide false\n"
                                  << "collapsed false\n";
                } else if (tmptok == "alg") {
-                       inset = new InsetFloat("algorithm");
+                       inset = new InsetFloat(params, "algorithm");
                        old_float << "placement htbp\n"
                                  << "wide false\n"
                                  << "collapsed false\n";
                } else if (tmptok == "wide-fig") {
-                       inset = new InsetFloat("figure");
+                       inset = new InsetFloat(params, "figure");
                        //InsetFloat * tmp = new InsetFloat("figure");
                        //tmp->wide(true);
                        //inset = tmp;
@@ -594,7 +609,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
                                  << "wide true\n"
                                  << "collapsed false\n";
                } else if (tmptok == "wide-tab") {
-                       inset = new InsetFloat("table");
+                       inset = new InsetFloat(params, "table");
                        //InsetFloat * tmp = new InsetFloat("table");
                        //tmp->wide(true);
                        //inset = tmp;
@@ -1162,6 +1177,8 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
                the_end_read = true;
 #ifndef NO_COMPABILITY
 #ifndef NO_PEXTRA_REALLY
+               if (minipar == par)
+                       par = 0;
                minipar = parBeforeMinipage = 0;
 #endif
 #endif
@@ -1218,7 +1235,8 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
        if (checkminipage && (call_depth == 1)) {
        checkminipage = false;
        if (minipar && (minipar != par) &&
-           (par->params().pextraType() == Paragraph::PEXTRA_MINIPAGE)) {
+           (par->params().pextraType() == Paragraph::PEXTRA_MINIPAGE))
+       {
                lyxerr << "minipages in a row" << endl;
                if (par->params().pextraStartMinipage()) {
                        lyxerr << "start new minipage" << endl;
@@ -1249,12 +1267,12 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
                                p->params().depth(parBeforeMinipage->params().depth());
                                parBeforeMinipage = p;
                        }
-                       InsetMinipage * mini = new InsetMinipage;
+                       InsetMinipage * mini = new InsetMinipage(params);
                        mini->pos(static_cast<InsetMinipage::Position>(par->params().pextraAlignment()));
                        mini->pageWidth(LyXLength(par->params().pextraWidth()));
                        if (!par->params().pextraWidthp().empty()) {
                            lyxerr << "WP:" << mini->pageWidth().asString() << endl;
-                           mini->pageWidth(LyXLength((par->params().pextraWidthp())+"%"));
+                           mini->pageWidth(LyXLength((par->params().pextraWidthp())+"p%"));
                        }
                        Paragraph * op = mini->firstParagraph();
                        mini->inset.paragraph(par);
@@ -1330,14 +1348,24 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
                if (!first_par || (first_par == par))
                        first_par = p;
 
-               InsetMinipage * mini = new InsetMinipage;
+               InsetMinipage * mini = new InsetMinipage(params);
                mini->pos(static_cast<InsetMinipage::Position>(minipar->params().pextraAlignment()));
                mini->pageWidth(LyXLength(minipar->params().pextraWidth()));
                if (!par->params().pextraWidthp().empty()) {
                    lyxerr << "WP:" << mini->pageWidth().asString() << endl;
-                   mini->pageWidth(LyXLength((par->params().pextraWidthp())+"%"));
+                   mini->pageWidth(LyXLength((par->params().pextraWidthp())+"p%"));
                }
+
+               Paragraph * op = mini->firstParagraph();
                mini->inset.paragraph(minipar);
+               //
+               // and free the old ones!
+               //
+               while(op) {
+                       Paragraph * pp = op->next();
+                       delete op;
+                       op = pp;
+               }
                        
                // Insert the minipage last in the
                // previous paragraph.
@@ -1496,26 +1524,26 @@ void Buffer::readInset(LyXLex & lex, Paragraph *& par,
                                              true);
                        alreadyread = true;
                } else if (tmptok == "Note") {
-                       inset = new InsetNote;
+                       inset = new InsetNote(params);
                } else if (tmptok == "Include") {
                        InsetCommandParams p("Include");
                        inset = new InsetInclude(p, *this);
                } else if (tmptok == "ERT") {
-                       inset = new InsetERT;
+                       inset = new InsetERT(params);
                } else if (tmptok == "Tabular") {
                        inset = new InsetTabular(*this);
                } else if (tmptok == "Text") {
-                       inset = new InsetText;
+                       inset = new InsetText(params);
                } else if (tmptok == "Foot") {
-                       inset = new InsetFoot;
+                       inset = new InsetFoot(params);
                } else if (tmptok == "Marginal") {
-                       inset = new InsetMarginal;
+                       inset = new InsetMarginal(params);
                } else if (tmptok == "Minipage") {
-                       inset = new InsetMinipage;
+                       inset = new InsetMinipage(params);
                } else if (tmptok == "Float") {
                        lex.next();
                        string tmptok = lex.getString();
-                       inset = new InsetFloat(tmptok);
+                       inset = new InsetFloat(params, tmptok);
 #if 0
                } else if (tmptok == "List") {
                        inset = new InsetList;
@@ -1523,7 +1551,7 @@ void Buffer::readInset(LyXLex & lex, Paragraph *& par,
                        inset = new InsetList;
 #endif
                } else if (tmptok == "Caption") {
-                       inset = new InsetCaption;
+                       inset = new InsetCaption(params);
                } else if (tmptok == "FloatList") {
                        inset = new InsetFloatList;
                }
@@ -1762,16 +1790,27 @@ bool Buffer::writeFile(string const & fname, bool flag) const
 }
 
 
+namespace {
+
+pair<int, string> const addDepth(int depth, int ldepth)
+{
+       int d = depth * 2;
+       if (ldepth > depth)
+               d += (ldepth - depth) * 2;
+       return make_pair(d, string(d, ' '));
+}
+
+}
+
+
 string const Buffer::asciiParagraph(Paragraph const * par,
                                     unsigned int linelen,
                                     bool noparbreak) const
 {
        ostringstream buffer;
-       ostringstream word;
        Paragraph::depth_type depth = 0;
        int ltype = 0;
        Paragraph::depth_type ltype_depth = 0;
-       string::size_type currlinelen = 0;
        bool ref_printed = false;
 //     if (!par->previous()) {
 #if 0
@@ -1792,26 +1831,26 @@ string const Buffer::asciiParagraph(Paragraph const * par,
 #endif
                
        // First write the layout
-       string const & tmp = lowercase(par->layout());
-       if (tmp == "itemize") {
+       string const & tmp = par->layout();
+       if (compare_no_case(tmp, "itemize") == 0) {
                ltype = 1;
                ltype_depth = depth + 1;
-       } else if (tmp == "enumerate") {
+       } else if (compare_no_case(tmp, "enumerate") == 0) {
                ltype = 2;
                ltype_depth = depth + 1;
-       } else if (contains(tmp, "ection")) {
+       } else if (contains(lowercase(tmp), "ection")) {
                ltype = 3;
                ltype_depth = depth + 1;
-       } else if (contains(tmp, "aragraph")) {
+       } else if (contains(lowercase(tmp), "aragraph")) {
                ltype = 4;
                ltype_depth = depth + 1;
-       } else if (tmp == "description") {
+       } else if (compare_no_case(tmp, "description") == 0) {
                ltype = 5;
                ltype_depth = depth + 1;
-       } else if (tmp == "abstract") {
+       } else if (compare_no_case(tmp, "abstract") == 0) {
                ltype = 6;
                ltype_depth = 0;
-       } else if (tmp == "bibliography") {
+       } else if (compare_no_case(tmp, "bibliography") == 0) {
                ltype = 7;
                ltype_depth = 0;
        } else {
@@ -1835,12 +1874,16 @@ string const Buffer::asciiParagraph(Paragraph const * par,
 //     }
 
        // linelen <= 0 is special and means we don't have pargraph breaks
+
+       string::size_type currlinelen = 0;
+
        if (!noparbreak) {
                if (linelen > 0)
                        buffer << "\n\n";
-               for (Paragraph::depth_type j = 0; j < depth; ++j)
-                       buffer << "  ";
-               currlinelen = depth * 2;
+
+               buffer << string(depth * 2, ' ');
+               currlinelen += depth * 2;
+
                //--
                // we should probably change to the paragraph language in the
                // gettext here (if possible) so that strings are outputted in
@@ -1852,46 +1895,52 @@ string const Buffer::asciiParagraph(Paragraph const * par,
                case 5: // Description
                        break;
                case 6: // Abstract
-                       if (linelen > 0)
+                       if (linelen > 0) {
                                buffer << _("Abstract") << "\n\n";
-                       else
-                               buffer << _("Abstract: ");
+                               currlinelen = 0;
+                       } else {
+                               string const abst = _("Abstract: ");
+                               buffer << abst;
+                               currlinelen += abst.length();
+                       }
                        break;
                case 7: // Bibliography
                        if (!ref_printed) {
-                               if (linelen > 0)
+                               if (linelen > 0) {
                                        buffer << _("References") << "\n\n";
-                               else
-                                       buffer << _("References: ");
+                                       currlinelen = 0;
+                               } else {
+                                       string const refs = _("References: ");
+                                       buffer << refs;
+                                       currlinelen += refs.length();
+                               }
+                               
                                ref_printed = true;
                        }
                        break;
                default:
-                       buffer << par->params().labelString() << " ";
-                       break;
+               {
+                       string const parlab = par->params().labelString();
+                       buffer << parlab << " ";
+                       currlinelen += parlab.length() + 1;
+               }
+               break;
+               
                }
        }
-       string s = buffer.str();
-       if (s.rfind('\n') != string::npos) {
-               string dummy;
-               s = rsplit(buffer.str().c_str(), dummy, '\n');
-       }
-       currlinelen = s.length();
+
        if (!currlinelen) {
-               for (Paragraph::depth_type j = 0; j < depth; ++j)
-                       buffer << "  ";
-               currlinelen = depth * 2;
-               if (ltype_depth > depth) {
-                       for (Paragraph::depth_type j = ltype_depth;
-                                j > depth; --j)
-                       {
-                               buffer << "  ";
-                       }
-                       currlinelen += (ltype_depth-depth)*2;
-               }
+               pair<int, string> p = addDepth(depth, ltype_depth);
+               buffer << p.second;
+               currlinelen += p.first;
        }
-       // this is to change the linebreak to do it by word a bit more intelligent
-       // hopefully! (only in the case where we have a max linelenght!) (Jug)
+       
+       // this is to change the linebreak to do it by word a bit more
+       // intelligent hopefully! (only in the case where we have a
+       // max linelenght!) (Jug)
+
+       string word;
+       
        for (pos_type i = 0; i < par->size(); ++i) {
                char c = par->getUChar(params, i);
                switch (c) {
@@ -1900,82 +1949,73 @@ string const Buffer::asciiParagraph(Paragraph const * par,
                        Inset const * inset = par->getInset(i);
                        if (inset) {
                                if (linelen > 0) {
-                                       buffer << word.str();
-                                       word.str("");
+                                       buffer << word;
+                                       currlinelen += word.length();
+                                       word.erase();
                                }
                                if (inset->ascii(this, buffer, linelen)) {
                                        // to be sure it breaks paragraph
                                        currlinelen += linelen;
                                }
-#if 0
-                               else {
-                                       string dummy;
-                                       string const s =
-                                               rsplit(buffer.str().c_str(),
-                                                      dummy, '\n');
-                                       currlinelen = s.length();
-                               }
-#endif
                        }
                }
                break;
                
                case Paragraph::META_NEWLINE:
                        if (linelen > 0) {
-                               buffer << word.str() << "\n";
-                               word.str("");
-                               for (Paragraph::depth_type j = 0; 
-                                    j < depth; ++j)
-                                       buffer << "  ";
-                               currlinelen = depth * 2;
-                               if (ltype_depth > depth) {
-                                       for (Paragraph::depth_type j = ltype_depth;
-                                                j > depth; --j)
-                                               buffer << "  ";
-                                       currlinelen += (ltype_depth - depth) * 2;
-                               }
+                               buffer << word << "\n";
+                               word.erase();
+
+                               pair<int, string> p = addDepth(depth,
+                                                              ltype_depth);
+                               buffer << p.second;
+                               currlinelen = p.first;
                        }
                        break;
                        
                case Paragraph::META_HFILL:
-                       buffer << word.str() << "\t";
-                       currlinelen += word.str().length() + 1;
-                       word.str("");
+                       buffer << word << "\t";
+                       currlinelen += word.length() + 1;
+                       word.erase();
                        break;
 
                default:
                        if (c == ' ') {
-                               buffer << word.str() << ' ';
-                               currlinelen += word.str().length() + 1;
-                               word.str("");
+                               if (linelen > 0 &&
+                                   currlinelen + word.length() > linelen - 10) {
+                                       buffer << "\n";
+                                       pair<int, string> p =
+                                               addDepth(depth, ltype_depth);
+                                       buffer << p.second;
+                                       currlinelen = p.first;
+                               }
+
+                               buffer << word << ' ';
+                               currlinelen += word.length() + 1;
+                               word.erase();
+
                        } else {
                                if (c != '\0') {
-                                       word << c;
+                                       word.push_back(c);
                                } else {
                                        lyxerr[Debug::INFO] <<
                                                "writeAsciiFile: NULL char in structure." << endl;
                                }
                                if ((linelen > 0) &&
-                                       (currlinelen+word.str().length()) > linelen)
+                                       (currlinelen + word.length()) > linelen)
                                {
                                        buffer << "\n";
-                                       for (Paragraph::depth_type j = 0; j < depth; ++j)
-                                               buffer << "  ";
-                                       currlinelen = depth * 2;
-                                       if (ltype_depth > depth) {
-                                               for (Paragraph::depth_type j = ltype_depth;
-                                                        j > depth; --j)
-                                               {
-                                                       buffer << "  ";
-                                               }
-                                               currlinelen += (ltype_depth-depth)*2;
-                                       }
+
+                                       pair<int, string> p =
+                                               addDepth(depth, ltype_depth);
+                                       buffer << p.second;
+                                       currlinelen = p.first;
                                }
                        }
                        break;
                }
        }
-       buffer << word.str();
+       buffer << word;
        return buffer.str().c_str();
 }
 
@@ -2011,22 +2051,19 @@ void Buffer::makeLaTeXFile(string const & fname,
 {
        lyxerr[Debug::LATEX] << "makeLaTeXFile..." << endl;
        
-       niceFile = nice; // this will be used by Insetincludes.
-
-       tex_code_break_column = lyxrc.ascii_linelen;
-
-        LyXTextClass const & tclass =
-               textclasslist[params.textclass];
-
        ofstream ofs(fname.c_str());
        if (!ofs) {
                Alert::err_alert(_("Error: Cannot open file: "), fname);
                return;
        }
        
+       niceFile = nice; // this will be used by Insetincludes.
+
+       tex_code_break_column = lyxrc.ascii_linelen;
+
        // validate the buffer.
        lyxerr[Debug::LATEX] << "  Validating buffer..." << endl;
-       LaTeXFeatures features(params, tclass.size());
+       LaTeXFeatures features(params);
        validate(features);
        lyxerr[Debug::LATEX] << "  Buffer validation done." << endl;
        
@@ -2061,9 +2098,11 @@ void Buffer::makeLaTeXFile(string const & fname,
                        texrow.newline();
                }
                if (!original_path.empty()) {
+                       string inputpath = os::external_path(original_path);
+                       subst(inputpath, "~", "\\string~");
                        ofs << "\\makeatletter\n"
                            << "\\def\\input@path{{"
-                           << os::external_path(original_path) << "/}}\n"
+                           << inputpath << "/}}\n"
                            << "\\makeatother\n";
                        texrow.newline();
                        texrow.newline();
@@ -2072,6 +2111,8 @@ void Buffer::makeLaTeXFile(string const & fname,
                
                ofs << "\\documentclass";
                
+               LyXTextClass const & tclass = textclasslist[params.textclass];
+               
                ostringstream options; // the document class options.
                
                if (tokenPos(tclass.opt_fontsize(),
@@ -2158,9 +2199,7 @@ void Buffer::makeLaTeXFile(string const & fname,
                        ofs << '[' << strOptions << ']';
                }
                
-               ofs << '{'
-                   << textclasslist[params.textclass].latexname()
-                   << "}\n";
+               ofs << '{' << tclass.latexname() << "}\n";
                texrow.newline();
                // end of \documentclass defs
                
@@ -2496,6 +2535,9 @@ void Buffer::makeLaTeXFile(string const & fname,
        
        lyxerr[Debug::INFO] << "Finished making latex file." << endl;
        lyxerr[Debug::INFO] << "Row count was " << texrow.rows()-1 << "." << endl;
+
+       // we want this to be true outside previews (for insetexternal)
+       niceFile = true;
 }
 
 
@@ -2583,21 +2625,21 @@ bool Buffer::isSGML() const
 }
 
 
-void Buffer::sgmlOpenTag(ostream & os, Paragraph::depth_type depth,
+void Buffer::sgmlOpenTag(ostream & os, Paragraph::depth_type,
                         string const & latexname) const
 {
        if (!latexname.empty() && latexname != "!-- --")
                //os << "<!-- " << depth << " -->" << "<" << latexname << ">";
-               os << string(depth, ' ') << "<" << latexname << ">\n";
+               os << "<" << latexname << ">";
 }
 
 
-void Buffer::sgmlCloseTag(ostream & os, Paragraph::depth_type depth,
+void Buffer::sgmlCloseTag(ostream & os, Paragraph::depth_type,
                          string const & latexname) const
 {
        if (!latexname.empty() && latexname != "!-- --")
                //os << "<!-- " << depth << " -->" << "</" << latexname << ">\n";
-               os << string(depth, ' ') << "</" << latexname << ">\n";
+               os << "</" << latexname << ">";
 }
 
 
@@ -2612,21 +2654,23 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
 
        niceFile = nice; // this will be used by included files.
 
-        LyXTextClass const & tclass = textclasslist[params.textclass];
-
-       LaTeXFeatures features(params, tclass.size());
+       LaTeXFeatures features(params);
        
        validate(features);
 
        texrow.reset();
 
-       string top_element = textclasslist[params.textclass].latexname();
+        LyXTextClass const & tclass = textclasslist[params.textclass];
+
+       string top_element = tclass.latexname();
 
        if (!body_only) {
                ofs << "<!doctype linuxdoc system";
 
                string preamble = params.preamble;
-               preamble += features.getIncludedFiles(fname);
+               const string name = nice ? ChangeExtension(filename_, ".sgml")
+                        : fname;
+               preamble += features.getIncludedFiles(name);
                preamble += features.getLyXSGMLEntities();
 
                if (!preamble.empty()) {
@@ -2654,8 +2698,7 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
        vector<string> environment_stack(5);
 
        while (par) {
-               LyXLayout const & style =
-                       textclasslist[params.textclass][par->layout()];
+               LyXLayout const & style = tclass[par->layout()];
 
                // treat <toc> as a special case for compatibility with old code
                if (par->isInset(0)) {
@@ -2778,6 +2821,9 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
 
        ofs.close();
        // How to check for successful close
+
+       // we want this to be true outside previews (for insetexternal)
+       niceFile = true;
 }
 
 
@@ -3053,22 +3099,22 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 
        niceFile = nice; // this will be used by Insetincludes.
 
-        LyXTextClass const & tclass =
-               textclasslist[params.textclass];
-
-       LaTeXFeatures features(params, tclass.size());
+       LaTeXFeatures features(params);
        validate(features);
    
        texrow.reset();
 
-       string top_element = textclasslist[params.textclass].latexname();
+        LyXTextClass const & tclass = textclasslist[params.textclass];
+       string top_element = tclass.latexname();
 
        if (!only_body) {
                ofs << "<!DOCTYPE " << top_element
                    << "  PUBLIC \"-//OASIS//DTD DocBook V4.1//EN\"";
 
                string preamble = params.preamble;
-               preamble += features.getIncludedFiles(fname);
+               const string name = nice ? ChangeExtension(filename_, ".sgml")
+                        : fname;
+               preamble += features.getIncludedFiles(name);
                preamble += features.getLyXSGMLEntities();
 
                if (!preamble.empty()) {
@@ -3110,8 +3156,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
                string c_params;
                int desc_on = 0; // description mode
 
-               LyXLayout const & style =
-                       textclasslist[params.textclass][par->layout()];
+               LyXLayout const & style = tclass[par->layout()];
 
                // environment tag closing
                for (; depth > par->params().depth(); --depth) {
@@ -3339,6 +3384,9 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 
        ofs.close();
        // How to check for successful close
+
+       // we want this to be true outside previews (for insetexternal)
+       niceFile = true;
 }
 
 
@@ -3410,7 +3458,7 @@ void Buffer::simpleDocBookOnePar(ostream & os,
        // resets description flag correctly
        if (desc_on == 1) {
                // <term> not closed...
-               os << "</term>";
+               os << "</term>\n<listitem><para>&nbsp;</para>";
        }
        if (style.free_spacing) os << '\n';
 }
@@ -3567,8 +3615,8 @@ Buffer::Lists const Buffer::getLists() const
        Paragraph * par = paragraph;
 
        LyXTextClass const & textclass = textclasslist[params.textclass];
-       bool found = textclass.hasLayout("caption");
-       string const layout("caption");
+       bool found = textclass.hasLayout("Caption");
+       string const layout("Caption");
 
        while (par) {
                char const labeltype = textclass[par->layout()].labeltype;
@@ -3614,7 +3662,7 @@ Buffer::Lists const Buffer::getLists() const
                                }
                        }
                } else {
-                       lyxerr << "caption not found" << endl;
+                       lyxerr << "Caption not found" << endl;
                }
                
                par = par->next();