#include "encoding.h"
#include "language.h"
#include "LaTeXFeatures.h"
-#include "latexrunparams.h"
+#include "LColor.h"
+#include "lyxlength.h"
#include "lyxrc.h"
+#include "outputparams.h"
#include "texrow.h"
-#include "support/LAssert.h"
+#include <boost/next_prior.hpp>
-using namespace lyx::support;
using lyx::pos_type;
+
using std::endl;
-using std::ostream;
using std::upper_bound;
using std::lower_bound;
+using std::string;
+using std::ostream;
+
-// Initialize static member.
-ShareContainer<LyXFont> Paragraph::Pimpl::FontTable::container;
// Initialization of the counter for the paragraph id's,
unsigned int Paragraph::Pimpl::paragraph_id = 0;
: params(p.params), owner_(owner)
{
inset_owner = p.inset_owner;
- text = p.text;
fontlist = p.fontlist;
id_ = paragraph_id++;
}
-void Paragraph::Pimpl::clear()
-{
- text.clear();
-#warning changes ?
-}
-
-
void Paragraph::Pimpl::setContentsFromPar(Paragraph const & par)
{
- text = par.pimpl_->text;
+ owner_->text_ = par.text_;
if (par.pimpl_->tracking()) {
changes_.reset(new Changes(*(par.pimpl_->changes_.get())));
}
void Paragraph::Pimpl::markErased()
{
- Assert(tracking());
+ BOOST_ASSERT(tracking());
// FIXME: we should actually remove INSERTED chars.
// difficult because owning insettexts/tabulars need
Paragraph::value_type Paragraph::Pimpl::getChar(pos_type pos) const
{
-#if 1
- // This is in the critical path for loading!
- pos_type const siz = size();
-
- Assert(pos <= siz);
-
- if (pos == siz) {
- lyxerr << "getChar() on pos " << pos << " in par id "
- << owner_->id() << " of size " << siz
- << " is a bit silly !" << endl;
- return '\0';
- }
-
- return text[pos];
-#else
- Assert(pos < size());
- return text[pos];
-#endif
-}
-
-
-void Paragraph::Pimpl::setChar(pos_type pos, value_type c)
-{
-#warning changes
- text[pos] = c;
+ return owner_->getChar(pos);
}
-void Paragraph::Pimpl::insertChar(pos_type pos, value_type c,
- LyXFont const & font, Change change)
+void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, Change change)
{
- Assert(pos <= size());
+ BOOST_ASSERT(pos <= size());
if (tracking()) {
changes_->record(change, pos);
// maybe inserting ascii text)
if (pos == size()) {
// when appending characters, no need to update tables
- text.push_back(c);
- owner_->setFont(pos, font);
+ owner_->text_.push_back(c);
return;
}
- text.insert(text.begin() + pos, c);
+ owner_->text_.insert(owner_->text_.begin() + pos, c);
// Update the font table.
FontTable search_font(pos, LyXFont());
// Update the insets
owner_->insetlist.increasePosAfterPos(pos);
-
- owner_->setFont(pos, font);
}
void Paragraph::Pimpl::insertInset(pos_type pos,
- InsetOld * inset, LyXFont const & font, Change change)
+ InsetBase * inset, Change change)
{
- Assert(inset);
- Assert(pos <= size());
+ BOOST_ASSERT(inset);
+ BOOST_ASSERT(pos <= size());
- insertChar(pos, META_INSET, font, change);
- Assert(text[pos] == META_INSET);
+ insertChar(pos, META_INSET, change);
+ BOOST_ASSERT(owner_->text_[pos] == META_INSET);
// Add a new entry in the insetlist.
owner_->insetlist.insert(inset, pos);
-
- if (inset_owner)
- inset->setOwner(inset_owner);
}
void Paragraph::Pimpl::eraseIntern(pos_type pos)
{
// if it is an inset, delete the inset entry
- if (text[pos] == Paragraph::META_INSET) {
+ if (owner_->text_[pos] == Paragraph::META_INSET) {
owner_->insetlist.erase(pos);
}
- text.erase(text.begin() + pos);
+ owner_->text_.erase(owner_->text_.begin() + pos);
// Erase entries in the tables.
FontTable search_font(pos, LyXFont());
bool Paragraph::Pimpl::erase(pos_type pos)
{
- Assert(pos < size());
+ BOOST_ASSERT(pos < size());
if (tracking()) {
Change::Type changetype(changes_->lookup(pos));
// only allow the actual removal if it was /new/ text
if (changetype != Change::INSERTED) {
- if (text[pos] == Paragraph::META_INSET) {
- InsetOld * i(owner_->getInset(pos));
- i->markErased();
+ if (owner_->text_[pos] == Paragraph::META_INSET) {
+ owner_->getInset(pos)->markErased();
}
return false;
}
int Paragraph::Pimpl::erase(pos_type start, pos_type end)
{
pos_type i = start;
- pos_type count = end - start;
- while (count) {
- if (!erase(i)) {
+ for (pos_type count = end - start; count; --count) {
+ if (!erase(i))
++i;
- }
- --count;
}
return end - i;
}
// does the wanted text start at point?
for (string::size_type i = 0; i < str.length(); ++i) {
- if (str[i] != text[pos + i])
+ if (str[i] != owner_->text_[pos + i])
return false;
}
BufferParams const & bparams,
ostream & os,
TexRow & texrow,
- LatexRunParams const & runparams,
+ OutputParams const & runparams,
LyXFont & font,
LyXFont & running_font,
LyXFont & basefont,
if (c != '\0')
os << c;
} else {
- InsetOld const * inset = owner_->getInset(i);
- inset->ascii(buf, os, 0);
+ owner_->getInset(i)->plaintext(buf, os, runparams);
}
return;
}
// and then split to handle the two modes separately.
switch (c) {
case Paragraph::META_INSET: {
- InsetOld * inset = owner_->getInset(i);
+ InsetBase * inset = owner_->getInset(i);
// FIXME: remove this check
if (!inset)
break;
// FIXME: move this to InsetNewline::latex
- if (inset->lyxCode() == InsetOld::NEWLINE_CODE) {
+ if (inset->lyxCode() == InsetBase::NEWLINE_CODE) {
// newlines are handled differently here than
// the default in simpleTeXSpecialChars().
if (!style.newline_allowed) {
}
bool close = false;
- int const len = os.tellp();
- //ostream::pos_type const len = os.tellp();
- if ((inset->lyxCode() == InsetOld::GRAPHICS_CODE
- || inset->lyxCode() == InsetOld::MATH_CODE
- || inset->lyxCode() == InsetOld::URL_CODE)
+ ostream::pos_type const len = os.tellp();
+
+ if ((inset->lyxCode() == InsetBase::GRAPHICS_CODE
+ || inset->lyxCode() == InsetBase::MATH_CODE
+ || inset->lyxCode() == InsetBase::URL_CODE)
&& running_font.isRightToLeft()) {
os << "\\L{";
close = true;
texrow.start(owner_->id(), i + 1);
column = 0;
} else {
- column += int(os.tellp()) - len;
+ column += os.tellp() - len;
}
}
break;
column += 17;
break;
- case '*': case '[': case ']':
+ case '*': case '[':
// avoid being mistaken for optional arguments
os << '{' << c << '}';
column += 2;
BufferParams const & bparams = features.bufferParams();
// check the params.
- if (params.lineTop() || params.lineBottom())
- features.require("lyxline");
if (!params.spacing().isDefault())
features.require("setspace");
features.require("ParagraphLeftIndent");
// then the insets
- InsetList::iterator icit = owner_->insetlist.begin();
- InsetList::iterator iend = owner_->insetlist.end();
+ InsetList::const_iterator icit = owner_->insetlist.begin();
+ InsetList::const_iterator iend = owner_->insetlist.end();
for (; icit != iend; ++icit) {
if (icit->inset) {
icit->inset->validate(features);
if (layout.needprotect &&
- icit->inset->lyxCode() == InsetOld::FOOT_CODE)
+ icit->inset->lyxCode() == InsetBase::FOOT_CODE)
features.require("NeedLyXFootnoteCode");
}
}