#include "insets/InsetBibitem.h"
#include "insets/InsetLabel.h"
-// needed only for inTableCell()
-#include "insets/InsetText.h"
+#include "support/assert.h"
#include "support/convert.h"
#include "support/debug.h"
#include "support/gettext.h"
bool Paragraph::isChanged(pos_type start, pos_type end) const
{
- BOOST_ASSERT(start >= 0 && start <= size());
- BOOST_ASSERT(end > start && end <= size() + 1);
+ LASSERT(start >= 0 && start <= size(), /**/);
+ LASSERT(end > start && end <= size() + 1, /**/);
return d->changes_.isChanged(start, end);
}
void Paragraph::setChange(pos_type pos, Change const & change)
{
- BOOST_ASSERT(pos >= 0 && pos <= size());
+ LASSERT(pos >= 0 && pos <= size(), /**/);
d->changes_.set(change, pos);
// see comment in setChange(Change const &) above
Change const & Paragraph::lookupChange(pos_type pos) const
{
- BOOST_ASSERT(pos >= 0 && pos <= size());
+ LASSERT(pos >= 0 && pos <= size(), /**/);
return d->changes_.lookup(pos);
}
void Paragraph::acceptChanges(BufferParams const & bparams, pos_type start,
pos_type end)
{
- BOOST_ASSERT(start >= 0 && start <= size());
- BOOST_ASSERT(end > start && end <= size() + 1);
+ LASSERT(start >= 0 && start <= size(), /**/);
+ LASSERT(end > start && end <= size() + 1, /**/);
for (pos_type pos = start; pos < end; ++pos) {
switch (lookupChange(pos).type) {
void Paragraph::rejectChanges(BufferParams const & bparams,
pos_type start, pos_type end)
{
- BOOST_ASSERT(start >= 0 && start <= size());
- BOOST_ASSERT(end > start && end <= size() + 1);
+ LASSERT(start >= 0 && start <= size(), /**/);
+ LASSERT(end > start && end <= size() + 1, /**/);
for (pos_type pos = start; pos < end; ++pos) {
switch (lookupChange(pos).type) {
void Paragraph::Private::insertChar(pos_type pos, char_type c,
Change const & change)
{
- BOOST_ASSERT(pos >= 0 && pos <= int(text_.size()));
+ LASSERT(pos >= 0 && pos <= int(text_.size()), /**/);
// track change
changes_.insert(change, pos);
void Paragraph::insertInset(pos_type pos, Inset * inset,
Change const & change)
{
- BOOST_ASSERT(inset);
- BOOST_ASSERT(pos >= 0 && pos <= size());
+ LASSERT(inset, /**/);
+ LASSERT(pos >= 0 && pos <= size(), /**/);
d->insertChar(pos, META_INSET, change);
- BOOST_ASSERT(d->text_[pos] == META_INSET);
+ LASSERT(d->text_[pos] == META_INSET, /**/);
// Add a new entry in the insetlist_.
d->insetlist_.insert(inset, pos);
bool Paragraph::eraseChar(pos_type pos, bool trackChanges)
{
- BOOST_ASSERT(pos >= 0 && pos <= size());
+ LASSERT(pos >= 0 && pos <= size(), /**/);
// keep the logic here in sync with the logic of isMergedOnEndOfParDeletion()
int Paragraph::eraseChars(pos_type start, pos_type end, bool trackChanges)
{
- BOOST_ASSERT(start >= 0 && start <= size());
- BOOST_ASSERT(end >= start && end <= size() + 1);
+ LASSERT(start >= 0 && start <= size(), /**/);
+ LASSERT(end >= start && end <= size() + 1, /**/);
pos_type i = start;
for (pos_type count = end - start; count; --count) {
unsigned int & column)
{
Inset * inset = owner_->getInset(i);
- BOOST_ASSERT(inset);
+ LASSERT(inset, /**/);
if (style.pass_thru) {
inset->plaintext(os, runparams);
if (c != '\0')
os << to_utf8(docstring(1, c));
else
- lyxerr << "ERROR (Paragraph::writeFile):"
- " NULL char in structure." << endl;
+ LYXERR0("NUL char in structure.");
++column;
break;
}
pos_type pos) const
{
if (pos > size()) {
- lyxerr << " pos: " << pos << " size: " << size() << endl;
- BOOST_ASSERT(pos <= size());
+ LYXERR0("pos: " << pos << " size: " << size());
+ LASSERT(pos <= size(), /**/);
}
FontList::const_iterator cit = d->fontlist_.fontIterator(pos);
FontSpan Paragraph::fontSpan(pos_type pos) const
{
- BOOST_ASSERT(pos <= size());
+ LASSERT(pos <= size(), /**/);
pos_type start = 0;
FontList::const_iterator cit = d->fontlist_.begin();
}
// This should not happen, but if so, we take no chances.
- //lyxerr << "Paragraph::getEndPosOfFontSpan: This should not happen!"
- // << endl;
+ // LYXERR0("Paragraph::getEndPosOfFontSpan: This should not happen!");
return FontSpan(pos, pos);
}
Font const Paragraph::getFont(BufferParams const & bparams, pos_type pos,
Font const & outerfont) const
{
- BOOST_ASSERT(pos >= 0);
+ LASSERT(pos >= 0, /**/);
Font font = getFontSettings(bparams, pos);
}
-char_type
-Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const
+char_type Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const
{
char_type c = d->text_[pos];
if (!lyxrc.rtl_support)
}
if (uc != c && getFontSettings(bparams, pos).isRightToLeft())
return uc;
- else
- return c;
+ return c;
}
void Paragraph::setFont(pos_type pos, Font const & font)
{
- BOOST_ASSERT(pos <= size());
+ LASSERT(pos <= size(), /**/);
// First, reduce font against layout/label font
// Update: The setCharFont() routine in text2.cpp already
bool Paragraph::forceEmptyLayout() const
{
Inset const * const inset = inInset();
- return inset && inInset()->forceEmptyLayout();
+ if (!inset)
+ return true;
+ return inset->forceEmptyLayout();
}
bool Paragraph::allowParagraphCustomization() const
{
- return inInset() && inInset()->allowParagraphCustomization(0);
-}
-
-
-namespace {
- // This is a hack based upon one in InsetText::neverIndent().
- // When we have a real InsetTableCell, then we won't need this
- // method, because InsetTableCell will return the right values,
- // viz: InsetTableCell::useEmptyLayout() should return true, but
- // InsetTableCell::forceEmptyLayout() should still return false.
- //
- // The #include "insets/InsetText.h" can also be removed then.
- bool inTableCell(Inset const * inset)
- {
- InsetText const * txt = inset->asInsetText();
- if (!txt)
- return false;
- return txt->isTableCell();
- }
+ Inset const * const inset = inInset();
+ if (!inset)
+ return true;
+ return inset->allowParagraphCustomization();
}
bool Paragraph::useEmptyLayout() const
{
Inset const * const inset = inInset();
- return inset &&
- (inTableCell(inset) || inInset()->useEmptyLayout());
+ if (!inset)
+ return false;
+ return inset->useEmptyLayout();
}
bool Paragraph::isHfill(pos_type pos) const
{
Inset const * inset = getInset(pos);
- return inset && inset->lyxCode() == HFILL_CODE;
+ return inset && (inset->lyxCode() == SPACE_CODE &&
+ inset->isStretchableSpace());
}
char_type Paragraph::transformChar(char_type c, pos_type pos) const
{
- if (!Encodings::is_arabic(c))
+ if (!Encodings::isArabicChar(c))
return c;
char_type prev_char = ' ';
for (pos_type i = pos - 1; i >= 0; --i) {
char_type const par_char = d->text_[i];
- if (!Encodings::isComposeChar_arabic(par_char)) {
+ if (!Encodings::isArabicComposeChar(par_char)) {
prev_char = par_char;
break;
}
for (pos_type i = pos + 1, end = size(); i < end; ++i) {
char_type const par_char = d->text_[i];
- if (!Encodings::isComposeChar_arabic(par_char)) {
+ if (!Encodings::isArabicComposeChar(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))
+ if (Encodings::isArabicChar(next_char)) {
+ if (Encodings::isArabicChar(prev_char) &&
+ !Encodings::isArabicSpecialChar(prev_char))
return Encodings::transformChar(c, Encodings::FORM_MEDIAL);
else
return Encodings::transformChar(c, Encodings::FORM_INITIAL);
} else {
- if (Encodings::is_arabic(prev_char) &&
- !Encodings::is_arabic_special(prev_char))
+ if (Encodings::isArabicChar(prev_char) &&
+ !Encodings::isArabicSpecialChar(prev_char))
return Encodings::transformChar(c, Encodings::FORM_FINAL);
else
return Encodings::transformChar(c, Encodings::FORM_ISOLATED);
void Paragraph::updateWords(CursorSlice const & sl)
{
- BOOST_ASSERT(&sl.paragraph() == this);
+ LASSERT(&sl.paragraph() == this, /**/);
deregisterWords();
collectWords(sl);
registerWords();