X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetListings.cpp;h=b847131f57acb95002b3e707dc73fea573e045f3;hb=62b06c64ed624d51cce785e083d59cab18b36b69;hp=2768b831da270634d08b25c3d79c843fe9f32f74;hpb=8753847055d89ceddc670fd9758c7dd665f899ab;p=lyx.git diff --git a/src/insets/InsetListings.cpp b/src/insets/InsetListings.cpp index 2768b831da..b847131f57 100644 --- a/src/insets/InsetListings.cpp +++ b/src/insets/InsetListings.cpp @@ -4,7 +4,7 @@ * Licence details can be found in the file COPYING. * * \author Bo Peng - * \author Jürgen Spitzmüller + * \author Jürgen Spitzmüller * * Full author contact details are available in file CREDITS. */ @@ -12,25 +12,37 @@ #include #include "InsetListings.h" -#include "InsetCaption.h" #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 "support/gettext.h" -#include "InsetList.h" +#include "InsetCaption.h" #include "Language.h" -#include "MetricsInfo.h" +#include "LaTeXFeatures.h" +#include "Lexer.h" +#include "output_latex.h" +#include "output_xhtml.h" +#include "OutputParams.h" #include "TextClass.h" +#include "TexRow.h" +#include "texstream.h" +#include "support/debug.h" #include "support/docstream.h" +#include "support/gettext.h" #include "support/lstrings.h" +#include "support/lassert.h" + +#include "frontends/alert.h" +#include "frontends/Application.h" -#include +#include "support/regex.h" #include @@ -39,19 +51,18 @@ using namespace lyx::support; namespace lyx { -using boost::regex; -char const lstinline_delimiters[] = - "!*()-=+|;:'\"`,<.>/?QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm"; - -InsetListings::InsetListings(Buffer const & buf, InsetListingsParams const & par) - : InsetCollapsable(buf, par.status()) -{} +InsetListings::InsetListings(Buffer * buf, InsetListingsParams const & par) + : InsetCaptionable(buf,"listing") +{ + params_.setMinted(buffer().params().use_minted); + status_ = par.status(); +} InsetListings::~InsetListings() { - InsetListingsMailer(*this).hideDialog(); + hideDialogs("listings", this); } @@ -61,18 +72,12 @@ Inset::DisplayType InsetListings::display() const } -void InsetListings::updateLabels(ParIterator const & it) +docstring InsetListings::layoutName() const { - Counters & cnts = buffer().params().documentClass().counters(); - string const saveflt = cnts.current_float(); - - // Tell to captions what the current float is - cnts.current_float("listing"); - - InsetCollapsable::updateLabels(it); - - //reset afterwards - cnts.current_float(saveflt); + if (buffer().params().use_minted) + return from_ascii("MintedListings"); + else + return from_ascii("Listings"); } @@ -88,7 +93,7 @@ void InsetListings::write(ostream & os) const os << "inline true\n"; else os << "inline false\n"; - InsetCollapsable::write(os); + InsetCaptionable::write(os); } @@ -96,7 +101,7 @@ void InsetListings::read(Lexer & lex) { while (lex.isOK()) { lex.next(); - string const token = lex.getString(); + string token = lex.getString(); if (token == "lstparams") { lex.next(); string const value = lex.getString(); @@ -110,29 +115,81 @@ void InsetListings::read(Lexer & lex) break; } } - InsetCollapsable::read(lex); -} - - -docstring InsetListings::editMessage() const -{ - return _("Opened Listing Inset"); + InsetCaptionable::read(lex); } -int InsetListings::latex(odocstream & os, OutputParams const & runparams) const +void InsetListings::latex(otexstream & os, OutputParams const & runparams) const { string param_string = params().params(); // NOTE: I use {} to quote text, which is an experimental feature // of the listings package (see page 25 of the manual) - int lines = 0; - bool isInline = params().isInline(); + bool const isInline = params().isInline(); + bool const use_minted = buffer().params().use_minted; + string minted_language; + string float_placement; + bool const isfloat = params().isFloat(); + if (use_minted && (isfloat || contains(param_string, "language="))) { + // Get float placement and/or language of the code, + // then remove the relative options. + vector opts = + getVectorFromString(param_string, ",", false); + for (size_t i = 0; i < opts.size(); ++i) { + if (prefixIs(opts[i], "float")) { + if (prefixIs(opts[i], "float=")) + float_placement = opts[i].substr(6); + opts.erase(opts.begin() + i--); + } + else if (prefixIs(opts[i], "language=")) { + minted_language = opts[i].substr(9); + opts.erase(opts.begin() + i--); + } + } + param_string = getStringFromVector(opts, ","); + } + // Minted needs a language specification + if (minted_language.empty()) + minted_language = "TeX"; + // get the paragraphs. We can not output them directly to given odocstream // because we can not yet determine the delimiter character of \lstinline docstring code; + docstring uncodable; ParagraphList::const_iterator par = paragraphs().begin(); ParagraphList::const_iterator end = paragraphs().end(); + bool encoding_switched = false; + Encoding const * const save_enc = runparams.encoding; + // The listings package cannot deal with multi-byte-encoded + // glyphs, except if full-unicode aware backends + // such as XeTeX or LuaTeX are used, and with pLaTeX. + bool const multibyte_possible = use_minted || runparams.isFullUnicode() + || (buffer().params().encoding().package() == Encoding::japanese + && runparams.encoding->package() == Encoding::japanese); + + if (!multibyte_possible && !runparams.encoding->hasFixedWidth()) { + // We need to switch to a singlebyte encoding, due to + // the restrictions of the listings package (see above). + // This needs to be consistent with + // LaTeXFeatures::getTClassI18nPreamble(). + Language const * const outer_language = + (runparams.local_font != 0) ? + runparams.local_font->language() + : buffer().params().language; + // We try if there's a singlebyte encoding for the current + // language; if not, fall back to latin1. + Encoding const * const lstenc = + (outer_language->encoding()->hasFixedWidth()) ? + outer_language->encoding() + : encodings.fromLyXName("iso8859-1"); + switchEncoding(os.os(), buffer().params(), runparams, *lstenc, true); + runparams.encoding = lstenc; + encoding_switched = true; + } + + bool const captionfirst = !isfloat && par->isInset(0) + && par->getInset(0)->lyxCode() == CAPTION_CODE; + while (par != end) { pos_type siz = par->size(); bool captionline = false; @@ -140,84 +197,230 @@ int InsetListings::latex(odocstream & os, OutputParams const & runparams) const if (i == 0 && par->isInset(i) && i + 1 == siz) captionline = true; // ignore all struck out text and (caption) insets - if (par->isDeleted(i) || par->isInset(i)) + if (par->isDeleted(i) + || (par->isInset(i) && par->getInset(i)->lyxCode() == CAPTION_CODE)) + continue; + if (par->isInset(i)) { + // Currently, this can only be a quote inset + // that is output as plain quote here, but + // we use more generic code anyway. + otexstringstream ots; + OutputParams rp = runparams; + rp.pass_thru = true; + par->getInset(i)->latex(ots, rp); + code += ots.str(); continue; - code += par->getChar(i); + } + char_type c = par->getChar(i); + // we can only output characters covered by the current + // encoding! + try { + if (runparams.encoding->encodable(c)) + code += c; + else if (runparams.dryrun) { + code += "<" + _("LyX Warning: ") + + _("uncodable character") + " '"; + code += docstring(1, c); + code += "'>"; + } else + uncodable += c; + } catch (EncodingException & /* e */) { + if (runparams.dryrun) { + code += "<" + _("LyX Warning: ") + + _("uncodable character") + " '"; + code += docstring(1, c); + code += "'>"; + } else + uncodable += c; + } } ++par; // 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) code += "\n"; - ++lines; - } } if (isInline) { - char const * delimiter = lstinline_delimiters; - for (; delimiter != '\0'; ++delimiter) - if (!contains(code, *delimiter)) - break; + static const docstring delimiters = + from_utf8("!*()-=+|;:'\"`,<.>/?QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm"); + + size_t pos = delimiters.find_first_not_of(code); + // This code piece contains all possible special character? !!! // Replace ! with a warning message and use ! as delimiter. - if (*delimiter == '\0') { - code = subst(code, from_ascii("!"), from_ascii(" WARNING: no lstline delimiter can be used ")); - delimiter = lstinline_delimiters; + if (pos == string::npos) { + docstring delim_error = "<" + _("LyX Warning: ") + + _("no more lstline delimiters available") + ">"; + code = subst(code, from_ascii("!"), delim_error); + pos = 0; + if (!runparams.dryrun && !runparams.silent) { + // FIXME: warning should be passed to the error dialog + frontend::Alert::warning(_("Running out of delimiters"), + _("For inline program listings, one character must be reserved\n" + "as a delimiter. One of the listings, however, uses all available\n" + "characters, so none is left for delimiting purposes.\n" + "For the time being, I have replaced '!' by a warning, but you\n" + "must investigate!")); + } + } + docstring const delim(1, delimiters[pos]); + if (use_minted) { + os << "\\mintinline"; + if (!param_string.empty()) + os << "[" << from_utf8(param_string) << "]"; + os << "{" << minted_language << "}"; + } else { + os << "\\lstinline"; + if (!param_string.empty()) + os << "[" << from_utf8(param_string) << "]"; + else if (pos >= delimiters.find('Q')) + // We need to terminate the command before + // the delimiter + os << " "; + } + os << delim << code << delim; + } else if (use_minted) { + OutputParams rp = runparams; + rp.moving_arg = true; + TexString caption = getCaption(rp); + if (isfloat) { + os << breakln << "\\begin{listing}"; + if (!float_placement.empty()) + os << '[' << float_placement << "]"; + } else if (captionfirst && !caption.str.empty()) { + os << breakln << "\\lyxmintcaption[t]{" + << move(caption) << "}\n"; + } + os << breakln << "\\begin{minted}"; + if (!param_string.empty()) + os << "[" << param_string << "]"; + os << "{" << minted_language << "}\n" + << code << breakln << "\\end{minted}\n"; + if (isfloat) { + if (!caption.str.empty()) + os << "\\caption{" << move(caption) << "}\n"; + os << "\\end{listing}\n"; + } else if (!captionfirst && !caption.str.empty()) { + os << breakln << "\\lyxmintcaption[b]{" + << move(caption) << "}"; } - if (param_string.empty()) - os << "\\lstinline" << *delimiter; - else - os << "\\lstinline[" << from_ascii(param_string) << "]" << *delimiter; - os << code - << *delimiter; } else { OutputParams rp = runparams; - // FIXME: the line below would fix bug 4182, - // but real_current_font moved to cursor. - //rp.local_font = &text_.real_current_font; rp.moving_arg = true; - docstring const caption = getCaption(rp); - runparams.encoding = rp.encoding; - if (param_string.empty() && caption.empty()) - os << "\n\\begingroup\n\\inputencoding{latin1}\n\\begin{lstlisting}\n"; + TexString caption = getCaption(rp); + os << breakln << "\\begin{lstlisting}"; + if (param_string.empty() && caption.str.empty()) + os << "\n"; else { - os << "\n\\begingroup\n\\inputencoding{latin1}\n\\begin{lstlisting}["; - if (!caption.empty()) { - os << "caption={" << caption << '}'; + if (!runparams.nice) + os << safebreakln; + os << "["; + if (!caption.str.empty()) { + os << "caption={" << move(caption) << '}'; if (!param_string.empty()) os << ','; } os << from_utf8(param_string) << "]\n"; } - lines += 4; - os << code << "\n\\end{lstlisting}\n\\endgroup\n"; - lines += 3; + os << code << breakln << "\\end{lstlisting}\n"; + } + + if (encoding_switched){ + // Switch back + switchEncoding(os.os(), buffer().params(), runparams, *save_enc, true); + runparams.encoding = save_enc; + } + + if (!uncodable.empty() && !runparams.silent) { + // issue a warning about omitted characters + // FIXME: should be passed to the error dialog + if (!multibyte_possible && !runparams.encoding->hasFixedWidth()) + frontend::Alert::warning(_("Uncodable characters in listings inset"), + bformat(_("The following characters in one of the program listings are\n" + "not representable in the current encoding and have been omitted:\n%1$s.\n" + "This is due to a restriction of the listings package, which does\n" + "not support your encoding '%2$s'.\n" + "Toggling 'Use non-TeX fonts' in Document > Settings...\n" + "might help."), + uncodable, _(runparams.encoding->guiName()))); + else + frontend::Alert::warning(_("Uncodable characters in listings inset"), + bformat(_("The following characters in one of the program listings are\n" + "not representable in the current encoding and have been omitted:\n%1$s."), + uncodable)); + } +} + + +docstring InsetListings::xhtml(XHTMLStream & os, OutputParams const & rp) const +{ + odocstringstream ods; + XHTMLStream out(ods); + + bool const isInline = params().isInline(); + if (isInline) + out << html::CompTag("br"); + else { + out << html::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"); + } + + InsetLayout const & il = getLayout(); + string const & tag = il.htmltag(); + string attr = "class ='listings"; + string const lang = params().getParamValue("language"); + if (!lang.empty()) + attr += " " + lang; + attr += "'"; + out << html::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); + + if (isInline) { + out << html::CompTag("br"); + // escaping will already have been done + os << XHTMLStream::ESCAPE_NONE << ods.str(); + } else { + out << html::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; } + return def; +} - return lines; + +string InsetListings::contextMenuName() const +{ + return "context-listings"; } void InsetListings::doDispatch(Cursor & cur, FuncRequest & cmd) { - switch (cmd.action) { + switch (cmd.action()) { case LFUN_INSET_MODIFY: { - InsetListingsMailer::string2params(to_utf8(cmd.argument()), params()); + cur.recordUndoInset(this); + InsetListings::string2params(to_utf8(cmd.argument()), params()); break; } + case LFUN_INSET_DIALOG_UPDATE: - InsetListingsMailer(*this).updateDialog(&cur.bv()); + cur.bv().updateDialog("listings", params2string(params())); break; - case LFUN_MOUSE_RELEASE: { - if (cmd.button() == mouse_button::button3 && hitButton(cmd)) { - InsetListingsMailer(*this).showDialog(&cur.bv()); - break; - } - InsetCollapsable::doDispatch(cur, cmd); - break; - } + default: - InsetCollapsable::doDispatch(cur, cmd); + InsetCaptionable::doDispatch(cur, cmd); break; } } @@ -226,103 +429,105 @@ void InsetListings::doDispatch(Cursor & cur, FuncRequest & cmd) bool InsetListings::getStatus(Cursor & cur, FuncRequest const & cmd, FuncStatus & status) const { - switch (cmd.action) { + switch (cmd.action()) { + case LFUN_INSET_MODIFY: case LFUN_INSET_DIALOG_UPDATE: - status.enabled(true); - return true; - case LFUN_CAPTION_INSERT: - status.enabled(!params().isInline()); + status.setEnabled(true); return true; + case LFUN_CAPTION_INSERT: { + // the inset outputs at most one caption + if (params().isInline() || getCaptionInset()) { + status.setEnabled(false); + return true; + } + } default: - return InsetCollapsable::getStatus(cur, cmd, status); + return InsetCaptionable::getStatus(cur, cmd, status); } } -void InsetListings::setButtonLabel() +docstring const InsetListings::buttonLabel(BufferView const & bv) const { // FIXME UNICODE - if (decoration() == InsetLayout::Classic) - setLabel(isOpen() ? _("Listing") : getNewLabel(_("Listing"))); + if (decoration() == InsetLayout::CLASSIC) + return isOpen(bv) ? _("Listing") : getNewLabel(_("Listing")); else - setLabel(getNewLabel(_("Listing"))); + return getNewLabel(_("Listing")); } void InsetListings::validate(LaTeXFeatures & features) const { - features.require("listings"); - InsetCollapsable::validate(features); + features.useInsetLayout(getLayout()); + string param_string = params().params(); + if (buffer().params().use_minted) { + features.require("minted"); + OutputParams rp = features.runparams(); + if (!params().isFloat() && !getCaption(rp).str.empty()) + features.require("lyxmintcaption"); + } else { + features.require("listings"); + if (contains(param_string, "\\color")) + features.require("color"); + } + InsetCaptionable::validate(features); } bool InsetListings::showInsetDialog(BufferView * bv) const { - InsetListingsMailer(const_cast(*this)).showDialog(bv); + bv->showDialog("listings", params2string(params()), + const_cast(this)); return true; } -docstring InsetListings::getCaption(OutputParams const & runparams) const -{ - if (paragraphs().empty()) - return docstring(); - - ParagraphList::const_iterator pit = paragraphs().begin(); - for (; pit != paragraphs().end(); ++pit) { - InsetList::const_iterator it = pit->insetList().begin(); - for (; it != pit->insetList().end(); ++it) { - Inset & inset = *it->inset; - if (inset.lyxCode() == CAPTION_CODE) { - odocstringstream ods; - InsetCaption * ins = - static_cast(it->inset); - ins->getOptArg(ods, runparams); - ins->getArgument(ods, runparams); - // the caption may contain \label{} but the listings - // package prefer caption={}, label={} - docstring cap = ods.str(); - if (!contains(to_utf8(cap), "\\label{")) - return cap; - // convert from - // blah1\label{blah2} blah3 - // to - // blah1 blah3},label={blah2 - // to form options - // caption={blah1 blah3},label={blah2} - // - // NOTE that } is not allowed in blah2. - regex const reg("(.*)\\\\label\\{(.*?)\\}(.*)"); - string const new_cap("\\1\\3},label={\\2"); - return from_utf8(regex_replace(to_utf8(cap), reg, new_cap)); - } - } - } - return docstring(); -} - - -string const InsetListingsMailer::name_("listings"); - -InsetListingsMailer::InsetListingsMailer(InsetListings & inset) - : inset_(inset) -{} - - -string const InsetListingsMailer::inset2string(Buffer const &) const +TexString InsetListings::getCaption(OutputParams const & runparams) const { - return params2string(inset_.params()); + InsetCaption const * ins = getCaptionInset(); + if (ins == 0) + return TexString(); + + otexstringstream os; + ins->getArgs(os, runparams); + ins->getArgument(os, runparams); + + // TODO: The code below should be moved to support, and then the test + // in ../tests should be moved there as well. + + // the caption may contain \label{} but the listings + // package prefer caption={}, label={} + TexString cap = os.release(); + if (buffer().params().use_minted + || !contains(cap.str, from_ascii("\\label{"))) + return cap; + // convert from + // blah1\label{blah2} blah3 + // to + // blah1 blah3},label={blah2 + // to form options + // caption={blah1 blah3},label={blah2} + // + // NOTE that } is not allowed in blah2. + regex const reg("(.*)\\\\label\\{(.*?)\\}(.*)"); + string const new_cap("$1$3},label={$2"); + // TexString validity: the substitution preserves the number of newlines. + // Moreover we assume that $2 does not contain newlines, so that the texrow + // information remains accurate. + cap.str = from_utf8(regex_replace(to_utf8(cap.str), reg, new_cap)); + return cap; } -void InsetListingsMailer::string2params(string const & in, +void InsetListings::string2params(string const & in, InsetListingsParams & params) { params = InsetListingsParams(); if (in.empty()) return; istringstream data(in); - Lexer lex(0, 0); + Lexer lex; lex.setStream(data); // discard "listings", which is only used to determine inset lex.next(); @@ -330,11 +535,10 @@ void InsetListingsMailer::string2params(string const & in, } -string const -InsetListingsMailer::params2string(InsetListingsParams const & params) +string InsetListings::params2string(InsetListingsParams const & params) { ostringstream data; - data << name_ << " "; + data << "listings" << ' '; params.write(data); return data.str(); }