#include <boost/tuple/tuple.hpp>
#include <boost/bind.hpp>
+#include <algorithm>
#include <list>
#include <stack>
#include <sstream>
using std::ostringstream;
-ParagraphList::ParagraphList()
-{}
-
-
Paragraph::Paragraph()
: begin_of_body_(0), pimpl_(new Paragraph::Pimpl(this))
{
Paragraph::Paragraph(Paragraph const & par)
: itemdepth(par.itemdepth), insetlist(par.insetlist),
dim_(par.dim_),
- rows_(par.rows_), layout_(par.layout_),
+ rows_(par.rows_), rowSignature_(par.rowSignature_),
+ layout_(par.layout_),
text_(par.text_), begin_of_body_(par.begin_of_body_),
pimpl_(new Paragraph::Pimpl(*par.pimpl_, this))
{
rows_ = par.rows_;
dim_ = par.dim_;
+ rowSignature_ = par.rowSignature_;
layout_ = par.layout();
text_ = par.text_;
begin_of_body_ = par.begin_of_body_;
lyx::time_type const curtime(lyx::current_time());
int column = 0;
- for (pos_type i = 0; i < size(); ++i) {
+ for (pos_type i = 0; i <= size(); ++i) {
- Change change = pimpl_->lookupChangeFull(i);
+ Change change = pimpl_->lookupChange(i);
Changes::lyxMarkChange(os, column, curtime, running_change, change);
running_change = change;
+ if (i == size())
+ break;
+
// Write font changes
LyXFont font2 = getFontSettings(bparams, i);
if (font2 != font1) {
}
}
- // to make reading work properly
- if (!size()) {
- running_change = pimpl_->lookupChange(0);
- Changes::lyxMarkChange(os, column, curtime,
- Change(Change::UNCHANGED), running_change);
- }
- Changes::lyxMarkChange(os, column, curtime,
- running_change, Change(Change::UNCHANGED));
-
os << "\n\\end_layout\n";
}
void Paragraph::insert(pos_type start, string const & str,
LyXFont const & font)
{
- int size = str.size();
- for (int i = 0 ; i < size ; ++i)
+ for (size_t i = 0, n = str.size(); i != n ; ++i)
insertChar(start + i, str[i], font);
}
-bool Paragraph::checkInsertChar(LyXFont &)
-{
- return true;
-}
-
-
void Paragraph::insertChar(pos_type pos, Paragraph::value_type c,
Change change)
{
}
-InsetBase * Paragraph::getInset(pos_type pos)
-{
- BOOST_ASSERT(pos < size());
- return insetlist.get(pos);
-}
-
-
-InsetBase const * Paragraph::getInset(pos_type pos) const
-{
- BOOST_ASSERT(pos < size());
- return insetlist.get(pos);
-}
-
-
// Gets uninstantiated font setting at position.
LyXFont const Paragraph::getFontSettings(BufferParams const & bparams,
pos_type pos) const
}
-lyx::pos_type Paragraph::getEndPosOfFontSpan(lyx::pos_type pos) const
+FontSpan Paragraph::fontSpan(lyx::pos_type pos) const
{
BOOST_ASSERT(pos <= size());
+ lyx::pos_type start = 0;
Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
- for (; cit != end; ++cit)
- if (cit->pos() >= pos)
- return cit->pos();
+ for (; cit != end; ++cit) {
+ if (cit->pos() >= pos) {
+ if (pos >= beginOfBody())
+ return FontSpan(std::max(start, beginOfBody()),
+ cit->pos());
+ else
+ return FontSpan(start,
+ std::min(beginOfBody() - 1,
+ cit->pos()));
+ }
+ start = cit->pos() + 1;
+ }
// This should not happen, but if so, we take no chances.
//lyxerr << "Paragraph::getEndPosOfFontSpan: This should not happen!"
// << endl;
- return pos;
+ return FontSpan(pos, pos);
}
// Gets uninstantiated font setting at position 0
-LyXFont const Paragraph::getFirstFontSettings() const
+LyXFont const Paragraph::getFirstFontSettings(BufferParams const & bparams) const
{
if (!empty() && !pimpl_->fontlist.empty())
return pimpl_->fontlist[0].font();
- return LyXFont(LyXFont::ALL_INHERIT);
+ return LyXFont(LyXFont::ALL_INHERIT, bparams.language);
}
LyXFont font = getFontSettings(bparams, pos);
font.realize(layoutfont);
font.realize(outerfont);
- font.realize(bparams.getLyXTextClass().defaultfont());
+ font.realize(bparams.getFont());
return font;
}
LyXFont tmpfont = layout()->labelfont;
tmpfont.setLanguage(getParLanguage(bparams));
tmpfont.realize(outerfont);
- tmpfont.realize(bparams.getLyXTextClass().defaultfont());
+ tmpfont.realize(bparams.getFont());
return tmpfont;
}
LyXFont tmpfont = layout()->font;
tmpfont.setLanguage(getParLanguage(bparams));
tmpfont.realize(outerfont);
- tmpfont.realize(bparams.getLyXTextClass().defaultfont());
+ tmpfont.realize(bparams.getFont());
return tmpfont;
}
if (it->pos() >= pos)
break;
}
- unsigned int i = distance(beg, it);
+ size_t const i = distance(beg, it);
bool notfound = (it == endit);
if (!notfound && pimpl_->fontlist[i].font() == font)
return 0;
int i = 0;
- while (!empty() && (isNewline(0) || isLineSeparator(0))) {
- // Set Change::Type to Change::INSERTED to quietly remove it
- setChange(0, Change::INSERTED);
+ while (!empty() && (isNewline(0) || isLineSeparator(0))
+ && (lookupChange(0).type != Change::DELETED)) {
erase(0);
++i;
}
{
if (!insetlist.empty()) {
InsetBase * inset = insetlist.begin()->inset;
- if (inset->lyxCode() == InsetBase::BIBTEX_CODE)
+ if (inset->lyxCode() == InsetBase::BIBITEM_CODE)
return static_cast<InsetBibitem *>(inset);
}
return 0;
bool Paragraph::forceDefaultParagraphs() const
{
- return inInset() && inInset()->forceDefaultParagraphs(inInset());
+ return inInset() && inInset()->forceDefaultParagraphs(0);
}
LyXFont basefont;
- LaTeXFeatures features(buf, bparams, runparams.nice);
+ LaTeXFeatures features(buf, bparams, runparams);
// output change tracking marks only if desired,
// if dvipost is installed,
open_font = true;
}
- Change::Type change = pimpl_->lookupChange(i);
+ Change::Type change = pimpl_->lookupChange(i).type;
column += Changes::latexMarkChange(os, running_change,
change, output);
if (output || running_change != Change::DELETED) {
OutputParams rp = runparams;
rp.free_spacing = style->free_spacing;
- rp.local_language = font.language()->babel();
+ rp.local_font = &font;
rp.intitle = style->intitle;
pimpl_->simpleTeXSpecialChars(buf, bparams,
os, texrow, rp,
}
-namespace {
-
-/// return true if the char is a meta-character for an inset
-inline
-bool IsInsetChar(char c)
-{
- return (c == Paragraph::META_INSET);
-}
-
-} // namespace anon
-
-
-
-bool Paragraph::isHfill(pos_type pos) const
-{
- return isInset(pos)
- && getInset(pos)->lyxCode() == InsetBase::HFILL_CODE;
-}
-
-
bool Paragraph::isNewline(pos_type pos) const
{
return isInset(pos)
}
-bool Paragraph::isSeparator(pos_type pos) const
-{
- return IsSeparatorChar(getChar(pos));
-}
-
-
bool Paragraph::isLineSeparator(pos_type pos) const
{
value_type const c = getChar(pos);
- return IsLineSeparatorChar(c)
- || (IsInsetChar(c) && getInset(pos) &&
+ return isLineSeparatorChar(c)
+ || (c == Paragraph::META_INSET && getInset(pos) &&
getInset(pos)->isLineSeparator());
}
return getInset(pos)->isLetter();
else {
value_type const c = getChar(pos);
- return IsLetterChar(c) || IsDigit(c);
+ return isLetterChar(c) || isDigit(c);
}
}
Paragraph::getParLanguage(BufferParams const & bparams) const
{
if (!empty())
- return getFirstFontSettings().language();
+ return getFirstFontSettings(bparams).language();
#ifdef WITH_WARNINGS
#warning FIXME we should check the prev par as well (Lgb)
#endif
bool Paragraph::isRightToLeftPar(BufferParams const & bparams) const
{
return lyxrc.rtl_support
- && getParLanguage(bparams)->RightToLeft()
+ && getParLanguage(bparams)->rightToLeft()
&& ownerCode() != InsetBase::ERT_CODE;
}
for (pos_type i = 0; i < size(); ++i) {
value_type c = getChar(i);
- if (IsPrintable(c))
+ if (isPrintable(c))
s += c;
else if (c == META_INSET &&
getInset(i)->lyxCode() == InsetBase::MATH_CODE) {
for (pos_type i = beg; i < end; ++i) {
value_type const c = getUChar(buffer.params(), i);
- if (IsPrintable(c))
+ if (isPrintable(c))
os << c;
else if (c == META_INSET)
- getInset(i)->plaintext(buffer, os, runparams);
+ getInset(i)->textString(buffer, os, runparams);
}
return os.str();
}
-void Paragraph::setInsetOwner(UpdatableInset * inset)
+void Paragraph::setInsetOwner(InsetBase * inset)
{
pimpl_->inset_owner = inset;
}
}
-void Paragraph::cleanChanges()
+void Paragraph::cleanChanges(ChangeTracking ct)
{
- pimpl_->cleanChanges();
+ pimpl_->cleanChanges(ct);
}
-Change::Type Paragraph::lookupChange(lyx::pos_type pos) const
+Change const Paragraph::lookupChange(lyx::pos_type pos) const
{
- BOOST_ASSERT(empty() || pos < size());
+ BOOST_ASSERT(pos <= size());
return pimpl_->lookupChange(pos);
}
-Change const Paragraph::lookupChangeFull(lyx::pos_type pos) const
-{
- BOOST_ASSERT(empty() || pos < size());
- return pimpl_->lookupChangeFull(pos);
-}
-
-
bool Paragraph::isChanged(pos_type start, pos_type end) const
{
return pimpl_->isChanged(start, end);
}
-void Paragraph::setChange(lyx::pos_type pos, Change::Type type)
+void Paragraph::setChangeType(lyx::pos_type pos, Change::Type type)
{
- pimpl_->setChange(pos, type);
+ pimpl_->setChangeType(pos, type);
}
-void Paragraph::markErased()
+void Paragraph::setChange(lyx::pos_type pos, Change change)
{
- pimpl_->markErased();
+ pimpl_->setChange(pos, change);
+}
+
+
+void Paragraph::markErased(bool erased)
+{
+ pimpl_->markErased(erased);
}
}
-UpdatableInset * Paragraph::inInset() const
+InsetBase * Paragraph::inInset() const
{
return pimpl_->inset_owner;
}
}
-Row & Paragraph::getRow(pos_type pos)
+Row & Paragraph::getRow(pos_type pos, bool boundary)
{
BOOST_ASSERT(!rows().empty());
+ // If boundary is set we should return the row on which
+ // the character before is inside.
+ if (pos > 0 && boundary)
+ --pos;
+
RowList::iterator rit = rows_.end();
RowList::iterator const begin = rows_.begin();
}
-Row const & Paragraph::getRow(pos_type pos) const
+Row const & Paragraph::getRow(pos_type pos, bool boundary) const
{
BOOST_ASSERT(!rows().empty());
+ // If boundary is set we should return the row on which
+ // the character before is inside.
+ if (pos > 0 && boundary)
+ --pos;
+
RowList::const_iterator rit = rows_.end();
RowList::const_iterator const begin = rows_.begin();
unsigned char Paragraph::transformChar(unsigned char c, pos_type pos) const
{
if (!Encodings::is_arabic(c))
- if (lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 && IsDigit(c))
+ if (lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 && isDigit(c))
return c + (0xb0 - '0');
else
return c;
- unsigned char const prev_char = pos > 0 ? getChar(pos - 1) : ' ';
- unsigned char next_char = ' ';
+ value_type const prev_char = pos > 0 ? getChar(pos - 1) : ' ';
+ value_type next_char = ' ';
for (pos_type i = pos + 1, end = size(); i < end; ++i) {
- unsigned char const par_char = getChar(i);
- if (!Encodings::IsComposeChar_arabic(par_char)) {
+ value_type const par_char = getChar(i);
+ if (!Encodings::isComposeChar_arabic(par_char)) {
next_char = par_char;
break;
}
if (Encodings::is_arabic(next_char)) {
if (Encodings::is_arabic(prev_char) &&
!Encodings::is_arabic_special(prev_char))
- return Encodings::TransformChar(c, Encodings::FORM_MEDIAL);
+ return Encodings::transformChar(c, Encodings::FORM_MEDIAL);
else
- return Encodings::TransformChar(c, Encodings::FORM_INITIAL);
+ return Encodings::transformChar(c, Encodings::FORM_INITIAL);
} else {
if (Encodings::is_arabic(prev_char) &&
!Encodings::is_arabic_special(prev_char))
- return Encodings::TransformChar(c, Encodings::FORM_FINAL);
+ return Encodings::transformChar(c, Encodings::FORM_FINAL);
else
- return Encodings::TransformChar(c, Encodings::FORM_ISOLATED);
+ return Encodings::transformChar(c, Encodings::FORM_ISOLATED);
}
}
projects / lyx.git / blobdiff