X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetNomencl.cpp;h=ac990b14080423c447de52e9dceaae3507ae2747;hb=2bbf8e5f2d4ffd691258f94ba46baebf5aa3204c;hp=c3e7aefb2d57178f34641796a3f0b1b4e97b7430;hpb=07b6198f4c3aa6dfe3245394b660966fd3e85c99;p=features.git diff --git a/src/insets/InsetNomencl.cpp b/src/insets/InsetNomencl.cpp index c3e7aefb2d..ac990b1408 100644 --- a/src/insets/InsetNomencl.cpp +++ b/src/insets/InsetNomencl.cpp @@ -3,8 +3,10 @@ * This file is part of LyX, the document processor. * Licence details can be found in the file COPYING. * - * \author Lars Gullik Bjønnes + * \author Lars Gullik Bjønnes * \author O. U. Baran + * \author Uwe Stöhr + * \author Jürgen Spitzmüller * * Full author contact details are available in file CREDITS. */ @@ -15,42 +17,83 @@ #include "Buffer.h" #include "DispatchResult.h" +#include "Font.h" +#include "Encoding.h" #include "FuncRequest.h" -#include "gettext.h" +#include "FuncStatus.h" #include "InsetIterator.h" +#include "InsetList.h" #include "LaTeXFeatures.h" -#include "MetricsInfo.h" +#include "Length.h" +#include "LyX.h" +#include "OutputParams.h" +#include "output_xhtml.h" #include "sgml.h" +#include "frontends/FontMetrics.h" + +#include "support/docstream.h" +#include "support/gettext.h" +#include "support/lstrings.h" + +using namespace std; +using namespace lyx::support; namespace lyx { -using std::string; +///////////////////////////////////////////////////////////////////// +// +// InsetNomencl +// +///////////////////////////////////////////////////////////////////// -InsetNomencl::InsetNomencl(InsetCommandParams const & p) - : InsetCommand(p, "nomenclature"), +InsetNomencl::InsetNomencl(Buffer * buf, InsetCommandParams const & p) + : InsetCommand(buf, p), nomenclature_entry_id(sgml::uniqueID(from_ascii("nomen"))) {} -CommandInfo const * InsetNomencl::findInfo(std::string const & /* cmdName */) +ParamInfo const & InsetNomencl::findInfo(string const & /* cmdName */) { - static const char * const paramnames[] = {"prefix", "symbol", "description", ""}; - static const bool isoptional[] = {true, false, false}; - static const CommandInfo info = {3, paramnames, isoptional}; - return &info; + static ParamInfo param_info_; + if (param_info_.empty()) { + param_info_.add("prefix", ParamInfo::LATEX_OPTIONAL); + param_info_.add("symbol", ParamInfo::LATEX_REQUIRED, + ParamInfo::HANDLING_LATEXIFY); + param_info_.add("description", ParamInfo::LATEX_REQUIRED, + ParamInfo::HANDLING_LATEXIFY); + } + return param_info_; } -docstring const InsetNomencl::getScreenLabel(Buffer const &) const +docstring InsetNomencl::screenLabel() const { - return _("Nom"); + size_t const maxLabelChars = 25; + + docstring label = _("Nom: ") + getParam("symbol"); + if (label.size() > maxLabelChars) { + label.erase(maxLabelChars - 3); + label += "..."; + } + return label; } -int InsetNomencl::docbook(Buffer const &, odocstream & os, - OutputParams const &) const +docstring InsetNomencl::toolTip(BufferView const & /*bv*/, int /*x*/, int /*y*/) const +{ + docstring tip = _("Nomenclature Symbol: ") + getParam("symbol") + "\n"; + tip += _("Description: ") + "\t" + + subst(getParam("description"), from_ascii("\\\\"), from_ascii("\n\t")); + if (!getParam("prefix").empty()) + tip += "\n" + _("Sorting: ") + getParam("prefix"); + return tip; +} + + + +int InsetNomencl::docbook(odocstream & os, OutputParams const &) const { os << "" << sgml::escapeString(getParam("symbol")) @@ -59,6 +102,12 @@ int InsetNomencl::docbook(Buffer const &, odocstream & os, } +docstring InsetNomencl::xhtml(XHTMLStream &, OutputParams const &) const +{ + return docstring(); +} + + int InsetNomencl::docbookGlossary(odocstream & os) const { os << "\n" @@ -79,38 +128,96 @@ void InsetNomencl::validate(LaTeXFeatures & features) const } -InsetPrintNomencl::InsetPrintNomencl(InsetCommandParams const & p) - : InsetCommand(p, string()) +///////////////////////////////////////////////////////////////////// +// +// InsetPrintNomencl +// +///////////////////////////////////////////////////////////////////// + +InsetPrintNomencl::InsetPrintNomencl(Buffer * buf, InsetCommandParams const & p) + : InsetCommand(buf, p) {} -CommandInfo const * InsetPrintNomencl::findInfo(std::string const & /* cmdName */) +ParamInfo const & InsetPrintNomencl::findInfo(string const & /* cmdName */) { - static const char * const paramnames[] = {"labelwidth", ""}; - static const bool isoptional[] = {true}; - static const CommandInfo info = {1, paramnames, isoptional}; - return &info; + // The symbol width is set via nomencl's \nomlabelwidth in + // InsetPrintNomencl::latex and not as optional parameter of + // \printnomenclature + static ParamInfo param_info_; + if (param_info_.empty()) { + // how is the width set? + // values: none|auto|custom + param_info_.add("set_width", ParamInfo::LYX_INTERNAL); + // custom width + param_info_.add("width", ParamInfo::LYX_INTERNAL); + } + return param_info_; } -docstring const InsetPrintNomencl::getScreenLabel(Buffer const &) const +docstring InsetPrintNomencl::screenLabel() const { return _("Nomenclature"); } -int InsetPrintNomencl::docbook(Buffer const & buf, odocstream & os, - OutputParams const &) const +void InsetPrintNomencl::doDispatch(Cursor & cur, FuncRequest & cmd) +{ + switch (cmd.action()) { + + case LFUN_INSET_MODIFY: { + InsetCommandParams p(NOMENCL_PRINT_CODE); + // FIXME UNICODE + InsetCommand::string2params(to_utf8(cmd.argument()), p); + if (p.getCmdName().empty()) { + cur.noScreenUpdate(); + break; + } + setParams(p); + break; + } + + default: + InsetCommand::doDispatch(cur, cmd); + break; + } +} + + +bool InsetPrintNomencl::getStatus(Cursor & cur, FuncRequest const & cmd, + FuncStatus & status) const +{ + switch (cmd.action()) { + + case LFUN_INSET_DIALOG_UPDATE: + case LFUN_INSET_MODIFY: + status.setEnabled(true); + return true; + + default: + return InsetCommand::getStatus(cur, cmd, status); + } +} + + +docstring InsetPrintNomencl::xhtml(XHTMLStream &, OutputParams const &) const +{ + return docstring(); +} + + +int InsetPrintNomencl::docbook(odocstream & os, OutputParams const &) const { os << "\n"; int newlines = 2; - for (InsetIterator it = inset_iterator_begin(buf.inset()); it;) { + InsetIterator it = inset_iterator_begin(buffer().inset()); + while (it) { if (it->lyxCode() == NOMENCL_CODE) { newlines += static_cast(*it).docbookGlossary(os); ++it; - } else if(it->lyxCode() == NOTE_CODE && - static_cast(*it).params().type == InsetNoteParams::Note) { - // Don't output anything nested in note insets + } else if (!it->producesOutput()) { + // Ignore contents of insets that are not in output size_t const depth = it.depth(); ++it; while (it.depth() > depth) @@ -124,6 +231,95 @@ int InsetPrintNomencl::docbook(Buffer const & buf, odocstream & os, } +namespace { +docstring nomenclWidest(Buffer const & buffer, OutputParams const & runparams) +{ + // nomenclWidest() determines and returns the widest used + // nomenclature symbol in the document + + int w = 0; + docstring symb; + InsetNomencl const * nomencl = 0; + ParagraphList::const_iterator it = buffer.paragraphs().begin(); + ParagraphList::const_iterator end = buffer.paragraphs().end(); + + for (; it != end; ++it) { + if (it->insetList().empty()) + continue; + InsetList::const_iterator iit = it->insetList().begin(); + InsetList::const_iterator eend = it->insetList().end(); + for (; iit != eend; ++iit) { + Inset * inset = iit->inset; + if (inset->lyxCode() != NOMENCL_CODE) + continue; + nomencl = static_cast(inset); + docstring const symbol = + nomencl->getParam("symbol"); + // This is only an approximation, + // but the best we can get. + int const wx = use_gui ? + theFontMetrics(Font()).width(symbol) : + symbol.size(); + if (wx > w) { + w = wx; + symb = symbol; + } + } + } + // return the widest (or an empty) string + if (symb.empty()) + return symb; + + // we have to encode the string properly + docstring latex_symb; + for (size_t n = 0; n < symb.size(); ++n) { + try { + latex_symb += runparams.encoding->latexChar(symb[n]); + } catch (EncodingException & /* e */) { + if (runparams.dryrun) { + latex_symb += "<" + _("LyX Warning: ") + + _("uncodable character") + " '"; + latex_symb += docstring(1, symb[n]); + latex_symb += "'>"; + } + } + } + return latex_symb; +} +} // namespace anon + + +int InsetPrintNomencl::latex(odocstream & os, OutputParams const & runparams_in) const +{ + OutputParams runparams = runparams_in; + int lines = 0; + if (getParam("set_width") == "auto") { + docstring widest = nomenclWidest(buffer(), runparams); + // Set the label width via nomencl's command \nomlabelwidth. + // This must be output before the command \printnomenclature + if (!widest.empty()) { + os << "\\settowidth{\\nomlabelwidth}{" + << widest + << "}\n"; + ++lines; + } + } else if (getParam("set_width") == "custom") { + // custom length as optional arg of \printnomenclature + string const width = + Length(to_ascii(getParam("width"))).asLatexString(); + os << '\\' + << from_ascii(getCmdName()) + << '[' + << from_ascii(width) + << "]{}"; + return lines; + } + // output the command \printnomenclature + os << getCommand(runparams); + return lines; +} + + void InsetPrintNomencl::validate(LaTeXFeatures & features) const { features.require("nomencl"); @@ -136,4 +332,10 @@ InsetCode InsetPrintNomencl::lyxCode() const } +docstring InsetPrintNomencl::contextMenu(BufferView const &, int, int) const +{ + return from_ascii("context-nomenclprint"); +} + + } // namespace lyx