#include "Compare.h"
#include "Author.h"
+#include "Buffer.h"
#include "BufferParams.h"
#include "Changes.h"
+#include "CutAndPaste.h"
+#include "ErrorList.h"
#include "Font.h"
#include "insets/InsetText.h"
+#include "support/docstream.h"
#include "support/lassert.h"
#include "support/qstring_helpers.h"
-#include <boost/next_prior.hpp>
-
using namespace std;
using namespace lyx::support;
: from(from_), to(to_)
{}
- DocRange(Buffer const * buf)
+ DocRange(Buffer const * buf) :
+ from(doc_iterator_begin(buf)),
+ to(doc_iterator_end(buf))
{
- from = doc_iterator_begin(buf);
- to = doc_iterator_end(buf);
to.backwardPos();
}
DocPair()
{}
- DocPair(DocIterator o_, DocIterator n_)
+ DocPair(DocIterator const & o_, DocIterator const & n_)
: o(o_), n(n_)
{}
- bool operator!=(DocPair const & rhs)
+ bool operator!=(DocPair const & rhs) const
{
// this might not be intuitive but correct for our purpose
return o != rhs.o && n != rhs.n;
public:
///
Impl(Compare const & compare)
- : abort_(false), N_(0), M_(0), offset_reverse_diagonal_(0),
- odd_offset_(0), compare_(compare),
- old_buf_(0), new_buf_(0), dest_buf_(0), dest_pars_(0),
- recursion_level_(0), nested_inset_level_(0), D_(0)
+ : abort_(false), n_(0), m_(0), offset_reverse_diagonal_(0),
+ odd_offset_(false), compare_(compare),
+ old_buf_(nullptr), new_buf_(nullptr), dest_buf_(nullptr),
+ dest_pars_(nullptr), recursion_level_(0), nested_inset_level_(0), D_(0)
{}
///
void writeToDestBuffer(ParagraphList const & copy_pars) const;
/// The length of the old chunk currently processed
- int N_;
+ int n_;
/// The length of the new chunk currently processed
- int M_;
+ int m_;
/// The offset diagonal of the reverse path of the
/// currently processed chunk
int offset_reverse_diagonal_;
// Copy the buffer params to the destination buffer
dest_buffer->params() = options_.settings_from_new
? new_buffer->params() : old_buffer->params();
-
// Copy extra authors to the destination buffer
AuthorList const & extra_authors = options_.settings_from_new ?
old_buffer->params().authors() : new_buffer->params().authors();
for (; it != extra_authors.end(); ++it)
dest_buffer->params().authors().record(*it);
- doStatusMessage();
+ // We will need this later
+ DocumentClassConstPtr const olddc =
+ dest_buffer->params().documentClassPtr();
+ // We do not want to share the DocumentClass with the other Buffer.
+ // See bug #10295.
+ dest_buffer->params().makeDocumentClass(dest_buffer->isClone(), dest_buffer->isInternal());
- // do the real work
+ doStatusMessage();
+ // Do the real work
if (!doCompare())
return;
+ // The comparison routine simply copies the paragraphs over into the
+ // new buffer with the document class from wherever they came from.
+ // So we need to reset the document class of all the paragraphs.
+ // See bug #10295.
+ ErrorList el;
+ cap::switchBetweenClasses(
+ olddc, dest_buffer->params().documentClassPtr(),
+ static_cast<InsetText &>(dest_buffer->inset()), el);
+
finished(pimpl_->abort_);
- return;
}
pit_type startpit = range.from.pit();
pit_type endpit = range.to.pit();
ParagraphList const & ps_ = range.text()->paragraphs();
- ParagraphList tmp_pars(boost::next(ps_.begin(), startpit),
- boost::next(ps_.begin(), endpit + 1));
+ ParagraphList tmp_pars(ps_.iterator_at(startpit),
+ ps_.iterator_at(endpit + 1));
// Remove the end of the last paragraph; afterwards, remove the
// beginning of the first paragraph. Keep this order - there may only
if (os[k].empty() && os_r[kk].empty()) {
// No, there is no snake at all, in which case
// the length of the shortest edit script is M+N.
- LATTEST(2 * D - odd_offset_ == M_ + N_);
+ LATTEST(2 * D - odd_offset_ == m_ + n_);
return NoSnake;
}
DocPair & middle_snake)
{
// The lengths of the old and new chunks.
- N_ = rp.o.length();
- M_ = rp.n.length();
+ n_ = rp.o.length();
+ m_ = rp.n.length();
// Forward paths are centered around the 0-diagonal; reverse paths
// are centered around the diagonal N - M. (Delta in the article)
- offset_reverse_diagonal_ = N_ - M_;
+ offset_reverse_diagonal_ = n_ - m_;
// If the offset is odd, only check for overlap while extending forward
// paths, otherwise only check while extending reverse paths.
nrs.reset(DocIterator());
// In the formula below, the "+ 1" ensures we round like ceil()
- int const D_max = (M_ + N_ + 1)/2;
+ int const D_max = (m_ + n_ + 1)/2;
// D is the number of horizontal and vertical steps, i.e.
// different characters in the old and new chunk.
for (int D = 0; D <= D_max; ++D) {
diff_i(rp_new);
for (pit_type p = 0; p < (pit_type)dest_pars_->size(); ++p) {
- (*dest_pars_)[p].setBuffer(const_cast<Buffer &>(*dest_buf));
+ (*dest_pars_)[p].setInsetBuffers(const_cast<Buffer &>(*dest_buf));
(*dest_pars_)[p].setInsetOwner(&dest_buf_->inset());
}