anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-12-23 13:31:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

My simple testing of Martins patch, shows that it works as expected.

Browse Source 
Applied.


git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@4883 a592a061-630c-0410-9148-cb99ea01b6c8
This commit is contained in:
Lars Gullik Bjønnes 2002-08-06 22:40:59 +00:00
parent 6b5c9696b6
commit 960db78b52
7 changed files with 365 additions and 351 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
src/ChangeLog
View File

@ -1,3 +1,11 @@
2002-08-06 Martin Vermeer <martin.vermeer@hut.fi>
* counters.[Ch]
* text2.C
* paragraph.[Ch]
* makefile.am: move counters functionality over from
text2.C/paragraph.[Ch] to counters.[Ch], and make proper C++.
2002-08-06 John Levon <levon@movementarian.org>
* WordLangTuple.h: new file for word + language code tuple
@ -27,70 +35,78 @@
2002-08-06 John Levon <levon@movementarian.org>
* pspell.C: fix a crash, and allow new aspell to work
2002-08-06 John Levon <levon@movementarian.org>
* lyxfunc.C:
* kbmap.C: small cleanup
* vspace.h:
* vspace.C: add const
2002-08-05 John Levon <levon@movementarian.org>
* LyXAction.C: back to tabular-insert
2002-08-04 John Levon <levon@movementarian.org>
* BufferView.h:
* BufferView.C: cosmetic change
* BufferView_pimpl.C: s/IGNORE_CODE/NOTE_CODE/
* bufferlist.C:
* buffer.h:
* buffer.C:
* lyxcb.h:
* lyxcb.C:
* lyxserver.C:
* lyxvc.C:
* vc-backend.C:
* lyxserver.C:
* lyxvc.C:
* vc-backend.C:
* BufferView2.C: purge all "Lyx" not "LyX" strings
* lyxcursor.h:
* lyxcursor.C: attempt to add some documentation
* lyxfunc.C:
* commandtags.h:
* LyXAction.C:
* ToolbarDefaults.C:
* LyXAction.C:
* ToolbarDefaults.C:
* BufferView_pimpl.C: remove LFUN_DIALOG_TABULAR_INSERT and
merge with LFUN_TABULAR_INSERT
* Makefile.am:
* Makefile.am:
* SpellBase.h:
* ispell.h:
* ispell.C:
* ispell.C:
* pspell.h:
* pspell.C: split up i/pspell implementations into separate
files, many cleanups
* lyxlex.C: unrevert, with a proper fix for prefix.length() == 0
* lyxlex.C: unrevert, with a proper fix for prefix.length() == 0
* text2.C: some cleanup
* lyxfunc.C: don't check for isp_command == "none" any more, it
didn't make any sense
2002-08-06 Martin Vermeer <martin.vermeer@hut.fi>
* counters.[Ch]
* text2.C
* paragraph.[Ch]
* makefile.am: move counters functionality over
from text2.C/paragraph.[Ch] to counters.[Ch], and
make proper C++.
2002-08-02 John Levon <levon@movementarian.org>
* buffer.C: s/lyxconvert/lyx2lyx/
2002-08-02 Angus Leeming <leeming@lyx.org>
* lyxlex.C: revert John's change as it breaks reading of the user
preamble.
2002-08-02 Angus Leeming <leeming@lyx.org>
* importer.C (Import):
@ -100,14 +116,14 @@
2002-08-02 John Levon <levon@movementarian.org>
* lyxlex.C: small cleanup
2002-08-02 John Levon <levon@movementarian.org>
* text2.C (status): small cleanup, no logic change
2002-08-01 John Levon <levon@movementarian.org>
* buffer.h:
* buffer.h:
* buffer.C (writeFile): don't output alerts, caller
handles this
@ -120,20 +136,20 @@
* lyxserver.C: don't let incidental errors get
in the way (errno)
2002-07-30 John Levon <levon@movementarian.org>
* lyxfunc.C: disable character dialog in ERT inset (partial fix)
2002-07-30 John Levon <levon@movementarian.org>
* lyxserver.h:
* lyxserver.C: remove I/O callback too
2002-07-30 Jean-Marc Lasgouttes <lasgouttes@freesurf.fr>
* lyxfunc.C (getStatus): disable LFUN_LATEX_LOG when there is no
log.
log.
2002-07-29 Lars Gullik Bjønnes <larsbj@gullik.net>

4
src/Makefile.am
View File

@ -35,8 +35,6 @@ EXTRA_DIST = config.h.in stamp-h.in cheaders ext_l10n.h version.C.in \
Sectioning.C \
Variables.C \
Variables.h \
counters.C \
counters.h \
tracer.C \
tracer.h
@ -109,6 +107,8 @@ lyx_SOURCES = \
config.h.in \
converter.C \
converter.h \
counters.C \
counters.h \
debug.C \
debug.h \
encoding.C \

270
src/counters.C
View File

@ -17,8 +17,10 @@
#include "counters.h"
#include "debug.h"
#include "support/lstrings.h"
using std::endl;
using std::vector;
Counter::Counter()
@ -48,7 +50,6 @@ int Counter::value() const
void Counter::step()
{
++value_;
onstep.emit();
}
@ -57,15 +58,54 @@ void Counter::reset()
value_ = 0;
}
Counters::~Counters()
string Counter::master() const
{
// We need this since we store the Counter's as pointers in
// the counterList.
for (CounterList::iterator it = counterList.begin();
it != counterList.end();
++it)
delete it->second;
return master_;
}
void Counter::setMaster(string const & m)
{
master_ = m;
}
Counters::Counters()
{
// Ehh, should this take a textclass arg?
// Sectioning counters:
newCounter("part");
newCounter("chapter");
newCounter("section", "chapter");
newCounter("subsection", "section");
newCounter("subsubsection", "subsection");
newCounter("paragraph", "subsubsection");
newCounter("subparagraph", "paragraph");
sects.push_back("chapter");
sects.push_back("section");
sects.push_back("subsection");
sects.push_back("subsubsection");
sects.push_back("paragraph");
sects.push_back("subparagraph");
// Enumeration counters:
newCounter("enumi");
newCounter("enumii", "enumi");
newCounter("enumiii", "enumii");
newCounter("enumiv", "enumiii");
enums.push_back("enumi");
enums.push_back("enumii");
enums.push_back("enumiii");
enums.push_back("enumiv");
// Biblio:
newCounter("bibitem");
// Float counters:
newCounter("Figure");
newCounter("Table");
}
@ -73,36 +113,37 @@ void Counters::newCounter(string const & newc)
{
// First check if newc already exist
CounterList::iterator cit = counterList.find(newc);
// if alrady exist give warning and return
// if already exist give warning and return
if (cit != counterList.end()) {
lyxerr << "The new counter already exist." << endl;
lyxerr << "The new counter already exists." << endl;
return;
}
counterList[newc] = new Counter;
counterList[newc];
cit = counterList.find(newc);
cit->second.setMaster("");
}
void Counters::newCounter(string const & newc, string const & oldc)
void Counters::newCounter(string const & newc, string const & masterc)
{
// First check if newc already exist
// First check if newc already exists
CounterList::iterator cit = counterList.find(newc);
// if already existant give warning and return
if (cit != counterList.end()) {
lyxerr << "The new counter already exist." << endl;
lyxerr << "The new counter already exists." << endl;
return;
}
// then check if oldc exist
CounterList::iterator it = counterList.find(oldc);
// then check if masterc exists
CounterList::iterator it = counterList.find(masterc);
// if not give warning and return
if (it == counterList.end()) {
lyxerr << "The old counter does not exist." << endl;
lyxerr << "The master counter does not exist." << endl;
return;
}
Counter * tmp = new Counter;
it->second->onstep.connect(SigC::slot(tmp,
&Counter::reset));
counterList[newc] = tmp;
counterList[newc];
cit = counterList.find(newc);
cit->second.setMaster(masterc);
}
@ -110,10 +151,10 @@ void Counters::set(string const & ctr, int val)
{
CounterList::iterator it = counterList.find(ctr);
if (it == counterList.end()) {
lyxerr << "Counter does not exist." << endl;
lyxerr << "set: Counter does not exist: " << ctr << endl;
return;
}
it->second->set(val);
it->second.set(val);
}
@ -121,10 +162,10 @@ void Counters::addto(string const & ctr, int val)
{
CounterList::iterator it = counterList.find(ctr);
if (it == counterList.end()) {
lyxerr << "Counter does not exist." << endl;
lyxerr << "addto: Counter does not exist: " << ctr << endl;
return;
}
it->second->addto(val);
it->second.addto(val);
}
@ -132,10 +173,10 @@ int Counters::value(string const & ctr) const
{
CounterList::const_iterator cit = counterList.find(ctr);
if (cit == counterList.end()) {
lyxerr << "Counter does not exist." << endl;
lyxerr << "value: Counter does not exist: " << ctr << endl;
return 0;
}
return cit->second->value();
return cit->second.value();
}
@ -143,8 +184,177 @@ void Counters::step(string const & ctr)
{
CounterList::iterator it = counterList.find(ctr);
if (it == counterList.end()) {
lyxerr << "Counter does not exist." << endl;
lyxerr << "step: Counter does not exist: " << ctr << endl;
return;
}
it->second->step();
it->second.step();
it = counterList.begin();
CounterList::iterator end = counterList.end();
for (; it != end; ++it) {
if (it->second.master() == ctr) {
it->second.reset();
}
}
}
void Counters::reset(string const & match)
{
CounterList::iterator it = counterList.begin();
CounterList::iterator end = counterList.end();
for (; it != end; ++it) {
if (it->first.find(match) != string::npos || match == "")
it->second.reset();
}
}
void Counters::copy(Counters & from, Counters & to, string const & match)
{
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));
}
}
}
namespace {
inline
char loweralphaCounter(int n)
{
if (n < 1 || n > 26)
return '?';
else
return 'a' + n - 1;
}
inline
char alphaCounter(int n)
{
if (n < 1 || n > 26)
return '?';
else
return 'A' + n - 1;
}
inline
char hebrewCounter(int n)
{
static const char hebrew[22] = {
'à', 'á', 'â', 'ã', 'ä', 'å', 'æ', 'ç', 'è',
'é', 'ë', 'ì', 'î', 'ð', 'ñ', 'ò', 'ô', 'ö',
'÷', 'ø', 'ù', 'ú'
};
if (n < 1 || n > 22)
return '?';
else
return hebrew[n-1];
}
inline
string const romanCounter(int n)
{
static char const * roman[20] = {
"i", "ii", "iii", "iv", "v",
"vi", "vii", "viii", "ix", "x",
"xi", "xii", "xiii", "xiv", "xv",
"xvi", "xvii", "xviii", "xix", "xx"
};
if (n < 1 || n > 20)
return "??";
else
return roman[n-1];
}
} // namespace anon
string Counters::labelItem(string const & ctr,
string const & numbertype,
string const & langtype,
bool first)
{
ostringstream s, o;
CounterList::iterator it = counterList.find(ctr);
if (it == counterList.end()) {
lyxerr << "Counter does not exist." << endl;
return "";
}
string mstr = it->second.master();
if (!first) {
s << "." << value(ctr);
} else {
if (numbertype == "sectioning" || numbertype == "appendix") {
if (numbertype == "appendix") {
if (langtype == "hebrew") {
o << hebrewCounter(value(ctr));
} else {
o << alphaCounter(value(ctr));
}
} else o << value(ctr);
}
s << o.str();
}
return s.str();
}
string Counters::numberLabel(string const & ctr,
string const & numbertype,
string const & langtype,
int head)
{
ostringstream s, o;
if (numbertype == "sectioning" || numbertype == "appendix") {
if (ctr == "chapter" && head == 0) {
s << labelItem("chapter", numbertype, langtype, true);
} else if (ctr == "section" && head <= 1) {
s << numberLabel("chapter", numbertype, langtype, head)
<< labelItem("section", numbertype, langtype, head == 1);
} else if (ctr == "subsection" && head <= 2) {
s << numberLabel("section", numbertype, langtype, head)
<< labelItem("subsection", numbertype, langtype, head == 2);
} else if (ctr == "subsubsection" && head <= 3) {
s << numberLabel("subsection", numbertype, langtype, head)
<< labelItem("subsubsection", numbertype, langtype, head == 3);
} else if (ctr == "paragraph" && head <= 4) {
s << numberLabel("subsubsection", numbertype, langtype, head)
<< labelItem("paragraph", numbertype, langtype, head == 4);
} else if (ctr == "subparagraph" && head <= 5) {
s << numberLabel("paragraph", numbertype, langtype, head)
<< labelItem("subparagraph", numbertype, langtype, head == 5);
} else if (ctr == "Figure" || ctr == "Table") {
// figure, table, ...
lyxerr << "Counter:" << ctr << endl;
s << numberLabel("chapter", numbertype, langtype, head)
<< labelItem(ctr, numbertype, langtype, head == 1);
}
} else if (numbertype == "enumeration") {
ostringstream ei, eii, eiii, eiv;
//string ei, eiii, eiv;
//char eii;
if (langtype == "hebrew") {
ei << '.' << value("enumi");
eii << '(' << hebrewCounter(value("enumii")) << ')';
eiii << '.' << romanCounter(value("enumiii"));
eiv << '.' << alphaCounter(value("enumiv"));
} else {
ei << value("enumi") << '.';
eii << '(' << loweralphaCounter(value("enumii")) << ')';
eiii << romanCounter(value("enumiii")) << '.';
eiv << alphaCounter(value("enumiv")) << '.';
}
if (ctr == "enumii") {
s << eii.str();
} else if (ctr == "enumi") {
s << ei.str();
} else if (ctr == "enumiii") {
s << eiii.str();
} else if (ctr == "enumiv") {
s << eiv.str();
}
}
return s.str();
}

41
src/counters.h
View File

@ -19,14 +19,11 @@
#endif
#include "LString.h"
#include <boost/signals/signal0.hpp>
#include <boost/signals/trackable.hpp>
#include <map>
#include <vector>
///
class Counter : public boost::trackable {
class Counter {
public:
///
Counter();
@ -41,10 +38,15 @@ public:
///
void reset();
///
boost::signal0<void> onstep;
private:
string master() const;
///
void setMaster(string const & m);
///
private:
int value_;
///
string master_;
};
@ -54,7 +56,9 @@ private:
class Counters {
public:
///
~Counters();
Counters();
///
//~Counters();
///
void newCounter(string const & newc);
///
@ -67,12 +71,29 @@ public:
int value(string const & ctr) const;
///
void step(string const & ctr);
// string refstep(string const & cou);
///
void reset(string const & match = "");
///
void copy(Counters & from, Counters & to, string const & match = "");
///
string labelItem(string const & ctr,
string const & labeltype,
string const & langtype = "latin",
bool first = false);
///
string numberLabel(string const & ctr,
string const & labeltype,
string const & langtype = "latin",
int head = 0);
///
std::vector<string> enums, sects;
private:
///
typedef std::map<string, Counter*> CounterList;
typedef std::map<string, Counter> CounterList;
///
CounterList counterList;
};
#endif

25
src/paragraph.C
View File

@ -77,8 +77,6 @@ extern BufferView * current_view;
Paragraph::Paragraph()
: pimpl_(new Paragraph::Pimpl(this))
{
for (int i = 0; i < 10; ++i)
setCounter(i, 0);
next_ = 0;
previous_ = 0;
enumdepth = 0;
@ -92,8 +90,6 @@ Paragraph::Paragraph()
Paragraph::Paragraph(Paragraph * par)
: pimpl_(new Paragraph::Pimpl(this))
{
for (int i = 0; i < 10; ++i)
setCounter(i, 0);
enumdepth = 0;
itemdepth = 0;
@ -113,8 +109,6 @@ Paragraph::Paragraph(Paragraph * par)
Paragraph::Paragraph(Paragraph const & lp, bool same_ids)
: pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this, same_ids))
{
for (int i = 0; i < 10; ++i)
setCounter(i, 0);
enumdepth = 0;
itemdepth = 0;
next_ = 0;
@ -2154,25 +2148,6 @@ void Paragraph::clearContents()
pimpl_->clear();
}
void Paragraph::setCounter(int i, int v)
{
pimpl_->counter_[i] = v;
}
int Paragraph::getCounter(int i) const
{
return pimpl_->counter_[i];
}
void Paragraph::incCounter(int i)
{
pimpl_->counter_[i]++;
}
void Paragraph::setChar(pos_type pos, value_type c)
{
pimpl_->setChar(pos, c);

11
src/paragraph.h
View File

@ -19,6 +19,7 @@
#include "insets/inset.h" // Just for Inset::Code
#include "lyxfont.h" // Just for LyXFont::FONT_SIZE
#include "support/types.h"
#include "counters.h"
class ParagraphParameters;
class BufferParams;
@ -169,13 +170,6 @@ public:
///
void layout(LyXLayout_ptr const & new_layout);
///
void setCounter(int i, int v);
///
int getCounter(int i) const;
///
void incCounter(int i);
///
char enumdepth;
@ -401,6 +395,9 @@ public:
/// returns inset iterator of the first inset at or after pos.
inset_iterator InsetIterator(lyx::pos_type pos);
///
Counters ctrs;
private:
/// if anything uses this we don't want it to.
Paragraph(Paragraph const &);

293
src/text2.C
View File

@ -32,6 +32,7 @@
#include "FloatList.h"
#include "language.h"
#include "ParagraphParameters.h"
#include "counters.h"
#include "insets/inseterror.h"
#include "insets/insetbib.h"
@ -387,7 +388,7 @@ void LyXText::insertParagraph(BufferView * bview, Paragraph * par,
Row * row) const
{
insertRow(row, par, 0); /* insert a new row, starting
* at postition 0 */
* at position 0 */
setCounter(bview->buffer(), par); // set the counters
@ -1211,60 +1212,6 @@ void LyXText::setParagraph(BufferView * bview,
}
char loweralphaCounter(int n)
{
if (n < 1 || n > 26)
return '?';
else
return 'a' + n - 1;
}
namespace {
inline
char alphaCounter(int n)
{
if (n < 1 || n > 26)
return '?';
else
return 'A' + n - 1;
}
inline
char hebrewCounter(int n)
{
static const char hebrew[22] = {
'à', 'á', 'â', 'ã', 'ä', 'å', 'æ', 'ç', 'è',
'é', 'ë', 'ì', 'î', 'ð', 'ñ', 'ò', 'ô', 'ö',
'÷', 'ø', 'ù', 'ú'
};
if (n < 1 || n > 22)
return '?';
else
return hebrew[n-1];
}
inline
string const romanCounter(int n)
{
static char const * roman[20] = {
"i", "ii", "iii", "iv", "v",
"vi", "vii", "viii", "ix", "x",
"xi", "xii", "xiii", "xiv", "xv",
"xvi", "xvii", "xviii", "xix", "xx"
};
if (n < 1 || n > 20)
return "??";
else
return roman[n-1];
}
} // namespace anon
// set the counter of a paragraph. This includes the labels
void LyXText::setCounter(Buffer const * buf, Paragraph * par) const
{
@ -1274,22 +1221,18 @@ void LyXText::setCounter(Buffer const * buf, Paragraph * par) const
// copy the prev-counters to this one,
// unless this is the first paragraph
if (par->previous()) {
for (int i = 0; i < 10; ++i) {
par->setCounter(i, par->previous()->getFirstCounter(i));
}
par->ctrs.copy(par->previous()->ctrs, par->ctrs, "");
par->params().appendix(par->previous()->params().appendix());
if (!par->params().appendix() && par->params().startOfAppendix()) {
par->params().appendix(true);
for (int i = 0; i < 10; ++i) {
par->setCounter(i, 0);
}
par->ctrs.reset("");
}
par->enumdepth = par->previous()->enumdepth;
par->itemdepth = par->previous()->itemdepth;
} else {
for (int i = 0; i < 10; ++i) {
par->setCounter(i, 0);
}
par->ctrs.reset("");
par->params().appendix(par->params().startOfAppendix());
par->enumdepth = 0;
par->itemdepth = 0;
@ -1315,11 +1258,8 @@ void LyXText::setCounter(Buffer const * buf, Paragraph * par) const
&& par->previous()->getDepth() > par->getDepth()
&& layout->labeltype != LABEL_BIBLIO) {
par->enumdepth = par->depthHook(par->getDepth())->enumdepth;
par->setCounter(6 + par->enumdepth,
par->depthHook(par->getDepth())->getCounter(6 + par->enumdepth));
// reset the counters.A depth change is like a breaking layout
for (int i = 6 + par->enumdepth + 1; i < 10; ++i)
par->setCounter(i, 0);
par->ctrs.set(par->ctrs.enums[par->enumdepth],
par->depthHook(par->getDepth())->ctrs.value(par->ctrs.enums[par->enumdepth]));
}
if (!par->params().labelString().empty()) {
@ -1333,13 +1273,17 @@ void LyXText::setCounter(Buffer const * buf, Paragraph * par) const
} else {
par->setLabelWidthString(string());
}
// is it a layout that has an automatic label?
if (layout->labeltype >= LABEL_COUNTER_CHAPTER) {
int i = layout->labeltype - LABEL_COUNTER_CHAPTER;
string numbertype, langtype;
ostringstream s;
if (i >= 0 && i<= buf->params.secnumdepth) {
par->incCounter(i); // increment the counter
par->ctrs.step(par->ctrs.sects[i]);
// Is there a label? Useful for Chapter layout
if (!par->params().appendix()) {
@ -1354,195 +1298,40 @@ void LyXText::setCounter(Buffer const * buf, Paragraph * par) const
par->params().labelString(string());
}
ostringstream s;
// Use if an integer is here less than elegant. For now.
int head = textclass.maxcounter() - LABEL_COUNTER_CHAPTER;
if (!par->params().appendix()) {
switch (2 * LABEL_COUNTER_CHAPTER -
textclass.maxcounter() + i) {
case LABEL_COUNTER_CHAPTER:
s << par->getCounter(i);
break;
case LABEL_COUNTER_SECTION:
s << par->getCounter(i - 1) << '.'
<< par->getCounter(i);
break;
case LABEL_COUNTER_SUBSECTION:
s << par->getCounter(i - 2) << '.'
<< par->getCounter(i - 1) << '.'
<< par->getCounter(i);
break;
case LABEL_COUNTER_SUBSUBSECTION:
s << par->getCounter(i - 3) << '.'
<< par->getCounter(i - 2) << '.'
<< par->getCounter(i - 1) << '.'
<< par->getCounter(i);
break;
case LABEL_COUNTER_PARAGRAPH:
s << par->getCounter(i - 4) << '.'
<< par->getCounter(i - 3) << '.'
<< par->getCounter(i - 2) << '.'
<< par->getCounter(i - 1) << '.'
<< par->getCounter(i);
break;
case LABEL_COUNTER_SUBPARAGRAPH:
s << par->getCounter(i - 5) << '.'
<< par->getCounter(i - 4) << '.'
<< par->getCounter(i - 3) << '.'
<< par->getCounter(i - 2) << '.'
<< par->getCounter(i - 1) << '.'
<< par->getCounter(i);
break;
default:
// Can this ever be reached? And in the
// case it is, how can this be correct?
// (Lgb)
s << par->getCounter(i) << '.';
break;
}
} else { // appendix
switch (2 * LABEL_COUNTER_CHAPTER - textclass.maxcounter() + i) {
case LABEL_COUNTER_CHAPTER:
if (par->isRightToLeftPar(buf->params))
s << hebrewCounter(par->getCounter(i));
else
s << alphaCounter(par->getCounter(i));
break;
case LABEL_COUNTER_SECTION:
if (par->isRightToLeftPar(buf->params))
s << hebrewCounter(par->getCounter(i - 1));
else
s << alphaCounter(par->getCounter(i - 1));
s << '.'
<< par->getCounter(i);
break;
case LABEL_COUNTER_SUBSECTION:
if (par->isRightToLeftPar(buf->params))
s << hebrewCounter(par->getCounter(i - 2));
else
s << alphaCounter(par->getCounter(i - 2));
s << '.'
<< par->getCounter(i-1) << '.'
<< par->getCounter(i);
break;
case LABEL_COUNTER_SUBSUBSECTION:
if (par->isRightToLeftPar(buf->params))
s << hebrewCounter(par->getCounter(i-3));
else
s << alphaCounter(par->getCounter(i-3));
s << '.'
<< par->getCounter(i-2) << '.'
<< par->getCounter(i-1) << '.'
<< par->getCounter(i);
break;
case LABEL_COUNTER_PARAGRAPH:
if (par->isRightToLeftPar(buf->params))
s << hebrewCounter(par->getCounter(i-4));
else
s << alphaCounter(par->getCounter(i-4));
s << '.'
<< par->getCounter(i-3) << '.'
<< par->getCounter(i-2) << '.'
<< par->getCounter(i-1) << '.'
<< par->getCounter(i);
break;
case LABEL_COUNTER_SUBPARAGRAPH:
if (par->isRightToLeftPar(buf->params))
s << hebrewCounter(par->getCounter(i-5));
else
s << alphaCounter(par->getCounter(i-5));
s << '.'
<< par->getCounter(i-4) << '.'
<< par->getCounter(i-3) << '.'
<< par->getCounter(i-2) << '.'
<< par->getCounter(i-1) << '.'
<< par->getCounter(i);
break;
default:
// Can this ever be reached? And in the
// case it is, how can this be correct?
// (Lgb)
s << par->getCounter(i) << '.';
break;
}
numbertype = "sectioning";
} else {
numbertype = "appendix";
if (par->isRightToLeftPar(buf->params))
langtype = "hebrew";
else
langtype = "latin";
}
s << par->ctrs.numberLabel(par->ctrs.sects[i],
numbertype, langtype, head);
par->params().labelString(par->params().labelString() +s.str().c_str());
// We really want to remove the c_str as soon as
// possible...
for (i++; i < 10; ++i) {
// reset the following counters
par->setCounter(i, 0);
}
// reset enum counters
par->ctrs.reset("enum");
} else if (layout->labeltype < LABEL_COUNTER_ENUMI) {
for (i++; i < 10; ++i) {
// reset the following counters
par->setCounter(i, 0);
}
par->ctrs.reset("enum");
} else if (layout->labeltype == LABEL_COUNTER_ENUMI) {
par->incCounter(i + par->enumdepth);
int number = par->getCounter(i + par->enumdepth);
ostringstream s;
switch (par->enumdepth) {
case 1:
if (par->isRightToLeftPar(buf->params))
s << '('
<< hebrewCounter(number)
<< ')';
else
s << '('
<< loweralphaCounter(number)
<< ')';
break;
case 2:
if (par->isRightToLeftPar(buf->params))
s << '.' << romanCounter(number);
else
s << romanCounter(number) << '.';
break;
case 3:
if (par->isRightToLeftPar(buf->params))
s << '.'
<< alphaCounter(number);
else
s << alphaCounter(number)
<< '.';
break;
default:
if (par->isRightToLeftPar(buf->params))
s << '.' << number;
else
s << number << '.';
break;
}
par->ctrs.step(par->ctrs.enums[par->enumdepth]);
s << par->ctrs.numberLabel(par->ctrs.enums[par->enumdepth],
"enumeration", langtype);
par->params().labelString(s.str().c_str());
for (i += par->enumdepth + 1; i < 10; ++i) {
// reset the following counters
par->setCounter(i, 0);
}
}
} else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
int i = LABEL_COUNTER_ENUMI - LABEL_COUNTER_CHAPTER + par->enumdepth;
par->incCounter(i);
int number = par->getCounter(i);
par->ctrs.step("bibitem");
int number = par->ctrs.value("bibitem");
if (!par->bibkey) {
InsetCommandParams p("bibitem" );
par->bibkey = new InsetBibKey(p);
@ -1563,8 +1352,13 @@ void LyXText::setCounter(Buffer const * buf, Paragraph * par) const
InsetFloat * tmp = static_cast<InsetFloat*>(par->inInset()->owner());
Floating const & fl
= floatList.getType(tmp->type());
// Why doesn't it work? -- MV
par->ctrs.step(fl.name());
// We should get the correct number here too.
s = fl.name() + " #:";
ostringstream o;
o << fl.name() << " " << par->ctrs.value(fl.name()) << ":";
s = o.str();
} else {
/* par->SetLayout(0);
s = layout->labelstring; */
@ -1576,8 +1370,9 @@ void LyXText::setCounter(Buffer const * buf, Paragraph * par) const
/* reset the enumeration counter. They are always resetted
* when there is any other layout between */
for (int i = 6 + par->enumdepth; i < 10; ++i)
par->setCounter(i, 0);
for (int i = par->enumdepth + 1; i < 4; i++) {
par->ctrs.set(par->ctrs.enums[i], 0);
}
}
}