fix counters updating mechanism

git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@9682 a592a061-630c-0410-9148-cb99ea01b6c8

diff --git a/lib/ChangeLog b/lib/ChangeLog
index d469e59200d52fa584242190e0a01ace00563651..7b879a872233880ca204ca4551af5e2d28e4e222 100644 (file)
--- a/lib/ChangeLog
+++ b/lib/ChangeLog
@@ -1,3 +1,7 @@
+2005-02-20  Jean-Marc Lasgouttes  <lasgouttes@lyx.org>
+
+       * layouts/stdlayouts.inc: change labelstring to "Senseless!"
+
 2005-02-21  Angus Leeming  <leeming@lyx.org>
 
        * CREDITS: add some missing pretty printing info.

diff --git a/lib/layouts/stdlayouts.inc b/lib/layouts/stdlayouts.inc
index 8a777964596a174478b5a901021b7174344b4549..00e66229a258191a9b602158ce3e2587c7738170 100644 (file)
--- a/lib/layouts/stdlayouts.inc
+++ b/lib/layouts/stdlayouts.inc
@@ -71,7 +71,7 @@ Style Caption
        Align                 Center
        AlignPossible         Center
        LabelType             Sensitive
-       LabelString   Caption
+       LabelString           "Senseless!"
        OptionalArgs          1
        LabelFont
          Series              Bold

diff --git a/src/BufferView_pimpl.C b/src/BufferView_pimpl.C
index 2ed15ec3ceadf5bb93e0cf400275892437bd0f78..716a88bcb83401bd0bfdfab89b11c3c7662cbe0a 100644 (file)
--- a/src/BufferView_pimpl.C
+++ b/src/BufferView_pimpl.C
@@ -74,6 +74,7 @@
 #include "support/types.h"
 
 #include <boost/bind.hpp>
+#include <boost/current_function.hpp>
 
 #include <functional>
 #include <vector>

diff --git a/src/ChangeLog b/src/ChangeLog
index f0c46b92934f1577d46b63235dd21543e658f4c4..f829eb127453518e7a313f5b281d4ab317965314 100644 (file)
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,29 @@
+2005-02-24  Jean-Marc Lasgouttes  <lasgouttes@lyx.org>
+
+       * text2.C (updateCounters, setCounter, expandLabel): move to
+       buffer_funcs.
+
+       * buffer_funcs.C (updateCounters): turn into a free standing
+       function and add a buffer parameter. Remove dead code for tracking
+       labelstring change.
+       (setCounter): change into a free-standing function which gets a
+       dociterator as argument. Use this iterator to fix captions in a
+       simple way. When no float is found above the caption, use the
+       labelstring of the caption layout as default.
+
+       * text.C (breakParagraph, backspace): 
+       * text2.C (init, setLayout, changeDepth):
+       * text3.C (dispatch): 
+       * CutAndPaste.C (cutSelection, pasteSelection): pass a buffer to
+       updateCounters.
+
+       * dociterator.C (forwardPar): make it much faster by calling
+       forwardPos() only when really necessary.
+
+       * output_docbook.C (makeCommand): adapt to expandLabel move.
+
+       * cursor.C: remove unused variable
+
 2005-02-24  Johnathan Burchill  <jkerrb@users.sourceforge.net>
 
        * paragraph_funcs.C: fix crash when pasting insets in change 

diff --git a/src/CutAndPaste.C b/src/CutAndPaste.C
index ea55f938b8ec8e60232ed029b792f57d2bf0eba9..af8912c0fdb78b3f5f791c07f3100d3440f25f78 100644 (file)
--- a/src/CutAndPaste.C
+++ b/src/CutAndPaste.C
@@ -503,7 +503,7 @@ void cutSelection(LCursor & cur, bool doclear, bool realcut)
 
                // need a valid cursor. (Lgb)
                cur.clearSelection();
-               text->updateCounters();
+               updateCounters(cur.buffer());
        }
 
        if (cur.inMathed()) {
@@ -596,7 +596,7 @@ void pasteSelection(LCursor & cur, size_t sel_index)
                cur.resetAnchor();
                text->setCursor(cur, ppp.first, ppp.second);
                cur.setSelection();
-               text->updateCounters();
+               updateCounters(cur.buffer());
        }
 
        if (cur.inMathed()) {

diff --git a/src/buffer_funcs.C b/src/buffer_funcs.C
index 8ffce464dfabb885bbfcd7b1322f0885bffc5fbd..057be070d7e6639f621d2e1b129f443c9631e365 100644 (file)
--- a/src/buffer_funcs.C
+++ b/src/buffer_funcs.C
@@ -18,16 +18,25 @@
 #include "bufferlist.h"
 #include "bufferparams.h"
 #include "dociterator.h"
+#include "counters.h"
 #include "errorlist.h"
+#include "Floating.h"
+#include "FloatList.h"
 #include "gettext.h"
 #include "LaTeX.h"
+#include "lyxtextclass.h"
 #include "paragraph.h"
+#include "ParagraphList_fwd.h"
+#include "ParagraphParameters.h"
+#include "pariterator.h"
 #include "lyxvc.h"
 #include "texrow.h"
 #include "vc-backend.h"
 
 #include "frontends/Alert.h"
 
+#include "insets/insetbibitem.h"
+
 #include "support/filetools.h"
 #include "support/fs_extras.h"
 #include "support/lyxlib.h"
@@ -35,6 +44,7 @@
 #include <boost/bind.hpp>
 #include <boost/filesystem/operations.hpp>
 
+using lyx::pit_type;
 using lyx::support::bformat;
 using lyx::support::LibFileSearch;
 using lyx::support::MakeDisplayPath;
@@ -42,6 +52,7 @@ using lyx::support::OnlyFilename;
 using lyx::support::OnlyPath;
 using lyx::support::unlink;
 
+using std::min;
 using std::string;
 
 namespace fs = boost::filesystem;
@@ -252,3 +263,255 @@ int countWords(DocIterator const & from, DocIterator const & to)
 
        return count;
 }
+
+
+namespace {
+
+void incrementItemDepth(ParagraphList & pars, pit_type pit, pit_type first_pit)
+{
+       int const cur_labeltype = pars[pit].layout()->labeltype;
+
+       if (cur_labeltype != LABEL_ENUMERATE && cur_labeltype != LABEL_ITEMIZE)
+               return;
+
+       int const cur_depth = pars[pit].getDepth();
+
+       pit_type prev_pit = pit - 1;
+       while (true) {
+               int const prev_depth = pars[prev_pit].getDepth();
+               int const prev_labeltype = pars[prev_pit].layout()->labeltype;
+               if (prev_depth == 0 && cur_depth > 0) {
+                       if (prev_labeltype == cur_labeltype) {
+                               pars[pit].itemdepth = pars[prev_pit].itemdepth + 1;
+                       }
+                       break;
+               } else if (prev_depth < cur_depth) {
+                       if (prev_labeltype == cur_labeltype) {
+                               pars[pit].itemdepth = pars[prev_pit].itemdepth + 1;
+                               break;
+                       }
+               } else if (prev_depth == cur_depth) {
+                       if (prev_labeltype == cur_labeltype) {
+                               pars[pit].itemdepth = pars[prev_pit].itemdepth;
+                               break;
+                       }
+               }
+               if (prev_pit == first_pit)
+                       break;
+
+               --prev_pit;
+       }
+}
+
+
+void resetEnumCounterIfNeeded(ParagraphList & pars, pit_type pit,
+       pit_type firstpit, Counters & counters)
+{
+       if (pit == firstpit)
+               return;
+
+       int const cur_depth = pars[pit].getDepth();
+       pit_type prev_pit = pit - 1;
+       while (true) {
+               int const prev_depth = pars[prev_pit].getDepth();
+               int const prev_labeltype = pars[prev_pit].layout()->labeltype;
+               if (prev_depth <= cur_depth) {
+                       if (prev_labeltype != LABEL_ENUMERATE) {
+                               switch (pars[pit].itemdepth) {
+                               case 0:
+                                       counters.reset("enumi");
+                               case 1:
+                                       counters.reset("enumii");
+                               case 2:
+                                       counters.reset("enumiii");
+                               case 3:
+                                       counters.reset("enumiv");
+                               }
+                       }
+                       break;
+               }
+
+               if (prev_pit == firstpit)
+                       break;
+
+               --prev_pit;
+       }
+}
+
+
+// set the counter of a paragraph. This includes the labels
+void setCounter(Buffer const & buf, ParIterator & it)
+{
+       Paragraph & par = *it;
+       BufferParams const & bufparams = buf.params();
+       LyXTextClass const & textclass = bufparams.getLyXTextClass();
+       LyXLayout_ptr const & layout = par.layout();
+       Counters & counters = textclass.counters();
+
+       // Always reset
+       par.itemdepth = 0;
+
+       if (it.pit() == 0) {
+               par.params().appendix(par.params().startOfAppendix());
+       } else {
+               par.params().appendix(it.plist()[it.pit() - 1].params().appendix());
+               if (!par.params().appendix() &&
+                   par.params().startOfAppendix()) {
+                       par.params().appendix(true);
+                       textclass.counters().reset();
+               }
+
+               // Maybe we have to increment the item depth.
+               incrementItemDepth(it.plist(), it.pit(), 0);
+       }
+
+       // erase what was there before
+       par.params().labelString(string());
+
+       if (layout->margintype == MARGIN_MANUAL) {
+               if (par.params().labelWidthString().empty())
+                       par.setLabelWidthString(layout->labelstring());
+       } else {
+               par.setLabelWidthString(string());
+       }
+
+       // is it a layout that has an automatic label?
+       if (layout->labeltype == LABEL_COUNTER) {
+               counters.step(layout->counter);
+               string label = expandLabel(textclass, layout, par.params().appendix());
+               par.params().labelString(label);
+       } else if (layout->labeltype == LABEL_ITEMIZE) {
+               // At some point of time we should do something more
+               // clever here, like:
+               //   par.params().labelString(
+               //    bufparams.user_defined_bullet(par.itemdepth).getText());
+               // for now, use a simple hardcoded label
+               string itemlabel;
+               switch (par.itemdepth) {
+               case 0:
+                       itemlabel = "*";
+                       break;
+               case 1:
+                       itemlabel = "-";
+                       break;
+               case 2:
+                       itemlabel = "@";
+                       break;
+               case 3:
+                       itemlabel = "·";
+                       break;
+               }
+
+               par.params().labelString(itemlabel);
+       } else if (layout->labeltype == LABEL_ENUMERATE) {
+               // Maybe we have to reset the enumeration counter.
+               resetEnumCounterIfNeeded(it.plist(), it.pit(), 0, counters);
+
+               // FIXME
+               // Yes I know this is a really, really! bad solution
+               // (Lgb)
+               string enumcounter = "enum";
+
+               switch (par.itemdepth) {
+               case 2:
+                       enumcounter += 'i';
+               case 1:
+                       enumcounter += 'i';
+               case 0:
+                       enumcounter += 'i';
+                       break;
+               case 3:
+                       enumcounter += "iv";
+                       break;
+               default:
+                       // not a valid enumdepth...
+                       break;
+               }
+
+               counters.step(enumcounter);
+
+               par.params().labelString(counters.enumLabel(enumcounter));
+       } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
+               counters.step("bibitem");
+               int number = counters.value("bibitem");
+               if (par.bibitem()) {
+                       par.bibitem()->setCounter(number);
+                       par.params().labelString(layout->labelstring());
+               }
+               // In biblio should't be following counters but...
+       } else if (layout->labeltype == LABEL_SENSITIVE) {
+               // Search for the first float or wrap inset in the iterator
+               string type;
+               size_t i = it.depth();
+               while (i > 0) {
+                       --i;
+                       InsetBase * const in = &it[i].inset();
+                       if (in->lyxCode() == InsetBase::FLOAT_CODE
+                           || in->lyxCode() == InsetBase::WRAP_CODE) 
+                               type = in->getInsetName();
+                               break;
+               }
+
+               string s;
+               if (!type.empty()) {
+                       Floating const & fl = textclass.floats().getType(type);
+
+                       counters.step(fl.type());
+
+                       // Doesn't work... yet.
+                       s = bformat(_("%1$s #:"), buf.B_(fl.name()));
+               } else {
+                       // par->SetLayout(0);
+                       s = buf.B_(layout->labelstring());
+               }
+
+               par.params().labelString(s);
+       } else
+               par.params().labelString(buf.B_(layout->labelstring()));
+}
+
+} // anon namespace
+
+
+void updateCounters(Buffer const & buf)
+{
+       // start over
+       buf.params().getLyXTextClass().counters().reset();
+
+       for (ParIterator it = par_iterator_begin(buf.inset()); it; ++it) {
+               // reduce depth if necessary
+               if (it.pit()) {
+                       Paragraph const & prevpar = it.plist()[it.pit() - 1];
+                       it->params().depth(min(it->params().depth(),
+                                              prevpar.getMaxDepthAfter()));
+               } else
+                       it->params().depth(0);
+
+               // set the counter for this paragraph
+               setCounter(buf, it);
+       }
+}
+
+
+string expandLabel(LyXTextClass const & textclass,
+       LyXLayout_ptr const & layout, bool appendix)
+{
+       string fmt = appendix ?
+               layout->labelstring_appendix() : layout->labelstring();
+
+       // handle 'inherited level parts' in 'fmt',
+       // i.e. the stuff between '@' in   '@Section@.\arabic{subsection}'
+       size_t const i = fmt.find('@', 0);
+       if (i != string::npos) {
+               size_t const j = fmt.find('@', i + 1);
+               if (j != string::npos) {
+                       string parent(fmt, i + 1, j - i - 1);
+                       string label = expandLabel(textclass, textclass[parent], appendix);
+                       fmt = string(fmt, 0, i) + label + string(fmt, j + 1, string::npos);
+               }
+       }
+
+       return textclass.counters().counterLabel(fmt);
+}
+
+

diff --git a/src/buffer_funcs.h b/src/buffer_funcs.h
index db433142ece6cbefb54f2fac51d81f052ef897f4..aa4b2a7ce0aa5e69a45a37d396e980fd11aed050 100644 (file)
--- a/src/buffer_funcs.h
+++ b/src/buffer_funcs.h
@@ -12,12 +12,15 @@
 #ifndef BUFFER_FUNCS_H
 #define BUFFER_FUNCS_H
 
+#include "lyxlayout_ptr_fwd.h"
+
 #include <string>
 
 
 class Buffer;
 class DocIterator;
 class ErrorList;
+class LyXTextClass;
 class TeXErrors;
 
 /**
@@ -42,5 +45,12 @@ void bufferErrors(Buffer const &, ErrorList const &);
 /// Count the number of words in the text between these two iterators
 int countWords(DocIterator const & from, DocIterator const & to);
 
+/// Expand the counters for the labelstring of \c layout
+std::string expandLabel(LyXTextClass const & textclass,
+               LyXLayout_ptr const & layout, bool appendix);
+
+/// updates all counters
+void updateCounters(Buffer const &);
+
 
 #endif // BUFFER_FUNCS_H

diff --git a/src/cursor.C b/src/cursor.C
index ac9bd45ab8ec4aff76e5812afd04d4b9dc4f3a03..a9fd17e47b3a70f975964267243c0d236f251b4f 100644 (file)
--- a/src/cursor.C
+++ b/src/cursor.C
@@ -123,8 +123,6 @@ namespace {
        {
                BOOST_ASSERT(!cursor.empty());
                CursorSlice bottom = cursor[0];
-               LyXText * text = bottom.text();
-               BOOST_ASSERT(text);
 
                DocIterator it = doc_iterator_begin(bottom.inset());
                DocIterator const et = doc_iterator_end(bottom.inset());

diff --git a/src/dociterator.C b/src/dociterator.C
index b4fd5c2218892b23fc26617c782ea0f2451d8137..74c5aa38a6b510c4f547c3a62e00fe3040151509 100644 (file)
--- a/src/dociterator.C
+++ b/src/dociterator.C
@@ -382,8 +382,27 @@ void DocIterator::forwardPosNoDescend()
 void DocIterator::forwardPar()
 {
        forwardPos();
-       while (!empty() && (!inTexted() || pos() != 0))
+
+#if 0
+       DocIterator cmp(*this);
+#endif
+       
+       while (!empty() && (!inTexted() || pos() != 0)) {
+               if (inTexted()) {
+                       pos_type const lastp = lastpos();
+                       Paragraph const & par = paragraph();
+                       pos_type & pos = top().pos();
+                       while (pos < lastp && !par.isInset(pos))
+                               ++pos;
+               }
                forwardPos();
+       }
+
+#if 0
+       while (!cmp.empty() && (!cmp.inTexted() || cmp.pos() != 0))
+               cmp.forwardPos();
+       BOOST_ASSERT(cmp == *this);
+#endif
 }
 
 

diff --git a/src/lyxtext.h b/src/lyxtext.h
index 5153b1e5149bf7b05952bf0c6d92e6e0d09bd44a..b4bef7289d78f73f36db04a44d7b504f20242921 100644 (file)
--- a/src/lyxtext.h
+++ b/src/lyxtext.h
@@ -261,8 +261,6 @@ public:
        /// current text heigth
        int height() const;
 
-       /// updates all counters
-       void updateCounters();
        /// Returns an inset if inset was hit, or 0 if not.
        InsetBase * checkInsetHit(int x, int y) const;
 
@@ -374,8 +372,6 @@ private:
        /// delete double space or empty paragraphs around old cursor
        bool deleteEmptyParagraphMechanism(LCursor & cur, LCursor const & old);
 
-       ///
-       void setCounter(Buffer const &, pit_type pit);
        ///
        void deleteWordForward(LCursor & cur);
        ///
@@ -402,9 +398,4 @@ private:
 /// return the default height of a row in pixels, considering font zoom
 int defaultRowHeight();
 
-///
-std::string expandLabel(LyXTextClass const & textclass,
-               LyXLayout_ptr const & layout, bool appendix);
-
-
 #endif // LYXTEXT_H

diff --git a/src/output_docbook.C b/src/output_docbook.C
index 152ab9d380adf6513343b78824582a1ba0a5986b..d31597edd2f01d1b3e8c2009c788ac9ff336a082 100644 (file)
--- a/src/output_docbook.C
+++ b/src/output_docbook.C
@@ -14,12 +14,13 @@
 #include "output_docbook.h"
 
 #include "buffer.h"
+#include "buffer_funcs.h"
 #include "bufferparams.h"
 #include "counters.h"
 #include "debug.h"
-#include "lyxtext.h"
 #include "paragraph.h"
 #include "paragraph_funcs.h"
+#include "ParagraphList_fwd.h"
 #include "ParagraphParameters.h"
 #include "sgml.h"
 

diff --git a/src/text.C b/src/text.C
index dff9e416f55e5a31f7b4ee56aee0ea1ed1a299e0..bf07d9fc9140dd7d142896f6bbb6605c49a76bdf 100644 (file)
--- a/src/text.C
+++ b/src/text.C
@@ -20,6 +20,7 @@
 
 #include "author.h"
 #include "buffer.h"
+#include "buffer_funcs.h"
 #include "bufferparams.h"
 #include "BufferView.h"
 #include "cursor.h"
@@ -1074,7 +1075,7 @@ void LyXText::breakParagraph(LCursor & cur, bool keep_layout)
        while (!pars_[next_par].empty() && pars_[next_par].isNewline(0))
                pars_[next_par].erase(0);
 
-       updateCounters();
+       updateCounters(cur.buffer());
 
        // This check is necessary. Otherwise the new empty paragraph will
        // be deleted automatically. And it is more friendly for the user!
@@ -1609,7 +1610,7 @@ void LyXText::backspace(LCursor & cur)
                                --cur.pos();
 
                        // the counters may have changed
-                       updateCounters();
+                       updateCounters(cur.buffer());
                        setCursor(cur, cur.pit(), cur.pos(), false);
                }
        } else {

diff --git a/src/text2.C b/src/text2.C
index 673287fbbb595796f0fedb4242fbf7cb15b9ebde..8d32a397de70dd773e0900590c4ac4c176316586 100644 (file)
--- a/src/text2.C
+++ b/src/text2.C
@@ -26,15 +26,12 @@
 #include "bufferparams.h"
 #include "BufferView.h"
 #include "Bullet.h"
-#include "counters.h"
 #include "coordcache.h"
 #include "cursor.h"
 #include "CutAndPaste.h"
 #include "debug.h"
 #include "dispatchresult.h"
 #include "errorlist.h"
-#include "Floating.h"
-#include "FloatList.h"
 #include "funcrequest.h"
 #include "gettext.h"
 #include "language.h"
@@ -45,26 +42,21 @@
 #include "paragraph.h"
 #include "paragraph_funcs.h"
 #include "ParagraphParameters.h"
+#include "pariterator.h"
 #include "undo.h"
 #include "vspace.h"
 
 #include "frontends/font_metrics.h"
 #include "frontends/LyXView.h"
 
-#include "insets/insetbibitem.h"
 #include "insets/insetenv.h"
-#include "insets/insetfloat.h"
-#include "insets/insetwrap.h"
 
-#include "support/lstrings.h"
 #include "support/textutils.h"
-#include "support/convert.h"
 
 #include <sstream>
 
 using lyx::pit_type;
 using lyx::pos_type;
-using lyx::support::bformat;
 
 using std::endl;
 using std::ostringstream;
@@ -93,7 +85,7 @@ void LyXText::init(BufferView * bv)
                pars_[pit].rows().clear();
 
        current_font = getFont(pars_[0], 0);
-       updateCounters();
+       updateCounters(*bv->buffer());
 }
 
 
@@ -337,7 +329,7 @@ void LyXText::setLayout(LCursor & cur, string const & layout)
        pit_type start = cur.selBegin().pit();
        pit_type end = cur.selEnd().pit() + 1;
        setLayout(start, end, layout);
-       updateCounters();
+       updateCounters(cur.buffer());
 }
 
 
@@ -398,7 +390,7 @@ void LyXText::changeDepth(LCursor & cur, DEPTH_CHANGE type)
        }
        // this handles the counter labels, and also fixes up
        // depth values for follow-on (child) paragraphs
-       updateCounters();
+       updateCounters(cur.buffer());
 }
 
 
@@ -582,304 +574,6 @@ void LyXText::setParagraph(LCursor & cur,
 }
 
 
-string expandLabel(LyXTextClass const & textclass,
-       LyXLayout_ptr const & layout, bool appendix)
-{
-       string fmt = appendix ?
-               layout->labelstring_appendix() : layout->labelstring();
-
-       // handle 'inherited level parts' in 'fmt',
-       // i.e. the stuff between '@' in   '@Section@.\arabic{subsection}'
-       size_t const i = fmt.find('@', 0);
-       if (i != string::npos) {
-               size_t const j = fmt.find('@', i + 1);
-               if (j != string::npos) {
-                       string parent(fmt, i + 1, j - i - 1);
-                       string label = expandLabel(textclass, textclass[parent], appendix);
-                       fmt = string(fmt, 0, i) + label + string(fmt, j + 1, string::npos);
-               }
-       }
-
-       return textclass.counters().counterLabel(fmt);
-}
-
-
-namespace {
-
-void incrementItemDepth(ParagraphList & pars, pit_type pit, pit_type first_pit)
-{
-       int const cur_labeltype = pars[pit].layout()->labeltype;
-
-       if (cur_labeltype != LABEL_ENUMERATE && cur_labeltype != LABEL_ITEMIZE)
-               return;
-
-       int const cur_depth = pars[pit].getDepth();
-
-       pit_type prev_pit = pit - 1;
-       while (true) {
-               int const prev_depth = pars[prev_pit].getDepth();
-               int const prev_labeltype = pars[prev_pit].layout()->labeltype;
-               if (prev_depth == 0 && cur_depth > 0) {
-                       if (prev_labeltype == cur_labeltype) {
-                               pars[pit].itemdepth = pars[prev_pit].itemdepth + 1;
-                       }
-                       break;
-               } else if (prev_depth < cur_depth) {
-                       if (prev_labeltype == cur_labeltype) {
-                               pars[pit].itemdepth = pars[prev_pit].itemdepth + 1;
-                               break;
-                       }
-               } else if (prev_depth == cur_depth) {
-                       if (prev_labeltype == cur_labeltype) {
-                               pars[pit].itemdepth = pars[prev_pit].itemdepth;
-                               break;
-                       }
-               }
-               if (prev_pit == first_pit)
-                       break;
-
-               --prev_pit;
-       }
-}
-
-
-void resetEnumCounterIfNeeded(ParagraphList & pars, pit_type pit,
-       pit_type firstpit, Counters & counters)
-{
-       if (pit == firstpit)
-               return;
-
-       int const cur_depth = pars[pit].getDepth();
-       pit_type prev_pit = pit - 1;
-       while (true) {
-               int const prev_depth = pars[prev_pit].getDepth();
-               int const prev_labeltype = pars[prev_pit].layout()->labeltype;
-               if (prev_depth <= cur_depth) {
-                       if (prev_labeltype != LABEL_ENUMERATE) {
-                               switch (pars[pit].itemdepth) {
-                               case 0:
-                                       counters.reset("enumi");
-                               case 1:
-                                       counters.reset("enumii");
-                               case 2:
-                                       counters.reset("enumiii");
-                               case 3:
-                                       counters.reset("enumiv");
-                               }
-                       }
-                       break;
-               }
-
-               if (prev_pit == firstpit)
-                       break;
-
-               --prev_pit;
-       }
-}
-
-} // anon namespace
-
-
-// set the counter of a paragraph. This includes the labels
-void LyXText::setCounter(Buffer const & buf, pit_type pit)
-{
-       Paragraph & par = pars_[pit];
-       BufferParams const & bufparams = buf.params();
-       LyXTextClass const & textclass = bufparams.getLyXTextClass();
-       LyXLayout_ptr const & layout = par.layout();
-       Counters & counters = textclass.counters();
-
-       // Always reset
-       par.itemdepth = 0;
-
-       if (pit == 0) {
-               par.params().appendix(par.params().startOfAppendix());
-       } else {
-               par.params().appendix(pars_[pit - 1].params().appendix());
-               if (!par.params().appendix() &&
-                   par.params().startOfAppendix()) {
-                       par.params().appendix(true);
-                       textclass.counters().reset();
-               }
-
-               // Maybe we have to increment the item depth.
-               incrementItemDepth(pars_, pit, 0);
-       }
-
-       // erase what was there before
-       par.params().labelString(string());
-
-       if (layout->margintype == MARGIN_MANUAL) {
-               if (par.params().labelWidthString().empty())
-                       par.setLabelWidthString(layout->labelstring());
-       } else {
-               par.setLabelWidthString(string());
-       }
-
-       // is it a layout that has an automatic label?
-       if (layout->labeltype == LABEL_COUNTER) {
-               BufferParams const & bufparams = buf.params();
-               LyXTextClass const & textclass = bufparams.getLyXTextClass();
-               counters.step(layout->counter);
-               string label = expandLabel(textclass, layout, par.params().appendix());
-               par.params().labelString(label);
-       } else if (layout->labeltype == LABEL_ITEMIZE) {
-               // At some point of time we should do something more
-               // clever here, like:
-               //   par.params().labelString(
-               //    bufparams.user_defined_bullet(par.itemdepth).getText());
-               // for now, use a simple hardcoded label
-               string itemlabel;
-               switch (par.itemdepth) {
-               case 0:
-                       itemlabel = "*";
-                       break;
-               case 1:
-                       itemlabel = "-";
-                       break;
-               case 2:
-                       itemlabel = "@";
-                       break;
-               case 3:
-                       itemlabel = "·";
-                       break;
-               }
-
-               par.params().labelString(itemlabel);
-       } else if (layout->labeltype == LABEL_ENUMERATE) {
-               // Maybe we have to reset the enumeration counter.
-               resetEnumCounterIfNeeded(pars_, pit, 0, counters);
-
-               // FIXME
-               // Yes I know this is a really, really! bad solution
-               // (Lgb)
-               string enumcounter = "enum";
-
-               switch (par.itemdepth) {
-               case 2:
-                       enumcounter += 'i';
-               case 1:
-                       enumcounter += 'i';
-               case 0:
-                       enumcounter += 'i';
-                       break;
-               case 3:
-                       enumcounter += "iv";
-                       break;
-               default:
-                       // not a valid enumdepth...
-                       break;
-               }
-
-               counters.step(enumcounter);
-
-               par.params().labelString(counters.enumLabel(enumcounter));
-       } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
-               counters.step("bibitem");
-               int number = counters.value("bibitem");
-               if (par.bibitem()) {
-                       par.bibitem()->setCounter(number);
-                       par.params().labelString(layout->labelstring());
-               }
-               // In biblio should't be following counters but...
-       } else {
-               string s = buf.B_(layout->labelstring());
-
-               // the caption hack:
-               if (layout->labeltype == LABEL_SENSITIVE) {
-                       pit_type end = paragraphs().size();
-                       pit_type tmppit = pit;
-                       InsetBase * in = 0;
-                       bool isOK = false;
-                       while (tmppit != end) {
-                               in = pars_[tmppit].inInset();
-                               // FIXME: in should be always valid.
-                               if (in &&
-                                   (in->lyxCode() == InsetBase::FLOAT_CODE ||
-                                    in->lyxCode() == InsetBase::WRAP_CODE)) {
-                                       isOK = true;
-                                       break;
-                               }
-#ifdef WITH_WARNINGS
-#warning replace this code by something that works
-// This code does not work because we have currently no way to move up
-// in the hierarchy of insets (JMarc 16/08/2004)
-#endif
-#if 0
-/* I think this code is supposed to be useful when one has a caption
- * in a minipage in a figure inset. We need to go up to be able to see
- * that the caption should use "Figure" as label
- */
-                               else {
-                                       Paragraph const * owner = &ownerPar(buf, in);
-                                       tmppit = 0;
-                                       for ( ; tmppit != end; ++tmppit)
-                                               if (&pars_[tmppit] == owner)
-                                                       break;
-                               }
-#else
-                               ++tmppit;
-#endif
-                       }
-
-                       if (isOK) {
-                               string type;
-
-                               if (in->lyxCode() == InsetBase::FLOAT_CODE)
-                                       type = static_cast<InsetFloat*>(in)->params().type;
-                               else if (in->lyxCode() == InsetBase::WRAP_CODE)
-                                       type = static_cast<InsetWrap*>(in)->params().type;
-                               else
-                                       BOOST_ASSERT(false);
-
-                               Floating const & fl = textclass.floats().getType(type);
-
-                               counters.step(fl.type());
-
-                               // Doesn't work... yet.
-                               s = bformat(_("%1$s #:"), buf.B_(fl.name()));
-                       } else {
-                               // par->SetLayout(0);
-                               // s = layout->labelstring;
-                               s = _("Senseless: ");
-                       }
-               }
-               par.params().labelString(s);
-
-       }
-}
-
-
-// Updates all counters.
-void LyXText::updateCounters()
-{
-       // start over
-       bv()->buffer()->params().getLyXTextClass().counters().reset();
-
-       bool update_pos = false;
-
-       pit_type end = paragraphs().size();
-       for (pit_type pit = 0; pit != end; ++pit) {
-               string const oldLabel = pars_[pit].params().labelString();
-               size_t maxdepth = 0;
-               if (pit != 0)
-                       maxdepth = pars_[pit - 1].getMaxDepthAfter();
-
-               if (pars_[pit].params().depth() > maxdepth)
-                       pars_[pit].params().depth(maxdepth);
-
-               // setCounter can potentially change the labelString.
-               setCounter(*bv()->buffer(), pit);
-               string const & newLabel = pars_[pit].params().labelString();
-               if (oldLabel != newLabel) {
-                       //lyxerr[Debug::DEBUG] << "changing labels: old: " << oldLabel << " new: "
-                       //      << newLabel << endl;
-                       update_pos = true;
-               }
-       }
-}
-
-
 // this really should just insert the inset and not move the cursor.
 void LyXText::insertInset(LCursor & cur, InsetBase * inset)
 {

diff --git a/src/text3.C b/src/text3.C
index 2b7f2c434f62abe5f58193da9c9d9ff792daceb0..5fb9e0ddcabb84ea224ec029ce3445020055e716 100644 (file)
--- a/src/text3.C
+++ b/src/text3.C
@@ -20,6 +20,7 @@
 #include "FloatList.h"
 #include "FuncStatus.h"
 #include "buffer.h"
+#include "buffer_funcs.h"
 #include "bufferparams.h"
 #include "BufferView.h"
 #include "cursor.h"
@@ -297,6 +298,10 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd)
                Paragraph & par = cur.paragraph();
                bool start = !par.params().startOfAppendix();
 
+#ifdef WITH_WARNINGS
+#warning The code below only makes sense a top level.
+// Should LFUN_APPENDIX be restricted to top-level paragraphs?
+#endif
                // ensure that we have only one start_of_appendix in this document
                for (pit_type tmp = 0, end = pars_.size(); tmp != end; ++tmp) {
                        if (pars_[tmp].params().startOfAppendix()) {
@@ -310,7 +315,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd)
                par.params().startOfAppendix(start);
 
                // we can set the refreshing parameters now
-               updateCounters();
+               updateCounters(cur.buffer());
                break;
        }