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 const & 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::reset()
 208 {
 209         for (auto const & t: tocs_)
 210                 t.second->clear();
 211         tocs_.clear();
 212         builders_.clear();
 213         resetOutlinerNames();
 214 }
 215
 216
 217 void TocBackend::update(bool output_active, UpdateType utype)
 218 {
 219         reset();
 220         if (buffer_->isInternal())
 221                 return;
 222
 223         DocIterator dit;
 224         buffer_->inset().addToToc(dit, output_active, utype, *this);
 225 }
 226
 227
 228 Toc::const_iterator TocBackend::item(string const & type,
 229                                      DocIterator const & dit) const
 230 {
 231         TocList::const_iterator toclist_it = tocs_.find(type);
 232         // Is the type supported?
 233         // We will try to make the best of it in release mode
 234         LASSERT(toclist_it != tocs_.end(), toclist_it = tocs_.begin());
 235         return findItem(*toclist_it->second, dit);
 236 }
 237
 238
 239 void TocBackend::writePlaintextTocList(string const & type,
 240         odocstringstream & os, size_t max_length) const
 241 {
 242         TocList::const_iterator cit = tocs_.find(type);
 243         if (cit != tocs_.end()) {
 244                 Toc::const_iterator ccit = cit->second->begin();
 245                 Toc::const_iterator end = cit->second->end();
 246                 for (; ccit != end; ++ccit) {
 247                         os << ccit->asString() << from_utf8("\n");
 248                         if (os.str().size() > max_length)
 249                                 break;
 250                 }
 251         }
 252 }
 253
 254
 255 docstring TocBackend::outlinerName(string const & type) const
 256 {
 257         map<string, docstring>::const_iterator const it
 258                 = outliner_names_.find(type);
 259         if (it != outliner_names_.end())
 260                 return it->second;
 261
 262         // Legacy treatment of index:... type
 263         if (support::prefixIs(type, "index:")) {
 264                 string const itype = support::split(type, ':');
 265                 IndicesList const & indiceslist = buffer_->params().indiceslist();
 266                 Index const * index = indiceslist.findShortcut(from_utf8(itype));
 267                 docstring indextype = _("unknown type!");
 268                 if (index)
 269                         indextype = index->index();
 270                 return support::bformat(_("Index Entries (%1$s)"), indextype);
 271         }
 272
 273         LYXERR0("Missing OutlinerName for " << type << "!");
 274         return from_utf8(type);
 275 }
 276
 277
 278 void TocBackend::resetOutlinerNames()
 279 {
 280         outliner_names_.clear();
 281         // names from this document class
 282         for (auto const & name
 283                      : buffer_->params().documentClass().outlinerNames())
 284                 addName(name.first, translateIfPossible(name.second));
 285         // Hardcoded types
 286         addName("tableofcontents", _("Table of Contents"));
 287         addName("change", _("Changes"));
 288         addName("senseless", _("Senseless"));
 289         addName("citation", _("Citations"));
 290         addName("label", _("Labels and References"));
 291         addName("brokenrefs", _("Broken References and Citations"));
 292         // Customizable, but the corresponding insets have no layout definition
 293         addName("child", _("Child Documents"));
 294         addName("graphics", _("Graphics"));
 295         addName("equation", _("Equations"));
 296         addName("external", _("External Material"));
 297         addName("math-macro", _("Math Macros"));
 298         addName("nomencl", _("Nomenclature Entries"));
 299 }
 300
 301
 302 void TocBackend::addName(string const & type, docstring const & name)
 303 {
 304         if (name.empty())
 305                 return;
 306         // only inserts if the key does not exist
 307         outliner_names_.insert({type, name});
 308 }
 309
 310
 311 bool TocBackend::isOther(std::string const & type)
 312 {
 313         return type == "graphics"
 314                 || type == "note"
 315                 || type == "branch"
 316                 || type == "change"
 317                 || type == "label"
 318                 || type == "citation"
 319                 || type == "equation"
 320                 || type == "footnote"
 321                 || type == "marginalnote"
 322                 || type == "nomencl"
 323                 || type == "listings"
 324                 || type == "math-macro"
 325                 || type == "external"
 326                 || type == "senseless"
 327                 || type == "index"
 328                 || type.substr(0,6) == "index:";
 329 }
 330
 331
 332 } // namespace lyx