void Paragraph::Pimpl::clear()
{
text.clear();
-#warning changes ?
+#warning changes ?
}
lyxerr[Debug::CHANGES] << "already tracking for par " << id_ << endl;
return;
}
-
+
lyxerr[Debug::CHANGES] << "track changes for par "
<< id_ << " type " << type << endl;
changes_.reset(new Changes(type));
changes_->set(type, 0, size());
}
-
+
void Paragraph::Pimpl::untrackChanges()
{
changes_.reset(0);
}
-
+
void Paragraph::Pimpl::cleanChanges()
{
// if we're not tracking, we don't want to reset...
changes_->set(Change::INSERTED, 0, size());
}
-
+
bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const
{
if (!tracking())
return changes_->isChangeEdited(start, end);
}
-
+
void Paragraph::Pimpl::setChange(pos_type pos, Change::Type type)
{
if (!tracking())
changes_->set(type, pos);
}
-
+
Change::Type Paragraph::Pimpl::lookupChange(pos_type pos) const
{
if (!tracking())
return changes_->lookup(pos);
}
-
+
Change const Paragraph::Pimpl::lookupChangeFull(pos_type pos) const
{
return changes_->lookupFull(pos);
}
-
-
+
+
void Paragraph::Pimpl::markErased()
{
lyx::Assert(tracking());
changes_->reset(Change::DELETED);
}
-
+
void Paragraph::Pimpl::acceptChange(pos_type start, pos_type end)
{
if (!tracking())
return;
-
+
if (!size()) {
changes_.reset(new Changes(Change::UNCHANGED));
return;
}
-
- lyxerr << "acceptchange" << endl;
+
+ lyxerr << "acceptchange" << endl;
pos_type i = start;
for (; i < end; ++i) {
}
}
- lyxerr << "endacceptchange" << endl;
+ lyxerr << "endacceptchange" << endl;
changes_->reset(Change::UNCHANGED);
}
{
if (!tracking())
return;
-
+
if (!size()) {
changes_.reset(new Changes(Change::UNCHANGED));
return;
}
-
+
pos_type i = start;
for (; i < end; ++i) {
changes_->reset(Change::UNCHANGED);
}
-
+
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();
+
lyx::Assert(pos <= siz);
- // This is stronger, and I belive that this is the assertion
- // that we should really use. (Lgb)
- //Assert(pos < size());
- // Then this has no meaning. (Lgb)
- if (!siz || 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
+ lyx::Assert(pos < size());
+ return text[pos];
+#endif
}
// only allow the actual removal if it was /new/ text
if (changetype != Change::INSERTED) {
- if (text[pos] == Paragraph::META_INSET) {
+ if (text[pos] == Paragraph::META_INSET) {
Inset * i(owner_->getInset(pos));
i->markErased();
}
return true;
}
-
+
void Paragraph::Pimpl::eraseIntern(pos_type pos)
{
// if it is an inset, delete the inset entry
erasePos(pos);
}
-
+
bool Paragraph::Pimpl::erase(pos_type start, pos_type end)
{
pos_type i = start;
++i;
} else {
any_erased = true;
- }
+ }
--count;
}
return any_erased;
}
-
+
void Paragraph::Pimpl::simpleTeXBlanks(ostream & os, TexRow & texrow,
pos_type const i,
unsigned int & column,
LyXFont const & font,
LyXLayout const & style)
{
- if (style.pass_thru) return;
+ if (style.pass_thru)
+ return;
+
if (column > lyxrc.ascii_linelen
&& i
&& getChar(i - 1) != ' '
return true;
}
-
+
void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf,
BufferParams const & bparams,
ostream & os,
value_type const c)
{
if (style.pass_thru) {
- if (c != '\0') os << c;
+ if (c != Paragraph::META_INSET) {
+ if (c != '\0')
+ os << c;
+ } else {
+ Inset const * inset = owner_->getInset(i);
+ inset->ascii(buf, os, 0);
+ }
return;
}
+
// Two major modes: LaTeX or plain
// Handle here those cases common to both modes
// and then split to handle the two modes separately.
// FIXME: remove this check
if (!inset)
break;
-
+
+ // FIXME: move this to InsetNewline::latex
+ if (inset->lyxCode() == Inset::NEWLINE_CODE) {
+ // 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 = owner_->getLayoutFont(bparams);
+ running_font = basefont;
+
+ if (font.family() == LyXFont::TYPEWRITER_FAMILY)
+ os << '~';
+
+ if (moving_arg)
+ os << "\\protect ";
+
+ os << "\\\\\n";
+ }
+ texrow.newline();
+ texrow.start(owner_, i + 1);
+ column = 0;
+ break;
+ }
+
if (inset->isTextInset()) {
column += Changes::latexMarkChange(os, running_change,
Change::UNCHANGED);
running_change = Change::UNCHANGED;
}
-
+
bool close = false;
int const len = os.tellp();
//ostream::pos_type const len = os.tellp();
}
break;
- case Paragraph::META_NEWLINE:
- if (open_font) {
- column += running_font.latexWriteEndChanges(os,
- basefont,
- basefont);
- open_font = false;
- }
- basefont = owner_->getLayoutFont(bparams);
- running_font = basefont;
- break;
-
- case Paragraph::META_HFILL:
- os << "\\hfill{}";
- column += 7;
- break;
-
default:
// And now for the special cases within each mode
}
-
-Paragraph * Paragraph::Pimpl::TeXDeeper(Buffer const * buf,
- BufferParams const & bparams,
- ostream & os, TexRow & texrow)
-{
- lyxerr[Debug::LATEX] << "TeXDeeper... " << this << endl;
- Paragraph * par = owner_;
-
- while (par && par->params().depth() == owner_->params().depth()) {
- if (par->layout()->isEnvironment()) {
- par = par->TeXEnvironment(buf, bparams,
- os, texrow);
- } else {
- par = par->TeXOnePar(buf, bparams,
- os, texrow, false);
- }
- }
- lyxerr[Debug::LATEX] << "TeXDeeper...done " << par << endl;
-
- return par;
-}
-
-
void Paragraph::Pimpl::validate(LaTeXFeatures & features,
LyXLayout const & layout) const
{
}
-Paragraph * Paragraph::Pimpl::getParFromID(int id) const
-{
- InsetList::iterator cit = owner_->insetlist.begin();
- InsetList::iterator lend = owner_->insetlist.end();
- Paragraph * result;
- for (; cit != lend; ++cit) {
- if ((result = cit.getInset()->getParFromID(id)))
- return result;
- }
- return 0;
-}
-
-
LyXFont const Paragraph::Pimpl::realizeFont(LyXFont const & font,
BufferParams const & bparams) const
{
projects / lyx.git / blobdiff