]> git.lyx.org Git - lyx.git/blobdiff - src/Paragraph.cpp
Assure correct spacing of colored items in mathed
[lyx.git] / src / Paragraph.cpp
index 5d1a7fe82041de854a1433a66ddeb0aad066d9d0..f2d97fe7c97cb9dbc60eac15e39e056391b14ec8 100644 (file)
@@ -64,6 +64,7 @@
 #include "support/lassert.h"
 #include "support/lstrings.h"
 #include "support/textutils.h"
+#include "output_docbook.h"
 
 #include <atomic>
 #include <sstream>
@@ -83,14 +84,6 @@ using namespace lyx::support;
 
 namespace lyx {
 
-namespace {
-
-/// Inset identifier (above 0x10ffff, for ucs-4)
-char_type const META_INSET = 0x200001;
-
-} // namespace
-
-
 /////////////////////////////////////////////////////////////////////
 //
 // SpellResultRange
@@ -273,9 +266,9 @@ private:
        Ranges ranges_;
        /// the area of the paragraph with pending spell check
        FontSpan refresh_;
-       bool needs_refresh_;
        /// spell state cache version number
        SpellChecker::ChangeNumber current_change_number_;
+       bool needs_refresh_;
 
 
        void correctRangesAfterPos(pos_type pos, int offset)
@@ -459,7 +452,7 @@ public:
        {
                int numskips = 0;
                while (it != et && it->first < start) {
-                       int skip = it->last - it->first + 1;
+                       long skip = it->last - it->first + 1;
                        start += skip;
                        numskips += skip;
                        ++it;
@@ -486,9 +479,6 @@ public:
        ///
        FontList fontlist_;
 
-       ///
-       int id_;
-
        ///
        ParagraphParameters params_;
 
@@ -513,11 +503,13 @@ public:
        Layout const * layout_;
        ///
        SpellCheckerState speller_state_;
+       ///
+       int id_;
 };
 
 
 Paragraph::Private::Private(Paragraph * owner, Layout const & layout)
-       : owner_(owner), inset_owner_(nullptr), id_(-1), begin_of_body_(0), layout_(&layout)
+       : owner_(owner), inset_owner_(nullptr), begin_of_body_(0), layout_(&layout), id_(-1)
 {
        text_.reserve(100);
 }
@@ -530,17 +522,16 @@ int Paragraph::Private::make_id()
        // LFUN_PARAGRAPH_GOTO to switch to a different buffer, for instance in the
        // outliner.
        // (thread-safe)
-       static atomic_uint next_id(0);
+       static int next_id(0);
        return next_id++;
 }
 
 
 Paragraph::Private::Private(Private const & p, Paragraph * owner)
        : owner_(owner), inset_owner_(p.inset_owner_), fontlist_(p.fontlist_),
-         id_(make_id()),
          params_(p.params_), changes_(p.changes_), insetlist_(p.insetlist_),
          begin_of_body_(p.begin_of_body_), text_(p.text_), words_(p.words_),
-         layout_(p.layout_)
+         layout_(p.layout_), id_(make_id())
 {
        requestSpellCheck(p.text_.size());
 }
@@ -548,11 +539,11 @@ Paragraph::Private::Private(Private const & p, Paragraph * owner)
 
 Paragraph::Private::Private(Private const & p, Paragraph * owner,
        pos_type beg, pos_type end)
-       : owner_(owner), inset_owner_(p.inset_owner_), id_(make_id()),
+       : owner_(owner), inset_owner_(p.inset_owner_),
          params_(p.params_), changes_(p.changes_),
          insetlist_(p.insetlist_, beg, end),
          begin_of_body_(p.begin_of_body_), words_(p.words_),
-         layout_(p.layout_)
+         layout_(p.layout_), id_(make_id())
 {
        if (beg >= pos_type(p.text_.size()))
                return;
@@ -1052,9 +1043,11 @@ void Paragraph::Private::latexInset(BufferParams const & bparams,
                bool needPar = false;
                bool closeLanguage = arabtex
                        || basefont.isRightToLeft() == running_font.isRightToLeft();
+               // We pass non_inherit_inset = true here since size switches
+               // ought not to be terminated here (#8384).
                unsigned int count = running_font.latexWriteEndChanges(os,
                                        bparams, runparams, basefont, basefont,
-                                       needPar, closeLanguage);
+                                       needPar, closeLanguage, true);
                column += count;
                // if any font properties were closed, update the running_font,
                // making sure, however, to leave the language as it was
@@ -1066,8 +1059,15 @@ void Paragraph::Private::latexInset(BufferParams const & bparams,
                        running_font = basefont;
                        if (!closeLanguage)
                                running_font.setLanguage(copy_font.language());
-                       // leave font open if language is still open
-                       open_font = (running_font.language() == basefont.language());
+                       // For these, we use switches, so no need to close
+                       basefont.fontInfo().setSize(copy_font.fontInfo().size());
+                       basefont.fontInfo().setFamily(copy_font.fontInfo().family());
+                       basefont.fontInfo().setSeries(copy_font.fontInfo().series());
+                       // leave font open if language or any of the switches is still open
+                       open_font = (running_font.language() == basefont.language()
+                                    || running_font.fontInfo().size() == basefont.fontInfo().size()
+                                    || running_font.fontInfo().family() == basefont.fontInfo().family()
+                                    || running_font.fontInfo().series() == basefont.fontInfo().series());
                        if (closeLanguage)
                                runparams.local_font = &basefont;
                }
@@ -2054,13 +2054,6 @@ docstring Paragraph::expandLabel(Layout const & layout,
 }
 
 
-docstring Paragraph::expandDocBookLabel(Layout const & layout,
-               BufferParams const & bparams) const
-{
-       return expandParagraphLabel(layout, bparams, false);
-}
-
-
 docstring Paragraph::expandParagraphLabel(Layout const & layout,
                BufferParams const & bparams, bool process_appendix) const
 {
@@ -2400,6 +2393,11 @@ void Paragraph::latex(BufferParams const & bparams,
        pos_type body_pos = beginOfBody();
        unsigned int column = 0;
 
+       // If we are inside an non inheritFont() inset, the real outerfont is local_font
+       Font const real_outerfont = (!inInset().inheritFont()
+                                    && runparams.local_font != nullptr)
+                       ? Font(runparams.local_font->fontInfo()) : outerfont;
+
        if (body_pos > 0) {
                // the optional argument is kept in curly brackets in
                // case it contains a ']'
@@ -2409,9 +2407,9 @@ void Paragraph::latex(BufferParams const & bparams,
                // braces when it parses \item.
                os << "[{";
                column += 2;
-               basefont = getLabelFont(bparams, outerfont);
+               basefont = getLabelFont(bparams, real_outerfont);
        } else {
-               basefont = getLayoutFont(bparams, outerfont);
+               basefont = getLayoutFont(bparams, real_outerfont);
        }
 
        // Which font is currently active?
@@ -2456,7 +2454,7 @@ void Paragraph::latex(BufferParams const & bparams,
                                                basefont, basefont, needPar);
                                        open_font = false;
                                }
-                               basefont = getLayoutFont(bparams, outerfont);
+                               basefont = getLayoutFont(bparams, real_outerfont);
                                running_font = basefont;
 
                                column += Changes::latexMarkChange(os, bparams,
@@ -2523,8 +2521,8 @@ void Paragraph::latex(BufferParams const & bparams,
                                                basefont, needPar);
                                        open_font = false;
                                }
-                               basefont = (body_pos > i) ? getLabelFont(bparams, outerfont)
-                                                         : getLayoutFont(bparams, outerfont);
+                               basefont = (body_pos > i) ? getLabelFont(bparams, real_outerfont)
+                                                         : getLayoutFont(bparams, real_outerfont);
                                running_font = basefont;
                                column += Changes::latexMarkChange(os, bparams,
                                        Change(Change::INSERTED), change, rp);
@@ -2544,8 +2542,8 @@ void Paragraph::latex(BufferParams const & bparams,
                                                basefont, basefont, needPar);
                                open_font = false;
                        }
-                       basefont = (body_pos > i) ? getLabelFont(bparams, outerfont)
-                                                 : getLayoutFont(bparams, outerfont);
+                       basefont = (body_pos > i) ? getLabelFont(bparams, real_outerfont)
+                                                 : getLayoutFont(bparams, real_outerfont);
                        running_font = basefont;
                        column += Changes::latexMarkChange(os, bparams, runningChange,
                                                           change, runparams);
@@ -2657,10 +2655,11 @@ void Paragraph::latex(BufferParams const & bparams,
                                os << '}';
                                column += 1;
                        }
-                       odocstringstream ods;
-                       column += current_font.latexWriteStartChanges(ods, bparams,
+                       otexstringstream ots;
+                       bool const non_inherit_inset = (c == META_INSET && getInset(i) && !getInset(i)->inheritFont());
+                       column += current_font.latexWriteStartChanges(ots, bparams,
                                                              runparams, basefont,
-                                                             last_font);
+                                                             last_font, non_inherit_inset);
                        // Check again for display math in ulem commands as a
                        // font change may also occur just before a math inset.
                        if (runparams.inDisplayMath && !deleted_display_math
@@ -2672,19 +2671,17 @@ void Paragraph::latex(BufferParams const & bparams,
                        }
                        running_font = current_font;
                        open_font = true;
-                       docstring fontchange = ods.str();
+                       docstring fontchange = ots.str();
+                       os << fontchange;
                        // check whether the fontchange ends with a \\textcolor
-                       // modifier and the text starts with a space (bug 4473)
+                       // modifier and the text starts with a space. If so we
+                       // need to add } in order to prevent \\textcolor from gobbling
+                       // the space (bug 4473).
                        docstring const last_modifier = rsplit(fontchange, '\\');
                        if (prefixIs(last_modifier, from_ascii("textcolor")) && c == ' ')
-                               os << fontchange << from_ascii("{}");
-                       // check if the fontchange ends with a trailing blank
-                       // (like "\small " (see bug 3382)
-                       else if (suffixIs(fontchange, ' ') && c == ' ')
-                               os << fontchange.substr(0, fontchange.size() - 1)
-                                  << from_ascii("{}");
-                       else
-                               os << fontchange;
+                               os << from_ascii("{}");
+                       else if (ots.terminateCommand())
+                               os << termcmd;
                        if (in_ct_deletion) {
                                // We have to close and then reopen \lyxdeleted,
                                // as strikeout needs to be on lowest level.
@@ -2743,10 +2740,10 @@ void Paragraph::latex(BufferParams const & bparams,
                                                pit < 0 || pars[pit].empty()
                                                ? pars[pit].getLayoutFont(
                                                                bparams,
-                                                               outerfont)
+                                                               real_outerfont)
                                                : pars[pit].getFont(bparams,
                                                        pars[pit].size() - 1,
-                                                       outerfont);
+                                                       real_outerfont);
                                        if (lastfont.fontInfo().size() !=
                                            basefont.fontInfo().size()) {
                                                ++parInline;
@@ -2754,7 +2751,7 @@ void Paragraph::latex(BufferParams const & bparams,
                                        }
                                }
                                d->latexInset(bparams, os, rp, running_font,
-                                               basefont, outerfont, open_font,
+                                               basefont, real_outerfont, open_font,
                                                runningChange, style, i, column);
                                if (incremented)
                                        --parInline;
@@ -2839,8 +2836,8 @@ void Paragraph::latex(BufferParams const & bparams,
                // since this produces unwanted whitespace.
 
                Font const font = empty()
-                       ? getLayoutFont(bparams, outerfont)
-                       : getFont(bparams, size() - 1, outerfont);
+                       ? getLayoutFont(bparams, real_outerfont)
+                       : getFont(bparams, size() - 1, real_outerfont);
 
                InsetText const * textinset = inInset().asInsetText();
 
@@ -2952,18 +2949,17 @@ string Paragraph::getID(Buffer const &, OutputParams const &)
 }
 
 
-pos_type Paragraph::firstWordDocBook(odocstream & os, OutputParams const & runparams)
-       const
+pos_type Paragraph::firstWordDocBook(XMLStream & xs, OutputParams const & runparams) const
 {
        pos_type i;
        for (i = 0; i < size(); ++i) {
                if (Inset const * inset = getInset(i)) {
-                       inset->docbook(os, runparams);
+                       inset->docbook(xs, runparams);
                } else {
                        char_type c = d->text_[i];
                        if (c == ' ')
                                break;
-                       os << xml::escapeChar(c, XMLStream::ESCAPE_ALL);
+                       xs << c;
                }
        }
        return i;
@@ -3005,57 +3001,331 @@ bool Paragraph::Private::onlyText(Buffer const & buf, Font const & outerfont, po
 }
 
 
-void Paragraph::simpleDocBookOnePar(Buffer const & buf,
-                                   odocstream & os,
-                                   OutputParams const & runparams,
-                                   Font const & outerfont,
-                                   pos_type initial) const
+namespace {
+
+void doFontSwitchDocBook(vector<xml::FontTag> & tagsToOpen,
+                  vector<xml::EndFontTag> & tagsToClose,
+                  bool & flag, FontState curstate, xml::FontTypes type)
 {
+       if (curstate == FONT_ON) {
+               tagsToOpen.push_back(docbookStartFontTag(type));
+               flag = true;
+       } else if (flag) {
+               tagsToClose.push_back(docbookEndFontTag(type));
+               flag = false;
+       }
+}
+
+class OptionalFontType {
+public:
+       xml::FontTypes ft;
+       bool has_value;
+
+       OptionalFontType(): ft(xml::FT_EMPH), has_value(false) {} // A possible value at random for ft.
+       OptionalFontType(xml::FontTypes ft): ft(ft), has_value(true) {}
+};
+
+OptionalFontType fontShapeToXml(FontShape fs)
+{
+       switch (fs) {
+       case ITALIC_SHAPE:
+               return {xml::FT_ITALIC};
+       case SLANTED_SHAPE:
+               return {xml::FT_SLANTED};
+       case SMALLCAPS_SHAPE:
+               return {xml::FT_SMALLCAPS};
+       case UP_SHAPE:
+       case INHERIT_SHAPE:
+               return {};
+       default:
+               // the other tags are for internal use
+               LATTEST(false);
+               return {};
+       }
+}
+
+OptionalFontType fontFamilyToXml(FontFamily fm)
+{
+       switch (fm) {
+       case ROMAN_FAMILY:
+               return {xml::FT_ROMAN};
+       case SANS_FAMILY:
+               return {xml::FT_SANS};
+       case TYPEWRITER_FAMILY:
+               return {xml::FT_TYPE};
+       case INHERIT_FAMILY:
+               return {};
+       default:
+               // the other tags are for internal use
+               LATTEST(false);
+               return {};
+       }
+}
+
+OptionalFontType fontSizeToXml(FontSize fs)
+{
+       switch (fs) {
+       case TINY_SIZE:
+               return {xml::FT_SIZE_TINY};
+       case SCRIPT_SIZE:
+               return {xml::FT_SIZE_SCRIPT};
+       case FOOTNOTE_SIZE:
+               return {xml::FT_SIZE_FOOTNOTE};
+       case SMALL_SIZE:
+               return {xml::FT_SIZE_SMALL};
+       case LARGE_SIZE:
+               return {xml::FT_SIZE_LARGE};
+       case LARGER_SIZE:
+               return {xml::FT_SIZE_LARGER};
+       case LARGEST_SIZE:
+               return {xml::FT_SIZE_LARGEST};
+       case HUGE_SIZE:
+               return {xml::FT_SIZE_HUGE};
+       case HUGER_SIZE:
+               return {xml::FT_SIZE_HUGER};
+       case INCREASE_SIZE:
+               return {xml::FT_SIZE_INCREASE};
+       case DECREASE_SIZE:
+               return {xml::FT_SIZE_DECREASE};
+       case INHERIT_SIZE:
+       case NORMAL_SIZE:
+               return {};
+       default:
+               // the other tags are for internal use
+               LATTEST(false);
+               return {};
+       }
+}
+
+struct DocBookFontState
+{
+       FontShape  curr_fs   = INHERIT_SHAPE;
+       FontFamily curr_fam  = INHERIT_FAMILY;
+       FontSize   curr_size = INHERIT_SIZE;
+
+       // track whether we have opened these tags
        bool emph_flag = false;
+       bool bold_flag = false;
+       bool noun_flag = false;
+       bool ubar_flag = false;
+       bool dbar_flag = false;
+       bool sout_flag = false;
+       bool xout_flag = false;
+       bool wave_flag = false;
+       // shape tags
+       bool shap_flag = false;
+       // family tags
+       bool faml_flag = false;
+       // size tags
+       bool size_flag = false;
+};
+
+std::tuple<vector<xml::FontTag>, vector<xml::EndFontTag>> computeDocBookFontSwitch(FontInfo const & font_old,
+                                                                                          Font const & font,
+                                                                                          std::string const & default_family,
+                                                                                          DocBookFontState & fs)
+{
+       vector<xml::FontTag> tagsToOpen;
+       vector<xml::EndFontTag> tagsToClose;
+
+       // emphasis
+       FontState curstate = font.fontInfo().emph();
+       if (font_old.emph() != curstate)
+               doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.emph_flag, curstate, xml::FT_EMPH);
+
+       // noun
+       curstate = font.fontInfo().noun();
+       if (font_old.noun() != curstate)
+               doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.noun_flag, curstate, xml::FT_NOUN);
+
+       // underbar
+       curstate = font.fontInfo().underbar();
+       if (font_old.underbar() != curstate)
+               doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.ubar_flag, curstate, xml::FT_UBAR);
+
+       // strikeout
+       curstate = font.fontInfo().strikeout();
+       if (font_old.strikeout() != curstate)
+               doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.sout_flag, curstate, xml::FT_SOUT);
+
+       // xout
+       curstate = font.fontInfo().xout();
+       if (font_old.xout() != curstate)
+               doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.xout_flag, curstate, xml::FT_XOUT);
+
+       // double underbar
+       curstate = font.fontInfo().uuline();
+       if (font_old.uuline() != curstate)
+               doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.dbar_flag, curstate, xml::FT_DBAR);
+
+       // wavy line
+       curstate = font.fontInfo().uwave();
+       if (font_old.uwave() != curstate)
+               doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.wave_flag, curstate, xml::FT_WAVE);
+
+       // bold
+       // a little hackish, but allows us to reuse what we have.
+       curstate = (font.fontInfo().series() == BOLD_SERIES ? FONT_ON : FONT_OFF);
+       if (font_old.series() != font.fontInfo().series())
+               doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.bold_flag, curstate, xml::FT_BOLD);
+
+       // Font shape
+       fs.curr_fs = font.fontInfo().shape();
+       FontShape old_fs = font_old.shape();
+       if (old_fs != fs.curr_fs) {
+               if (fs.shap_flag) {
+                       OptionalFontType tag = fontShapeToXml(old_fs);
+                       if (tag.has_value)
+                               tagsToClose.push_back(docbookEndFontTag(tag.ft));
+                       fs.shap_flag = false;
+               }
+
+               OptionalFontType tag = fontShapeToXml(fs.curr_fs);
+               if (tag.has_value)
+                       tagsToOpen.push_back(docbookStartFontTag(tag.ft));
+       }
+
+       // Font family
+       fs.curr_fam = font.fontInfo().family();
+       FontFamily old_fam = font_old.family();
+       if (old_fam != fs.curr_fam) {
+               if (fs.faml_flag) {
+                       OptionalFontType tag = fontFamilyToXml(old_fam);
+                       if (tag.has_value)
+                               tagsToClose.push_back(docbookEndFontTag(tag.ft));
+                       fs.faml_flag = false;
+               }
+               switch (fs.curr_fam) {
+                       case ROMAN_FAMILY:
+                               // we will treat a "default" font family as roman, since we have
+                               // no other idea what to do.
+                               if (default_family != "rmdefault" && default_family != "default") {
+                                       tagsToOpen.push_back(docbookStartFontTag(xml::FT_ROMAN));
+                                       fs.faml_flag = true;
+                               }
+                               break;
+                       case SANS_FAMILY:
+                               if (default_family != "sfdefault") {
+                                       tagsToOpen.push_back(docbookStartFontTag(xml::FT_SANS));
+                                       fs.faml_flag = true;
+                               }
+                               break;
+                       case TYPEWRITER_FAMILY:
+                               if (default_family != "ttdefault") {
+                                       tagsToOpen.push_back(docbookStartFontTag(xml::FT_TYPE));
+                                       fs.faml_flag = true;
+                               }
+                               break;
+                       case INHERIT_FAMILY:
+                               break;
+                       default:
+                               // the other tags are for internal use
+                               LATTEST(false);
+                               break;
+               }
+       }
+
+       // Font size
+       fs.curr_size = font.fontInfo().size();
+       FontSize old_size = font_old.size();
+       if (old_size != fs.curr_size) {
+               if (fs.size_flag) {
+                       OptionalFontType tag = fontSizeToXml(old_size);
+                       if (tag.has_value)
+                               tagsToClose.push_back(docbookEndFontTag(tag.ft));
+                       fs.size_flag = false;
+               }
+
+               OptionalFontType tag = fontSizeToXml(fs.curr_size);
+               if (tag.has_value) {
+                       tagsToOpen.push_back(docbookStartFontTag(tag.ft));
+                       fs.size_flag = true;
+               }
+       }
+
+       return std::tuple<vector<xml::FontTag>, vector<xml::EndFontTag>>(tagsToOpen, tagsToClose);
+}
+
+} // anonymous namespace
+
+
+void Paragraph::simpleDocBookOnePar(Buffer const & buf,
+                                    XMLStream & xs,
+                                    OutputParams const & runparams,
+                                    Font const & outerfont,
+                                    bool start_paragraph, bool close_paragraph,
+                                    pos_type initial) const
+{
+       // track whether we have opened these tags
+       DocBookFontState fs;
+
+       if (start_paragraph)
+               xs.startDivision(allowEmpty());
 
        Layout const & style = *d->layout_;
        FontInfo font_old =
-               style.labeltype == LABEL_MANUAL ? style.labelfont : style.font;
+                       style.labeltype == LABEL_MANUAL ? style.labelfont : style.font;
 
-       if (style.pass_thru && !d->onlyText(buf, outerfont, initial))
-               os << "]]>";
+       string const default_family =
+                       buf.masterBuffer()->params().fonts_default_family;
+
+       vector<xml::FontTag> tagsToOpen;
+       vector<xml::EndFontTag> tagsToClose;
 
        // parsing main loop
        for (pos_type i = initial; i < size(); ++i) {
-               Font font = getFont(buf.params(), i, outerfont);
-
-               // handle <emphasis> tag
-               if (font_old.emph() != font.fontInfo().emph()) {
-                       if (font.fontInfo().emph() == FONT_ON) {
-                               os << "<emphasis>";
-                               emph_flag = true;
-                       } else if (i != initial) {
-                               os << "</emphasis>";
-                               emph_flag = false;
-                       }
-               }
+               // let's not show deleted material in the output
+               if (isDeleted(i))
+                       continue;
+
+               Font const font = getFont(buf.masterBuffer()->params(), i, outerfont);
+
+               // Determine which tags should be opened or closed.
+               tie(tagsToOpen, tagsToClose) = computeDocBookFontSwitch(font_old, font, default_family, fs);
+
+               // FIXME XHTML
+               // Other such tags? What about the other text ranges?
+
+               vector<xml::EndFontTag>::const_iterator cit = tagsToClose.begin();
+               vector<xml::EndFontTag>::const_iterator cen = tagsToClose.end();
+               for (; cit != cen; ++cit)
+                       xs << *cit;
+
+               vector<xml::FontTag>::const_iterator sit = tagsToOpen.begin();
+               vector<xml::FontTag>::const_iterator sen = tagsToOpen.end();
+               for (; sit != sen; ++sit)
+                       xs << *sit;
+
+               tagsToClose.clear();
+               tagsToOpen.clear();
 
                if (Inset const * inset = getInset(i)) {
-                       inset->docbook(os, runparams);
+                       if (!runparams.for_toc || inset->isInToc()) {
+                               OutputParams np = runparams;
+                               np.local_font = &font;
+                               // If the paragraph has size 1, then we are in the "special
+                               // case" where we do not output the containing paragraph info.
+                               // This "special case" is defined in more details in output_docbook.cpp, makeParagraphs. The results
+                               // of that brittle logic is passed to this function through open_par.
+                               if (!inset->getLayout().htmlisblock() && size() != 1) // TODO: htmlisblock here too!
+                                       np.docbook_in_par = true;
+                               inset->docbook(xs, np);
+                       }
                } else {
-                       char_type c = d->text_[i];
-
-                       if (style.pass_thru)
-                               os.put(c);
-                       else
-                               os << xml::escapeChar(c, XMLStream::EscapeSettings::ESCAPE_ALL);
+                       char_type c = getUChar(buf.masterBuffer()->params(), runparams, i);
+                       xs << c;
                }
                font_old = font.fontInfo();
        }
 
-       if (emph_flag) {
-               os << "</emphasis>";
-       }
-
-       if (style.free_spacing)
-               os << '\n';
-       if (style.pass_thru && !d->onlyText(buf, outerfont, initial))
-               os << "<![CDATA[";
+       // FIXME, this code is just imported from XHTML
+       // I'm worried about what happens if a branch, say, is itself
+       // wrapped in some font stuff. I think that will not work.
+       xs.closeFontTags();
+       if (runparams.docbook_in_listing)
+               xs << xml::CR();
+       if (close_paragraph)
+               xs.endDivision();
 }