#include "paragraph.h"
#include "paragraph_pimpl.h"
-#include "lyxrc.h"
-#include "layout.h"
-#include "language.h"
+
#include "buffer.h"
#include "bufferparams.h"
-#include "debug.h"
-#include "texrow.h"
#include "BufferView.h"
+#include "changes.h"
#include "encoding.h"
-#include "ParameterStruct.h"
+#include "debug.h"
#include "gettext.h"
-#include "changes.h"
+#include "language.h"
+#include "latexrunparams.h"
+#include "layout.h"
+#include "lyxrc.h"
+#include "paragraph_funcs.h"
+#include "ParameterStruct.h"
+#include "texrow.h"
+
+#include "Lsstream.h"
#include "insets/insetbibitem.h"
#include "insets/insetoptarg.h"
+#include "insets/insetenv.h"
#include "support/filetools.h"
#include "support/lstrings.h"
#ifndef NO_NEXT
next_ = 0;
previous_ = 0;
+#else
+ next_par_ = 0;
+ prev_par_ = 0;
#endif
enumdepth = 0;
itemdepth = 0;
}
-#ifndef NO_NEXT
-// This constructor inserts the new paragraph in a list.
-// It is placed after par.
-Paragraph::Paragraph(Paragraph * par)
- : pimpl_(new Paragraph::Pimpl(this))
-{
- enumdepth = 0;
- itemdepth = 0;
-
- // double linked list begin
- next_ = par->next_;
- if (next_)
- next_->previous_ = this;
- previous_ = par;
- previous_->next_ = this;
- // end
-
- params().clear();
-}
-#endif
-
-
Paragraph::Paragraph(Paragraph const & lp, bool same_ids)
: pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this, same_ids))
{
#ifndef NO_NEXT
next_ = 0;
previous_ = 0;
+#else
+ next_par_ = 0;
+ prev_par_ = 0;
#endif
// this is because of the dummy layout of the paragraphs that
// follow footnotes
}
}
break;
- case META_NEWLINE:
- os << "\n\\newline \n";
- column = 0;
- break;
case '\\':
os << "\n\\backslash \n";
column = 0;
}
-void Paragraph::erase(pos_type pos)
+bool Paragraph::erase(pos_type pos)
{
- pimpl_->erase(pos);
+ return pimpl_->erase(pos);
}
-bool Paragraph::erase(pos_type start, pos_type end)
+int Paragraph::erase(pos_type start, pos_type end)
{
return pimpl_->erase(start, end);
}
// The difference is that this one is used for generating the LaTeX file,
// and thus cosmetic "improvements" are disallowed: This has to deliver
// the true picture of the buffer. (Asger)
-// If position is -1, we get the layout font of the paragraph.
-// If position is -2, we get the font of the manual label of the paragraph.
-LyXFont const Paragraph::getFont(BufferParams const & bparams,
- pos_type pos) const
+LyXFont const Paragraph::getFont(BufferParams const & bparams, pos_type pos,
+ LyXFont const & outerfont) const
{
lyx::Assert(pos >= 0);
LyXFont tmpfont = getFontSettings(bparams, pos);
tmpfont.realize(layoutfont);
+ tmpfont.realize(outerfont);
- return pimpl_->realizeFont(tmpfont, bparams);
+ return realizeFont(tmpfont, bparams);
}
-LyXFont const Paragraph::getLabelFont(BufferParams const & bparams) const
+LyXFont const Paragraph::getLabelFont(BufferParams const & bparams,
+ LyXFont const & outerfont) const
{
LyXLayout_ptr const & lout = layout();
LyXFont tmpfont = lout->labelfont;
tmpfont.setLanguage(getParLanguage(bparams));
+ tmpfont.realize(outerfont);
- return pimpl_->realizeFont(tmpfont, bparams);
+ return realizeFont(tmpfont, bparams);
}
-LyXFont const Paragraph::getLayoutFont(BufferParams const & bparams) const
+LyXFont const Paragraph::getLayoutFont(BufferParams const & bparams,
+ LyXFont const & outerfont) const
{
LyXLayout_ptr const & lout = layout();
LyXFont tmpfont = lout->font;
tmpfont.setLanguage(getParLanguage(bparams));
+ tmpfont.realize(outerfont);
- return pimpl_->realizeFont(tmpfont, bparams);
+ return realizeFont(tmpfont, bparams);
}
#endif
-void Paragraph::makeSameLayout(Paragraph const * par)
+void Paragraph::makeSameLayout(Paragraph const & par)
{
- layout(par->layout());
+ layout(par.layout());
// move to pimpl?
- params() = par->params();
+ params() = par.params();
}
}
-bool Paragraph::hasSameLayout(Paragraph const * par) const
+bool Paragraph::hasSameLayout(Paragraph const & par) const
{
return
- par->layout() == layout() &&
- params().sameLayout(par->params());
-}
-
-
-int Paragraph::getEndLabel() const
-{
- Paragraph const * par = this;
- depth_type par_depth = getDepth();
- while (par) {
- LyXLayout_ptr const & layout = par->layout();
- int const endlabeltype = layout->endlabeltype;
-
- if (endlabeltype != END_LABEL_NO_LABEL) {
- if (!next_)
- return endlabeltype;
-
- depth_type const next_depth = next_->getDepth();
- if (par_depth > next_depth ||
- (par_depth == next_depth
- && layout != next_->layout()))
- return endlabeltype;
- break;
- }
- if (par_depth == 0)
- break;
- par = par->outerHook();
- if (par)
- par_depth = par->getDepth();
- }
- return END_LABEL_NO_LABEL;
+ par.layout() == layout() &&
+ params().sameLayout(par.params());
}
// and remember the previous character to
// remove unnecessary GetChar() calls
pos_type i = 0;
- if (i < size() && getChar(i) != Paragraph::META_NEWLINE) {
+ if (i < size() && !isNewline(i)) {
++i;
char previous_char = 0;
char temp = 0;
- if (i < size()
- && (previous_char = getChar(i)) != Paragraph::META_NEWLINE) {
- // Yes, this ^ is supposed to be "= " not "=="
- ++i;
- while (i < size()
- && previous_char != ' '
- && (temp = getChar(i)) != Paragraph::META_NEWLINE) {
+ if (i < size()) {
+ previous_char = getChar(i);
+ if (!isNewline(i)) {
++i;
- previous_char = temp;
+ while (i < size() && previous_char != ' ') {
+ temp = getChar(i);
+ if (isNewline(i))
+ break;
+
+ ++i;
+ previous_char = temp;
+ }
}
}
}
}
-Paragraph * Paragraph::depthHook(depth_type depth)
-{
- Paragraph * newpar = this;
-
- do {
- newpar = newpar->previous();
- } while (newpar && newpar->getDepth() > depth);
-
- if (!newpar) {
- if (previous() || getDepth())
- lyxerr << "ERROR (Paragraph::DepthHook): "
- "no hook." << endl;
- newpar = this;
- }
-
- return newpar;
-}
-
-
-Paragraph const * Paragraph::depthHook(depth_type depth) const
-{
- Paragraph const * newpar = this;
-
- do {
- newpar = newpar->previous();
- } while (newpar && newpar->getDepth() > depth);
-
- if (!newpar) {
- if (previous() || getDepth())
- lyxerr << "ERROR (Paragraph::DepthHook): "
- "no hook." << endl;
- newpar = this;
- }
-
- return newpar;
-}
-
-
-Paragraph * Paragraph::outerHook()
-{
- if (!getDepth())
- return 0;
- return depthHook(depth_type(getDepth() - 1));
-}
-
-
-Paragraph const * Paragraph::outerHook() const
-{
- if (!getDepth())
- return 0;
- return depthHook(depth_type(getDepth() - 1));
-}
-
-
// returns -1 if inset not found
int Paragraph::getPositionOfInset(Inset const * inset) const
{
// This one spits out the text of the paragraph
bool Paragraph::simpleTeXOnePar(Buffer const * buf,
BufferParams const & bparams,
+ LyXFont const & outerfont,
ostream & os, TexRow & texrow,
+ LatexRunParams const & runparams,
bool moving_arg)
{
lyxerr[Debug::LATEX] << "SimpleTeXOnePar... " << this << endl;
if (body_pos > 0) {
os << '[';
++column;
- basefont = getLabelFont(bparams);
+ basefont = getLabelFont(bparams, outerfont);
} else {
- basefont = getLayoutFont(bparams);
+ basefont = getLayoutFont(bparams, outerfont);
}
moving_arg |= style->needprotect;
Change::Type running_change = Change::UNCHANGED;
- texrow.start(this, 0);
+ texrow.start(id(), 0);
// if the paragraph is empty, the loop will not be entered at all
if (empty()) {
column += running_font.latexWriteEndChanges(os, basefont, basefont);
open_font = false;
}
- basefont = getLayoutFont(bparams);
+ basefont = getLayoutFont(bparams, outerfont);
running_font = basefont;
os << ']';
++column;
value_type c = getChar(i);
// Fully instantiated font
- LyXFont font = getFont(bparams, i);
+ LyXFont font = getFont(bparams, i, outerfont);
LyXFont const last_font = running_font;
// outside font change, i.e. we write "\textXX{text} "
// rather than "\textXX{text }". (Asger)
if (open_font && c == ' ' && i <= size() - 2) {
- LyXFont const & next_font = getFont(bparams, i + 1);
+ LyXFont const & next_font = getFont(bparams, i + 1, outerfont);
if (next_font != running_font
&& next_font != font) {
font = next_font;
column += Changes::latexMarkChange(os, running_change, change);
running_change = change;
- if (c == Paragraph::META_NEWLINE) {
- // newlines are handled differently here than
- // the default in SimpleTeXSpecialChars().
- if (!style->newline_allowed) {
- os << '\n';
- } else {
- if (open_font) {
- column += running_font.latexWriteEndChanges(os, basefont, basefont);
- open_font = false;
- }
- basefont = getLayoutFont(bparams);
- running_font = basefont;
- if (font.family() ==
- LyXFont::TYPEWRITER_FAMILY) {
- os << '~';
- }
- if (moving_arg)
- os << "\\protect ";
-
- os << "\\\\\n";
- }
- texrow.newline();
- texrow.start(this, i + 1);
- column = 0;
- } else {
- pimpl_->simpleTeXSpecialChars(buf, bparams,
- os, texrow, moving_arg,
- font, running_font,
- basefont, open_font,
- running_change,
- *style, i, column, c);
- }
+ LatexRunParams rp = runparams;
+ rp.fragile = moving_arg;
+ pimpl_->simpleTeXSpecialChars(buf, bparams,
+ os, texrow, runparams,
+ font, running_font,
+ basefont, outerfont, open_font,
+ running_change,
+ *style, i, column, c);
}
column += Changes::latexMarkChange(os,
running_font
.latexWriteEndChanges(os, basefont,
next_->getFont(bparams,
- 0));
+ 0, outerfont));
} else {
running_font.latexWriteEndChanges(os, basefont,
basefont);
bool Paragraph::isHfill(pos_type pos) const
{
return IsInsetChar(getChar(pos))
- && getInset(pos)->lyxCode() == Inset::HFILL_CODE;
+ && getInset(pos)->lyxCode() == Inset::HFILL_CODE;
}
bool Paragraph::isNewline(pos_type pos) const
{
- return pos >= 0 && IsNewlineChar(getChar(pos));
+ return IsInsetChar(getChar(pos))
+ && getInset(pos)->lyxCode() == Inset::NEWLINE_CODE;
}
{
if (!empty()) {
return getFirstFontSettings().language();
- } else if (previous_)
+#warning FIXME we should check the prev par as well (Lgb)
+#if 0
+ } else if (previous_) {
return previous_->getParLanguage(bparams);
- else
+#endif
+ }else
return bparams.language;
}
void Paragraph::changeLanguage(BufferParams const & bparams,
- Language const * from, Language const * to)
+ Language const * from, Language const * to)
{
for (pos_type i = 0; i < size(); ++i) {
LyXFont font = getFontSettings(bparams, i);
value_type const c = getUChar(buffer->params, i);
if (IsPrintable(c))
os << c;
- else if (c == META_NEWLINE)
- os << '\n';
- else if (c == META_INSET)
+ else if (c == META_INSET)
getInset(i)->ascii(buffer, os);
}
pimpl_->inset_owner = i;
InsetList::iterator it = insetlist.begin();
InsetList::iterator end = insetlist.end();
- for (; it != end; ++it)
+ for (; it != end; ++it)
if (it.getInset())
it.getInset()->setOwner(i);
}
}
-void Paragraph::setContentsFromPar(Paragraph * par)
+void Paragraph::setContentsFromPar(Paragraph const & par)
{
pimpl_->setContentsFromPar(par);
}
LyXLayout_ptr const & Paragraph::layout() const
{
+ Inset * inset = inInset();
+ if (inset && inset->lyxCode() == Inset::ENVIRONMENT_CODE)
+ return static_cast<InsetEnvironment*>(inset)->layout();
return layout_;
}
}
-bool Paragraph::isFirstInSequence() const
-{
- Paragraph const * dhook = depthHook(getDepth());
- return (dhook == this
- || dhook->layout() != layout()
- || dhook->getDepth() != getDepth());
-}
-
-
Inset * Paragraph::inInset() const
{
return pimpl_->inset_owner;
projects / lyx.git / blobdiff