X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Finsets%2FInsetRef.cpp;h=124738daf7a88d6e0bea4584527eaf2d5d72a545;hb=de67b68b1dc140321e5d0e2e6b4507c972703744;hp=146a85dd492ed2740eda08852e9b2577d3b75547;hpb=670efa8f646218f2a378f0cc614c4c37a9f6b89a;p=lyx.git diff --git a/src/insets/InsetRef.cpp b/src/insets/InsetRef.cpp index 146a85dd49..124738daf7 100644 --- a/src/insets/InsetRef.cpp +++ b/src/insets/InsetRef.cpp @@ -15,6 +15,7 @@ #include "BufferParams.h" #include "Cursor.h" #include "DispatchResult.h" +#include "FuncStatus.h" #include "InsetLabel.h" #include "Language.h" #include "LaTeXFeatures.h" @@ -39,25 +40,27 @@ namespace lyx { InsetRef::InsetRef(Buffer * buf, InsetCommandParams const & p) - : InsetCommand(buf, p) + : InsetCommand(buf, p), broken_(false) {} InsetRef::InsetRef(InsetRef const & ir) - : InsetCommand(ir) + : InsetCommand(ir), broken_(false) {} bool InsetRef::isCompatibleCommand(string const & s) { //FIXME This is likely not the best way to handle this. //But this stuff is hardcoded elsewhere already. - return s == "ref" + return s == "ref" || s == "pageref" - || s == "vref" + || s == "vref" || s == "vpageref" || s == "formatted" + || s == "prettyref" // for InsetMathRef FIXME || s == "eqref" - || s == "nameref"; + || s == "nameref" + || s == "labelonly"; } @@ -68,36 +71,103 @@ 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_; } +void InsetRef::doDispatch(Cursor & cur, FuncRequest & cmd) +{ + string const inset = cmd.getArg(0); + string const arg = cmd.getArg(1); + string pstring; + if (cmd.action() == LFUN_INSET_MODIFY && inset == "ref") { + if (arg == "toggle-plural") + pstring = "plural"; + else if (arg == "toggle-caps") + pstring = "caps"; + else if (arg == "toggle-noprefix") + pstring = "noprefix"; + } + // otherwise not for us + if (pstring.empty()) + return InsetCommand::doDispatch(cur, cmd); + + bool const isSet = (getParam(pstring) == "true"); + setParam(pstring, from_ascii(isSet ? "false" : "true")); +} + + +bool InsetRef::getStatus(Cursor & cur, FuncRequest const & cmd, + FuncStatus & status) const +{ + if (cmd.action() != LFUN_INSET_MODIFY) + return InsetCommand::getStatus(cur, cmd, status); + if (cmd.getArg(0) != "ref") + return InsetCommand::getStatus(cur, cmd, status); + + string const arg = cmd.getArg(1); + string pstring; + if (arg == "toggle-plural") + pstring = "plural"; + else if (arg == "toggle-caps") + pstring = "caps"; + if (!pstring.empty()) { + status.setEnabled(buffer().params().use_refstyle && + params().getCmdName() == "formatted"); + bool const isSet = (getParam(pstring) == "true"); + status.setOnOff(isSet); + return true; + } + if (arg == "toggle-noprefix") { + status.setEnabled(params().getCmdName() == "labelonly"); + bool const isSet = (getParam("noprefix") == "true"); + status.setOnOff(isSet); + return true; + } + // otherwise not for us + return InsetCommand::getStatus(cur, cmd, status); +} + + +namespace { + +void capitalize(docstring & s) { + char_type t = uppercase(s[0]); + s[0] = t; +} + +} // namespace + + // the ref argument is the label name we are referencing. // we expect ref to be in the form: pfx:suffix. // -// if it isn't, then we can't produce a formatted reference, +// if it isn't, then we can't produce a formatted reference, // so we return "\ref" and put ref into label. // -// for refstyle, we return "\pfxcmd", and put suffix into +// for refstyle, we return "\pfxcmd", and put suffix into // label and pfx into prefix. this is because refstyle expects // the command: \pfxcmd{suffix}. -// +// // for prettyref, we return "\prettyref" and put ref into label // 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 InsetRef::getFormattedCmd(docstring const & ref, + docstring & label, docstring & prefix, docstring const & caps) const { static docstring const defcmd = from_ascii("\\ref"); static docstring const prtcmd = from_ascii("\\prettyref"); - + label = split(ref, prefix, ':'); // 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; @@ -108,7 +178,7 @@ docstring InsetRef::getFormattedCmd(docstring const & ref, label = ref; return defcmd; } - + if (!buffer().params().use_refstyle) { // \prettyref uses the whole label label = ref; @@ -126,6 +196,9 @@ docstring InsetRef::getFormattedCmd(docstring const & ref, return defcmd; } } + if (caps == "true") { + capitalize(prefix); + } return from_ascii("\\") + prefix + from_ascii("ref"); } @@ -135,7 +208,7 @@ docstring InsetRef::getEscapedLabel(OutputParams const & rp) const InsetCommandParams const & p = params(); ParamInfo const & pi = p.info(); ParamInfo::ParamData const & pd = pi["reference"]; - return p.prepareCommand(rp, getParam("reference"), pd.handling()); + return p.prepareCommand(rp, getParam("reference"), pd.handling()); } @@ -153,15 +226,34 @@ void InsetRef::latex(otexstream & os, OutputParams const & rp) const // "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); - os << fcmd << '{' << label << '}'; + 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 + // 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"); @@ -229,8 +321,12 @@ docstring InsetRef::xhtml(XHTMLStream & xs, OutputParams const & op) const op.local_font->language()->lang()); else if (cmd == "eqref") display_string = '(' + value + ')'; - else if (cmd == "formatted") + 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). @@ -239,7 +335,7 @@ docstring InsetRef::xhtml(XHTMLStream & xs, OutputParams const & op) const // But the label might be referencing a section, yet not be // in that section. So this is not trivial. display_string = il->prettyCounter(); - } else + } else display_string = ref; // FIXME What we'd really like to do is to be able to output some @@ -276,31 +372,55 @@ void InsetRef::updateBuffer(ParIterator const & it, UpdateType) 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().params().isLatex() && !getParam("name").empty()) { label += "||"; label += getParam("name"); } - + unsigned int const maxLabelChars = 24; if (label.size() > maxLabelChars) { tooltip_ = label; support::truncateWithEllipsis(label, maxLabelChars); } else tooltip_ = from_ascii(""); + screen_label_ = label; + broken_ = false; +} + + +docstring InsetRef::screenLabel() const +{ + return (broken_ ? _("BROKEN: ") : docstring()) + screen_label_; } void InsetRef::addToToc(DocIterator const & cpit, bool output_active, - UpdateType) const + UpdateType, TocBackend & backend) const { docstring const & label = getParam("reference"); if (buffer().insetLabel(label)) @@ -308,9 +428,10 @@ void InsetRef::addToToc(DocIterator const & cpit, bool output_active, return; // It seems that this reference does not point to any valid label. - screen_label_ = _("BROKEN: ") + screen_label_; - shared_ptr toc = buffer().tocBackend().toc("label"); - toc->push_back(TocItem(cpit, 0, screen_label_, output_active)); + + broken_ = true; + shared_ptr toc = backend.toc("label"); + toc->push_back(TocItem(cpit, 0, screenLabel(), output_active)); } @@ -323,14 +444,15 @@ void InsetRef::validate(LaTeXFeatures & features) const docstring const data = getEscapedLabel(features.runparams()); docstring label; docstring prefix; - string const fcmd = to_utf8(getFormattedCmd(data, label, prefix)); + docstring const fcmd = + getFormattedCmd(data, label, prefix, getParam("caps")); if (buffer().params().use_refstyle) { features.require("refstyle"); if (prefix == "cha") - features.addPreambleSnippet("\\let\\charef=\\chapref"); + features.addPreambleSnippet(from_ascii("\\let\\charef=\\chapref")); else if (!prefix.empty()) { - string lcmd = "\\AtBeginDocument{\\providecommand" + - fcmd + "[1]{\\ref{" + to_utf8(prefix) + ":#1}}}"; + docstring lcmd = "\\AtBeginDocument{\\providecommand" + + fcmd + "[1]{\\ref{" + prefix + ":#1}}}"; features.addPreambleSnippet(lcmd); } } else { @@ -338,7 +460,7 @@ void InsetRef::validate(LaTeXFeatures & features) const // 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 (cmd == "eqref" && !buffer().params().use_refstyle) // with refstyle, we simply output "(\ref{label})" @@ -356,6 +478,7 @@ InsetRef::type_info const InsetRef::types[] = { { "vref", N_("Standard+Textual Page"), N_("Ref+Text: ")}, { "formatted", N_("Formatted"), N_("Format: ")}, { "nameref", N_("Reference to Name"), N_("NameRef: ")}, + { "labelonly", N_("Label Only"), N_("Label: ")}, { "", "", "" } }; @@ -375,9 +498,9 @@ string const & InsetRef::getName(int type) } -docstring InsetRef::getTOCString() const +docstring InsetRef::getTOCString() const { - return tooltip_.empty() ? screen_label_ : tooltip_; + return tooltip_.empty() ? screenLabel() : tooltip_; } } // namespace lyx