#include <config.h>
#include "paragraph_pimpl.h"
+#include "paragraph.h"
#include "bufferparams.h"
#include "debug.h"
#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 <boost/next_prior.hpp>
using lyx::pos_type;
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;
lyxerr[Debug::CHANGES] << "track changes for par "
<< id_ << " type " << type << endl;
changes_.reset(new Changes(type));
- changes_->set(type, 0, size());
+ changes_->set(type, 0, size() + 1);
}
}
-void Paragraph::Pimpl::cleanChanges()
+void Paragraph::Pimpl::cleanChanges(Paragraph::ChangeTracking ct)
{
- // if we're not tracking, we don't want to reset...
- if (!tracking())
+ // if the paragraph was not tracked and we don't know the buffer's
+ // change tracking state, we do nothing
+ if ((ct == Paragraph::trackingUnknown) && !tracking())
return;
+ // untrack everything if we are in a buffer where ct is disabled
+ else if (ct == Paragraph::trackingOff) {
+ untrackChanges();
+ return;
+ }
+
+ // in a buffer where ct is enabled, set everything to INSERTED
changes_.reset(new Changes(Change::INSERTED));
- changes_->set(Change::INSERTED, 0, size());
+ changes_->set(Change::INSERTED, 0, size() + 1);
}
}
-void Paragraph::Pimpl::setChange(pos_type pos, Change::Type type)
+void Paragraph::Pimpl::setChangeType(pos_type pos, Change::Type type)
{
if (!tracking())
return;
}
-Change::Type Paragraph::Pimpl::lookupChange(pos_type pos) const
+void Paragraph::Pimpl::setChange(pos_type pos, Change change)
{
if (!tracking())
- return Change::UNCHANGED;
+ return;
- return changes_->lookup(pos);
+ changes_->set(change, pos);
}
-Change const Paragraph::Pimpl::lookupChangeFull(pos_type pos) const
+Change const Paragraph::Pimpl::lookupChange(pos_type pos) const
{
if (!tracking())
return Change(Change::UNCHANGED);
- return changes_->lookupFull(pos);
+ return changes_->lookup(pos);
}
-void Paragraph::Pimpl::markErased()
+void Paragraph::Pimpl::markErased(bool erased)
{
BOOST_ASSERT(tracking());
- // FIXME: we should actually remove INSERTED chars.
- // difficult because owning insettexts/tabulars need
- // to update themselves when rows etc. change
- changes_->set(Change::DELETED, 0, size());
- changes_->reset(Change::DELETED);
+ if (erased) {
+ erase(0, size());
+ } else {
+ for (pos_type i = 0; i < size(); ++i) {
+ changes_->set(Change::UNCHANGED, i);
+ if (owner_->isInset(i))
+ owner_->getInset(i)->markErased(false);
+ }
+ }
}
return;
}
- lyxerr << "acceptchange" << endl;
+ lyxerr[Debug::CHANGES] << "acceptchange" << endl;
pos_type i = start;
for (; i < end; ++i) {
- switch (lookupChange(i)) {
+ switch (lookupChange(i).type) {
case Change::UNCHANGED:
break;
break;
case Change::DELETED:
- eraseIntern(i);
- changes_->erase(i);
- --end;
- --i;
+ // Suppress access to nonexistent
+ // "end-of-paragraph char":
+ if (i < size()) {
+ eraseIntern(i);
+ changes_->erase(i);
+ --end;
+ --i;
+ }
break;
}
}
- lyxerr << "endacceptchange" << endl;
+ lyxerr[Debug::CHANGES] << "endacceptchange" << endl;
changes_->reset(Change::UNCHANGED);
}
pos_type i = start;
for (; i < end; ++i) {
- switch (lookupChange(i)) {
+ switch (lookupChange(i).type) {
case Change::UNCHANGED:
break;
case Change::INSERTED:
- eraseIntern(i);
- changes_->erase(i);
- --end;
- --i;
+ if (i < size()) {
+ eraseIntern(i);
+ changes_->erase(i);
+ --end;
+ --i;
+ }
break;
case Change::DELETED:
changes_->set(Change::UNCHANGED, i);
+ // No real char at position size():
+ if (i < size() && owner_->isInset(i))
+ owner_->getInset(i)->markErased(false);
break;
}
}
}
-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)
{
BOOST_ASSERT(pos <= size());
if (pos == size()) {
// when appending characters, no need to update tables
owner_->text_.push_back(c);
- owner_->setFont(pos, font);
return;
}
// 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)
{
BOOST_ASSERT(inset);
BOOST_ASSERT(pos <= size());
- insertChar(pos, META_INSET, font, change);
+ 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);
}
bool Paragraph::Pimpl::erase(pos_type pos)
{
- BOOST_ASSERT(pos < size());
+ BOOST_ASSERT(pos <= size());
if (tracking()) {
- Change::Type changetype(changes_->lookup(pos));
+ Change::Type changetype(changes_->lookup(pos).type);
changes_->record(Change(Change::DELETED), pos);
// only allow the actual removal if it was /new/ text
if (changetype != Change::INSERTED) {
- if (owner_->text_[pos] == Paragraph::META_INSET) {
- InsetOld * i(owner_->getInset(pos));
- i->markErased();
- }
+ if (pos < size() && owner_->isInset(pos))
+ owner_->getInset(pos)->markErased(true);
return false;
}
}
- eraseIntern(pos);
- return true;
+ // Don't physically access nonexistent end-of-paragraph char
+ if (pos < size()) {
+ eraseIntern(pos);
+ return true;
+ }
+
+ 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;
}
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, runparams);
+ 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) {
break;
}
- if (inset->isTextInset()) {
+ // output change tracking marks only if desired,
+ // if dvipost is installed,
+ // and with dvi/ps (other formats don't work)
+ LaTeXFeatures features(buf, bparams, runparams);
+ bool const output = bparams.output_changes
+ && runparams.flavor == OutputParams::LATEX
+ && features.isAvailable("dvipost");
+
+ if (inset->canTrackChanges()) {
column += Changes::latexMarkChange(os, running_change,
- Change::UNCHANGED);
+ Change::UNCHANGED, output);
running_change = Change::UNCHANGED;
}
bool close = false;
ostream::pos_type const len = os.tellp();
- if ((inset->lyxCode() == InsetOld::GRAPHICS_CODE
- || inset->lyxCode() == InsetOld::MATH_CODE
- || inset->lyxCode() == InsetOld::URL_CODE)
+ if ((inset->lyxCode() == InsetBase::GRAPHICS_CODE
+ || inset->lyxCode() == InsetBase::MATH_CODE
+ || inset->lyxCode() == InsetBase::URL_CODE)
&& running_font.isRightToLeft()) {
os << "\\L{";
close = true;
if ((bparams.inputenc == "latin1" ||
bparams.inputenc == "latin9") ||
(bparams.inputenc == "auto" &&
- (font.language()->encoding()->LatexName()
+ (font.language()->encoding()->latexName()
== "latin1" ||
- font.language()->encoding()->LatexName()
+ font.language()->encoding()->latexName()
== "latin9"))) {
os << "\\ensuremath{"
<< c
column += 17;
break;
- case '*': case '[': case ']':
+ case '*': case '[':
// avoid being mistaken for optional arguments
os << '{' << c << '}';
column += 2;
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");
}
}
projects / lyx.git / blobdiff