src/TocBackend.cpp

   1 /**
   2  * \file TocBackend.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Jean-Marc Lasgouttes
   7  * \author Angus Leeming
   8  * \author Abdelrazak Younes
   9  * \author Guillaume Munch
  10  *
  11  * Full author contact details are available in file CREDITS.
  12  */
  13
  14 #include <config.h>
  15
  16 #include "TocBackend.h"
  17
  18 #include "Buffer.h"
  19 #include "BufferParams.h"
  20 #include "IndicesList.h"
  21 #include "InsetList.h"
  22 #include "Paragraph.h"
  23 #include "TextClass.h"
  24
  25 #include "insets/InsetArgument.h"
  26
  27 #include "support/debug.h"
  28 #include "support/docstream.h"
  29 #include "support/gettext.h"
  30 #include "support/lassert.h"
  31 #include "support/lstrings.h"
  32
  33 using namespace std;
  34
  35
  36 namespace lyx {
  37
  38
  39 ///////////////////////////////////////////////////////////////////////////
  40 //
  41 // TocItem implementation
  42 //
  43 ///////////////////////////////////////////////////////////////////////////
  44
  45 TocItem::TocItem(DocIterator const & dit, int d, docstring const & s,
  46                  bool output_active, FuncRequest action)
  47         : dit_(dit), depth_(d), str_(s), output_(output_active),
  48           action_(action)
  49 {
  50 }
  51
  52
  53 int TocItem::id() const
  54 {
  55         return dit_.paragraph().id();
  56 }
  57
  58
  59 docstring const TocItem::asString() const
  60 {
  61         static char_type const cross = 0x2716; // ✖ U+2716 HEAVY MULTIPLICATION X
  62         static char_type const thin = 0x2009; // U+2009 THIN SPACE
  63         docstring prefix;
  64         if (!output_) {
  65                 prefix += cross;
  66                 prefix += thin;
  67         }
  68         return prefix + str_;
  69 }
  70
  71
  72 FuncRequest TocItem::action() const
  73 {
  74         if (action_.action() == LFUN_UNKNOWN_ACTION) {
  75                 return FuncRequest(LFUN_PARAGRAPH_GOTO, dit_.paragraphGotoArgument());
  76         } else
  77                 return action_;
  78 }
  79
  80
  81 ///////////////////////////////////////////////////////////////////////////
  82 //
  83 // TocBackend implementation
  84 //
  85 ///////////////////////////////////////////////////////////////////////////
  86
  87 Toc::const_iterator TocBackend::findItem(Toc const & toc,
  88                                          DocIterator const & dit)
  89 {
  90         Toc::const_iterator last = toc.begin();
  91         Toc::const_iterator it = toc.end();
  92         if (it == last)
  93                 return it;
  94         --it;
  95         DocIterator dit_text = dit.getInnerText();
  96
  97         for (; it != last; --it) {
  98                 // We verify that we don't compare contents of two
  99                 // different document. This happens when you
 100                 // have parent and child documents.
 101                 if (&it->dit()[0].inset() != &dit_text[0].inset())
 102                         continue;
 103                 if (it->dit() <= dit_text)
 104                         return it;
 105         }
 106
 107         // We are before the first Toc Item:
 108         return last;
 109 }
 110
 111
 112 Toc::iterator TocBackend::findItem(Toc & toc, int depth, docstring const & str)
 113 {
 114         if (toc.empty())
 115                 return toc.end();
 116         Toc::iterator it = toc.begin();
 117         Toc::iterator itend = toc.end();
 118         for (; it != itend; ++it) {
 119                 if (it->depth() == depth && it->str() == str)
 120                         break;
 121         }
 122         return it;
 123 }
 124
 125
 126 shared_ptr<Toc const> TocBackend::toc(string const & type) const
 127 {
 128         // Is the type already supported?
 129         TocList::const_iterator it = tocs_.find(type);
 130         LASSERT(it != tocs_.end(), { return make_shared<Toc>(); });
 131         return it->second;
 132 }
 133
 134
 135 shared_ptr<Toc> TocBackend::toc(string const & type)
 136 {
 137         // std::map::insert only really performs the insertion if the key is not
 138         // already bound, and otherwise returns an iterator to the element already
 139         // there, see manual.
 140         return tocs_.insert({type, make_shared<Toc>()}).first->second;
 141 }
 142
 143
 144 TocBuilder & TocBackend::builder(string const & type)
 145 {
 146         auto p = make_unique<TocBuilder>(toc(type));
 147         return * builders_.insert(make_pair(type, move(p))).first->second;
 148 }
 149
 150
 151 // FIXME: This function duplicates functionality from InsetText::iterateForToc.
 152 // Both have their own way of computing the TocItem for "tableofcontents". The
 153 // TocItem creation and update should be made in a dedicated function and
 154 // updateItem should be rewritten to uniformly update the matching items from
 155 // all TOCs.
 156 bool TocBackend::updateItem(DocIterator const & dit_in)
 157 {
 158         // we need a text
 159         DocIterator dit = dit_in.getInnerText();
 160
 161         if (dit.text()->getTocLevel(dit.pit()) == Layout::NOT_IN_TOC)
 162                 return false;
 163
 164         if (toc("tableofcontents")->empty()) {
 165                 // FIXME: should not happen,
 166                 // a call to TocBackend::update() is missing somewhere
 167                 LYXERR0("TocBackend::updateItem called but the TOC is empty!");
 168                 return false;
 169         }
 170
 171         BufferParams const & bufparams = buffer_->params();
 172         const int min_toclevel = bufparams.documentClass().min_toclevel();
 173
 174         Toc::const_iterator toc_item = item("tableofcontents", dit);
 175
 176         docstring tocstring;
 177
 178         // For each paragraph, traverse its insets and let them add
 179         // their toc items
 180         //
 181         // FIXME: This is supposed to accomplish the same as the body of
 182         // InsetText::iterateForToc(), probably
 183         Paragraph & par = toc_item->dit().paragraph();
 184         for (auto const & table : par.insetList())
 185                 if (InsetArgument const * arg = table.inset->asInsetArgument()) {
 186                         tocstring = par.labelString();
 187                         if (!tocstring.empty())
 188                                 tocstring += ' ';
 189                         arg->text().forOutliner(tocstring,TOC_ENTRY_LENGTH);
 190                         break;
 191                 }
 192
 193         int const toclevel = toc_item->dit().text()->
 194                 getTocLevel(toc_item->dit().pit());
 195         if (toclevel != Layout::NOT_IN_TOC && toclevel >= min_toclevel
 196                 && tocstring.empty())
 197                 par.forOutliner(tocstring, TOC_ENTRY_LENGTH);
 198
 199         support::truncateWithEllipsis(tocstring, TOC_ENTRY_LENGTH);
 200         const_cast<TocItem &>(*toc_item).str(tocstring);
 201
 202         buffer_->updateTocItem("tableofcontents", dit);
 203         return true;
 204 }
 205
 206
 207 void TocBackend::update(bool output_active, UpdateType utype)
 208 {
 209         for (TocList::iterator it = tocs_.begin(); it != tocs_.end(); ++it)
 210                 it->second->clear();
 211         tocs_.clear();
 212         builders_.clear();
 213         resetOutlinerNames();
 214         if (!buffer_->isInternal()) {
 215                 DocIterator dit;
 216                 buffer_->inset().addToToc(dit, output_active, utype, *this);
 217         }
 218 }
 219
 220
 221 Toc::const_iterator TocBackend::item(string const & type,
 222                                      DocIterator const & dit) const
 223 {
 224         TocList::const_iterator toclist_it = tocs_.find(type);
 225         // Is the type supported?
 226         // We will try to make the best of it in release mode
 227         LASSERT(toclist_it != tocs_.end(), toclist_it = tocs_.begin());
 228         return findItem(*toclist_it->second, dit);
 229 }
 230
 231
 232 void TocBackend::writePlaintextTocList(string const & type,
 233         odocstringstream & os, size_t max_length) const
 234 {
 235         TocList::const_iterator cit = tocs_.find(type);
 236         if (cit != tocs_.end()) {
 237                 Toc::const_iterator ccit = cit->second->begin();
 238                 Toc::const_iterator end = cit->second->end();
 239                 for (; ccit != end; ++ccit) {
 240                         os << ccit->asString() << from_utf8("\n");
 241                         if (os.str().size() > max_length)
 242                                 break;
 243                 }
 244         }
 245 }
 246
 247
 248 docstring TocBackend::outlinerName(string const & type) const
 249 {
 250         map<string, docstring>::const_iterator const it
 251                 = outliner_names_.find(type);
 252         if (it != outliner_names_.end())
 253                 return it->second;
 254
 255         // Legacy treatment of index:... type
 256         if (support::prefixIs(type, "index:")) {
 257                 string const itype = support::split(type, ':');
 258                 IndicesList const & indiceslist = buffer_->params().indiceslist();
 259                 Index const * index = indiceslist.findShortcut(from_utf8(itype));
 260                 docstring indextype = _("unknown type!");
 261                 if (index)
 262                         indextype = index->index();
 263                 return support::bformat(_("Index Entries (%1$s)"), indextype);
 264         }
 265
 266         LYXERR0("Missing OutlinerName for " << type << "!");
 267         return from_utf8(type);
 268 }
 269
 270
 271 void TocBackend::resetOutlinerNames()
 272 {
 273         outliner_names_.clear();
 274         // names from this document class
 275         for (pair<string, docstring> const & name
 276                      : buffer_->params().documentClass().outlinerNames())
 277                 addName(name.first, translateIfPossible(name.second));
 278         // Hardcoded types
 279         addName("tableofcontents", _("Table of Contents"));
 280         addName("change", _("Changes"));
 281         addName("senseless", _("Senseless"));
 282         addName("citation", _("Citations"));
 283         addName("label", _("Labels and References"));
 284         // Customizable, but the corresponding insets have no layout definition
 285         addName("child", _("Child Documents"));
 286         addName("graphics", _("Graphics"));
 287         addName("equation", _("Equations"));
 288         addName("external", _("External Material"));
 289         addName("math-macro", _("Math Macros"));
 290         addName("nomencl", _("Nomenclature Entries"));
 291 }
 292
 293
 294 void TocBackend::addName(string const & type, docstring const & name)
 295 {
 296         if (name.empty())
 297                 return;
 298         // only inserts if the key does not exist
 299         outliner_names_.insert({type, name});
 300 }
 301
 302
 303 bool TocBackend::isOther(std::string const & type)
 304 {
 305         return type == "graphics"
 306                 || type == "note"
 307                 || type == "branch"
 308                 || type == "change"
 309                 || type == "label"
 310                 || type == "citation"
 311                 || type == "equation"
 312                 || type == "footnote"
 313                 || type == "marginalnote"
 314                 || type == "nomencl"
 315                 || type == "listings"
 316                 || type == "math-macro"
 317                 || type == "external"
 318                 || type == "senseless"
 319                 || type == "index"
 320                 || type.substr(0,6) == "index:";
 321 }
 322
 323
 324 } // namespace lyx