extern string bibitemWidest(Buffer const *);
// this is a minibuffer
-static char minibuffer_char;
-static LyXFont minibuffer_font;
-static Inset * minibuffer_inset;
+
+namespace {
+
+char minibuffer_char;
+LyXFont minibuffer_font;
+Inset * minibuffer_inset;
+
+} // namespace anon
extern BufferView * current_view;
for (int i = 0; i < 10; ++i) setCounter(i , 0);
enumdepth = 0;
itemdepth = 0;
- next = 0;
- previous = 0;
+ next_ = 0;
+ previous_ = 0;
#ifndef NEW_INSETS
footnoteflag = LyXParagraph::NO_FOOTNOTE;
footnotekind = LyXParagraph::FOOTNOTE; // should not be needed
enumdepth = 0;
itemdepth = 0;
// double linked list begin
- next = par->next;
- if (next)
- next->previous = this;
- previous = par;
- previous->next = this;
+ next_ = par->next_;
+ if (next_)
+ next_->previous_ = this;
+ previous_ = par;
+ previous_->next_ = this;
// end
#ifndef NEW_INSETS
footnoteflag = LyXParagraph::NO_FOOTNOTE;
char footflag, char dth) const
{
#ifndef NEW_INSETS
- if (
- footnoteflag != LyXParagraph::NO_FOOTNOTE ||
- !previous
- || previous->footnoteflag == LyXParagraph::NO_FOOTNOTE
- ) {
-#endif
-
-#ifndef NEW_INSETS
+ if (footnoteflag != LyXParagraph::NO_FOOTNOTE ||
+ !previous_
+ || previous_->footnoteflag == LyXParagraph::NO_FOOTNOTE) {
// The beginning or the end of a footnote environment?
if (footflag != footnoteflag) {
footflag = footnoteflag;
}
os << "\\align " << string_align[h] << " ";
}
+#ifndef NO_PEXTRA
if (params.pextraType() != PEXTRA_NONE) {
os << "\\pextra_type " << params.pextraType();
if (params.pextraType() == PEXTRA_MINIPAGE) {
}
os << '\n';
}
+#endif
#ifndef NEW_INSETS
} else {
// Dummy layout. This means that a footnote ended.
}
// now write the next paragraph
- if (next)
- next->writeFile(buf, os, bparams, footflag, dth);
+ if (next_)
+ next_->writeFile(buf, os, bparams, footflag, dth);
}
(*cit).inset->Validate(features);
}
+#ifndef NO_PEXTRA
if (params.pextraType() == PEXTRA_INDENT)
features.LyXParagraphIndent = true;
if (params.pextraType() == PEXTRA_FLOATFLT)
features.floatflt = true;
+#endif
#ifndef NEW_INSETS
if (layout.needprotect
- && next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE)
+ && next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE)
features.NeedLyXFootnoteCode = true;
#endif
+#ifndef NO_PEXTRA
if (bparams.paragraph_separation == BufferParams::PARSEP_INDENT
&& params.pextraType() == LyXParagraph::PEXTRA_MINIPAGE)
features.NeedLyXMinipageIndent = true;
+#endif
#ifndef NEW_INSETS
if (footnoteflag != NO_FOOTNOTE && footnotekind == ALGORITHM)
features.algorithm = true;
// the destructor removes the new paragraph from the list
LyXParagraph::~LyXParagraph()
{
- if (previous)
- previous->next = next;
- if (next)
- next->previous = previous;
+ if (previous_)
+ previous_->next_ = next_;
+ if (next_)
+ next_->previous_ = previous_;
for (InsetList::iterator it = insetlist.begin();
it != insetlist.end(); ++it) {
// > because last is the next unused position, and you can
// use it if you want
if (pos > size()) {
- if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
+ if (next_ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
NextAfterFootnote()->Erase(pos - text.size() - 1);
else
lyxerr.debug() << "ERROR (LyXParagraph::Erase): "
// > because last is the next unused position, and you can
// use it if you want
if (pos > size()) {
- if (next
- && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
+ if (next_
+ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
NextAfterFootnote()->InsertChar(pos - text.size() - 1,
c);
else
// > because last is the next unused position, and you can
// use it if you want
if (pos > size()) {
- if (next
- && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
+ if (next_
+ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
NextAfterFootnote()
->InsertInset(pos - text.size() - 1,
inset, font);
{
#ifndef NEW_INSETS
if (pos >= size()) {
- if (next
- && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
+ if (next_
+ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
return NextAfterFootnote()
->GetInset(pos - text.size() - 1);
else
{
#ifndef NEW_INSETS
if (pos >= size()) {
- if (next
- && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
+ if (next_
+ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
return NextAfterFootnote()
->GetInset(pos - text.size() - 1);
else
// > because last is the next unused position, and you can
// use it if you want
else if (pos > size()) {
- if (next
- && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
+ if (next_
+ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
return NextAfterFootnote()
->GetFontSettings(bparams,
pos - text.size() - 1);
}
#ifndef NEW_INSETS
- else if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE)
+ else if (next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE)
return NextAfterFootnote()->GetFirstFontSettings();
#endif
return LyXFont(LyXFont::ALL_INHERIT);
// > because last is the next unused position, and you can
// use it if you want
else if (pos > size()) {
- if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE)
+ if (next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE)
return NextAfterFootnote()
->GetChar(pos - text.size() - 1);
else
return '\0';
} else {
// We should have a footnote environment.
- if (!next || next->footnoteflag == LyXParagraph::NO_FOOTNOTE) {
+ if (!next_ || next_->footnoteflag == LyXParagraph::NO_FOOTNOTE) {
// Notice that LyX does request the
// last char from time to time. (Asger)
//lyxerr << "ERROR (LyXParagraph::GetChar): "
// "expected footnote." << endl;
return '\0';
}
- switch (next->footnotekind) {
+ switch (next_->footnotekind) {
case LyXParagraph::FOOTNOTE:
return LyXParagraph::META_FOOTNOTE;
case LyXParagraph::MARGIN:
}
-#ifdef NEW_INSETS
-#warning Remember to get rid of this one. (Lgb)
-#endif
+#ifndef NEW_INSETS
LyXParagraph::size_type LyXParagraph::Last() const
{
-#ifndef NEW_INSETS
- if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
+ if (next_ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
return text.size() + NextAfterFootnote()->Last() + 1;
// the 1 is the symbol
// for the footnote
else
-#endif
return text.size();
}
+#endif
#ifndef NEW_INSETS
// > because last is the next unused position, and you can
// use it if you want
if (pos > size()) {
- if (next
- && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
+ if (next_
+ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
return NextAfterFootnote()
->ParFromPos(pos - text.size() - 1);
else
// > because last is the next unused position, and you can
// use it if you want
if (pos > size()) {
- if (next
- && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
+ if (next_
+ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
return NextAfterFootnote()
->PositionInParFromPos(pos - text.size() - 1);
else
// > because last is the next unused position, and you can
// use it if you want
if (pos > size()) {
- if (next &&
- next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
+ if (next_ &&
+ next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
NextAfterFootnote()->SetFont(pos - text.size() - 1,
font);
} else
}
}
-
+
+
+void LyXParagraph::next(LyXParagraph * p)
+{
+ next_ = p;
+}
+
+
// This function is able to hide closed footnotes.
-LyXParagraph * LyXParagraph::Next()
+LyXParagraph * LyXParagraph::next()
+{
+#ifndef NEW_INSETS
+ if (next_ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
+ LyXParagraph * tmp = next_;
+ while (tmp
+ && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
+ tmp = tmp->next_;
+ if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE)
+ return tmp->next(); /* there can be more than one
+ footnote in a logical
+ paragraph */
+ else
+ return next_; // This should never happen!
+ } else
+#endif
+ return next_;
+}
+
+
+LyXParagraph const * LyXParagraph::next() const
{
#ifndef NEW_INSETS
- if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
- LyXParagraph * tmp = next;
+ if (next_ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
+ LyXParagraph * tmp = next_;
while (tmp
&& tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
- tmp = tmp->next;
+ tmp = tmp->next_;
if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE)
- return tmp->Next(); /* there can be more than one
+ return tmp->next(); /* there can be more than one
footnote in a logical
paragraph */
else
- return next; // This should never happen!
+ return next_; // This should never happen!
} else
#endif
- return next;
+ return next_;
}
#ifndef NEW_INSETS
LyXParagraph * LyXParagraph::NextAfterFootnote()
{
- if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
- LyXParagraph * tmp = next;
+ if (next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
+ LyXParagraph * tmp = next_;
while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE)
- tmp = tmp->next;
+ tmp = tmp->next_;
if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE)
return tmp; /* there can be more than one footnote
in a logical paragraph */
else
- return next; // This should never happen!
+ return next_; // This should never happen!
} else
- return next;
+ return next_;
}
#endif
#ifndef NEW_INSETS
LyXParagraph const * LyXParagraph::NextAfterFootnote() const
{
- if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
- LyXParagraph * tmp = next;
+ if (next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
+ LyXParagraph * tmp = next_;
while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE)
- tmp = tmp->next;
+ tmp = tmp->next_;
if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE)
return tmp; /* there can be more than one footnote
in a logical paragraph */
else
- return next; // This should never happen!
+ return next_; // This should never happen!
} else
- return next;
+ return next_;
}
#endif
LyXParagraph * LyXParagraph::PreviousBeforeFootnote()
{
LyXParagraph * tmp;
- if (previous && previous->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
- tmp = previous;
+ if (previous_ && previous_->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
+ tmp = previous_;
while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE)
- tmp = tmp->previous;
+ tmp = tmp->previous_;
if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE)
return tmp; /* there can be more than one footnote
in a logical paragraph */
else
- return previous; // This should never happen!
+ return previous_; // This should never happen!
} else
- return previous;
+ return previous_;
}
#endif
return this;
LyXParagraph * tmp = this;
- while (tmp->next
- && tmp->next->footnoteflag != LyXParagraph::NO_FOOTNOTE)
+ while (tmp->next_
+ && tmp->next_->footnoteflag != LyXParagraph::NO_FOOTNOTE)
tmp = tmp->NextAfterFootnote();
return tmp;
return this;
LyXParagraph const * tmp = this;
- while (tmp->next
- && tmp->next->footnoteflag != LyXParagraph::NO_FOOTNOTE)
+ while (tmp->next_
+ && tmp->next_->footnoteflag != LyXParagraph::NO_FOOTNOTE)
tmp = tmp->NextAfterFootnote();
return tmp;
while (tmppar &&
(tmppar->IsDummy()
|| tmppar->footnoteflag != LyXParagraph::NO_FOOTNOTE))
- tmppar = tmppar->previous;
+ tmppar = tmppar->previous_;
if (!tmppar) {
return this;
while (tmppar &&
(tmppar->IsDummy()
|| tmppar->footnoteflag != LyXParagraph::NO_FOOTNOTE))
- tmppar = tmppar->previous;
+ tmppar = tmppar->previous_;
if (!tmppar) {
return this;
#endif
+void LyXParagraph::previous(LyXParagraph * p)
+{
+ previous_ = p;
+}
+
+
// This function is able to hide closed footnotes.
-LyXParagraph * LyXParagraph::Previous()
+LyXParagraph * LyXParagraph::previous()
{
#ifndef NEW_INSETS
- LyXParagraph * tmp = previous;
+ LyXParagraph * tmp = previous_;
if (!tmp)
return tmp;
- if (tmp->previous
- && tmp->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
- tmp = tmp->previous;
+ if (tmp->previous_
+ && tmp->previous_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
+ tmp = tmp->previous_;
while (tmp
&& tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
- tmp = tmp->previous;
+ tmp = tmp->previous_;
if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE)
- return tmp->next->Previous();
+ return tmp->next_->previous();
else
- return previous;
+ return previous_;
} else
#endif
- return previous;
+ return previous_;
}
// This function is able to hide closed footnotes.
-LyXParagraph const * LyXParagraph::Previous() const
+LyXParagraph const * LyXParagraph::previous() const
{
#ifndef NEW_INSETS
- LyXParagraph * tmp = previous;
+ LyXParagraph * tmp = previous_;
if (!tmp)
return tmp;
- if (tmp->previous
- && tmp->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
- tmp = tmp->previous;
+ if (tmp->previous_
+ && tmp->previous_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
+ tmp = tmp->previous_;
while (tmp
&& tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
- tmp = tmp->previous;
+ tmp = tmp->previous_;
if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE)
- return tmp->next->Previous();
+ return tmp->next_->previous();
else
- return previous;
+ return previous_;
} else
#endif
- return previous;
+ return previous_;
}
tmp->params.depth(firstpar->params.depth());
tmp->params.noindent(firstpar->params.noindent());
#else
- if (Last() > pos || !Last() || flag == 2) {
+ if (size() > pos || !size() || flag == 2) {
tmp->SetOnlyLayout(bparams, layout);
tmp->params.align(params.align());
tmp->SetLabelWidthString(params.labelWidthString());
LyXParagraph * tmppar = this;
while (tmppar && (
(tmppar->IsDummy()
- && tmppar->previous->footnoteflag ==
+ && tmppar->previous_->footnoteflag ==
LyXParagraph::CLOSED_FOOTNOTE)
|| tmppar->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE))
- tmppar = tmppar->previous;
+ tmppar = tmppar->previous_;
if (!tmppar)
return this; // This should never happen!
int i = 0;
#ifndef NEW_INSETS
if (!IsDummy()) {
-#endif
while (Last()
+#else
+ while (size()
+#endif
&& (IsNewline(0) || IsLineSeparator(0))){
Erase(0);
++i;
// When can pos > Last()?
// I guess pos == Last() is possible.
- if (Last() > pos) {
+ if (size() > pos) {
// copy everything behind the break-position to the new
// paragraph
size_type pos_end = text.size() - 1;
void LyXParagraph::PasteParagraph(BufferParams const & bparams)
{
// copy the next paragraph to this one
- LyXParagraph * the_next = Next();
-#ifndef NEW_INSETS
- LyXParagraph * firstpar = FirstPhysicalPar();
-#endif
+ LyXParagraph * the_next = next();
// first the DTP-stuff
#ifndef NEW_INSETS
+ LyXParagraph * firstpar = FirstPhysicalPar();
firstpar->params.lineBottom(the_next->params.lineBottom());
firstpar->params.spaceBottom(the_next->params.spaceBottom());
firstpar->params.pagebreakBottom(the_next->params.pagebreakBottom());
+
+ size_type pos_end = the_next->text.size() - 1;
+ size_type pos_insert = Last();
#else
params.lineBottom(the_next->params.lineBottom());
params.spaceBottom(the_next->params.spaceBottom());
params.pagebreakBottom(the_next->params.pagebreakBottom());
-#endif
size_type pos_end = the_next->text.size() - 1;
- size_type pos_insert = Last();
+ size_type pos_insert = size();
+#endif
// ok, now copy the paragraph
size_type i, j;
}
// delete the next paragraph
- LyXParagraph * ppar = the_next->previous;
- LyXParagraph * npar = the_next->next;
+ LyXParagraph * ppar = the_next->previous_;
+ LyXParagraph * npar = the_next->next_;
delete the_next;
- ppar->next = npar;
+ ppar->next(npar);
}
void LyXParagraph::OpenFootnote(LyXParagraph::size_type pos)
{
LyXParagraph * par = ParFromPos(pos);
- par = par->next;
+ par = par->next_;
while (par && par->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
par->footnoteflag = LyXParagraph::OPEN_FOOTNOTE;
- par = par->next;
+ par = par->next_;
}
}
void LyXParagraph::CloseFootnote(LyXParagraph::size_type pos)
{
LyXParagraph * par = ParFromPos(pos);
- par = par->next;
+ par = par->next_;
while (par && par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) {
par->footnoteflag = LyXParagraph::CLOSED_FOOTNOTE;
- par = par->next;
+ par = par->next_;
}
}
#endif
#ifndef NEW_INSETS
if (footnoteflag == NO_FOOTNOTE)
last = LastPhysicalPar();
- else if (next->footnoteflag == NO_FOOTNOTE)
+ else if (next_->footnoteflag == NO_FOOTNOTE)
return endlabeltype;
#else
last = this;
#endif
- if (!last || !last->next)
+ if (!last || !last->next_)
return endlabeltype;
- int next_depth = last->next->GetDepth();
+ int next_depth = last->next_->GetDepth();
if (par_depth > next_depth ||
- (par_depth == next_depth && layout != last->next->GetLayout() ))
+ (par_depth == next_depth && layout != last->next_->GetLayout() ))
return endlabeltype;
break;
}
par->layout = new_layout;
+#ifndef NO_PEXTRA
if (par->params.pextraType() == PEXTRA_NONE) {
- if (par->Previous()) {
+#endif
+ if (par->previous()) {
#ifndef NEW_INSETS
- ppar = par->Previous()->FirstPhysicalPar();
+ ppar = par->previous()->FirstPhysicalPar();
#else
- ppar = par->Previous();
+ ppar = par->previous();
#endif
while(ppar
- && ppar->Previous()
+ && ppar->previous()
&& (ppar->params.depth() > par->params.depth()))
#ifndef NEW_INSETS
- ppar = ppar->Previous()->FirstPhysicalPar();
+ ppar = ppar->previous()->FirstPhysicalPar();
#else
- ppar = ppar->Previous();
+ ppar = ppar->previous();
#endif
}
- if (par->Next()) {
+ if (par->next()) {
#ifndef NEW_INSETS
- npar = par->Next()->NextAfterFootnote();
+ npar = par->next()->NextAfterFootnote();
#else
- npar = par->Next();
+ npar = par->next();
#endif
while(npar
- && npar->Next()
+ && npar->next()
&& (npar->params.depth() > par->params.depth()))
#ifndef NEW_INSETS
- npar = npar->Next()->NextAfterFootnote();
+ npar = npar->next()->NextAfterFootnote();
#else
- npar = npar->Next();
+ npar = npar->next();
#endif
}
+#ifndef NO_PEXTRA
if (ppar && (ppar->params.pextraType() != PEXTRA_NONE)) {
string p1 = ppar->params.pextraWidth();
string p2 = ppar->params.pextraWidthp();
p1, p2);
}
}
+#endif
}
par->params.spaceBottom(VSpace(VSpace::NONE));
par->params.spacing(Spacing(Spacing::Default));
+#ifndef NO_PEXTRA
if (par->params.pextraType() == PEXTRA_NONE) {
- if (par->Previous()) {
+#endif
+ if (par->previous()) {
#ifndef NEW_INSETS
- ppar = par->Previous()->FirstPhysicalPar();
+ ppar = par->previous()->FirstPhysicalPar();
#else
- ppar = par->Previous();
+ ppar = par->previous();
#endif
while(ppar
- && ppar->Previous()
+ && ppar->previous()
&& (ppar->params.depth() > par->params.depth()))
#ifndef NEW_INSETS
- ppar = ppar->Previous()->FirstPhysicalPar();
+ ppar = ppar->previous()->FirstPhysicalPar();
#else
- ppar = ppar->Previous();
+ ppar = ppar->previous();
#endif
}
- if (par->Next()) {
+ if (par->next()) {
#ifndef NEW_INSETS
- npar = par->Next()->NextAfterFootnote();
+ npar = par->next()->NextAfterFootnote();
#else
- npar = par->Next();
+ npar = par->next();
#endif
while(npar
- && npar->Next()
+ && npar->next()
&& (npar->params.depth() > par->params.depth()))
#ifndef NEW_INSETS
- npar = npar->Next()->NextAfterFootnote();
+ npar = npar->next()->NextAfterFootnote();
#else
- npar = npar->Next();
+ npar = npar->next();
#endif
}
+#ifndef NO_PEXTRA
if (ppar && (ppar->params.pextraType() != PEXTRA_NONE)) {
string const p1 = ppar->params.pextraWidth();
string const p2 = ppar->params.pextraWidthp();
p1, p2);
}
}
+#endif
}
#ifndef NEW_INSETS
if (i == 0 && i == size() &&
!(footnoteflag == LyXParagraph::NO_FOOTNOTE
- && next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE))
+ && next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE))
++i; /* the cursor should not jump
* to the main body if there
* is nothing in! */
do {
#ifndef NEW_INSETS
- newpar = newpar->FirstPhysicalPar()->Previous();
+ newpar = newpar->FirstPhysicalPar()->previous();
#else
- newpar = newpar->Previous();
+ newpar = newpar->previous();
#endif
} while (newpar && newpar->GetDepth() > deth
#ifndef NEW_INSETS
);
if (!newpar) {
- if (Previous() || GetDepth())
+ if (previous() || GetDepth())
lyxerr << "ERROR (LyXParagraph::DepthHook): "
"no hook." << endl;
newpar = this;
do {
#ifndef NEW_INSETS
- newpar = newpar->FirstPhysicalPar()->Previous();
+ newpar = newpar->FirstPhysicalPar()->previous();
#else
- newpar = newpar->Previous();
+ newpar = newpar->previous();
#endif
} while (newpar && newpar->GetDepth() > deth
#ifndef NEW_INSETS
);
if (!newpar) {
- if (Previous() || GetDepth())
+ if (previous() || GetDepth())
lyxerr << "ERROR (LyXParagraph::DepthHook): "
"no hook." << endl;
newpar = this;
#ifndef NEW_INSETS
// Think about footnotes.
if (footnoteflag == LyXParagraph::NO_FOOTNOTE
- && next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
+ && next_ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
int const further =
NextAfterFootnote()->GetPositionOfInset(inset);
if (further != -1)
}
if (!params.spacing().isDefault()
- && (!Previous() || !Previous()->HasSameLayout(this))) {
+ && (!previous() || !previous()->HasSameLayout(this))) {
os << params.spacing().writeEnvirBegin() << "\n";
texrow.newline();
}
Language const * language = getParLanguage(bparams);
Language const * doc_language = bparams.language;
- Language const * previous_language = previous
- ? previous->getParLanguage(bparams) : doc_language;
+ Language const * previous_language = previous_
+ ? previous_->getParLanguage(bparams) : doc_language;
if (language->babel() != doc_language->babel() &&
language->babel() != previous_language->babel()) {
os << subst(lyxrc.language_command_begin, "$$lang",
bool need_par = SimpleTeXOnePar(buf, bparams, os, texrow, moving_arg);
- LyXParagraph * par = next;
+ LyXParagraph * par = next_;
#ifndef NEW_INSETS
// Spit out footnotes
if (lyxrc.rtl_support) {
- if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE
- && next->footnoteflag != footnoteflag) {
+ if (next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE
+ && next_->footnoteflag != footnoteflag) {
LyXParagraph * p = 0;
bool is_rtl = (size() > 0)
? GetFontSettings(bparams,
? par->GetFontSettings(bparams,
par->size()-1).isRightToLeft()
: language->RightToLeft();
- if (par->next &&
- par->next->footnoteflag != LyXParagraph::NO_FOOTNOTE &&
+ if (par->next_ &&
+ par->next_->footnoteflag != LyXParagraph::NO_FOOTNOTE &&
(p = par->NextAfterFootnote()) != 0 &&
p->size() > 0 &&
p->GetFontSettings(bparams, 0).isRightToLeft() != is_rtl)
is_rtl = language->RightToLeft();
- par = par->next;
+ par = par->next_;
}
}
} else {
foot, foot_texrow, foot_count,
false);
par->SimpleTeXOnePar(buf, bparams, os, texrow, moving_arg);
- par = par->next;
+ par = par->next_;
}
}
#endif
// Is this really needed ? (Dekel)
// We do not need to use to change the font for the last paragraph
// or for a command.
+#ifndef NEW_INSETS
LyXFont font = getFont(bparams, Last() - 1);
+#else
+ LyXFont font = getFont(bparams, size() - 1);
+#endif
bool is_command = textclasslist.Style(bparams.textclass,
GetLayout()).isCommand();
- if (style.resfont.size() != font.size() && next && !is_command) {
+ if (style.resfont.size() != font.size() && next_ && !is_command) {
if (!need_par)
os << "{";
os << "\\" << font.latexSize() << " \\par}";
if (par
&& (par->layout != layout
|| par->params.depth() != params.depth()
- || par->params.pextraType() != params.pextraType()))
+#ifndef NO_PEXTRA
+ || par->params.pextraType() != params.pextraType()
+#endif
+ ))
break;
default:
// we don't need it for the last paragraph!!!
// or for tables in floats
// -- effectively creates a \par where there isn't one which
// breaks a \subfigure or \subtable.
- if (next) {
+ if (next_) {
// && footnoteflag == LyXParagraph::NO_FOOTNOTE) {
os << '\n';
texrow.newline();
further_blank_line = false;
if (params.lineBottom()) {
- os << "\\lyxline{\\" << getFont(bparams, Last() - 1).latexSize() << '}';
+#ifndef NEW_INSETS
+ os << "\\lyxline{\\" << getFont(bparams,
+ Last() - 1).latexSize() << '}';
+#else
+ os << "\\lyxline{\\" << getFont(bparams,
+ size() - 1).latexSize() << '}';
+#endif
further_blank_line = true;
}
}
// we don't need it for the last paragraph!!!
- if (next
+ if (next_
#ifndef NEW_INSETS
&& !(footnoteflag != LyXParagraph::NO_FOOTNOTE && par &&
par->footnoteflag == LyXParagraph::NO_FOOTNOTE)
if (style.isCommand()) {
os << '{';
++column;
- } else if (params.align() != LYX_ALIGN_LAYOUT && next) {
+ } else if (params.align() != LYX_ALIGN_LAYOUT && next_) {
// We do not need \par here (Dekel)
// os << "{\\par";
os << "{";
#ifndef NEW_INSETS
LyXParagraph * p = 0;
if (i == 0
- && previous &&
- previous->footnoteflag != LyXParagraph::NO_FOOTNOTE &&
+ && previous_ &&
+ previous_->footnoteflag != LyXParagraph::NO_FOOTNOTE &&
(p = PreviousBeforeFootnote()) != 0)
last_font = p->getFont(bparams, p->size() - 1);
else
// If we have an open font definition, we have to close it
if (open_font) {
LyXParagraph * p = 0;
- if (next
+ if (next_
#ifndef NEW_INSETS
- && next->footnoteflag != LyXParagraph::NO_FOOTNOTE
+ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE
&& (p = NextAfterFootnote()) != 0
#else
- && (p = next)
+ && (p = next_)
#endif
)
running_font.latexWriteEndChanges(os, basefont,
#endif
if (textclasslist.Style(bparams.textclass,
par->layout).isEnvironment()
- || par->params.pextraType() != PEXTRA_NONE) {
+#ifndef NO_PEXTRA
+ || par->params.pextraType() != PEXTRA_NONE
+#endif
+ ) {
par = par->TeXEnvironment(buf, bparams,
os, texrow
#ifndef NEW_INSETS
#endif
)
{
+#ifndef NO_PEXTRA
bool eindent_open = false;
+#endif
#ifndef NEW_INSETS
bool foot_this_level = false;
#endif
+#ifndef NO_PEXTRA
// flags when footnotetext should be appended to file.
static bool minipage_open = false;
static int minipage_open_depth = 0;
char par_sep = bparams.paragraph_separation;
+#endif
lyxerr[Debug::LATEX] << "TeXEnvironment... " << this << endl;
#ifndef NEW_INSETS
LyXLayout const & style =
textclasslist.Style(bparams.textclass,
layout);
-
+
+#ifndef NO_PEXTRA
if (params.pextraType() == PEXTRA_INDENT) {
if (!params.pextraWidth().empty()) {
os << "\\begin{LyXParagraphIndent}{"
eindent_open = true;
}
if ((params.pextraType() == PEXTRA_MINIPAGE) && !minipage_open) {
- if (params.pextraHfill() && Previous() &&
- (Previous()->params.pextraType() == PEXTRA_MINIPAGE)) {
+ if (params.pextraHfill() && previous() &&
+ (previous()->params.pextraType() == PEXTRA_MINIPAGE)) {
os << "\\hfill{}\n";
texrow.newline();
}
minipage_open = true;
minipage_open_depth = params.depth();
}
-
+#endif
#ifdef WITH_WARNINGS
#warning Define FANCY_FOOTNOTE_CODE to re-enable Allan footnote code
//I disabled it because it breaks when lists span on several
foot, foot_texrow, foot_count
#endif
);
-
+#ifndef NO_PEXTRA
if (minipage_open && par && !style.isEnvironment() &&
(par->params.pextraType() == PEXTRA_MINIPAGE) &&
par->params.pextraStartMinipage()) {
}
minipage_open = false;
}
+#endif
if (par && par->params.depth() > params.depth()) {
if (textclasslist.Style(bparams.textclass,
par->layout).isParagraph()
#endif
);
}
+#ifndef NO_PEXTRA
if (par && par->layout == layout && par->params.depth() == params.depth() &&
(par->params.pextraType() == PEXTRA_MINIPAGE) && !minipage_open) {
- if (par->params.pextraHfill() && par->Previous() &&
- (par->Previous()->params.pextraType() == PEXTRA_MINIPAGE)){
+ if (par->params.pextraHfill() && par->previous() &&
+ (par->previous()->params.pextraType() == PEXTRA_MINIPAGE)){
os << "\\hfill{}\n";
texrow.newline();
}
minipage_open = true;
minipage_open_depth = par->params.depth();
}
+#endif
} while (par
&& par->layout == layout
&& par->params.depth() == params.depth()
+#ifndef NO_PEXTRA
&& par->params.pextraType() == params.pextraType()
+#endif
#ifndef NEW_INSETS
&& par->footnoteflag == footnoteflag
#endif
);
if (style.isEnvironment()) {
- os << "\\end{" << style.latexname() << '}';
+ os << "\\end{" << style.latexname() << "}\n";
+
#ifndef NEW_INSETS
// maybe this should go after the minipage closes?
if (foot_this_level) {
}
#endif
}
+#ifndef NO_PEXTRA
if (minipage_open && (minipage_open_depth == params.depth()) &&
(!par || par->params.pextraStartMinipage() ||
par->params.pextraType() != PEXTRA_MINIPAGE)) {
os << '\n';
texrow.newline();
}
+#endif
lyxerr[Debug::LATEX] << "TeXEnvironment...done " << par << endl;
return par; // ale970302
}
LyXParagraph * par = this;
LyXLayout const & style =
textclasslist.Style(bparams.textclass,
- previous->GetLayout());
+ previous_->GetLayout());
if (style.needprotect && footnotekind != LyXParagraph::FOOTNOTE){
lyxerr << "ERROR (LyXParagraph::TeXFootnote): "
texrow.newline();
}
- lyxerr[Debug::LATEX] << "TeXFootnote...done " << par->next << endl;
+ lyxerr[Debug::LATEX] << "TeXFootnote...done " << par->next_ << endl;
return par;
}
bool LyXParagraph::IsDummy() const
{
- return (footnoteflag == LyXParagraph::NO_FOOTNOTE && previous
- && previous->footnoteflag != LyXParagraph::NO_FOOTNOTE);
+ return (footnoteflag == LyXParagraph::NO_FOOTNOTE && previous_
+ && previous_->footnoteflag != LyXParagraph::NO_FOOTNOTE);
}
#endif
+#ifndef NO_PEXTRA
void LyXParagraph::SetPExtraType(BufferParams const & bparams,
int type, string const & width,
string const & widthp)
while (par && (par->layout == layout)
&& (par->params.depth() == params.depth())) {
ppar = par;
- par = par->Previous();
+ par = par->previous();
#ifndef NEW_INSETS
if (par)
par = par->FirstPhysicalPar();
#endif
while (par && par->params.depth() > params.depth()) {
- par = par->Previous();
+ par = par->previous();
#ifndef NEW_INSETS
if (par)
par = par->FirstPhysicalPar();
#ifndef NEW_INSETS
par = par->NextAfterFootnote();
#else
- par = par->Next();
+ par = par->next();
#endif
if (par && (par->params.depth() > params.depth()))
par->SetPExtraType(bparams,
par = par->NextAfterFootnote();
#else
while (par && par->params.depth() > params.depth())
- par = par->Next();
+ par = par->next();
#endif
}
}
while (par && (par->layout == layout)
&& (par->params.depth() == params.depth())) {
ppar = par;
- par = par->Previous();
+ par = par->previous();
#ifndef NEW_INSETS
if (par)
par = par->FirstPhysicalPar();
#endif
while (par && par->params.depth() > params.depth()) {
- par = par->Previous();
+ par = par->previous();
#ifndef NEW_INSETS
if (par)
par = par->FirstPhysicalPar();
#ifndef NEW_INSETS
par = par->NextAfterFootnote();
#else
- par = par->Next();
+ par = par->next();
#endif
if (par && (par->params.depth() > params.depth()))
par->UnsetPExtraType(bparams);
par = par->NextAfterFootnote();
#else
while (par && par->params.depth() > params.depth())
- par = par->Next();
+ par = par->next();
#endif
}
}
}
+#endif
bool LyXParagraph::IsHfill(size_type pos) const
#endif
if (size() > 0)
return GetFirstFontSettings().language();
- else if (previous)
- return previous->getParLanguage(bparams);
+ else if (previous_)
+ return previous_->getParLanguage(bparams);
else
return bparams.language;
}
}
#ifndef NEW_INSETS
- if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE
+ if (next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE
&& footnoteflag == LyXParagraph::NO_FOOTNOTE)
s += NextAfterFootnote()->String(buffer, false);
projects / lyx.git / blobdiff