#include "Buffer.h"
#include "BufferParams.h"
-#include "Cursor.h"
-#include "FloatList.h"
-#include "FuncRequest.h"
+#include "IndicesList.h"
#include "InsetList.h"
-#include "Layout.h"
-#include "LyXAction.h"
#include "Paragraph.h"
-#include "ParIterator.h"
#include "TextClass.h"
#include "insets/InsetArgument.h"
-#include "support/convert.h"
#include "support/debug.h"
#include "support/docstream.h"
#include "support/gettext.h"
///////////////////////////////////////////////////////////////////////////
TocItem::TocItem(DocIterator const & dit, int d, docstring const & s,
- bool output_active, docstring const & t, FuncRequest action) :
- dit_(dit), depth_(d), str_(s), tooltip_(t), output_(output_active),
- action_(action)
+ bool output_active, FuncRequest action)
+ : dit_(dit), depth_(d), str_(s), output_(output_active),
+ action_(action)
{
}
}
-docstring const & TocItem::tooltip() const
-{
- return tooltip_.empty() ? str_ : tooltip_;
-}
-
-
docstring const TocItem::asString() const
{
static char_type const cross = 0x2716; // ✖ U+2716 HEAVY MULTIPLICATION X
return prefix + str_;
}
-namespace {
-
-// convert a DocIterator into an argument to LFUN_PARAGRAPH_GOTO
-docstring paragraph_goto_arg(DocIterator const & dit)
-{
- CursorSlice const & s = dit.innerTextSlice();
- return convert<docstring>(s.paragraph().id()) + ' ' +
- convert<docstring>(s.pos());
-}
-
-} // namespace anon
FuncRequest TocItem::action() const
{
if (action_.action() == LFUN_UNKNOWN_ACTION) {
- return FuncRequest(LFUN_PARAGRAPH_GOTO, paragraph_goto_arg(dit_));
+ return FuncRequest(LFUN_PARAGRAPH_GOTO, dit_.paragraphGotoArgument());
} else
return action_;
}
///////////////////////////////////////////////////////////////////////////
//
-// Toc implementation
+// TocBackend implementation
//
///////////////////////////////////////////////////////////////////////////
// We verify that we don't compare contents of two
// different document. This happens when you
// have parent and child documents.
- if (&it->dit_[0].inset() != &dit_text[0].inset())
+ if (&it->dit()[0].inset() != &dit_text[0].inset())
continue;
- if (it->dit_ <= dit_text)
+ if (it->dit() <= dit_text)
return it;
}
}
-///////////////////////////////////////////////////////////////////////////
-//
-// TocBuilder implementation
-//
-///////////////////////////////////////////////////////////////////////////
-
-TocBuilder::TocBuilder(shared_ptr<Toc> toc)
- : toc_(toc ? toc : lyx::make_shared<Toc>()),
- stack_()
-{
- LATTEST(toc);
-}
-
-void TocBuilder::pushItem(DocIterator const & dit, docstring const & s,
- bool output_active, bool is_captioned)
-{
- toc_->push_back(TocItem(dit, stack_.size(), s, output_active));
- frame f = {
- toc_->size() - 1, //pos
- is_captioned, //is_captioned
- };
- stack_.push(f);
-}
-
-void TocBuilder::captionItem(DocIterator const & dit, docstring const & s,
- bool output_active)
-{
- // first show the float before moving to the caption
- docstring arg = "paragraph-goto " + paragraph_goto_arg(dit);
- if (!stack_.empty())
- arg = "paragraph-goto " +
- paragraph_goto_arg((*toc_)[stack_.top().pos].dit_) + ";" + arg;
- FuncRequest func(LFUN_COMMAND_SEQUENCE, arg);
-
- if (!stack_.empty() && !stack_.top().is_captioned) {
- // The float we entered has not yet been assigned a caption.
- // Assign the caption string to it.
- TocItem & captionable = (*toc_)[stack_.top().pos];
- captionable.str(s);
- captionable.setAction(func);
- stack_.top().is_captioned = true;
- } else {
- // This is a new entry.
- pop();
- // the dit is at the float's level, e.g. for the contextual menu of
- // outliner entries
- DocIterator captionable_dit = dit;
- captionable_dit.pop_back();
- pushItem(captionable_dit, s, output_active, true);
- (*toc_)[stack_.top().pos].setAction(func);
- }
-}
-
-void TocBuilder::pop()
-{
- if (!stack_.empty())
- stack_.pop();
-}
-
-
-
-///////////////////////////////////////////////////////////////////////////
-//
-// TocBuilderStore implementation
-//
-///////////////////////////////////////////////////////////////////////////
-
-shared_ptr<TocBuilder> TocBuilderStore::get(string const & type,
- shared_ptr<Toc> toc)
-{
- map_t::const_iterator it = map_.find(type);
- if (it == map_.end()) {
- it = map_.insert(std::make_pair(type,
- lyx::make_shared<TocBuilder>(toc))).first;
- }
- return it->second;
-}
-
-
-
-///////////////////////////////////////////////////////////////////////////
-//
-// TocBackend implementation
-//
-///////////////////////////////////////////////////////////////////////////
-
shared_ptr<Toc const> TocBackend::toc(string const & type) const
{
// Is the type already supported?
TocList::const_iterator it = tocs_.find(type);
- LASSERT(it != tocs_.end(), { return lyx::make_shared<Toc>(); });
+ LASSERT(it != tocs_.end(), { return make_shared<Toc>(); });
return it->second;
}
shared_ptr<Toc> TocBackend::toc(string const & type)
{
- TocList::const_iterator it = tocs_.find(type);
- if (it == tocs_.end()) {
- it = tocs_.insert(std::make_pair(type, lyx::make_shared<Toc>())).first;
- }
- return it->second;
+ // std::map::insert only really performs the insertion if the key is not
+ // already bound, and otherwise returns an iterator to the element already
+ // there, see manual.
+ return tocs_.insert({type, make_shared<Toc>()}).first->second;
}
-shared_ptr<TocBuilder> TocBackend::builder(string const & type)
+TocBuilder & TocBackend::builder(string const & type)
{
- return builders_.get(type, toc(type));
+ auto p = make_unique<TocBuilder>(toc(type));
+ return * builders_.insert(make_pair(type, move(p))).first->second;
}
//
// FIXME: This is supposed to accomplish the same as the body of
// InsetText::iterateForToc(), probably
- Paragraph & par = toc_item->dit_.paragraph();
- InsetList::const_iterator it = par.insetList().begin();
- InsetList::const_iterator end = par.insetList().end();
- for (; it != end; ++it) {
- Inset & inset = *it->inset;
- if (inset.lyxCode() == ARG_CODE) {
+ Paragraph & par = toc_item->dit().paragraph();
+ for (auto const & table : par.insetList())
+ if (InsetArgument const * arg = table.inset->asInsetArgument()) {
tocstring = par.labelString();
if (!tocstring.empty())
tocstring += ' ';
- inset.asInsetText()->text().forOutliner(tocstring,TOC_ENTRY_LENGTH);
+ arg->text().forOutliner(tocstring,TOC_ENTRY_LENGTH);
break;
}
- }
- int const toclevel = toc_item->dit_.text()->
- getTocLevel(toc_item->dit_.pit());
+ int const toclevel = toc_item->dit().text()->
+ getTocLevel(toc_item->dit().pit());
if (toclevel != Layout::NOT_IN_TOC && toclevel >= min_toclevel
&& tocstring.empty())
par.forOutliner(tocstring, TOC_ENTRY_LENGTH);
it->second->clear();
tocs_.clear();
builders_.clear();
+ resetOutlinerNames();
if (!buffer_->isInternal()) {
DocIterator dit;
- buffer_->inset().addToToc(dit, output_active, utype);
+ buffer_->inset().addToToc(dit, output_active, utype, *this);
}
}
}
-docstring TocBackend::outlinerName(std::string const & type) const
+docstring TocBackend::outlinerName(string const & type) const
+{
+ map<string, docstring>::const_iterator const it
+ = outliner_names_.find(type);
+ if (it != outliner_names_.end())
+ return it->second;
+
+ // Legacy treatment of index:... type
+ if (support::prefixIs(type, "index:")) {
+ string const itype = support::split(type, ':');
+ IndicesList const & indiceslist = buffer_->params().indiceslist();
+ Index const * index = indiceslist.findShortcut(from_utf8(itype));
+ docstring indextype = _("unknown type!");
+ if (index)
+ indextype = index->index();
+ return support::bformat(_("Index Entries (%1$s)"), indextype);
+ }
+
+ LYXERR0("Missing OutlinerName for " << type << "!");
+ return from_utf8(type);
+}
+
+
+void TocBackend::resetOutlinerNames()
+{
+ outliner_names_.clear();
+ // names from this document class
+ for (pair<string, docstring> const & name
+ : buffer_->params().documentClass().outlinerNames())
+ addName(name.first, translateIfPossible(name.second));
+ // Hardcoded types
+ addName("tableofcontents", _("Table of Contents"));
+ addName("change", _("Changes"));
+ addName("senseless", _("Senseless"));
+ addName("citation", _("Citations"));
+ addName("label", _("Labels and References"));
+ // Customizable, but the corresponding insets have no layout definition
+ addName("child", _("Child Documents"));
+ addName("graphics", _("Graphics"));
+ addName("equation", _("Equations"));
+ addName("external", _("External Material"));
+ addName("math-macro", _("Math Macros"));
+ addName("nomencl", _("Nomenclature Entries"));
+}
+
+
+void TocBackend::addName(string const & type, docstring const & name)
+{
+ if (name.empty())
+ return;
+ // only inserts if the key does not exist
+ outliner_names_.insert({type, name});
+}
+
+
+bool TocBackend::isOther(std::string const & type)
{
- return translateIfPossible(
- buffer_->params().documentClass().outlinerName(type));
+ return type == "graphics"
+ || type == "note"
+ || type == "branch"
+ || type == "change"
+ || type == "label"
+ || type == "citation"
+ || type == "equation"
+ || type == "footnote"
+ || type == "marginalnote"
+ || type == "nomencl"
+ || type == "listings"
+ || type == "math-macro"
+ || type == "external"
+ || type == "senseless"
+ || type == "index"
+ || type.substr(0,6) == "index:";
}
projects / lyx.git / blobdiff