X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetRef.cpp;h=bae4992f66f156cb22cf9126ec652698adf30bca;hb=9c4929ca406091267dafa40f5e083a27db046bf6;hp=5fb240a95dab94312580d9aa168f5c89a15879fe;hpb=a8cd9a4b8fd325b00c75f601c66c6d618ba276db;p=lyx.git diff --git a/src/insets/InsetRef.cpp b/src/insets/InsetRef.cpp index 5fb240a95d..bae4992f66 100644 --- a/src/insets/InsetRef.cpp +++ b/src/insets/InsetRef.cpp @@ -3,7 +3,7 @@ * This file is part of LyX, the document processor. * Licence details can be found in the file COPYING. * - * \author José Matos + * \author José Matos * * Full author contact details are available in file CREDITS. */ @@ -12,109 +12,167 @@ #include "InsetRef.h" #include "Buffer.h" +#include "BufferParams.h" #include "Cursor.h" #include "DispatchResult.h" -#include "FuncRequest.h" -#include "gettext.h" +#include "InsetLabel.h" #include "LaTeXFeatures.h" -#include "LyXFunc.h" +#include "LyX.h" #include "OutputParams.h" +#include "output_xhtml.h" +#include "ParIterator.h" #include "sgml.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; namespace lyx { -using support::escape; -using std::string; -using std::ostream; - - -InsetRef::InsetRef(InsetCommandParams const & p, Buffer const & buf) - : InsetCommand(p, "ref"), isLatex(buf.isLatex()) +InsetRef::InsetRef(Buffer * buf, InsetCommandParams const & p) + : InsetCommand(buf, p) {} InsetRef::InsetRef(InsetRef const & ir) - : InsetCommand(ir), isLatex(ir.isLatex) + : InsetCommand(ir) {} -bool InsetRef::isCompatibleCommand(std::string const & s) { +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" || s == "pageref" || s == "vref" || s == "vpageref" - || s == "prettyref" - || s == "eqref"; + || s == "formatted" + || s == "eqref" + || s == "nameref"; } -CommandInfo const * InsetRef::findInfo(std::string const & /* cmdName */) +ParamInfo const & InsetRef::findInfo(string const & /* cmdName */) { - static const char * const paramnames[] = {"name", "reference", ""}; - static const bool isoptional[] = {true, false}; - static const CommandInfo info = {2, paramnames, isoptional}; - return &info; + static ParamInfo param_info_; + if (param_info_.empty()) { + param_info_.add("name", ParamInfo::LATEX_OPTIONAL); + param_info_.add("reference", ParamInfo::LATEX_REQUIRED, + ParamInfo::HANDLING_ESCAPE); + } + return param_info_; } -void InsetRef::doDispatch(Cursor & cur, FuncRequest & cmd) +// 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, +// so we return "\ref" and put ref into label. +// +// 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 { - switch (cmd.action) { - case LFUN_MOUSE_RELEASE: - // Eventually trigger dialog with button 3 not 1 - if (cmd.button() == mouse_button::button3) - lyx::dispatch(FuncRequest(LFUN_LABEL_GOTO, - getParam("reference"))); - else - InsetCommand::doDispatch(cur, cmd); - break; - - default: - InsetCommand::doDispatch(cur, cmd); + 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."); + label = ref; + prefix = from_ascii(""); + return defcmd; } -} + if (prefix.empty()) { + // we have ":xxxx" + label = ref; + return defcmd; + } + + if (!buffer().params().use_refstyle) { + // \prettyref uses the whole label + label = ref; + return prtcmd; + } -docstring const InsetRef::getScreenLabel(Buffer const &) const -{ - docstring temp; - for (int i = 0; !types[i].latex_name.empty(); ++i) { - if (getCmdName() == types[i].latex_name) { - temp = _(types[i].short_gui_name); - break; + // make sure the prefix is legal for a latex command + int const len = prefix.size(); + for (int i = 0; i < len; i++) { + char_type const c = prefix[i]; + if (!isAlphaASCII(c)) { + LYXERR0("Prefix `" << prefix << "' is invalid for LaTeX."); + // restore the label + label = ref; + return defcmd; } } - temp += getParam("reference"); + return from_ascii("\\") + prefix + from_ascii("ref"); +} - if (!isLatex && !getParam("name").empty()) { - temp += "||"; - temp += getParam("name"); - } - return temp; + +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()); } -int InsetRef::latex(Buffer const &, odocstream & os, - OutputParams const &) const +void InsetRef::latex(otexstream & os, OutputParams const & rp) const { - // 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, getCmdName()); - p["reference"] = getParam("reference"); - os << escape(p.getCommand()); - return 0; + string const cmd = getCmdName(); + docstring const data = getEscapedLabel(rp); + + if (rp.inulemcmd) + 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); + os << fcmd << '{' << label << '}'; + } + 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); + } + + if (rp.inulemcmd) + os << "}"; } -int InsetRef::plaintext(Buffer const &, odocstream & os, - OutputParams const &) const +int InsetRef::plaintext(odocstream & os, OutputParams const &) const { docstring const str = getParam("reference"); os << '[' << str << ']'; @@ -122,23 +180,22 @@ int InsetRef::plaintext(Buffer const &, odocstream & os, } -int InsetRef::docbook(Buffer const & buf, odocstream & os, - OutputParams const & runparams) const +int InsetRef::docbook(odocstream & os, OutputParams const & runparams) const { docstring const & name = getParam("name"); if (name.empty()) { if (runparams.flavor == OutputParams::XML) { os << ""; } else { os << ""; } } else { os << "" << getParam("name") << ""; @@ -148,21 +205,138 @@ int InsetRef::docbook(Buffer const & buf, odocstream & os, } -int InsetRef::textString(Buffer const & buf, odocstream & os, - OutputParams const & op) const +docstring InsetRef::xhtml(XHTMLStream & xs, OutputParams const &) const +{ + docstring const & ref = getParam("reference"); + InsetLabel const * il = buffer().insetLabel(ref); + string const & cmd = params().getCmdName(); + docstring display_string; + + if (il && !il->counterValue().empty()) { + // Try to construct a label from the InsetLabel we reference. + docstring const & value = il->counterValue(); + if (cmd == "ref") + display_string = value; + else if (cmd == "vref") + // 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"); + else if (cmd == "eqref") + display_string = bformat(from_ascii("equation (%1$s)"), value); + else if (cmd == "formatted" + // we don't really have the ability to handle these + // properly in XHTML output + || cmd == "nameref") + display_string = il->prettyCounter(); + } else + display_string = ref; + + // 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); + xs << display_string; + xs << html::EndTag("a"); + return docstring(); +} + + +void InsetRef::toString(odocstream & os) const { - return plaintext(buf, os, op); + plaintext(os, OutputParams(0)); +} + + +void InsetRef::forToc(docstring & os, size_t) const +{ + // There's no need for details in the TOC, and a long label + // will just get in the way. + os += '#'; +} + + +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)); + + docstring label; + for (int i = 0; !types[i].latex_name.empty(); ++i) { + if (getCmdName() == types[i].latex_name) { + label = _(types[i].short_gui_name); + break; + } + } + label += ref; + + 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) + tooltip_ = label; + else + tooltip_ = from_ascii(""); +} + + +void InsetRef::addToToc(DocIterator const & cpit) const +{ + docstring const & label = getParam("reference"); + if (buffer().insetLabel(label)) + // This InsetRef has already been taken care of in InsetLabel::addToToc(). + return; + + // 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_)); } void InsetRef::validate(LaTeXFeatures & features) const { - if (getCmdName() == "vref" || getCmdName() == "vpageref") + string const cmd = getCmdName(); + if (cmd == "vref" || cmd == "vpageref") features.require("varioref"); - else if (getCmdName() == "prettyref") - features.require("prettyref"); - else if (getCmdName() == "eqref") + else if (cmd == "formatted") { + docstring const data = getEscapedLabel(features.runparams()); + docstring label; + docstring prefix; + string const fcmd = to_utf8(getFormattedCmd(data, label, prefix)); + if (buffer().params().use_refstyle) { + features.require("refstyle"); + if (!prefix.empty()) { + string lcmd = "\\AtBeginDocument{\\providecommand" + + fcmd + "[1]{\\ref{" + to_utf8(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"); + } + } 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"); } @@ -172,7 +346,8 @@ InsetRef::type_info InsetRef::types[] = { { "pageref", N_("Page Number"), N_("Page: ")}, { "vpageref", N_("Textual Page Number"), N_("TextPage: ")}, { "vref", N_("Standard+Textual Page"), N_("Ref+Text: ")}, - { "prettyref", N_("PrettyRef"), N_("FormatRef: ")}, + { "formatted", N_("Formatted"), N_("Format: ")}, + { "nameref", N_("Reference to Name"), N_("NameRef:")}, { "", "", "" } };