#include "Buffer.h"
#include "BufferView.h"
#include "BufferParams.h"
-#include "Counters.h"
#include "Cursor.h"
-#include "DispatchResult.h"
#include "Encoding.h"
#include "FuncRequest.h"
#include "FuncStatus.h"
#include "InsetCaption.h"
+#include "InsetLabel.h"
+#include "InsetLayout.h"
#include "Language.h"
#include "LaTeXFeatures.h"
#include "Lexer.h"
#include "output_latex.h"
+#include "output_docbook.h"
#include "output_xhtml.h"
-#include "OutputParams.h"
-#include "TextClass.h"
#include "TexRow.h"
#include "texstream.h"
#include "frontends/alert.h"
#include "frontends/Application.h"
-#include "support/regex.h"
-
+#include <cstring>
+#include <regex>
#include <sstream>
using namespace std;
}
-Inset::DisplayType InsetListings::display() const
+int InsetListings::rowFlags() const
{
- return params().isInline() || params().isFloat() ? Inline : AlignLeft;
+ return params().isInline() || params().isFloat() ? Inline : Display | AlignLeft;
}
// Minted can deal with all encodings.
if (buffer().params().use_minted
|| inner_enc->name() == "utf8-plain"
- || (buffer().params().encoding().package() == Encoding::japanese
- && inner_enc->package() == Encoding::japanese)
+ || inner_enc->package() == Encoding::japanese
|| inner_enc->hasFixedWidth())
return 0;
// of the listings package (see page 25 of the manual)
bool const isInline = params().isInline();
bool const use_minted = buffer().params().use_minted;
+ static regex const reg1("(.*)(basicstyle=\\{)([^\\}]*)(\\\\ttfamily)([^\\}]*)(\\})(.*)");
+ static regex const reg2("(.*)(basicstyle=\\{)([^\\}]*)(\\\\rmfamily)([^\\}]*)(\\})(.*)");
+ static regex const reg3("(.*)(basicstyle=\\{)([^\\}]*)(\\\\sffamily)([^\\}]*)(\\})(.*)");
+ static regex const reg4("(.*)(basicstyle=\\{)([^\\}]*)(\\\\(tiny|scriptsize|footnotesize|small|normalsize|large|Large))([^\\}]*)(\\})(.*)");
+ static regex const reg5("(.*)(fontfamily=)(tt|sf|rm)(.*)");
+ static regex const reg6("(.*)(fontsize=\\{)(\\\\(tiny|scriptsize|footnotesize|small|normalsize|large|Large))(\\})(.*)");
+ if (use_minted) {
+ // If params have been entered with "listings", and then the user switched to "minted",
+ // we have params that need to be translated.
+ // FIXME: We should use a backend-abstract syntax in listings params instead!
+ // Substitute fontstyle option
+ smatch sub;
+ if (regex_match(param_string, sub, reg1))
+ param_string = sub.str(1) + "fontfamily=tt," + sub.str(2) + sub.str(3)
+ + sub.str(5) + sub.str(6) + sub.str(7);
+ if (regex_match(param_string, sub, reg2))
+ param_string = sub.str(1) + "fontfamily=rm," + sub.str(2) + sub.str(3)
+ + sub.str(5) + sub.str(6) + sub.str(7);
+ if (regex_match(param_string, sub, reg3))
+ param_string = sub.str(1) + "fontfamily=sf," + sub.str(2) + sub.str(3)
+ + sub.str(5) + sub.str(6) + sub.str(7);
+ // as well as fontsize option
+ if (regex_match(param_string, sub, reg4))
+ param_string = sub.str(1) + "fontsize={" + sub.str(4) + sub.str(3) + sub.str(7) + sub.str(8);
+ } else {
+ // And the same vice versa
+ // Substitute fontstyle option
+ smatch sub;
+ string basicstyle;
+ if (regex_match(param_string, sub, reg5)) {
+ basicstyle = "\\" + sub.str(3) + "family";
+ param_string = sub.str(1) + sub.str(4);
+ }
+ // as well as fontsize option
+ if (regex_match(param_string, sub, reg6)) {
+ basicstyle += sub.str(3);
+ param_string = sub.str(1) + sub.str(6);
+ }
+ if (!basicstyle.empty())
+ param_string = rtrim(param_string, ",") + ",basicstyle={" + basicstyle + "}";
+ }
+ if (runparams.use_polyglossia && runparams.local_font->isRightToLeft()) {
+ // We need to use the *latin switches (#11554)
+ smatch sub;
+ if (regex_match(param_string, sub, reg1))
+ param_string = sub.str(1) + sub.str(2) + sub.str(3) + sub.str(4)
+ + "latin" + sub.str(5) + sub.str(6) + sub.str(7);
+ if (regex_match(param_string, sub, reg2))
+ param_string = sub.str(1) + sub.str(2) + sub.str(3) + sub.str(4)
+ + "latin" + sub.str(5) + sub.str(6) + sub.str(7);
+ if (regex_match(param_string, sub, reg3))
+ param_string = sub.str(1) + sub.str(2) + sub.str(3) + sub.str(4)
+ + "latin" + sub.str(5) + sub.str(6) + sub.str(7);
+ }
string minted_language;
string float_placement;
bool const isfloat = params().isFloat();
if (prefixIs(opts[i], "float")) {
if (prefixIs(opts[i], "float="))
float_placement = opts[i].substr(6);
- opts.erase(opts.begin() + i--);
+ opts.erase(opts.begin() + int(i--));
}
else if (prefixIs(opts[i], "language=")) {
minted_language = opts[i].substr(9);
- opts.erase(opts.begin() + i--);
+ opts.erase(opts.begin() + int(i--));
}
}
param_string = getStringFromVector(opts, ",");
}
}
++par;
- // for the inline case, if there are multiple paragraphs
+ // Add new line between paragraphs in displayed listings.
+ // Exception: merged paragraphs in change tracking mode.
+ // Also, for the inline case, if there are multiple paragraphs
// they are simply joined. Otherwise, expect latex errors.
- if (par != end && !isInline && !captionline)
+ if (par != end && !isInline && !captionline && !par->parEndChange().deleted())
code += "\n";
}
if (isInline) {
}
-docstring InsetListings::xhtml(XHTMLStream & os, OutputParams const & rp) const
+docstring InsetListings::xhtml(XMLStream & os, OutputParams const & rp) const
{
odocstringstream ods;
- XHTMLStream out(ods);
+ XMLStream out(ods);
bool const isInline = params().isInline();
if (isInline)
- out << html::CompTag("br");
+ out << xml::CompTag("br");
else {
- out << html::StartTag("div", "class='float-listings'");
+ out << xml::StartTag("div", "class='float-listings'");
docstring caption = getCaptionHTML(rp);
if (!caption.empty())
- out << html::StartTag("div", "class='listings-caption'")
- << XHTMLStream::ESCAPE_NONE
- << caption << html::EndTag("div");
+ out << xml::StartTag("div", "class='listings-caption'")
+ << XMLStream::ESCAPE_NONE
+ << caption << xml::EndTag("div");
}
InsetLayout const & il = getLayout();
if (!lang.empty())
attr += " " + lang;
attr += "'";
- out << html::StartTag(tag, attr);
+ out << xml::StartTag(tag, attr);
OutputParams newrp = rp;
newrp.html_disable_captions = true;
// We don't want to convert dashes here. That's the only conversion we
// do for XHTML, so this is safe.
newrp.pass_thru = true;
docstring def = InsetText::insetAsXHTML(out, newrp, InsetText::JustText);
- out << html::EndTag(tag);
+ out << xml::EndTag(tag);
if (isInline) {
- out << html::CompTag("br");
+ out << xml::CompTag("br");
// escaping will already have been done
- os << XHTMLStream::ESCAPE_NONE << ods.str();
+ os << XMLStream::ESCAPE_NONE << ods.str();
} else {
- out << html::EndTag("div");
+ out << xml::EndTag("div");
// In this case, this needs to be deferred, but we'll put it
// before anything the text itself deferred.
def = ods.str() + '\n' + def;
}
+void InsetListings::docbook(XMLStream & xs, OutputParams const & rp) const
+{
+ InsetLayout const & il = getLayout();
+ bool isInline = params().isInline();
+
+ if (!isInline && !xs.isLastTagCR())
+ xs << xml::CR();
+
+ // In case of caption, the code must be wrapped, for instance in a figure. Also detect if there is a label.
+ // http://www.sagehill.net/docbookxsl/ProgramListings.html
+ // TODO: parts of this code could be merged with InsetFloat and findLabelInParagraph.
+ InsetCaption const * caption = getCaptionInset();
+ if (caption) {
+ InsetLabel const * label = getLabelInset();
+
+ // Ensure that the label will not be output a second time as an anchor.
+ OutputParams rpNoLabel = rp;
+ if (label)
+ rpNoLabel.docbook_anchors_to_ignore.emplace(label->screenLabel());
+
+ // Prepare the right set of attributes, including the label.
+ docstring attr = from_ascii("type='listing'");
+ if (label)
+ attr += " xml:id=\"" + xml::cleanID(label->screenLabel()) + "\"";
+
+ // Finally, generate the wrapper (including the label).
+ xs << xml::StartTag("figure", attr);
+ xs << xml::CR();
+ xs << xml::StartTag("title");
+ xs << XMLStream::ESCAPE_NONE << getCaptionDocBook(rpNoLabel);
+ xs << xml::EndTag("title");
+ xs << xml::CR();
+ }
+
+ // Forge the attributes.
+ std::string attrs;
+ if (!il.docbookattr().empty())
+ attrs += " role=\"" + il.docbookattr() + "\"";
+ std::string const lang = params().getParamValue("language");
+ if (!lang.empty())
+ attrs += " language=\"" + lang + "\"";
+
+ // Determine the tag to use. Use the layout-defined value if outside a paragraph.
+ std::string tag = il.docbooktag();
+ if (isInline)
+ tag = "code";
+
+ // Start the listing.
+ xs << xml::StartTag(tag, attrs);
+ xs.startDivision(false);
+
+ // Deal with the content of the listing.
+ OutputParams newrp = rp;
+ newrp.pass_thru = true;
+ newrp.docbook_make_pars = false;
+ newrp.par_begin = 0;
+ newrp.par_end = text().paragraphs().size();
+ newrp.docbook_in_listing = true;
+
+ docbookParagraphs(text(), buffer(), xs, newrp);
+
+ // Done with the listing.
+ xs.endDivision();
+ xs << xml::EndTag(tag);
+ if (!isInline)
+ xs << xml::CR();
+
+ if (caption) {
+ xs << xml::EndTag("figure");
+ xs << xml::CR();
+ }
+}
+
+
string InsetListings::contextMenuName() const
{
return "context-listings";
docstring const InsetListings::buttonLabel(BufferView const & bv) const
{
// FIXME UNICODE
- if (decoration() == InsetLayout::CLASSIC)
- return isOpen(bv) ? _("Listing") : getNewLabel(_("Listing"));
- else
- return getNewLabel(_("Listing"));
+ docstring const locked = tempfile_ ? docstring(1, 0x1F512) : docstring();
+ if (decoration() == InsetDecoration::CLASSIC)
+ return locked + (isOpen(bv) ? _("Listing") : getNewLabel(_("Listing")));
+ return locked + getNewLabel(_("Listing"));
}
OutputParams rp = features.runparams();
if (!params().isFloat() && !getCaption(rp).str.empty())
features.require("lyxmintcaption");
+ if (features.usePolyglossia() && features.hasRTLLanguage())
+ // minted loads color, but color must be loaded before bidi
+ // (i.e., polyglossia)
+ features.require("color");
} else {
features.require("listings");
if (contains(param_string, "\\color"))