X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetRef.cpp;h=31c0187cc1cadfeb01035c69f69a777d7ce7782f;hb=239b9919ffe28338d789e6dc9122228f77ab77a7;hp=aa0bcb573eb382d7210b1a6aadba920a6dec0624;hpb=4bf281106b401c34669dd66b7711705a7a212d7f;p=lyx.git diff --git a/src/insets/InsetRef.cpp b/src/insets/InsetRef.cpp index aa0bcb573e..31c0187cc1 100644 --- a/src/insets/InsetRef.cpp +++ b/src/insets/InsetRef.cpp @@ -16,18 +16,21 @@ #include "Cursor.h" #include "DispatchResult.h" #include "InsetLabel.h" +#include "Language.h" #include "LaTeXFeatures.h" #include "LyX.h" #include "OutputParams.h" #include "output_xhtml.h" #include "ParIterator.h" #include "sgml.h" +#include "texstream.h" #include "TocBackend.h" #include "support/debug.h" #include "support/docstream.h" #include "support/gettext.h" #include "support/lstrings.h" +#include "support/textutils.h" using namespace lyx::support; using namespace std; @@ -54,7 +57,8 @@ bool InsetRef::isCompatibleCommand(string const & s) { || s == "vpageref" || s == "formatted" || s == "eqref" - || s == "nameref"; + || s == "nameref" + || s == "labelonly"; } @@ -65,11 +69,24 @@ ParamInfo const & InsetRef::findInfo(string const & /* cmdName */) param_info_.add("name", ParamInfo::LATEX_OPTIONAL); param_info_.add("reference", ParamInfo::LATEX_REQUIRED, ParamInfo::HANDLING_ESCAPE); + param_info_.add("plural", ParamInfo::LYX_INTERNAL); + param_info_.add("caps", ParamInfo::LYX_INTERNAL); + param_info_.add("noprefix", ParamInfo::LYX_INTERNAL); } return param_info_; } +namespace { + +void capitalize(docstring & s) { + char_type t = uppercase(s[0]); + s[0] = t; +} + +} + + // the ref argument is the label name we are referencing. // we expect ref to be in the form: pfx:suffix. // @@ -81,10 +98,11 @@ ParamInfo const & InsetRef::findInfo(string const & /* cmdName */) // the command: \pfxcmd{suffix}. // // for prettyref, we return "\prettyref" and put ref into label -// and pfx into prefix. this is because prettyref +// and pfx into prefix. this is because prettyref uses the whole +// label, thus: \prettyref{pfx:suffix}. // docstring InsetRef::getFormattedCmd(docstring const & ref, - docstring & label, docstring & prefix) const + docstring & label, docstring & prefix, docstring const & caps) const { static docstring const defcmd = from_ascii("\\ref"); static docstring const prtcmd = from_ascii("\\prettyref"); @@ -93,7 +111,7 @@ docstring InsetRef::getFormattedCmd(docstring const & ref, // we have to have xxx:xxxxx... if (label.empty()) { - LYXERR0("Label `" << ref << "' contains no prefix."); + LYXERR0("Label `" << ref << "' contains no `:' separator."); label = ref; prefix = from_ascii(""); return defcmd; @@ -114,14 +132,17 @@ docstring InsetRef::getFormattedCmd(docstring const & ref, // make sure the prefix is legal for a latex command int const len = prefix.size(); for (int i = 0; i < len; i++) { - char_type c = prefix[i]; - if (c >= 0x80 || !isalpha(prefix[i])) { + char_type const c = prefix[i]; + if (!isAlphaASCII(c)) { LYXERR0("Prefix `" << prefix << "' is invalid for LaTeX."); // restore the label label = ref; return defcmd; } } + if (caps == "true") { + capitalize(prefix); + } return from_ascii("\\") + prefix + from_ascii("ref"); } @@ -135,30 +156,62 @@ docstring InsetRef::getEscapedLabel(OutputParams const & rp) const } -int InsetRef::latex(odocstream & os, OutputParams const & rp) const +void InsetRef::latex(otexstream & os, OutputParams const & rp) const { - string const cmd = getCmdName(); - if (cmd != "formatted") { + string const & cmd = getCmdName(); + docstring const & data = getEscapedLabel(rp); + + if (rp.inulemcmd > 0) + os << "\\mbox{"; + + if (cmd == "eqref" && buffer().params().use_refstyle) { + // we advertise this as printing "(n)", so we'll do that, at least + // for refstyle, since refstlye's own \eqref prints, by default, + // "equation n". if one wants \eqref, one can get it by using a + // formatted label in this case. + os << '(' << from_ascii("\\ref{") << data << from_ascii("})"); + } + else if (cmd == "formatted") { + docstring label; + docstring prefix; + docstring const fcmd = + getFormattedCmd(data, label, prefix, getParam("caps")); + os << fcmd; + if (buffer().params().use_refstyle && getParam("plural") == "true") + os << "[s]"; + os << '{' << label << '}'; + } + else if (cmd == "labelonly") { + docstring const & ref = getParam("reference"); + if (getParam("noprefix") != "true") + os << ref; + else { + docstring prefix; + docstring suffix = split(ref, prefix, ':'); + if (suffix.empty()) { + LYXERR0("Label `" << ref << "' contains no `:' separator."); + os << ref; + } else { + os << suffix; + } + } + } + else { // We don't want to output p_["name"], since that is only used // in docbook. So we construct new params, without it, and use that. InsetCommandParams p(REF_CODE, cmd); docstring const ref = getParam("reference"); p["reference"] = ref; os << p.getCommand(rp); - return 0; - } - - // so we're doing a formatted reference. - docstring const data = getEscapedLabel(rp); - docstring label; - docstring prefix; - docstring const fcmd = getFormattedCmd(data, label, prefix); - os << fcmd << '{' << label << '}'; - return 0; + } + + if (rp.inulemcmd > 0) + os << "}"; } -int InsetRef::plaintext(odocstream & os, OutputParams const &) const +int InsetRef::plaintext(odocstringstream & os, + OutputParams const &, size_t) const { docstring const str = getParam("reference"); os << '[' << str << ']'; @@ -191,7 +244,7 @@ int InsetRef::docbook(odocstream & os, OutputParams const & runparams) const } -docstring InsetRef::xhtml(XHTMLStream & xs, OutputParams const &) const +docstring InsetRef::xhtml(XHTMLStream & xs, OutputParams const & op) const { docstring const & ref = getParam("reference"); InsetLabel const * il = buffer().insetLabel(ref); @@ -207,14 +260,24 @@ docstring InsetRef::xhtml(XHTMLStream & xs, OutputParams const &) const // normally, would be "ref on page #", but we have no pages display_string = value; else if (cmd == "pageref" || cmd == "vpageref") - // normally would be "on page #", but we have no pages - display_string = _("elsewhere"); + // normally would be "on page #", but we have no pages. + display_string = translateIfPossible(from_ascii("elsewhere"), + op.local_font->language()->lang()); else if (cmd == "eqref") - display_string = bformat(from_ascii("equation (%1$s)"), value); - else if (cmd == "prettyref" - // we don't really have the ability to handle these - // properly in XHTML output - || cmd == "nameref") + display_string = '(' + value + ')'; + else if (cmd == "formatted") { + display_string = il->prettyCounter(); + if (buffer().params().use_refstyle && getParam("caps") == "true") + capitalize(display_string); + // it is hard to see what to do about plurals... + } + else if (cmd == "nameref") + // FIXME We don't really have the ability to handle these + // properly in XHTML output yet (bug #8599). + // It might not be that hard to do. We have the InsetLabel, + // and we can presumably find its paragraph using the TOC. + // But the label might be referencing a section, yet not be + // in that section. So this is not trivial. display_string = il->prettyCounter(); } else display_string = ref; @@ -222,17 +285,27 @@ docstring InsetRef::xhtml(XHTMLStream & xs, OutputParams const &) const // FIXME What we'd really like to do is to be able to output some // appropriate sort of text here. But to do that, we need to associate // some sort of counter with the label, and we don't have that yet. - string const attr = "href=\"#" + html::cleanAttr(to_utf8(ref)) + "\""; - xs << html::StartTag("a", attr); + docstring const attr = "href=\"#" + html::cleanAttr(ref) + '"'; + xs << html::StartTag("a", to_utf8(attr)); xs << display_string; xs << html::EndTag("a"); return docstring(); } -void InsetRef::tocString(odocstream & os) const +void InsetRef::toString(odocstream & os) const { - plaintext(os, OutputParams(0)); + odocstringstream ods; + plaintext(ods, OutputParams(0)); + os << ods.str(); +} + + +void InsetRef::forOutliner(docstring & os, size_t const, bool const) const +{ + // There's no need for details in the TOC, and a long label + // will just get in the way. + os += '#'; } @@ -240,38 +313,50 @@ void InsetRef::updateBuffer(ParIterator const & it, UpdateType) { docstring const & ref = getParam("reference"); // register this inset into the buffer reference cache. - buffer().references(ref).push_back(make_pair(this, it)); + buffer().addReference(ref, this, it); docstring label; + string const & cmd = getCmdName(); for (int i = 0; !types[i].latex_name.empty(); ++i) { - if (getCmdName() == types[i].latex_name) { + if (cmd == types[i].latex_name) { label = _(types[i].short_gui_name); break; } } - label += ref; + + if (cmd != "labelonly") + label += ref; + else { + if (getParam("noprefix") != "true") + label += ref; + else { + docstring prefix; + docstring suffix = split(ref, prefix, ':'); + if (suffix.empty()) { + label += ref; + } else { + label += suffix; + } + } + } - if (!buffer().isLatex() && !getParam("name").empty()) { + if (!buffer().params().isLatex() && !getParam("name").empty()) { label += "||"; label += getParam("name"); } - screen_label_ = label; - bool shortened = false; unsigned int const maxLabelChars = 24; - if (screen_label_.size() > maxLabelChars) { - screen_label_.erase(maxLabelChars - 3); - screen_label_ += "..."; - shortened = true; - } - if (shortened) + if (label.size() > maxLabelChars) { tooltip_ = label; - else + support::truncateWithEllipsis(label, maxLabelChars); + } else tooltip_ = from_ascii(""); + screen_label_ = label; } -void InsetRef::addToToc(DocIterator const & cpit) +void InsetRef::addToToc(DocIterator const & cpit, bool output_active, + UpdateType) const { docstring const & label = getParam("reference"); if (buffer().insetLabel(label)) @@ -280,8 +365,8 @@ void InsetRef::addToToc(DocIterator const & cpit) // It seems that this reference does not point to any valid label. screen_label_ = _("BROKEN: ") + screen_label_; - Toc & toc = buffer().tocBackend().toc("label"); - toc.push_back(TocItem(cpit, 0, screen_label_)); + shared_ptr toc = buffer().tocBackend().toc("label"); + toc->push_back(TocItem(cpit, 0, screen_label_, output_active)); } @@ -290,42 +375,45 @@ void InsetRef::validate(LaTeXFeatures & features) const string const cmd = getCmdName(); if (cmd == "vref" || cmd == "vpageref") features.require("varioref"); - else if (getCmdName() == "formatted") { + else if (cmd == "formatted") { docstring const data = getEscapedLabel(features.runparams()); docstring label; docstring prefix; + docstring const fcmd = + getFormattedCmd(data, label, prefix, getParam("caps")); if (buffer().params().use_refstyle) { features.require("refstyle"); - string const fcmd = to_utf8(getFormattedCmd(data, label, prefix)); - if (!prefix.empty()) { - string lcmd = "\\AtBeginDocument{\\providecommand" + - fcmd + "[1]{\\ref{" + to_utf8(prefix) + ":#1}}}"; + if (prefix == "cha") + features.addPreambleSnippet(from_ascii("\\let\\charef=\\chapref")); + else if (!prefix.empty()) { + docstring lcmd = "\\AtBeginDocument{\\providecommand" + + fcmd + "[1]{\\ref{" + prefix + ":#1}}}"; features.addPreambleSnippet(lcmd); - } else if (prefix == "cha") - features.addPreambleSnippet("\\let\\charef=\\chapref"); + } } else { features.require("prettyref"); // prettyref uses "cha" for chapters, so we provide a kind of // translation. if (prefix == "chap") - features.addPreambleSnippet("\\let\\pr@chap=\\pr@cha"); + features.addPreambleSnippet(from_ascii("\\let\\pr@chap=\\pr@cha")); } - } else if (getCmdName() == "eqref" && !buffer().params().use_refstyle) - // refstyle defines its own version + } else if (cmd == "eqref" && !buffer().params().use_refstyle) + // with refstyle, we simply output "(\ref{label})" features.require("amsmath"); else if (cmd == "nameref") features.require("nameref"); } -InsetRef::type_info InsetRef::types[] = { +InsetRef::type_info const InsetRef::types[] = { { "ref", N_("Standard"), N_("Ref: ")}, { "eqref", N_("Equation"), N_("EqRef: ")}, { "pageref", N_("Page Number"), N_("Page: ")}, { "vpageref", N_("Textual Page Number"), N_("TextPage: ")}, { "vref", N_("Standard+Textual Page"), N_("Ref+Text: ")}, { "formatted", N_("Formatted"), N_("Format: ")}, - { "nameref", N_("Reference to Name"), N_("NameRef:")}, + { "nameref", N_("Reference to Name"), N_("NameRef: ")}, + { "labelonly", N_("Label Only"), N_("Label: ")}, { "", "", "" } }; @@ -345,4 +433,9 @@ string const & InsetRef::getName(int type) } +docstring InsetRef::getTOCString() const +{ + return tooltip_.empty() ? screen_label_ : tooltip_; +} + } // namespace lyx