X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCounters.cpp;h=75c891128efa90777a0ba9a04a7164e5e14232aa;hb=268ae66e3c7df04effc329373dc887715d9c6f06;hp=f1b249dcc47bfcaf99a5d2aa9cc9f8e18804d4e8;hpb=88177a89cb15a528f462dc1645397f76deda44f5;p=lyx.git diff --git a/src/Counters.cpp b/src/Counters.cpp index f1b249dcc4..75c891128e 100644 --- a/src/Counters.cpp +++ b/src/Counters.cpp @@ -3,9 +3,9 @@ * 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 Martin Vermeer - * \author André Pönitz + * \author André Pönitz * \author Richard Heck (roman numerals) * * Full author contact details are available in file CREDITS. @@ -14,37 +14,117 @@ #include #include "Counters.h" -#include "debug.h" +#include "Layout.h" +#include "Lexer.h" -#include "support/lstrings.h" #include "support/convert.h" +#include "support/debug.h" +#include "support/gettext.h" +#include "support/lassert.h" +#include "support/lstrings.h" -#include - +#include #include -using std::endl; -using std::ostringstream; -using std::string; +using namespace std; +using namespace lyx::support; namespace lyx { -using support::lowercase; Counter::Counter() + : initial_value_(0) { reset(); } -Counter::Counter(docstring const & mc, docstring const & ls, - docstring const & lsa) - : master_(mc), labelstring_(ls), labelstringappendix_(lsa) +Counter::Counter(docstring const & mc, docstring const & ls, + docstring const & lsa) + : initial_value_(0), master_(mc), labelstring_(ls), labelstringappendix_(lsa) { reset(); } +bool Counter::read(Lexer & lex) +{ + enum { + CT_WITHIN = 1, + CT_LABELSTRING, + CT_LABELSTRING_APPENDIX, + CT_PRETTYFORMAT, + CT_INITIALVALUE, + CT_END + }; + + LexerKeyword counterTags[] = { + { "end", CT_END }, + { "initialvalue", CT_INITIALVALUE}, + { "labelstring", CT_LABELSTRING }, + { "labelstringappendix", CT_LABELSTRING_APPENDIX }, + { "prettyformat", CT_PRETTYFORMAT }, + { "within", CT_WITHIN } + }; + + lex.pushTable(counterTags); + + bool getout = false; + while (!getout && lex.isOK()) { + int le = lex.lex(); + switch (le) { + case Lexer::LEX_UNDEF: + lex.printError("Unknown counter tag `$$Token'"); + continue; + default: + break; + } + switch (le) { + case CT_WITHIN: + lex.next(); + master_ = lex.getDocString(); + if (master_ == "none") + master_.erase(); + break; + case CT_INITIALVALUE: + lex.next(); + initial_value_ = lex.getInteger(); + // getInteger() returns -1 on error, and larger + // negative values do not make much sense. + // In the other case, we subtract one, since the + // counter will be incremented before its first use. + if (initial_value_ <= -1) + initial_value_ = 0; + else + initial_value_ -= 1; + break; + case CT_PRETTYFORMAT: + lex.next(); + prettyformat_ = lex.getDocString(); + break; + case CT_LABELSTRING: + lex.next(); + labelstring_ = lex.getDocString(); + labelstringappendix_ = labelstring_; + break; + case CT_LABELSTRING_APPENDIX: + lex.next(); + labelstringappendix_ = lex.getDocString(); + break; + case CT_END: + getout = true; + break; + } + } + + // Here if have a full counter if getout == true + if (!getout) + LYXERR0("No End tag found for counter!"); + lex.popTable(); + return getout; +} + + void Counter::set(int v) { value_ = v; @@ -71,7 +151,7 @@ void Counter::step() void Counter::reset() { - value_ = 0; + value_ = initial_value_; } @@ -81,20 +161,36 @@ docstring const & Counter::master() const } -docstring const & Counter::labelString() const +bool Counter::checkAndRemoveMaster(docstring const & cnt) +{ + if (master_ != cnt) + return false; + master_ = docstring(); + return true; +} + + +docstring const & Counter::labelString(bool in_appendix) const +{ + return in_appendix ? labelstringappendix_ : labelstring_; +} + + +Counter::StringMap & Counter::flatLabelStrings(bool in_appendix) const { - return labelstring_; + return in_appendix ? flatlabelstringappendix_ : flatlabelstring_; } -docstring const & Counter::labelStringAppendix() const +Counters::Counters() : appendix_(false), subfloat_(false), longtable_(false) { - return labelstringappendix_; + layout_stack_.push_back(0); + counter_stack_.push_back(from_ascii("")); } void Counters::newCounter(docstring const & newc, - docstring const & masterc, + docstring const & masterc, docstring const & ls, docstring const & lsa) { @@ -104,20 +200,39 @@ void Counters::newCounter(docstring const & newc, << endl; return; } - counterList[newc] = Counter(masterc, ls, lsa); + counterList_[newc] = Counter(masterc, ls, lsa); } bool Counters::hasCounter(docstring const & c) const { - return counterList.find(c) != counterList.end(); + return counterList_.find(c) != counterList_.end(); +} + + +bool Counters::read(Lexer & lex, docstring const & name, bool makenew) +{ + if (hasCounter(name)) { + LYXERR(Debug::TCLASS, "Reading existing counter " << to_utf8(name)); + return counterList_[name].read(lex); + } + + LYXERR(Debug::TCLASS, "Reading new counter " << to_utf8(name)); + Counter cnt; + bool success = cnt.read(lex); + // if makenew is false, we will just discard what we read + if (success && makenew) + counterList_[name] = cnt; + else if (!success) + LYXERR0("Error reading counter `" << name << "'!"); + return success; } void Counters::set(docstring const & ctr, int const val) { - CounterList::iterator const it = counterList.find(ctr); - if (it == counterList.end()) { + CounterList::iterator const it = counterList_.find(ctr); + if (it == counterList_.end()) { lyxerr << "set: Counter does not exist: " << to_utf8(ctr) << endl; return; @@ -128,8 +243,8 @@ void Counters::set(docstring const & ctr, int const val) void Counters::addto(docstring const & ctr, int const val) { - CounterList::iterator const it = counterList.find(ctr); - if (it == counterList.end()) { + CounterList::iterator const it = counterList_.find(ctr); + if (it == counterList_.end()) { lyxerr << "addto: Counter does not exist: " << to_utf8(ctr) << endl; return; @@ -140,8 +255,8 @@ void Counters::addto(docstring const & ctr, int const val) int Counters::value(docstring const & ctr) const { - CounterList::const_iterator const cit = counterList.find(ctr); - if (cit == counterList.end()) { + CounterList::const_iterator const cit = counterList_.find(ctr); + if (cit == counterList_.end()) { lyxerr << "value: Counter does not exist: " << to_utf8(ctr) << endl; return 0; @@ -150,44 +265,73 @@ int Counters::value(docstring const & ctr) const } -void Counters::step(docstring const & ctr) +void Counters::resetSlaves(docstring const & ctr) +{ + CounterList::iterator it = counterList_.begin(); + CounterList::iterator const end = counterList_.end(); + for (; it != end; ++it) { + if (it->second.master() == ctr) { + it->second.reset(); + resetSlaves(it->first); + } + } +} + + +void Counters::stepMaster(docstring const & ctr, UpdateType utype) { - CounterList::iterator it = counterList.find(ctr); - if (it == counterList.end()) { + CounterList::iterator it = counterList_.find(ctr); + if (it == counterList_.end()) { + lyxerr << "step: Counter does not exist: " + << to_utf8(ctr) << endl; + return; + } + step(it->second.master(), utype); +} + + +void Counters::step(docstring const & ctr, UpdateType utype) +{ + CounterList::iterator it = counterList_.find(ctr); + if (it == counterList_.end()) { lyxerr << "step: Counter does not exist: " << to_utf8(ctr) << endl; return; } it->second.step(); - it = counterList.begin(); - CounterList::iterator const end = counterList.end(); - for (; it != end; ++it) { - if (it->second.master() == ctr) { - it->second.reset(); - } + if (utype == OutputUpdate) { + LBUFERR(!counter_stack_.empty()); + counter_stack_.pop_back(); + counter_stack_.push_back(ctr); } + + resetSlaves(ctr); } void Counters::reset() { appendix_ = false; + subfloat_ = false; current_float_.erase(); - CounterList::iterator it = counterList.begin(); - CounterList::iterator const end = counterList.end(); - for (; it != end; ++it) { + CounterList::iterator it = counterList_.begin(); + CounterList::iterator const end = counterList_.end(); + for (; it != end; ++it) it->second.reset(); - } + counter_stack_.clear(); + counter_stack_.push_back(from_ascii("")); + layout_stack_.clear(); + layout_stack_.push_back(0); } void Counters::reset(docstring const & match) { - BOOST_ASSERT(!match.empty()); + LASSERT(!match.empty(), return); - CounterList::iterator it = counterList.begin(); - CounterList::iterator end = counterList.end(); + CounterList::iterator it = counterList_.begin(); + CounterList::iterator end = counterList_.end(); for (; it != end; ++it) { if (it->first.find(match) != string::npos) it->second.reset(); @@ -195,10 +339,26 @@ void Counters::reset(docstring const & match) } +bool Counters::remove(docstring const & cnt) +{ + bool retval = counterList_.erase(cnt); + if (!retval) + return false; + CounterList::iterator it = counterList_.begin(); + CounterList::iterator end = counterList_.end(); + for (; it != end; ++it) { + if (it->second.checkAndRemoveMaster(cnt)) + LYXERR(Debug::TCLASS, "Removed master counter `" + + to_utf8(cnt) + "' from counter: " + to_utf8(it->first)); + } + return retval; +} + + void Counters::copy(Counters & from, Counters & to, docstring const & match) { - CounterList::iterator it = counterList.begin(); - CounterList::iterator end = counterList.end(); + CounterList::iterator it = counterList_.begin(); + CounterList::iterator end = counterList_.end(); for (; it != end; ++it) { if (it->first.find(match) != string::npos || match == "") { to.set(it->first, from.value(it->first)); @@ -239,36 +399,35 @@ char hebrewCounter(int const n) } - -//On the special cases, see http://mathworld.wolfram.com/RomanNumerals.html -//and for a list of roman numerals up to and including 3999, see -//http://www.research.att.com/~njas/sequences/a006968.txt. (Thanks to Joost -//for this info.) +// On the special cases, see http://mathworld.wolfram.com/RomanNumerals.html +// and for a list of roman numerals up to and including 3999, see +// http://www.research.att.com/~njas/sequences/a006968.txt. (Thanks to Joost +// for this info.) docstring const romanCounter(int const n) { static char const * const ones[9] = { "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX" }; - + static char const * const tens[9] = { "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC" }; - + static char const * const hunds[9] = { "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM" }; - - if (n > 1000 || n < 1) + + if (n >= 1000 || n < 1) return from_ascii("??"); - + int val = n; string roman; switch (n) { //special cases - case 900: + case 900: roman = "CM"; break; case 400: @@ -302,17 +461,35 @@ docstring const romanCounter(int const n) docstring const lowerromanCounter(int const n) { - return support::lowercase(romanCounter(n)); + return lowercase(romanCounter(n)); +} + + +docstring const fnsymbolCounter(int const n) +{ + switch(n) { + case 1: return docstring(1, 0x002a); //* + case 2: return docstring(1, 0x2020); // dagger + case 3: return docstring(1, 0x2021); // double dagger + case 4: return docstring(1, 0x00A7); // section sign + case 5: return docstring(1, 0x00B6); // pilcrow sign + case 6: return docstring(1, 0x2016); // vertical bar + case 7: return docstring(2, 0x002a); // two * + case 8: return docstring(2, 0x2020); // two daggers + case 9: return docstring(2, 0x2021); // two double daggers + default: + return from_ascii("?"); + }; } } // namespace anon docstring Counters::labelItem(docstring const & ctr, - docstring const & numbertype) + docstring const & numbertype) const { - CounterList::const_iterator const cit = counterList.find(ctr); - if (cit == counterList.end()) { + CounterList::const_iterator const cit = counterList_.find(ctr); + if (cit == counterList_.end()) { lyxerr << "Counter " << to_utf8(ctr) << " does not exist." << endl; @@ -336,51 +513,106 @@ docstring Counters::labelItem(docstring const & ctr, if (numbertype == "Roman") return romanCounter(val); + if (numbertype == "fnsymbol") + return fnsymbolCounter(val); + return convert(val); } -docstring Counters::theCounter(docstring const & counter) +docstring Counters::theCounter(docstring const & counter, + string const & lang) const { - if (!hasCounter(counter)) + CounterList::const_iterator it = counterList_.find(counter); + if (it == counterList_.end()) + return from_ascii("#"); + Counter const & ctr = it->second; + Counter::StringMap & sm = ctr.flatLabelStrings(appendix()); + Counter::StringMap::iterator smit = sm.find(lang); + if (smit != sm.end()) + return counterLabel(smit->second, lang); + + vector callers; + docstring const & fls = flattenLabelString(counter, appendix(), + lang, callers); + sm[lang] = fls; + return counterLabel(fls, lang); +} + + +docstring Counters::flattenLabelString(docstring const & counter, + bool in_appendix, + string const & lang, + vector & callers) const +{ + if (find(callers.begin(), callers.end(), counter) != callers.end()) { + // recursion detected + lyxerr << "Warning: Recursion in label for counter `" + << counter << "' detected" + << endl; return from_ascii("??"); + } + + CounterList::const_iterator it = counterList_.find(counter); + if (it == counterList_.end()) + return from_ascii("#"); + Counter const & c = it->second; - Counter const & c = counterList[counter]; - docstring ls = appendix() ? c.labelStringAppendix() : c.labelString(); + docstring ls = translateIfPossible(c.labelString(in_appendix), lang); + callers.push_back(counter); if (ls.empty()) { if (!c.master().empty()) - ls = from_ascii("\\the") + c.master() + from_ascii("."); - ls += from_ascii("\\arabic{") + counter + "}"; + ls = flattenLabelString(c.master(), in_appendix, lang, callers) + + from_ascii("."); + callers.pop_back(); + return ls + from_ascii("\\arabic{") + counter + "}"; } - return counterLabel(ls); + + while (true) { + //lyxerr << "ls=" << to_utf8(ls) << endl; + size_t const i = ls.find(from_ascii("\\the"), 0); + if (i == docstring::npos) + break; + size_t const j = i + 4; + size_t k = j; + while (k < ls.size() && lowercase(ls[k]) >= 'a' + && lowercase(ls[k]) <= 'z') + ++k; + docstring const newc = ls.substr(j, k - j); + docstring const repl = flattenLabelString(newc, in_appendix, + lang, callers); + ls.replace(i, k - j + 4, repl); + } + callers.pop_back(); + + return ls; } -docstring Counters::counterLabel(docstring const & format) +docstring Counters::counterLabel(docstring const & format, + string const & lang) const { docstring label = format; // FIXME: Using regexps would be better, but we compile boost without // wide regexps currently. - + docstring const the = from_ascii("\\the"); while (true) { - //lyxerr << "label=" << to_utf8(label) << endl; - size_t const i = label.find(from_ascii("\\the"), 0); + //lyxerr << "label=" << label << endl; + size_t const i = label.find(the, 0); if (i == docstring::npos) break; - size_t j = i + 4; + size_t const j = i + 4; size_t k = j; - while (k < label.size() && lowercase(label[k]) >= 'a' + while (k < label.size() && lowercase(label[k]) >= 'a' && lowercase(label[k]) <= 'z') ++k; - docstring counter = label.substr(j, k - j); - docstring repl = theCounter(counter); - label.replace(i, k - j + 4, repl); + docstring const newc(label, j, k - j); + label.replace(i, k - i, theCounter(newc, lang)); } - while (true) { - //lyxerr << "label=" << to_utf8(label) << endl; + //lyxerr << "label=" << label << endl; size_t const i = label.find('\\', 0); if (i == docstring::npos) @@ -393,13 +625,76 @@ docstring Counters::counterLabel(docstring const & format) break; docstring const numbertype(label, i + 1, j - i - 1); docstring const counter(label, j + 1, k - j - 1); - docstring const rep = labelItem(counter, numbertype); - label = docstring(label, 0, i) + rep - + docstring(label, k + 1, docstring::npos); + label.replace(i, k + 1 - i, labelItem(counter, numbertype)); } - //lyxerr << "DONE! label=" << to_utf8(label) << endl; + //lyxerr << "DONE! label=" << label << endl; return label; } +docstring Counters::prettyCounter(docstring const & name, + string const & lang) const +{ + CounterList::const_iterator it = counterList_.find(name); + if (it == counterList_.end()) + return from_ascii("#"); + Counter const & ctr = it->second; + + docstring const value = theCounter(name, lang); + docstring const & format = + translateIfPossible(ctr.prettyFormat(), lang); + if (format.empty()) + return value; + return subst(format, from_ascii("##"), value); +} + + +docstring Counters::currentCounter() const +{ + LBUFERR(!counter_stack_.empty()); + return counter_stack_.back(); +} + + +void Counters::setActiveLayout(Layout const & lay) +{ + LASSERT(!layout_stack_.empty(), return); + Layout const * const lastlay = layout_stack_.back(); + // we want to check whether the layout has changed and, if so, + // whether we are coming out of or going into an environment. + if (!lastlay) { + layout_stack_.pop_back(); + layout_stack_.push_back(&lay); + if (lay.isEnvironment()) + beginEnvironment(); + } else if (lastlay->name() != lay.name()) { + layout_stack_.pop_back(); + layout_stack_.push_back(&lay); + if (lastlay->isEnvironment()) { + // we are coming out of an environment + // LYXERR0("Out: " << lastlay->name()); + endEnvironment(); + } + if (lay.isEnvironment()) { + // we are going into a new environment + // LYXERR0("In: " << lay.name()); + beginEnvironment(); + } + } +} + + +void Counters::beginEnvironment() +{ + counter_stack_.push_back(counter_stack_.back()); +} + + +void Counters::endEnvironment() +{ + LASSERT(!counter_stack_.empty(), return); + counter_stack_.pop_back(); +} + + } // namespace lyx