#include "Buffer.h"
#include "BufferParams.h"
+#include "Changes.h"
#include "Counters.h"
#include "Encoding.h"
#include "debug.h"
#include "gettext.h"
+#include "InsetList.h"
#include "Language.h"
#include "LaTeXFeatures.h"
#include "Color.h"
/// Who owns us?
Paragraph * owner_;
+
+ ///
+ InsetList insetlist_;
};
inset_owner = p.inset_owner;
fontlist = p.fontlist;
id_ = paragraph_id++;
+ insetlist_ = p.insetlist_;
+ insetlist_.clone();
}
}
// Update the insets
- owner_->insetlist.increasePosAfterPos(pos);
+ insetlist_.increasePosAfterPos(pos);
}
insertChar(pos, META_INSET, change);
BOOST_ASSERT(owner_->text_[pos] == META_INSET);
- // Add a new entry in the insetlist.
- owner_->insetlist.insert(inset, pos);
+ // Add a new entry in the insetlist_.
+ insetlist_.insert(inset, pos);
}
// if it is an inset, delete the inset entry
if (owner_->text_[pos] == Paragraph::META_INSET) {
- owner_->insetlist.erase(pos);
+ insetlist_.erase(pos);
}
owner_->text_.erase(owner_->text_.begin() + pos);
for (; it != fend; ++it)
it->pos(it->pos() - 1);
- // Update the insetlist
- owner_->insetlist.decreasePosAfterPos(pos);
+ // Update the insetlist_
+ insetlist_.decreasePosAfterPos(pos);
return true;
}
if (style.pass_thru)
return false;
- if (i < size() - 1) {
+ if (i + 1 < size()) {
char_type next = getChar(i + 1);
if (Encodings::isCombiningChar(next)) {
// This space has an accent, so we must always output it.
&& column > lyxrc.plaintext_linelen
&& i
&& getChar(i - 1) != ' '
- && (i < size() - 1)
+ && (i + 1 < size())
// same in FreeSpacing mode
&& !owner_->isFreeSpacing()
// In typewriter mode, we want to avoid
Encoding const & encoding,
pos_type & i)
{
- // The latex command is "\textLANG{<spec>}" and we have to retain
- // "\textLANG{<spec>" for the first char but only "<spec>" for all
- // subsequent chars (this also works when we are passed untranslated
- // unicode).
+ // When the character is marked by the proper language, we simply
+ // get its code point in some encoding, otherwise we get the
+ // translation specified in the unicodesymbols file, which is
+ // something like "\textLANG{<spec>}". So, we have to retain
+ // "\textLANG{<spec>" for the first char but only "<spec>" for
+ // all subsequent chars.
docstring const latex1 = rtrim(encoding.latexChar(c), "}");
int length = latex1.length();
os << latex1;
- while (i < size() - 1) {
+ while (i + 1 < size()) {
char_type next = getChar(i + 1);
+ // Stop here if next character belongs to another
+ // language or there is a change tracking status.
if (!Encodings::isKnownLangChar(next, preamble) ||
runningChange != lookupChange(i + 1))
break;
if (cit->pos() >= i + 1)
break;
}
+ // Stop here if there is a font attribute change.
if (found && cit != end && prev_font != cit->font())
break;
docstring const latex = rtrim(encoding.latexChar(next), "}");
}
++i;
}
- // When the proper language is set, we are passed the straight unicode,
- // so we should not try to close the \textLANG command.
+ // When the proper language is set, we are simply passed a code
+ // point, so we should not try to close the \textLANG command.
if (prefixIs(latex1, from_ascii("\\" + preamble))) {
os << '}';
++length;
break;
// FIXME: move this to InsetNewline::latex
- if (inset->lyxCode() == Inset::NEWLINE_CODE) {
+ if (inset->lyxCode() == NEWLINE_CODE) {
// newlines are handled differently here than
// the default in simpleTeXSpecialChars().
if (!style.newline_allowed) {
bool close = false;
odocstream::pos_type const len = os.tellp();
- if ((inset->lyxCode() == Inset::GRAPHICS_CODE
- || inset->lyxCode() == Inset::MATH_CODE
- || inset->lyxCode() == Inset::URL_CODE)
+ if ((inset->lyxCode() == GRAPHICS_CODE
+ || inset->lyxCode() == MATH_CODE
+ || inset->lyxCode() == HYPERLINK_CODE)
&& running_font.isRightToLeft()) {
if (running_font.language()->lang() == "farsi")
os << "\\beginL{}";
if (pnr == phrases_nr && c != '\0') {
Encoding const & encoding = *(runparams.encoding);
- if (i < size() - 1) {
+ if (i + 1 < size()) {
char_type next = getChar(i + 1);
if (Encodings::isCombiningChar(next)) {
column += latexSurrogatePair(os, c, next, encoding) - 1;
features.require("ParagraphLeftIndent");
// then the insets
- InsetList::const_iterator icit = owner_->insetlist.begin();
- InsetList::const_iterator iend = owner_->insetlist.end();
+ InsetList::const_iterator icit = insetlist_.begin();
+ InsetList::const_iterator iend = insetlist_.end();
for (; icit != iend; ++icit) {
if (icit->inset) {
icit->inset->validate(features);
if (layout.needprotect &&
- icit->inset->lyxCode() == Inset::FOOT_CODE)
+ icit->inset->lyxCode() == FOOT_CODE)
features.require("NeedLyXFootnoteCode");
}
}
Paragraph::Paragraph(Paragraph const & par)
- : itemdepth(par.itemdepth), insetlist(par.insetlist),
+ : itemdepth(par.itemdepth),
layout_(par.layout_),
text_(par.text_), begin_of_body_(par.begin_of_body_),
pimpl_(new Paragraph::Pimpl(*par.pimpl_, this))
{
- //lyxerr << "Paragraph::Paragraph(Paragraph const&)" << endl;
- InsetList::iterator it = insetlist.begin();
- InsetList::iterator end = insetlist.end();
- for (; it != end; ++it)
- it->inset = it->inset->clone();
}
// needed as we will destroy the pimpl_ before copying it
if (&par != this) {
itemdepth = par.itemdepth;
-
- insetlist = par.insetlist;
- InsetList::iterator it = insetlist.begin();
- InsetList::iterator end = insetlist.end();
- for (; it != end; ++it)
- it->inset = it->inset->clone();
-
layout_ = par.layout();
text_ = par.text_;
begin_of_body_ = par.begin_of_body_;
}
-bool Paragraph::insetAllowed(Inset_code code)
+bool Paragraph::insetAllowed(InsetCode code)
{
return !pimpl_->inset_owner || pimpl_->inset_owner->insetAllowed(code);
}
int Paragraph::getPositionOfInset(Inset const * inset) const
{
// Find the entry.
- InsetList::const_iterator it = insetlist.begin();
- InsetList::const_iterator end = insetlist.end();
+ InsetList::const_iterator it = pimpl_->insetlist_.begin();
+ InsetList::const_iterator end = pimpl_->insetlist_.end();
for (; it != end; ++it)
if (it->inset == inset)
return it->pos;
InsetBibitem * Paragraph::bibitem() const
{
- if (!insetlist.empty()) {
- Inset * inset = insetlist.begin()->inset;
- if (inset->lyxCode() == Inset::BIBITEM_CODE)
+ if (!pimpl_->insetlist_.empty()) {
+ Inset * inset = pimpl_->insetlist_.begin()->inset;
+ if (inset->lyxCode() == BIBITEM_CODE)
return static_cast<InsetBibitem *>(inset);
}
return 0;
// paragraphs inside floats need different alignment tags to avoid
// unwanted space
-bool noTrivlistCentering(Inset::Code code)
+bool noTrivlistCentering(InsetCode code)
{
- return code == Inset::FLOAT_CODE || code == Inset::WRAP_CODE;
+ return code == FLOAT_CODE || code == WRAP_CODE;
}
string const corrected_env(string const & suffix, string const & env,
- Inset::Code code)
+ InsetCode code)
{
string output = suffix + "{";
if (noTrivlistCentering(code))
for (pos_type i = 0; i < size(); ++i) {
if (isInset(i)) {
Inset const * inset = getInset(i);
- Inset::Code lyx_code = inset->lyxCode();
- if (lyx_code != Inset::TOC_CODE &&
- lyx_code != Inset::INCLUDE_CODE &&
- lyx_code != Inset::GRAPHICS_CODE &&
- lyx_code != Inset::ERT_CODE &&
- lyx_code != Inset::LISTINGS_CODE &&
- lyx_code != Inset::FLOAT_CODE &&
- lyx_code != Inset::TABULAR_CODE) {
+ InsetCode lyx_code = inset->lyxCode();
+ if (lyx_code != TOC_CODE &&
+ lyx_code != INCLUDE_CODE &&
+ lyx_code != GRAPHICS_CODE &&
+ lyx_code != ERT_CODE &&
+ lyx_code != LISTINGS_CODE &&
+ lyx_code != FLOAT_CODE &&
+ lyx_code != TABULAR_CODE) {
return false;
}
} else {
for (pos_type i = 0; i < size(); ++i) {
if (isInset(i)) {
Inset const * inset = getInset(i);
- Inset::Code lyx_code = inset->lyxCode();
- if (lyx_code == Inset::LABEL_CODE) {
+ InsetCode lyx_code = inset->lyxCode();
+ if (lyx_code == LABEL_CODE) {
string const id = static_cast<InsetCommand const *>(inset)->getContents();
return "id='" + to_utf8(sgml::cleanID(buf, runparams, from_utf8(id))) + "'";
}
}
+bool Paragraph::isHfill(pos_type pos) const
+{
+ return isInset(pos)
+ && getInset(pos)->lyxCode() == HFILL_CODE;
+}
+
+
bool Paragraph::isNewline(pos_type pos) const
{
return isInset(pos)
- && getInset(pos)->lyxCode() == Inset::NEWLINE_CODE;
+ && getInset(pos)->lyxCode() == NEWLINE_CODE;
}
{
return lyxrc.rtl_support
&& getParLanguage(bparams)->rightToLeft()
- && ownerCode() != Inset::ERT_CODE
- && ownerCode() != Inset::LISTINGS_CODE;
+ && ownerCode() != ERT_CODE
+ && ownerCode() != LISTINGS_CODE;
}
}
-Inset::Code Paragraph::ownerCode() const
+InsetCode Paragraph::ownerCode() const
{
return pimpl_->inset_owner
- ? pimpl_->inset_owner->lyxCode() : Inset::NO_CODE;
+ ? pimpl_->inset_owner->lyxCode() : NO_CODE;
}
// for now we just need this, later should we need this in some
// other way we can always add a function to Inset too.
- return ownerCode() == Inset::ERT_CODE || ownerCode() == Inset::LISTINGS_CODE;
+ return ownerCode() == ERT_CODE || ownerCode() == LISTINGS_CODE;
}
{
if (layout()->keepempty)
return true;
- return ownerCode() == Inset::ERT_CODE || ownerCode() == Inset::LISTINGS_CODE;
+ return ownerCode() == ERT_CODE || ownerCode() == LISTINGS_CODE;
}
if (layout()->labeltype != LABEL_BIBLIO)
return 0;
- bool hasbibitem = !insetlist.empty()
+ bool hasbibitem = !pimpl_->insetlist_.empty()
// Insist on it being in pos 0
&& getChar(0) == Paragraph::META_INSET
- && insetlist.begin()->inset->lyxCode() == Inset::BIBITEM_CODE;
+ && pimpl_->insetlist_.begin()->inset->lyxCode() == BIBITEM_CODE;
docstring oldkey;
docstring oldlabel;
// we're assuming there's only one of these, which there
// should be.
int erasedInsetPosition = -1;
- InsetList::iterator it = insetlist.begin();
- InsetList::iterator end = insetlist.end();
+ InsetList::iterator it = pimpl_->insetlist_.begin();
+ InsetList::iterator end = pimpl_->insetlist_.end();
for (; it != end; ++it)
- if (it->inset->lyxCode() == Inset::BIBITEM_CODE
+ if (it->inset->lyxCode() == BIBITEM_CODE
&& it->pos > 0) {
InsetBibitem * olditem = static_cast<InsetBibitem *>(it->inset);
oldkey = olditem->getParam("key");
//erase one. So we give its properties to the beginning inset.
if (hasbibitem) {
InsetBibitem * inset =
- static_cast<InsetBibitem *>(insetlist.begin()->inset);
+ static_cast<InsetBibitem *>(pimpl_->insetlist_.begin()->inset);
if (!oldkey.empty())
inset->setParam("key", oldkey);
inset->setParam("label", oldlabel);
pimpl_->changes_.checkAuthors(authorList);
}
+
+bool Paragraph::isUnchanged(pos_type pos) const
+{
+ return lookupChange(pos).type == Change::UNCHANGED;
+}
+
+
+bool Paragraph::isInserted(pos_type pos) const
+{
+ return lookupChange(pos).type == Change::INSERTED;
+}
+
+
+bool Paragraph::isDeleted(pos_type pos) const
+{
+ return lookupChange(pos).type == Change::DELETED;
+}
+
+
+InsetList const & Paragraph::insetList() const
+{
+ return pimpl_->insetlist_;
+}
+
+
+Inset * Paragraph::releaseInset(pos_type pos)
+{
+ Inset * inset = pimpl_->insetlist_.release(pos);
+ /// does not honour change tracking!
+ eraseChar(pos, false);
+ return inset;
+}
+
+
+Inset * Paragraph::getInset(pos_type pos)
+{
+ return pimpl_->insetlist_.get(pos);
+}
+
+
+Inset const * Paragraph::getInset(pos_type pos) const
+{
+ return pimpl_->insetlist_.get(pos);
+}
+
} // namespace lyx
projects / lyx.git / blobdiff