X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetTOC.cpp;h=76a8dc9d1bfbe3f0b240a7908f853a1fb1d70d32;hb=57b69a5efddf9f3c148007322f00dad6c253a2ed;hp=9f20ee5675a30d9b4bc9a726eedb87fe72fd6917;hpb=ffe73b795b611625bc1acf59ab1569598d29dba2;p=lyx.git diff --git a/src/insets/InsetTOC.cpp b/src/insets/InsetTOC.cpp index 9f20ee5675..76a8dc9d1b 100644 --- a/src/insets/InsetTOC.cpp +++ b/src/insets/InsetTOC.cpp @@ -14,18 +14,23 @@ #include "Buffer.h" #include "BufferParams.h" +#include "BufferView.h" +#include "Cursor.h" #include "DispatchResult.h" +#include "Font.h" #include "FuncRequest.h" +#include "Language.h" #include "LaTeXFeatures.h" -#include "MetricsInfo.h" #include "OutputParams.h" #include "output_xhtml.h" #include "Paragraph.h" +#include "ParagraphParameters.h" #include "TextClass.h" #include "TocBackend.h" #include "support/debug.h" #include "support/gettext.h" +#include "support/lassert.h" #include @@ -33,9 +38,18 @@ using namespace std; namespace lyx { +namespace { +string cmd2type(string const & cmd) +{ + if (cmd == "lstlistoflistings") + return "listing"; + return cmd; +} +} + InsetTOC::InsetTOC(Buffer * buf, InsetCommandParams const & p) - : InsetCommand(buf, p, "toc") + : InsetCommand(buf, p) {} @@ -49,18 +63,59 @@ ParamInfo const & InsetTOC::findInfo(string const & /* cmdName */) } +bool InsetTOC::isCompatibleCommand(string const & cmd) +{ + return cmd == defaultCommand() || cmd == "lstlistoflistings"; +} + + docstring InsetTOC::screenLabel() const { if (getCmdName() == "tableofcontents") return buffer().B_("Table of Contents"); + if (getCmdName() == "lstlistoflistings") + return buffer().B_("List of Listings"); return _("Unknown TOC type"); } -int InsetTOC::plaintext(odocstream & os, OutputParams const &) const +void InsetTOC::doDispatch(Cursor & cur, FuncRequest & cmd) { + switch (cmd.action()) { + case LFUN_MOUSE_RELEASE: + if (!cur.selection() && cmd.button() == mouse_button::button1) { + cur.bv().showDialog("toc", params2string(params())); + cur.dispatched(); + } + break; + + default: + InsetCommand::doDispatch(cur, cmd); + } +} + + +docstring InsetTOC::layoutName() const +{ + if (getCmdName() == "lstlistoflistings") + return from_ascii("TOC:Listings"); + return from_ascii("TOC"); +} + + +void InsetTOC::validate(LaTeXFeatures & features) const +{ + InsetCommand::validate(features); + features.useInsetLayout(getLayout()); + if (getCmdName() == "lstlistoflistings") + features.require("listings"); +} + + +int InsetTOC::plaintext(odocstringstream & os, + OutputParams const &, size_t max_length) const { os << screenLabel() << "\n\n"; - buffer().tocBackend().writePlaintextTocList(getCmdName(), os); + buffer().tocBackend().writePlaintextTocList(cmd2type(getCmdName()), os, max_length); return PLAINTEXT_NEWLINE; } @@ -73,61 +128,54 @@ int InsetTOC::docbook(odocstream & os, OutputParams const &) const } -docstring InsetTOC::xhtml(XHTMLStream &, OutputParams const & op) const +void InsetTOC::makeTOCEntry(XHTMLStream & xs, + Paragraph const & par, OutputParams const & op) const { - // we'll use our own stream, because we are going to defer everything. - // that's how we deal with the fact that we're probably inside a standard - // paragraph, and we don't want to be. - odocstringstream ods; - XHTMLStream xs(ods); - // FIXME XHTML - // This is temporary. We'll get the main TOC working first. The rest will - // then be a fairly simple adapation of this code, I hope. - if (getCmdName() != "tableofcontents") - return docstring(); - Toc const & toc = buffer().tocBackend().toc("tableofcontents"); - if (toc.empty()) - return docstring(); + string const attr = "href='#" + par.magicLabel() + "' class='tocentry'"; + xs << html::StartTag("a", attr); - xs << StartTag("div", "class='toc'"); - - // we want to figure out look like a chapter, section, or whatever. - // so we're going to look for the layout with the minimum toclevel - // number. we'll take the first one, just because. - DocumentClass const & dc = buffer().params().documentClass(); - TextClass::LayoutList::const_iterator lit = dc.begin(); - TextClass::LayoutList::const_iterator len = dc.end(); - int minlevel = 1000; - Layout const * lay = NULL; - for (; lit != len; ++lit) { - int const level = lit->toclevel; - if (level == Layout::NOT_IN_TOC || level >= minlevel) - continue; - lay = &*lit; - minlevel = level; - } - - string const tocclass = lay ? lay->defaultCSSClass() + " ": ""; - string const tocattr = "class='" + tocclass + "tochead'"; - - xs << StartTag("div", tocattr) - << _("Table of Contents") - << EndTag("div"); + // First the label, if there is one + docstring const & label = par.params().labelString(); + if (!label.empty()) + xs << label << " "; + // Now the content of the TOC entry, taken from the paragraph itself + OutputParams ours = op; + ours.for_toc = true; + Font const dummy; + par.simpleLyXHTMLOnePar(buffer(), xs, ours, dummy); + + xs << html::EndTag("a") << html::CR(); +} + + +void InsetTOC::makeTOCWithDepth(XHTMLStream & xs, + Toc const & toc, OutputParams const & op) const +{ Toc::const_iterator it = toc.begin(); Toc::const_iterator const en = toc.end(); int lastdepth = 0; for (; it != en; ++it) { - Paragraph const & par = it->dit().innerParagraph(); - Font const dummy; + // do not output entries that are not actually included in the output, + // e.g., stuff in non-active branches or notes or whatever. + if (!it->isOutput()) + continue; + + // First, we need to manage increases and decreases of depth + // If there's no depth to deal with, we artifically set it to 1. int const depth = it->depth(); + + // Ignore stuff above the tocdepth + if (depth > buffer().params().tocdepth) + continue; + if (depth > lastdepth) { - xs.cr(); + xs << html::CR(); // open as many tags as we need to open to get to this level // this includes the tag for the current level for (int i = lastdepth + 1; i <= depth; ++i) { stringstream attr; attr << "class='lyxtoc-" << i << "'"; - xs << StartTag("div", attr.str()); + xs << html::StartTag("div", attr.str()) << html::CR(); } lastdepth = depth; } @@ -135,37 +183,95 @@ docstring InsetTOC::xhtml(XHTMLStream &, OutputParams const & op) const // close as many as we have to close to get back to this level // this includes closing the last tag at this level for (int i = lastdepth; i >= depth; --i) - xs << EndTag("div"); + xs << html::EndTag("div") << html::CR(); // now open our tag stringstream attr; attr << "class='lyxtoc-" << depth << "'"; - xs << StartTag("div", attr.str()); + xs << html::StartTag("div", attr.str()) << html::CR(); lastdepth = depth; } else { // no change of level, so close and open - xs << EndTag("div"); + xs << html::EndTag("div") << html::CR(); stringstream attr; attr << "class='lyxtoc-" << depth << "'"; - xs << StartTag("div", attr.str()); + xs << html::StartTag("div", attr.str()) << html::CR(); } - par.simpleLyXHTMLOnePar(buffer(), xs, op, dummy, true); + + // Now output TOC info for this entry + Paragraph const & par = it->dit().innerParagraph(); + makeTOCEntry(xs, par, op); } for (int i = lastdepth; i > 0; --i) - xs << EndTag("div"); - xs << EndTag("div"); - return ods.str(); + xs << html::EndTag("div") << html::CR(); } -void InsetTOC::validate(LaTeXFeatures & features) const +void InsetTOC::makeTOCNoDepth(XHTMLStream & xs, + Toc const & toc, const OutputParams & op) const +{ + Toc::const_iterator it = toc.begin(); + Toc::const_iterator const en = toc.end(); + for (; it != en; ++it) { + // do not output entries that are not actually included in the output, + // e.g., stuff in non-active branches or notes or whatever. + if (!it->isOutput()) + continue; + + xs << html::StartTag("div", "class='lyxtoc-flat'") << html::CR(); + + Paragraph const & par = it->dit().innerParagraph(); + makeTOCEntry(xs, par, op); + + xs << html::EndTag("div"); + } +} + + +docstring InsetTOC::xhtml(XHTMLStream &, OutputParams const & op) const { - if (features.runparams().flavor != OutputParams::HTML) - return; - features.addPreambleSnippet(""); + string const & command = getCmdName(); + if (command != "tableofcontents" && command != "lstlistoflistings") { + LYXERR0("TOC type " << command << " not yet implemented."); + LASSERT(false, return docstring()); + } + + shared_ptr toc = + buffer().masterBuffer()->tocBackend().toc(cmd2type(command)); + if (toc->empty()) + return docstring(); + + // we'll use our own stream, because we are going to defer everything. + // that's how we deal with the fact that we're probably inside a standard + // paragraph, and we don't want to be. + odocstringstream ods; + XHTMLStream xs(ods); + + xs << html::StartTag("div", "class='toc'"); + + // Title of TOC + InsetLayout const & il = getLayout(); + string const & tag = il.htmltag(); + docstring title = screenLabel(); + Layout const & lay = buffer().params().documentClass().htmlTOCLayout(); + string const & tocclass = lay.defaultCSSClass(); + string const tocattr = "class='tochead " + tocclass + "'"; + xs << html::StartTag(tag, tocattr) + << title + << html::EndTag(tag); + + // with lists of listings, at least, there is no depth + // to worry about. so the code can be simpler. + bool const use_depth = (command == "tableofcontents"); + + // Output of TOC + if (use_depth) + makeTOCWithDepth(xs, *toc, op); + else + makeTOCNoDepth(xs, *toc, op); + + xs << html::EndTag("div") << html::CR(); + return ods.str(); } + } // namespace lyx