#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"
+#include "Layout.h"
#include "Length.h"
#include "Font.h"
+#include "FontList.h"
#include "LyXRC.h"
-#include "Row.h"
#include "Messages.h"
#include "OutputParams.h"
#include "output_latex.h"
#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
-#include "rowpainter.h"
#include "sgml.h"
#include "TexRow.h"
#include "VSpace.h"
+#include "frontends/alert.h"
#include "frontends/FontMetrics.h"
#include "insets/InsetBibitem.h"
#include "support/convert.h"
#include "support/unicode.h"
-#include <boost/bind.hpp>
-#include <boost/next_prior.hpp>
-
-#include <algorithm>
#include <sstream>
-using std::distance;
using std::endl;
using std::string;
using std::ostream;
namespace lyx {
using support::contains;
+using support::prefixIs;
+using support::suffixIs;
using support::rsplit;
+using support::rtrim;
/////////////////////////////////////////////////////////////////////
//
-// Paragraph::Pimpl
+// Paragraph::Private
//
/////////////////////////////////////////////////////////////////////
-class Encoding;
-class LyXLayout;
-
-
-class Paragraph::Pimpl {
+class Paragraph::Private
+{
public:
///
- Pimpl(Paragraph * owner);
+ Private(Paragraph * owner);
/// "Copy constructor"
- Pimpl(Pimpl const &, Paragraph * owner);
-
- //
- // Change tracking
- //
- /// look up change at given pos
- Change const & lookupChange(pos_type pos) const;
- /// is there a change within the given range ?
- bool isChanged(pos_type start, pos_type end) const;
- /// will the paragraph be physically merged with the next
- /// one if the imaginary end-of-par character is logically deleted?
- bool isMergedOnEndOfParDeletion(bool trackChanges) const;
- /// set change for the entire par
- void setChange(Change const & change);
- /// set change at given pos
- void setChange(pos_type pos, Change const & change);
- /// accept changes within the given range
- void acceptChanges(BufferParams const & bparams, pos_type start, pos_type end);
- /// reject changes within the given range
- void rejectChanges(BufferParams const & bparams, pos_type start, pos_type end);
+ Private(Private const &, Paragraph * owner);
///
value_type getChar(pos_type pos) const;
///
void insertChar(pos_type pos, value_type c, Change const & change);
- ///
- void insertInset(pos_type pos, Inset * inset, Change const & change);
- /// (logically) erase the char at pos; return true if it was actually erased
- bool eraseChar(pos_type pos, bool trackChanges);
- /// (logically) erase the given range; return the number of chars actually erased
- int eraseChars(pos_type start, pos_type end, bool trackChanges);
- ///
- Inset * inset_owner;
-
- /** A font entry covers a range of positions. Notice that the
- entries in the list are inserted in random order.
- I don't think it's worth the effort to implement a more effective
- datastructure, because the number of different fonts in a paragraph
- is limited. (Asger)
- Nevertheless, I decided to store fontlist using a sorted vector:
- fontlist = { {pos_1,font_1} , {pos_2,font_2} , ... } where
- pos_1 < pos_2 < ..., font_{i-1} != font_i for all i,
- and font_i covers the chars in positions pos_{i-1}+1,...,pos_i
- (font_1 covers the chars 0,...,pos_1) (Dekel)
- */
- class FontTable {
- public:
- ///
- FontTable(pos_type p, Font const & f)
- : pos_(p), font_(f)
- {}
- ///
- pos_type pos() const { return pos_; }
- ///
- void pos(pos_type p) { pos_ = p; }
- ///
- Font const & font() const { return font_; }
- ///
- void font(Font const & f) { font_ = f;}
- private:
- /// End position of paragraph this font attribute covers
- pos_type pos_;
- /** Font. Interpretation of the font values:
- If a value is Font::INHERIT_*, it means that the font
- attribute is inherited from either the layout of this
- paragraph or, in the case of nested paragraphs, from the
- layout in the environment one level up until completely
- resolved.
- The values Font::IGNORE_* and Font::TOGGLE are NOT
- allowed in these font tables.
- */
- Font font_;
- };
- ///
- friend class matchFT;
- ///
- class matchFT {
- public:
- /// used by lower_bound and upper_bound
- int operator()(FontTable const & a, FontTable const & b) const {
- return a.pos() < b.pos();
- }
- };
-
- ///
- typedef std::vector<FontTable> FontList;
- ///
- FontList fontlist;
/// Output the surrogate pair formed by \p c and \p next to \p os.
/// \return the number of characters written.
int latexSurrogatePair(odocstream & os, value_type c, value_type next,
- Encoding const &);
+ Encoding const &);
+
/// Output a space in appropriate formatting (or a surrogate pair
/// if the next character is a combining character).
/// \return whether a surrogate pair was output.
bool simpleTeXBlanks(Encoding const &,
- odocstream &, TexRow & texrow,
+ odocstream &, TexRow & texrow,
pos_type & i,
unsigned int & column,
Font const & font,
- LyXLayout const & style);
+ Layout const & style);
+
+ /// Output consecutive known unicode chars, belonging to the same
+ /// language as specified by \p preamble, to \p os starting from \p c.
+ /// \return the number of characters written.
+ int knownLangChars(odocstream & os, value_type c, string & preamble,
+ Change &, Encoding const &, pos_type &);
///
void simpleTeXSpecialChars(Buffer const &, BufferParams const &,
- odocstream &,
- TexRow & texrow, OutputParams const &,
- Font & running_font,
+ odocstream &,
+ TexRow & texrow, OutputParams &,
+ Font & running_font,
Font & basefont,
Font const & outerfont,
bool & open_font,
- Change::Type & running_change,
- LyXLayout const & style,
+ Change & running_change,
+ Layout const & style,
pos_type & i,
unsigned int & column, value_type const c);
///
- void validate(LaTeXFeatures & features,
- LyXLayout const & layout) const;
+ void simpleTeXSpecialChar(
+ odocstream & os,
+ OutputParams & runparams,
+ Font & running_font,
+ Change & running_change,
+ pos_type & i,
+ unsigned int & column,
+ value_type const c);
///
- unsigned int id_;
- ///
- static unsigned int paragraph_id;
- ///
- ParagraphParameters params;
+ void validate(LaTeXFeatures & features,
+ Layout const & layout) const;
-private:
///
pos_type size() const { return owner_->size(); }
+
/// match a string against a particular point in the paragraph
bool isTextAt(std::string const & str, pos_type pos) const;
+
+ /// Which Paragraph owns us?
+ Paragraph * owner_;
+
+ /// In which Inset?
+ Inset * inset_owner_;
+
+ ///
+ FontList fontlist_;
+
+ ///
+ unsigned int id_;
+ ///
+ static unsigned int paragraph_id;
+ ///
+ ParagraphParameters params_;
/// for recording and looking up changes
Changes changes_;
- /// Who owns us?
- Paragraph * owner_;
+ ///
+ InsetList insetlist_;
};
// Initialization of the counter for the paragraph id's,
-unsigned int Paragraph::Pimpl::paragraph_id = 0;
+unsigned int Paragraph::Private::paragraph_id = 0;
namespace {
};
special_phrase const special_phrases[] = {
- { "LyX", from_ascii("\\LyX{}"), false },
- { "TeX", from_ascii("\\TeX{}"), true },
- { "LaTeX2e", from_ascii("\\LaTeXe{}"), true },
- { "LaTeX", from_ascii("\\LaTeX{}"), true },
+ { "LyX", from_ascii("\\protect\\LyX{}"), false },
+ { "TeX", from_ascii("\\protect\\TeX{}"), true },
+ { "LaTeX2e", from_ascii("\\protect\\LaTeXe{}"), true },
+ { "LaTeX", from_ascii("\\protect\\LaTeX{}"), true },
};
size_t const phrases_nr = sizeof(special_phrases)/sizeof(special_phrase);
} // namespace anon
-Paragraph::Pimpl::Pimpl(Paragraph * owner)
+Paragraph::Private::Private(Paragraph * owner)
: owner_(owner)
{
- inset_owner = 0;
+ inset_owner_ = 0;
id_ = paragraph_id++;
}
-Paragraph::Pimpl::Pimpl(Pimpl const & p, Paragraph * owner)
- : params(p.params), changes_(p.changes_), owner_(owner)
+Paragraph::Private::Private(Private const & p, Paragraph * owner)
+ : owner_(owner), inset_owner_(p.inset_owner_), fontlist_(p.fontlist_),
+ params_(p.params_), changes_(p.changes_), insetlist_(p.insetlist_)
{
- inset_owner = p.inset_owner;
- fontlist = p.fontlist;
id_ = paragraph_id++;
}
-bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const
+bool Paragraph::isChanged(pos_type start, pos_type end) const
{
BOOST_ASSERT(start >= 0 && start <= size());
BOOST_ASSERT(end > start && end <= size() + 1);
- return changes_.isChanged(start, end);
+ return d->changes_.isChanged(start, end);
}
-bool Paragraph::Pimpl::isMergedOnEndOfParDeletion(bool trackChanges) const {
+bool Paragraph::isMergedOnEndOfParDeletion(bool trackChanges) const {
// keep the logic here in sync with the logic of eraseChars()
if (!trackChanges) {
return true;
}
- Change change = changes_.lookup(size());
+ Change change = d->changes_.lookup(size());
return change.type == Change::INSERTED && change.author == 0;
}
-void Paragraph::Pimpl::setChange(Change const & change)
+void Paragraph::setChange(Change const & change)
{
// beware of the imaginary end-of-par character!
- changes_.set(change, 0, size() + 1);
+ d->changes_.set(change, 0, size() + 1);
/*
* Propagate the change recursively - but not in case of DELETED!
if (change.type != Change::DELETED) {
for (pos_type pos = 0; pos < size(); ++pos) {
- if (owner_->isInset(pos)) {
- owner_->getInset(pos)->setChange(change);
- }
+ if (isInset(pos))
+ getInset(pos)->setChange(change);
}
}
}
-void Paragraph::Pimpl::setChange(pos_type pos, Change const & change)
+void Paragraph::setChange(pos_type pos, Change const & change)
{
BOOST_ASSERT(pos >= 0 && pos <= size());
- changes_.set(change, pos);
+ d->changes_.set(change, pos);
// see comment in setChange(Change const &) above
if (change.type != Change::DELETED &&
- pos < size() && owner_->isInset(pos)) {
- owner_->getInset(pos)->setChange(change);
+ pos < size() && isInset(pos)) {
+ getInset(pos)->setChange(change);
}
}
-Change const & Paragraph::Pimpl::lookupChange(pos_type pos) const
+Change const & Paragraph::lookupChange(pos_type pos) const
{
BOOST_ASSERT(pos >= 0 && pos <= size());
- return changes_.lookup(pos);
+ return d->changes_.lookup(pos);
}
-void Paragraph::Pimpl::acceptChanges(BufferParams const & bparams, pos_type start, pos_type end)
+void Paragraph::acceptChanges(BufferParams const & bparams, pos_type start,
+ pos_type end)
{
BOOST_ASSERT(start >= 0 && start <= size());
BOOST_ASSERT(end > start && end <= size() + 1);
switch (lookupChange(pos).type) {
case Change::UNCHANGED:
// accept changes in nested inset
- if (pos < size() && owner_->isInset(pos)) {
- owner_->getInset(pos)->acceptChanges(bparams);
- }
+ if (pos < size() && isInset(pos))
+ getInset(pos)->acceptChanges(bparams);
break;
case Change::INSERTED:
- changes_.set(Change(Change::UNCHANGED), pos);
+ d->changes_.set(Change(Change::UNCHANGED), pos);
// also accept changes in nested inset
- if (pos < size() && owner_->isInset(pos)) {
- owner_->getInset(pos)->acceptChanges(bparams);
+ if (pos < size() && isInset(pos)) {
+ getInset(pos)->acceptChanges(bparams);
}
break;
}
-void Paragraph::Pimpl::rejectChanges(BufferParams const & bparams, pos_type start, pos_type end)
+void Paragraph::rejectChanges(BufferParams const & bparams,
+ pos_type start, pos_type end)
{
BOOST_ASSERT(start >= 0 && start <= size());
BOOST_ASSERT(end > start && end <= size() + 1);
switch (lookupChange(pos).type) {
case Change::UNCHANGED:
// reject changes in nested inset
- if (pos < size() && owner_->isInset(pos)) {
- owner_->getInset(pos)->rejectChanges(bparams);
+ if (pos < size() && isInset(pos)) {
+ getInset(pos)->rejectChanges(bparams);
}
break;
break;
case Change::DELETED:
- changes_.set(Change(Change::UNCHANGED), pos);
+ d->changes_.set(Change(Change::UNCHANGED), pos);
// Do NOT reject changes within a deleted inset!
// There may be insertions of a co-author inside of it!
}
-Paragraph::value_type Paragraph::Pimpl::getChar(pos_type pos) const
+Paragraph::value_type Paragraph::Private::getChar(pos_type pos) const
{
BOOST_ASSERT(pos >= 0 && pos <= size());
}
-void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, Change const & change)
+void Paragraph::Private::insertChar(pos_type pos, value_type c,
+ Change const & change)
{
BOOST_ASSERT(pos >= 0 && pos <= size());
owner_->text_.insert(owner_->text_.begin() + pos, c);
// Update the font table.
- FontTable search_font(pos, Font());
- for (FontList::iterator it
- = lower_bound(fontlist.begin(), fontlist.end(), search_font, matchFT());
- it != fontlist.end(); ++it)
- {
- it->pos(it->pos() + 1);
- }
+ fontlist_.increasePosAfterPos(pos);
// Update the insets
- owner_->insetlist.increasePosAfterPos(pos);
+ insetlist_.increasePosAfterPos(pos);
}
-void Paragraph::Pimpl::insertInset(pos_type pos, Inset * inset,
- Change const & change)
+void Paragraph::insertInset(pos_type pos, Inset * inset,
+ Change const & change)
{
BOOST_ASSERT(inset);
BOOST_ASSERT(pos >= 0 && pos <= size());
- insertChar(pos, META_INSET, change);
- BOOST_ASSERT(owner_->text_[pos] == META_INSET);
+ d->insertChar(pos, META_INSET, change);
+ BOOST_ASSERT(text_[pos] == META_INSET);
- // Add a new entry in the insetlist.
- owner_->insetlist.insert(inset, pos);
+ // Add a new entry in the insetlist_.
+ d->insetlist_.insert(inset, pos);
}
-bool Paragraph::Pimpl::eraseChar(pos_type pos, bool trackChanges)
+bool Paragraph::eraseChar(pos_type pos, bool trackChanges)
{
BOOST_ASSERT(pos >= 0 && pos <= size());
// keep the logic here in sync with the logic of isMergedOnEndOfParDeletion()
if (trackChanges) {
- Change change = changes_.lookup(pos);
+ Change change = d->changes_.lookup(pos);
- // set the character to DELETED if
+ // set the character to DELETED if
// a) it was previously unchanged or
// b) it was inserted by a co-author
}
// track change
- changes_.erase(pos);
+ d->changes_.erase(pos);
// if it is an inset, delete the inset entry
- if (owner_->text_[pos] == Paragraph::META_INSET) {
- owner_->insetlist.erase(pos);
- }
-
- owner_->text_.erase(owner_->text_.begin() + pos);
-
- // Erase entries in the tables.
- FontTable search_font(pos, Font());
-
- FontList::iterator it =
- lower_bound(fontlist.begin(),
- fontlist.end(),
- search_font, matchFT());
- if (it != fontlist.end() && it->pos() == pos &&
- (pos == 0 ||
- (it != fontlist.begin()
- && boost::prior(it)->pos() == pos - 1))) {
- // If it is a multi-character font
- // entry, we just make it smaller
- // (see update below), otherwise we
- // should delete it.
- unsigned int const i = it - fontlist.begin();
- fontlist.erase(fontlist.begin() + i);
- it = fontlist.begin() + i;
- if (i > 0 && i < fontlist.size() &&
- fontlist[i - 1].font() == fontlist[i].font()) {
- fontlist.erase(fontlist.begin() + i - 1);
- it = fontlist.begin() + i - 1;
- }
- }
+ if (text_[pos] == Paragraph::META_INSET)
+ d->insetlist_.erase(pos);
- // Update all other entries
- FontList::iterator fend = fontlist.end();
- for (; it != fend; ++it)
- it->pos(it->pos() - 1);
+ text_.erase(text_.begin() + pos);
- // Update the insetlist
- owner_->insetlist.decreasePosAfterPos(pos);
+ // Update the fontlist_
+ d->fontlist_.erase(pos);
+
+ // Update the insetlist_
+ d->insetlist_.decreasePosAfterPos(pos);
return true;
}
-int Paragraph::Pimpl::eraseChars(pos_type start, pos_type end, bool trackChanges)
+int Paragraph::eraseChars(pos_type start, pos_type end, bool trackChanges)
{
BOOST_ASSERT(start >= 0 && start <= size());
BOOST_ASSERT(end >= start && end <= size() + 1);
}
-int Paragraph::Pimpl::latexSurrogatePair(odocstream & os, value_type c,
+int Paragraph::Private::latexSurrogatePair(odocstream & os, value_type c,
value_type next, Encoding const & encoding)
{
// Writing next here may circumvent a possible font change between
}
-bool Paragraph::Pimpl::simpleTeXBlanks(Encoding const & encoding,
- odocstream & os, TexRow & texrow,
- pos_type & i,
+bool Paragraph::Private::simpleTeXBlanks(Encoding const & encoding,
+ odocstream & os, TexRow & texrow,
+ pos_type & i,
unsigned int & column,
Font const & font,
- LyXLayout const & style)
+ Layout const & style)
{
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
}
-bool Paragraph::Pimpl::isTextAt(string const & str, pos_type pos) const
+int Paragraph::Private::knownLangChars(odocstream & os,
+ value_type c,
+ string & preamble,
+ Change & runningChange,
+ Encoding const & encoding,
+ pos_type & i)
+{
+ // 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 + 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 != owner_->lookupChange(i + 1))
+ break;
+ Font prev_font;
+ bool found = false;
+ FontList::const_iterator cit = fontlist_.begin();
+ FontList::const_iterator end = fontlist_.end();
+ for (; cit != end; ++cit) {
+ if (cit->pos() >= i && !found) {
+ prev_font = cit->font();
+ found = true;
+ }
+ 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), "}");
+ docstring::size_type const j =
+ latex.find_first_of(from_ascii("{"));
+ if (j == docstring::npos) {
+ os << latex;
+ length += latex.length();
+ } else {
+ os << latex.substr(j + 1);
+ length += latex.substr(j + 1).length();
+ }
+ ++i;
+ }
+ // 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;
+ }
+ return length;
+}
+
+
+bool Paragraph::Private::isTextAt(string const & str, pos_type pos) const
{
pos_type const len = str.length();
return false;
}
- // is there a font change in middle of the word?
- FontList::const_iterator cit = fontlist.begin();
- FontList::const_iterator end = fontlist.end();
- for (; cit != end; ++cit) {
- if (cit->pos() >= pos)
- break;
- }
- if (cit != end && pos + len - 1 > cit->pos())
- return false;
-
- return true;
+ return fontlist_.hasChangeInRange(pos, len);
}
-void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
+void Paragraph::Private::simpleTeXSpecialChars(Buffer const & buf,
BufferParams const & bparams,
odocstream & os,
TexRow & texrow,
- OutputParams const & runparams,
+ OutputParams & runparams,
Font & running_font,
Font & basefont,
Font const & outerfont,
bool & open_font,
- Change::Type & running_change,
- LyXLayout const & style,
+ Change & running_change,
+ Layout const & style,
pos_type & i,
unsigned int & column,
value_type const c)
// Two major modes: LaTeX or plain
// Handle here those cases common to both modes
// and then split to handle the two modes separately.
- switch (c) {
- case Paragraph::META_INSET: {
- Inset * inset = owner_->getInset(i);
+ if (c != Paragraph::META_INSET) {
+ simpleTeXSpecialChar(os, runparams, running_font, running_change,
+ i, column, c);
+ return;
+ }
- // FIXME: remove this check
- if (!inset)
- break;
+ Inset * inset = owner_->getInset(i);
+ BOOST_ASSERT(inset);
- // 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;
- }
+ // FIXME: move this to InsetNewline::latex
+ if (inset->lyxCode() == 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, bparams, runparams,
+ basefont, basefont);
+ open_font = false;
+ }
- if (running_font.family() == Font::TYPEWRITER_FAMILY)
- os << '~';
+ if (running_font.family() == Font::TYPEWRITER_FAMILY)
+ os << '~';
- basefont = owner_->getLayoutFont(bparams, outerfont);
- running_font = basefont;
+ basefont = owner_->getLayoutFont(bparams, outerfont);
+ running_font = basefont;
- if (runparams.moving_arg)
- os << "\\protect ";
+ if (runparams.moving_arg)
+ os << "\\protect ";
- os << "\\\\\n";
- }
- texrow.newline();
- texrow.start(owner_->id(), i + 1);
- column = 0;
- break;
+ os << "\\\\\n";
}
+ texrow.newline();
+ texrow.start(owner_->id(), i + 1);
+ column = 0;
+ }
- // 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.outputChanges
- && runparams.flavor == OutputParams::LATEX
- && features.isAvailable("dvipost");
-
- if (inset->canTrackChanges()) {
- column += Changes::latexMarkChange(os, running_change,
- Change::UNCHANGED, output);
- running_change = Change::UNCHANGED;
- }
+ if (owner_->lookupChange(i).type == Change::DELETED) {
+ if( ++runparams.inDeletedInset == 1)
+ runparams.changeOfDeletedInset = owner_->lookupChange(i);
+ }
- bool close = false;
- odocstream::pos_type const len = os.tellp();
+ if (inset->canTrackChanges()) {
+ column += Changes::latexMarkChange(os, bparams, running_change,
+ Change(Change::UNCHANGED));
+ running_change = Change(Change::UNCHANGED);
+ }
- if ((inset->lyxCode() == Inset::GRAPHICS_CODE
- || inset->lyxCode() == Inset::MATH_CODE
- || inset->lyxCode() == Inset::URL_CODE)
- && running_font.isRightToLeft()) {
- os << "\\L{";
- close = true;
- }
+ bool close = false;
+ odocstream::pos_type const len = os.tellp();
-#ifdef WITH_WARNINGS
-#warning Bug: we can have an empty font change here!
-// if there has just been a font change, we are going to close it
-// right now, which means stupid latex code like \textsf{}. AFAIK,
-// this does not harm dvi output. A minor bug, thus (JMarc)
-#endif
- // some insets cannot be inside a font change command
- if (open_font && inset->noFontChange()) {
- column += running_font.latexWriteEndChanges(
- os, basefont, basefont);
- open_font = false;
+ if ((inset->lyxCode() == GRAPHICS_CODE
+ || inset->lyxCode() == MATH_CODE
+ || inset->lyxCode() == HYPERLINK_CODE)
+ && running_font.isRightToLeft()) {
+ if (running_font.language()->lang() == "farsi")
+ os << "\\beginL{}";
+ else
+ os << "\\L{";
+ close = true;
+ }
+
+ // FIXME: Bug: we can have an empty font change here!
+ // if there has just been a font change, we are going to close it
+ // right now, which means stupid latex code like \textsf{}. AFAIK,
+ // this does not harm dvi output. A minor bug, thus (JMarc)
+
+ // Some insets cannot be inside a font change command.
+ // However, even such insets *can* be placed in \L or \R
+ // or their equivalents (for RTL language switches), so we don't
+ // close the language in those cases.
+ // ArabTeX, though, cannot handle this special behavior, it seems.
+ bool arabtex = basefont.language()->lang() == "arabic_arabtex"
+ || running_font.language()->lang() == "arabic_arabtex";
+ if (open_font && inset->noFontChange()) {
+ bool closeLanguage = arabtex
+ || basefont.isRightToLeft() == running_font.isRightToLeft();
+ unsigned int count = running_font.latexWriteEndChanges(os,
+ bparams, runparams, basefont, basefont, closeLanguage);
+ column += count;
+ // if any font properties were closed, update the running_font,
+ // making sure, however, to leave the language as it was
+ if (count > 0) {
+ // FIXME: probably a better way to keep track of the old
+ // language, than copying the entire font?
+ Font const copy_font(running_font);
basefont = owner_->getLayoutFont(bparams, outerfont);
running_font = basefont;
+ if (!closeLanguage)
+ running_font.setLanguage(copy_font.language());
+ // leave font open if language is still open
+ open_font = (running_font.language() == basefont.language());
+ if (closeLanguage)
+ runparams.local_font = &basefont;
}
+ }
- int tmp = inset->latex(buf, os, runparams);
+ int tmp = inset->latex(buf, os, runparams);
- if (close)
+ if (close) {
+ if (running_font.language()->lang() == "farsi")
+ os << "\\endL{}";
+ else
os << '}';
+ }
- if (tmp) {
- for (int j = 0; j < tmp; ++j) {
- texrow.newline();
- }
- texrow.start(owner_->id(), i + 1);
- column = 0;
- } else {
- column += os.tellp() - len;
- }
+ if (tmp) {
+ for (int j = 0; j < tmp; ++j)
+ texrow.newline();
+
+ texrow.start(owner_->id(), i + 1);
+ column = 0;
+ } else {
+ column += os.tellp() - len;
}
- break;
- default:
- // And now for the special cases within each mode
+ if (owner_->lookupChange(i).type == Change::DELETED)
+ --runparams.inDeletedInset;
+}
- switch (c) {
- case '\\':
- os << "\\textbackslash{}";
- column += 15;
- break;
- case '|': case '<': case '>':
- // In T1 encoding, these characters exist
- if (lyxrc.fontenc == "T1") {
- os.put(c);
- //... but we should avoid ligatures
- if ((c == '>' || c == '<')
- && i <= size() - 2
- && getChar(i + 1) == c) {
- //os << "\\textcompwordmark{}";
- //column += 19;
- // Jean-Marc, have a look at
- // this. IÂ think this works
- // equally well:
- os << "\\,{}";
- // Lgb
- column += 3;
- }
- break;
- }
- // Typewriter font also has them
- if (running_font.family() == Font::TYPEWRITER_FAMILY) {
- os.put(c);
- break;
- }
- // Otherwise, we use what LaTeX
- // provides us.
- switch (c) {
- case '<':
- os << "\\textless{}";
- column += 10;
- break;
- case '>':
- os << "\\textgreater{}";
- column += 13;
- break;
- case '|':
- os << "\\textbar{}";
- column += 9;
- break;
- }
- break;
+void Paragraph::Private::simpleTeXSpecialChar(
+ odocstream & os,
+ OutputParams & runparams,
+ Font & running_font,
+ Change & running_change,
+ pos_type & i,
+ unsigned int & column,
+ value_type const c)
+{
+ if (runparams.verbatim) {
+ os.put(c);
+ return;
+ }
- case '-': // "--" in Typewriter mode -> "-{}-"
- if (i <= size() - 2 &&
- getChar(i + 1) == '-' &&
- running_font.family() == Font::TYPEWRITER_FAMILY) {
- os << "-{}";
- column += 2;
- } else {
- os << '-';
- }
- break;
+ switch (c) {
+ case '\\':
+ os << "\\textbackslash{}";
+ column += 15;
+ break;
- case '\"':
- os << "\\char`\\\"{}";
- column += 9;
+ case '|':
+ case '<':
+ case '>':
+ // In T1 encoding, these characters exist
+ if (lyxrc.fontenc == "T1") {
+ os.put(c);
+ //... but we should avoid ligatures
+ if ((c == '>' || c == '<')
+ && i <= size() - 2
+ && getChar(i + 1) == c) {
+ //os << "\\textcompwordmark{}";
+ //column += 19;
+ // Jean-Marc, have a look at
+ // this. IÂ think this works
+ // equally well:
+ os << "\\,{}";
+ // Lgb
+ column += 3;
+ }
break;
-
- case '$': case '&':
- case '%': case '#': case '{':
- case '}': case '_':
- os << '\\';
+ }
+ // Typewriter font also has them
+ if (running_font.family() == Font::TYPEWRITER_FAMILY) {
os.put(c);
- column += 1;
break;
-
- case '~':
- os << "\\textasciitilde{}";
- column += 16;
+ }
+ // Otherwise, we use what LaTeX
+ // provides us.
+ switch (c) {
+ case '<':
+ os << "\\textless{}";
+ column += 10;
break;
-
- case '^':
- os << "\\textasciicircum{}";
- column += 17;
+ case '>':
+ os << "\\textgreater{}";
+ column += 13;
+ break;
+ case '|':
+ os << "\\textbar{}";
+ column += 9;
break;
+ }
+ break;
- case '*': case '[':
- // avoid being mistaken for optional arguments
- os << '{';
- os.put(c);
- os << '}';
+ case '-': // "--" in Typewriter mode -> "-{}-"
+ if (i <= size() - 2 &&
+ getChar(i + 1) == '-' &&
+ running_font.family() == Font::TYPEWRITER_FAMILY) {
+ os << "-{}";
column += 2;
- break;
+ } else {
+ os << '-';
+ }
+ break;
- case ' ':
- // Blanks are printed before font switching.
- // Sure? I am not! (try nice-latex)
- // I am sure it's correct. LyX might be smarter
- // in the future, but for now, nothing wrong is
- // written. (Asger)
- break;
+ case '\"':
+ os << "\\char`\\\"{}";
+ column += 9;
+ break;
- default:
+ case '$': case '&':
+ case '%': case '#': case '{':
+ case '}': case '_':
+ os << '\\';
+ os.put(c);
+ column += 1;
+ break;
- // I assume this is hack treating typewriter as verbatim
- // FIXME UNICODE: This can fail if c cannot be encoded
- // in the current encoding.
- if (running_font.family() == Font::TYPEWRITER_FAMILY) {
- if (c != '\0') {
- os.put(c);
- }
- break;
- }
+ case '~':
+ os << "\\textasciitilde{}";
+ column += 16;
+ break;
- // LyX, LaTeX etc.
+ case '^':
+ os << "\\textasciicircum{}";
+ column += 17;
+ break;
- // FIXME: if we have "LaTeX" with a font
- // change in the middle (before the 'T', then
- // the "TeX" part is still special cased.
- // Really we should only operate this on
- // "words" for some definition of word
+ case '*': case '[':
+ // avoid being mistaken for optional arguments
+ os << '{';
+ os.put(c);
+ os << '}';
+ column += 2;
+ break;
- size_t pnr = 0;
+ case ' ':
+ // Blanks are printed before font switching.
+ // Sure? I am not! (try nice-latex)
+ // I am sure it's correct. LyX might be smarter
+ // in the future, but for now, nothing wrong is
+ // written. (Asger)
+ break;
- for (; pnr < phrases_nr; ++pnr) {
- if (isTextAt(special_phrases[pnr].phrase, i)) {
- os << special_phrases[pnr].macro;
- i += special_phrases[pnr].phrase.length() - 1;
- column += special_phrases[pnr].macro.length() - 1;
- break;
- }
+ default:
+ // I assume this is hack treating typewriter as verbatim
+ // FIXME UNICODE: This can fail if c cannot be encoded
+ // in the current encoding.
+ if (running_font.family() == Font::TYPEWRITER_FAMILY) {
+ if (c != '\0')
+ os.put(c);
+ break;
+ }
+
+ // LyX, LaTeX etc.
+
+ // FIXME: if we have "LaTeX" with a font
+ // change in the middle (before the 'T', then
+ // the "TeX" part is still special cased.
+ // Really we should only operate this on
+ // "words" for some definition of word
+
+ size_t pnr = 0;
+
+ for (; pnr < phrases_nr; ++pnr) {
+ if (isTextAt(special_phrases[pnr].phrase, i)) {
+ os << special_phrases[pnr].macro;
+ i += special_phrases[pnr].phrase.length() - 1;
+ column += special_phrases[pnr].macro.length() - 1;
+ break;
}
+ }
- if (pnr == phrases_nr && c != '\0') {
- Encoding const & encoding = *(runparams.encoding);
- if (i < size() - 1) {
- char_type next = getChar(i + 1);
- if (Encodings::isCombiningChar(next)) {
- column += latexSurrogatePair(os, c, next, encoding) - 1;
- ++i;
- break;
- }
- }
- docstring const latex = encoding.latexChar(c);
- if (latex.length() > 1 &&
- latex[latex.length() - 1] != '}') {
- // Prevent eating of a following
- // space or command corruption by
- // following characters
- column += latex.length() + 1;
- os << latex << "{}";
- } else {
- column += latex.length() - 1;
- os << latex;
+ if (pnr == phrases_nr && c != '\0') {
+ Encoding const & encoding = *(runparams.encoding);
+ if (i + 1 < size()) {
+ char_type next = getChar(i + 1);
+ if (Encodings::isCombiningChar(next)) {
+ column += latexSurrogatePair(os, c, next, encoding) - 1;
+ ++i;
+ break;
}
}
- break;
+ string preamble;
+ if (Encodings::isKnownLangChar(c, preamble)) {
+ column += knownLangChars(os, c, preamble, running_change,
+ encoding, i) - 1;
+ break;
+ }
+ docstring const latex = encoding.latexChar(c);
+ if (latex.length() > 1 && latex[latex.length() - 1] != '}') {
+ // Prevent eating of a following
+ // space or command corruption by
+ // following characters
+ column += latex.length() + 1;
+ os << latex << "{}";
+ } else {
+ column += latex.length() - 1;
+ os << latex;
+ }
}
+ break;
}
}
-void Paragraph::Pimpl::validate(LaTeXFeatures & features,
- LyXLayout const & layout) const
+void Paragraph::Private::validate(LaTeXFeatures & features,
+ Layout const & layout) const
{
- BufferParams const & bparams = features.bufferParams();
-
// check the params.
- if (!params.spacing().isDefault())
+ if (!params_.spacing().isDefault())
features.require("setspace");
// then the layouts
features.useLayout(layout.name());
// then the fonts
- Language const * doc_language = bparams.language;
-
- FontList::const_iterator fcit = fontlist.begin();
- FontList::const_iterator fend = fontlist.end();
- for (; fcit != fend; ++fcit) {
- if (fcit->font().noun() == Font::ON) {
- LYXERR(Debug::LATEX) << "font.noun: "
- << fcit->font().noun()
- << endl;
- features.require("noun");
- LYXERR(Debug::LATEX) << "Noun enabled. Font: "
- << to_utf8(fcit->font().stateText(0))
- << endl;
- }
- switch (fcit->font().color()) {
- case Color::none:
- case Color::inherit:
- case Color::ignore:
- // probably we should put here all interface colors used for
- // font displaying! For now I just add this ones I know of (Jug)
- case Color::latex:
- case Color::note:
- break;
- default:
- features.require("color");
- LYXERR(Debug::LATEX) << "Color enabled. Font: "
- << to_utf8(fcit->font().stateText(0))
- << endl;
- }
-
- Language const * language = fcit->font().language();
- if (language->babel() != doc_language->babel() &&
- language != ignore_language &&
- language != latex_language)
- {
- features.useLanguage(language);
- LYXERR(Debug::LATEX) << "Found language "
- << language->babel() << endl;
- }
- }
+ fontlist_.validate(features);
- if (!params.leftIndent().zero())
+ // then the indentation
+ if (!params_.leftIndent().zero())
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");
}
}
}
}
-
-} // namespace lyx
-
-
/////////////////////////////////////////////////////////////////////
//
// Paragraph
//
/////////////////////////////////////////////////////////////////////
-namespace lyx {
-
Paragraph::Paragraph()
- : begin_of_body_(0), pimpl_(new Paragraph::Pimpl(this))
+ : begin_of_body_(0), d(new Paragraph::Private(this))
{
itemdepth = 0;
- params().clear();
+ d->params_.clear();
}
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))
+ d(new Paragraph::Private(*par.d, 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().release();
}
Paragraph & Paragraph::operator=(Paragraph const & par)
{
- // needed as we will destroy the pimpl_ before copying it
+ // needed as we will destroy the private part 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().release();
-
layout_ = par.layout();
text_ = par.text_;
begin_of_body_ = par.begin_of_body_;
- delete pimpl_;
- pimpl_ = new Pimpl(*par.pimpl_, this);
+ delete d;
+ d = new Private(*par.d, this);
}
return *this;
}
Paragraph::~Paragraph()
{
- delete pimpl_;
- //
- //lyxerr << "Paragraph::paragraph_id = "
- // << Paragraph::paragraph_id << endl;
+ delete d;
}
}
// First write the layout
- os << "\n\\begin_layout " << layout()->name() << '\n';
+ os << "\n\\begin_layout " << to_utf8(layout()->name()) << '\n';
params().write(os);
int column = 0;
for (pos_type i = 0; i <= size(); ++i) {
- Change change = pimpl_->lookupChange(i);
+ Change change = lookupChange(i);
Changes::lyxMarkChange(os, column, running_change, change);
running_change = change;
void Paragraph::validate(LaTeXFeatures & features) const
{
- pimpl_->validate(features, *layout());
-}
-
-
-bool Paragraph::eraseChar(pos_type pos, bool trackChanges)
-{
- return pimpl_->eraseChar(pos, trackChanges);
-}
-
-
-int Paragraph::eraseChars(pos_type start, pos_type end, bool trackChanges)
-{
- return pimpl_->eraseChars(start, end, trackChanges);
+ d->validate(features, *layout());
}
void Paragraph::insert(pos_type start, docstring const & str,
- Font const & font, Change const & change)
+ Font const & font, Change const & change)
{
for (size_t i = 0, n = str.size(); i != n ; ++i)
insertChar(start + i, str[i], font, change);
void Paragraph::insertChar(pos_type pos, Paragraph::value_type c,
- bool trackChanges)
+ bool trackChanges)
{
- pimpl_->insertChar(pos, c, Change(trackChanges ?
- Change::INSERTED : Change::UNCHANGED));
+ d->insertChar(pos, c, Change(trackChanges ?
+ Change::INSERTED : Change::UNCHANGED));
}
void Paragraph::insertChar(pos_type pos, Paragraph::value_type c,
- Font const & font, bool trackChanges)
+ Font const & font, bool trackChanges)
{
- pimpl_->insertChar(pos, c, Change(trackChanges ?
- Change::INSERTED : Change::UNCHANGED));
+ d->insertChar(pos, c, Change(trackChanges ?
+ Change::INSERTED : Change::UNCHANGED));
setFont(pos, font);
}
void Paragraph::insertChar(pos_type pos, Paragraph::value_type c,
- Font const & font, Change const & change)
+ Font const & font, Change const & change)
{
- pimpl_->insertChar(pos, c, change);
+ d->insertChar(pos, c, change);
setFont(pos, font);
}
void Paragraph::insertInset(pos_type pos, Inset * inset,
- Change const & change)
-{
- pimpl_->insertInset(pos, inset, change);
-}
-
-
-void Paragraph::insertInset(pos_type pos, Inset * inset,
- Font const & font, Change const & change)
+ Font const & font, Change const & change)
{
- pimpl_->insertInset(pos, inset, change);
+ insertInset(pos, inset, change);
+ // Set the font/language of the inset...
setFont(pos, font);
}
-bool Paragraph::insetAllowed(Inset_code code)
+bool Paragraph::insetAllowed(InsetCode code)
{
- return !pimpl_->inset_owner || pimpl_->inset_owner->insetAllowed(code);
+ return !d->inset_owner_ || d->inset_owner_->insetAllowed(code);
}
BOOST_ASSERT(pos <= size());
}
- Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
- Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
- for (; cit != end; ++cit)
- if (cit->pos() >= pos)
- break;
-
- if (cit != end)
+ FontList::const_iterator cit = d->fontlist_.fontIterator(pos);
+ if (cit != d->fontlist_.end())
return cit->font();
if (pos == size() && !empty())
BOOST_ASSERT(pos <= size());
pos_type start = 0;
- Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
- Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
+ FontList::const_iterator cit = d->fontlist_.begin();
+ FontList::const_iterator end = d->fontlist_.end();
for (; cit != end; ++cit) {
if (cit->pos() >= pos) {
if (pos >= beginOfBody())
// Gets uninstantiated font setting at position 0
Font const Paragraph::getFirstFontSettings(BufferParams const & bparams) const
{
- if (!empty() && !pimpl_->fontlist.empty())
- return pimpl_->fontlist[0].font();
+ if (!empty() && !d->fontlist_.empty())
+ return d->fontlist_.begin()->font();
return Font(Font::ALL_INHERIT, bparams.language);
}
// Gets the fully instantiated font at a given position in a paragraph
-// This is basically the same function as LyXText::GetFont() in text2.cpp.
+// This is basically the same function as Text::GetFont() in text2.cpp.
// The difference is that this one is used for generating the LaTeX file,
// and thus cosmetic "improvements" are disallowed: This has to deliver
// the true picture of the buffer. (Asger)
{
BOOST_ASSERT(pos >= 0);
- LyXLayout_ptr const & lout = layout();
+ Font font = getFontSettings(bparams, pos);
pos_type const body_pos = beginOfBody();
-
- Font layoutfont;
if (pos < body_pos)
- layoutfont = lout->labelfont;
+ font.realize(layout_->labelfont);
else
- layoutfont = lout->font;
+ font.realize(layout_->font);
- Font font = getFontSettings(bparams, pos);
- font.realize(layoutfont);
font.realize(outerfont);
font.realize(bparams.getFont());
Font_size Paragraph::highestFontInRange
(pos_type startpos, pos_type endpos, Font_size def_size) const
{
- if (pimpl_->fontlist.empty())
- return def_size;
-
- Pimpl::FontList::const_iterator end_it = pimpl_->fontlist.begin();
- Pimpl::FontList::const_iterator const end = pimpl_->fontlist.end();
- for (; end_it != end; ++end_it) {
- if (end_it->pos() >= endpos)
- break;
- }
-
- if (end_it != end)
- ++end_it;
-
- Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
- for (; cit != end; ++cit) {
- if (cit->pos() >= startpos)
- break;
- }
-
- Font::FONT_SIZE maxsize = Font::SIZE_TINY;
- for (; cit != end_it; ++cit) {
- Font::FONT_SIZE size = cit->font().size();
- if (size == Font::INHERIT_SIZE)
- size = def_size;
- if (size > maxsize && size <= Font::SIZE_HUGER)
- maxsize = size;
- }
- return maxsize;
+ return d->fontlist_.highestInRange(startpos, endpos, def_size);
}
// First, reduce font against layout/label font
// Update: The setCharFont() routine in text2.cpp already
// reduces font, so we don't need to do that here. (Asger)
- // No need to simplify this because it will disappear
- // in a new kernel. (Asger)
- // Next search font table
-
- Pimpl::FontList::iterator beg = pimpl_->fontlist.begin();
- Pimpl::FontList::iterator it = beg;
- Pimpl::FontList::iterator endit = pimpl_->fontlist.end();
- for (; it != endit; ++it) {
- if (it->pos() >= pos)
- break;
- }
- size_t const i = distance(beg, it);
- bool notfound = (it == endit);
-
- if (!notfound && pimpl_->fontlist[i].font() == font)
- return;
-
- bool begin = pos == 0 || notfound ||
- (i > 0 && pimpl_->fontlist[i - 1].pos() == pos - 1);
- // Is position pos is a beginning of a font block?
- bool end = !notfound && pimpl_->fontlist[i].pos() == pos;
- // Is position pos is the end of a font block?
- if (begin && end) { // A single char block
- if (i + 1 < pimpl_->fontlist.size() &&
- pimpl_->fontlist[i + 1].font() == font) {
- // Merge the singleton block with the next block
- pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i);
- if (i > 0 && pimpl_->fontlist[i - 1].font() == font)
- pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i - 1);
- } else if (i > 0 && pimpl_->fontlist[i - 1].font() == font) {
- // Merge the singleton block with the previous block
- pimpl_->fontlist[i - 1].pos(pos);
- pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i);
- } else
- pimpl_->fontlist[i].font(font);
- } else if (begin) {
- if (i > 0 && pimpl_->fontlist[i - 1].font() == font)
- pimpl_->fontlist[i - 1].pos(pos);
- else
- pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i,
- Pimpl::FontTable(pos, font));
- } else if (end) {
- pimpl_->fontlist[i].pos(pos - 1);
- if (!(i + 1 < pimpl_->fontlist.size() &&
- pimpl_->fontlist[i + 1].font() == font))
- pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i + 1,
- Pimpl::FontTable(pos, font));
- } else { // The general case. The block is splitted into 3 blocks
- pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i,
- Pimpl::FontTable(pos - 1, pimpl_->fontlist[i].font()));
- pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i + 1,
- Pimpl::FontTable(pos, font));
- }
+
+ d->fontlist_.set(pos, font);
}
{
layout(par.layout());
// move to pimpl?
- params() = par.params();
+ d->params_ = par.params();
}
bool Paragraph::hasSameLayout(Paragraph const & par) const
{
- return par.layout() == layout() && params().sameLayout(par.params());
+ return par.layout() == layout() && d->params_.sameLayout(par.params());
}
// the next two functions are for the manual labels
docstring const Paragraph::getLabelWidthString() const
{
- if (!params().labelWidthString().empty())
+ if (layout()->margintype == MARGIN_MANUAL)
return params().labelWidthString();
else
return _("Senseless with this layout!");
}
-docstring Paragraph::expandLabel(LyXLayout_ptr const & layout,
+docstring Paragraph::expandLabel(LayoutPtr const & layout,
BufferParams const & bparams, bool process_appendix) const
{
- LyXTextClass const & tclass = bparams.getLyXTextClass();
+ TextClass const & tclass = bparams.getTextClass();
docstring fmt;
if (process_appendix && params().appendix())
else
fmt = translateIfPossible(layout->labelstring(), bparams);
+ if (fmt.empty() && layout->labeltype == LABEL_COUNTER
+ && !layout->counter.empty())
+ fmt = "\\the" + layout->counter;
+
// handle 'inherited level parts' in 'fmt',
// i.e. the stuff between '@' in '@Section@.\arabic{subsection}'
size_t const i = fmt.find('@', 0);
size_t const j = fmt.find('@', i + 1);
if (j != docstring::npos) {
docstring parent(fmt, i + 1, j - i - 1);
- // FIXME UNICODE
- docstring label = expandLabel(tclass[to_utf8(parent)], bparams);
- fmt = docstring(fmt, 0, i) + label + docstring(fmt, j + 1, docstring::npos);
+ docstring label = from_ascii("??");
+ if (tclass.hasLayout(parent))
+ docstring label = expandLabel(tclass[parent], bparams,
+ process_appendix);
+ fmt = docstring(fmt, 0, i) + label
+ + docstring(fmt, j + 1, docstring::npos);
}
}
}
-void Paragraph::applyLayout(LyXLayout_ptr const & new_layout)
+void Paragraph::applyLayout(LayoutPtr const & new_layout)
{
layout(new_layout);
- params().labelWidthString(docstring());
- params().align(LYX_ALIGN_LAYOUT);
- params().spacing(Spacing(Spacing::Default));
+ LyXAlignment const oldAlign = params().align();
+
+ if (!(oldAlign & layout()->alignpossible)) {
+ frontend::Alert::warning(_("Alignment not permitted"),
+ _("The new layout does not permit the alignment previously used.\nSetting to default."));
+ params().align(LYX_ALIGN_LAYOUT);
+ }
}
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 = d->insetlist_.begin();
+ InsetList::const_iterator end = d->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 (!d->insetlist_.empty()) {
+ Inset * inset = d->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))
// This could go to ParagraphParameters if we want to
int Paragraph::startTeXParParams(BufferParams const & bparams,
- odocstream & os, TexRow & texrow,
+ odocstream & os, TexRow & texrow,
bool moving_arg) const
{
int column = 0;
os << "\\noindent ";
column += 10;
}
+
+ LyXAlignment const curAlign = params().align();
- switch (params().align()) {
+ if (curAlign == layout()->align)
+ return column;
+
+ switch (curAlign) {
case LYX_ALIGN_NONE:
case LYX_ALIGN_BLOCK:
case LYX_ALIGN_LAYOUT:
break;
}
- switch (params().align()) {
+ switch (curAlign) {
case LYX_ALIGN_NONE:
case LYX_ALIGN_BLOCK:
case LYX_ALIGN_LAYOUT:
// This could go to ParagraphParameters if we want to
-int Paragraph::endTeXParParams(BufferParams const & bparams,
- odocstream & os, TexRow & texrow,
+int Paragraph::endTeXParParams(BufferParams const & bparams,
+ odocstream & os, TexRow & texrow,
bool moving_arg) const
{
int column = 0;
bool return_value = false;
- LyXLayout_ptr style;
+ LayoutPtr style;
// well we have to check if we are in an inset with unlimited
// length (all in one row) if that is true then we don't allow
bool asdefault = forceDefaultParagraphs();
if (asdefault) {
- style = bparams.getLyXTextClass().defaultLayout();
+ style = bparams.getTextClass().defaultLayout();
} else {
style = layout();
}
// of the body.
Font basefont;
- // output change tracking marks only if desired,
- // if dvipost is installed,
- // and with dvi/ps (other formats don't work)
- bool const output = bparams.outputChanges
- && runparams.flavor == OutputParams::LATEX
- && LaTeXFeatures::isAvailable("dvipost");
-
// Maybe we have to create a optional argument.
pos_type body_pos = beginOfBody();
unsigned int column = 0;
// Do we have an open font change?
bool open_font = false;
- Change::Type runningChangeType = Change::UNCHANGED;
+ Change runningChange = Change(Change::UNCHANGED);
texrow.start(id(), 0);
if (body_pos > 0) {
if (open_font) {
column += running_font.latexWriteEndChanges(
- os, basefont, basefont);
+ os, bparams, runparams,
+ basefont, basefont);
open_font = false;
}
basefont = getLayoutFont(bparams, outerfont);
running_font = basefont;
- column += Changes::latexMarkChange(os,
- runningChangeType, Change::UNCHANGED, output);
- runningChangeType = Change::UNCHANGED;
+ column += Changes::latexMarkChange(os, bparams,
+ runningChange, Change(Change::UNCHANGED));
+ runningChange = Change(Change::UNCHANGED);
os << "}] ";
column +=3;
}
if (!asdefault)
- column += startTeXParParams(bparams, os,
+ column += startTeXParParams(bparams, os,
texrow,
runparams.moving_arg);
}
- Change::Type changeType = pimpl_->lookupChange(i).type;
+ Change const & change = runparams.inDeletedInset ? runparams.changeOfDeletedInset
+ : lookupChange(i);
+
+ if (bparams.outputChanges && runningChange != change) {
+ if (open_font) {
+ column += running_font.latexWriteEndChanges(
+ os, bparams, runparams, basefont, basefont);
+ open_font = false;
+ }
+ basefont = getLayoutFont(bparams, outerfont);
+ running_font = basefont;
+
+ column += Changes::latexMarkChange(os, bparams, runningChange, change);
+ runningChange = change;
+ }
// do not output text which is marked deleted
// if change tracking output is disabled
- if (!output && changeType == Change::DELETED) {
- runningChangeType = changeType;
+ if (!bparams.outputChanges && change.type == Change::DELETED) {
continue;
}
++column;
-
- column += Changes::latexMarkChange(os, runningChangeType,
- changeType, output);
- runningChangeType = changeType;
value_type const c = getChar(i);
font.language() != running_font.language()))
{
column += running_font.latexWriteEndChanges(
- os, basefont,
+ os, bparams, runparams, basefont,
(i == body_pos-1) ? basefont : font);
running_font = basefont;
open_font = false;
}
// Switch file encoding if necessary
- int const count = switchEncoding(os, bparams,
- runparams.moving_arg, *(runparams.encoding),
- *(font.language()->encoding()));
- if (count > 0) {
- column += count;
- runparams.encoding = font.language()->encoding();
+ if (runparams.encoding->package() == Encoding::inputenc &&
+ font.language()->encoding()->package() == Encoding::inputenc) {
+ std::pair<bool, int> const enc_switch = switchEncoding(os, bparams,
+ runparams.moving_arg, *(runparams.encoding),
+ *(font.language()->encoding()));
+ if (enc_switch.first) {
+ column += enc_switch.second;
+ runparams.encoding = font.language()->encoding();
+ }
}
// Do we need to change font?
font.language() != running_font.language()) &&
i != body_pos - 1)
{
- column += font.latexWriteStartChanges(os, basefont,
- last_font);
+ odocstringstream ods;
+ column += font.latexWriteStartChanges(ods, bparams,
+ runparams, basefont,
+ last_font);
running_font = font;
open_font = true;
+ docstring fontchange = ods.str();
+ // check if the fontchange ends with a trailing blank
+ // (like "\small " (see bug 3382)
+ if (suffixIs(fontchange, ' ') && c == ' ')
+ os << fontchange.substr(0, fontchange.size() - 1)
+ << from_ascii("{}");
+ else
+ os << fontchange;
}
if (c == ' ') {
// simpleTeXSpecialChars ignores spaces if
// style->pass_thru is false.
if (i != body_pos - 1) {
- if (pimpl_->simpleTeXBlanks(
+ if (d->simpleTeXBlanks(
*(runparams.encoding), os, texrow,
i, column, font, *style))
// A surrogate pair was output. We
rp.free_spacing = style->free_spacing;
rp.local_font = &font;
rp.intitle = style->intitle;
- pimpl_->simpleTeXSpecialChars(buf, bparams, os,
+ d->simpleTeXSpecialChars(buf, bparams, os,
texrow, rp, running_font,
basefont, outerfont, open_font,
- runningChangeType, *style, i, column, c);
+ runningChange, *style, i, column, c);
+
+ // Set the encoding to that returned from simpleTeXSpecialChars (see
+ // comment for encoding member in OutputParams.h)
+ runparams.encoding = rp.encoding;
}
// If we have an open font definition, we have to close it
#ifdef FIXED_LANGUAGE_END_DETECTION
if (next_) {
running_font
- .latexWriteEndChanges(os, basefont,
+ .latexWriteEndChanges(os, bparams, runparams,
+ basefont,
next_->getFont(bparams, 0, outerfont));
} else {
- running_font.latexWriteEndChanges(os, basefont,
- basefont);
+ running_font.latexWriteEndChanges(os, bparams,
+ runparams, basefont, basefont);
}
#else
-#ifdef WITH_WARNINGS
-//#warning For now we ALWAYS have to close the foreign font settings if they are
-//#warning there as we start another \selectlanguage with the next paragraph if
-//#warning we are in need of this. This should be fixed sometime (Jug)
-#endif
- running_font.latexWriteEndChanges(os, basefont, basefont);
+//FIXME: For now we ALWAYS have to close the foreign font settings if they are
+//FIXME: there as we start another \selectlanguage with the next paragraph if
+//FIXME: we are in need of this. This should be fixed sometime (Jug)
+ running_font.latexWriteEndChanges(os, bparams, runparams,
+ basefont, basefont);
#endif
}
- column += Changes::latexMarkChange(os,
- runningChangeType, Change::UNCHANGED, output);
+ column += Changes::latexMarkChange(os, bparams, runningChange, Change(Change::UNCHANGED));
// Needed if there is an optional argument but no contents.
if (body_pos > 0 && body_pos == size()) {
}
if (!asdefault) {
- column += endTeXParParams(bparams, os, texrow,
+ column += endTeXParParams(bparams, os, texrow,
runparams.moving_arg);
}
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::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))) + "'";
}
if (c == ' ')
break;
os << sgml::escapeChar(c);
- }
+ }
}
return i;
}
{
bool emph_flag = false;
- LyXLayout_ptr const & style = layout();
+ LayoutPtr const & style = layout();
Font font_old =
style->labeltype == LABEL_MANUAL ? style->labelfont : style->font;
value_type c = getChar(i);
if (style->pass_thru)
- os.put(c);
+ os.put(c);
else
- os << sgml::escapeChar(c);
+ os << sgml::escapeChar(c);
}
font_old = font;
}
}
+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;
}
{
if (!empty())
return getFirstFontSettings(bparams).language();
-#ifdef WITH_WARNINGS
-#warning FIXME we should check the prev par as well (Lgb)
-#endif
+ // FIXME: we should check the prev par as well (Lgb)
return bparams.language;
}
-bool Paragraph::isRightToLeftPar(BufferParams const & bparams) const
+bool Paragraph::isRTL(BufferParams const & bparams) const
{
return lyxrc.rtl_support
&& getParLanguage(bparams)->rightToLeft()
- && ownerCode() != Inset::ERT_CODE;
+ && ownerCode() != ERT_CODE
+ && ownerCode() != LISTINGS_CODE;
}
bool Paragraph::isMultiLingual(BufferParams const & bparams) const
{
Language const * doc_language = bparams.language;
- Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
- Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
+ FontList::const_iterator cit = d->fontlist_.begin();
+ FontList::const_iterator end = d->fontlist_.end();
for (; cit != end; ++cit)
if (cit->font().language() != ignore_language &&
os << params().labelString() << ' ';
for (pos_type i = beg; i < end; ++i) {
- value_type const c = getUChar(buffer.params(), i);
+ value_type const c = getChar(i);
if (isPrintable(c))
os.put(c);
else if (c == META_INSET)
void Paragraph::setInsetOwner(Inset * inset)
{
- pimpl_->inset_owner = inset;
-}
-
-
-Change const & Paragraph::lookupChange(pos_type pos) const
-{
- BOOST_ASSERT(pos <= size());
- return pimpl_->lookupChange(pos);
-}
-
-
-bool Paragraph::isChanged(pos_type start, pos_type end) const
-{
- return pimpl_->isChanged(start, end);
-}
-
-
-bool Paragraph::isMergedOnEndOfParDeletion(bool trackChanges) const
-{
- return pimpl_->isMergedOnEndOfParDeletion(trackChanges);
-}
-
-
-void Paragraph::setChange(Change const & change)
-{
- pimpl_->setChange(change);
-}
-
-
-void Paragraph::setChange(pos_type pos, Change const & change)
-{
- pimpl_->setChange(pos, change);
-}
-
-
-void Paragraph::acceptChanges(BufferParams const & bparams, pos_type start, pos_type end)
-{
- return pimpl_->acceptChanges(bparams, start, end);
-}
-
-
-void Paragraph::rejectChanges(BufferParams const & bparams, pos_type start, pos_type end)
-{
- return pimpl_->rejectChanges(bparams, start, end);
+ d->inset_owner_ = inset;
}
int Paragraph::id() const
{
- return pimpl_->id_;
+ return d->id_;
}
-LyXLayout_ptr const & Paragraph::layout() const
+LayoutPtr const & Paragraph::layout() const
{
return layout_;
}
-void Paragraph::layout(LyXLayout_ptr const & new_layout)
+void Paragraph::layout(LayoutPtr const & new_layout)
{
layout_ = new_layout;
}
Inset * Paragraph::inInset() const
{
- return pimpl_->inset_owner;
+ return d->inset_owner_;
}
-Inset::Code Paragraph::ownerCode() const
+InsetCode Paragraph::ownerCode() const
{
- return pimpl_->inset_owner
- ? pimpl_->inset_owner->lyxCode() : Inset::NO_CODE;
+ return d->inset_owner_ ?
+ d->inset_owner_->lyxCode() : NO_CODE;
}
ParagraphParameters & Paragraph::params()
{
- return pimpl_->params;
+ return d->params_;
}
ParagraphParameters const & Paragraph::params() const
{
- return pimpl_->params;
+ return d->params_;
}
// 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;
+ return ownerCode() == ERT_CODE || ownerCode() == LISTINGS_CODE;
}
{
if (layout()->keepempty)
return true;
- return ownerCode() == Inset::ERT_CODE;
+ return ownerCode() == ERT_CODE || ownerCode() == LISTINGS_CODE;
}
}
-bool Paragraph::hfillExpansion(Row const & row, pos_type pos) const
+int Paragraph::checkBiblio(bool track_changes)
{
- if (!isHfill(pos))
- return false;
+ //FIXME From JS:
+ //This is getting more and more a mess. ...We really should clean
+ //up this bibitem issue for 1.6. See also bug 2743.
- BOOST_ASSERT(pos >= row.pos() && pos < row.endpos());
+ // Add bibitem insets if necessary
+ if (layout()->labeltype != LABEL_BIBLIO)
+ return 0;
- // expand at the end of a row only if there is another hfill on the same row
- if (pos == row.endpos() - 1) {
- for (pos_type i = row.pos(); i < pos; i++) {
- if (isHfill(i))
- return true;
- }
- return false;
+ bool hasbibitem = !d->insetlist_.empty()
+ // Insist on it being in pos 0
+ && getChar(0) == Paragraph::META_INSET
+ && d->insetlist_.begin()->inset->lyxCode() == BIBITEM_CODE;
+
+ docstring oldkey;
+ docstring oldlabel;
+
+ // remove a bibitem in pos != 0
+ // restore it later in pos 0 if necessary
+ // (e.g. if a user inserts contents _before_ the item)
+ // we're assuming there's only one of these, which there
+ // should be.
+ int erasedInsetPosition = -1;
+ InsetList::iterator it = d->insetlist_.begin();
+ InsetList::iterator end = d->insetlist_.end();
+ for (; it != end; ++it)
+ if (it->inset->lyxCode() == BIBITEM_CODE
+ && it->pos > 0) {
+ InsetBibitem * olditem = static_cast<InsetBibitem *>(it->inset);
+ oldkey = olditem->getParam("key");
+ oldlabel = olditem->getParam("label");
+ erasedInsetPosition = it->pos;
+ eraseChar(erasedInsetPosition, track_changes);
+ break;
}
- // expand at the beginning of a row only if it is the first row of a paragraph
- if (pos == row.pos()) {
- return pos == 0;
- }
+ //There was an InsetBibitem at the beginning, and we didn't
+ //have to erase one.
+ if (hasbibitem && erasedInsetPosition < 0)
+ return 0;
+
+ //There was an InsetBibitem at the beginning and we did have to
+ //erase one. So we give its properties to the beginning inset.
+ if (hasbibitem) {
+ InsetBibitem * inset =
+ static_cast<InsetBibitem *>(d->insetlist_.begin()->inset);
+ if (!oldkey.empty())
+ inset->setParam("key", oldkey);
+ inset->setParam("label", oldlabel);
+ return -erasedInsetPosition;
+ }
+
+ //There was no inset at the beginning, so we need to create one with
+ //the key and label of the one we erased.
+ InsetBibitem * inset(new InsetBibitem(InsetCommandParams(BIBITEM_CODE)));
+ // restore values of previously deleted item in this par.
+ if (!oldkey.empty())
+ inset->setParam("key", oldkey);
+ inset->setParam("label", oldlabel);
+ insertInset(0, static_cast<Inset *>(inset),
+ Change(track_changes ? Change::INSERTED : Change::UNCHANGED));
- // do not expand in some labels
- if (layout()->margintype != MARGIN_MANUAL && pos < beginOfBody())
- return false;
+ return 1;
+}
- // if there is anything between the first char of the row and
- // the specified position that is neither a newline nor an hfill,
- // the hfill will be expanded, otherwise it won't
- for (pos_type i = row.pos(); i < pos; i++) {
- if (!isNewline(i) && !isHfill(i))
- return true;
- }
- return false;
+
+void Paragraph::checkAuthors(AuthorList const & authorList)
+{
+ d->changes_.checkAuthors(authorList);
}
-bool Paragraph::checkBiblio(bool track_changes)
+bool Paragraph::isUnchanged(pos_type pos) const
{
- // Add bibitem insets if necessary
- if (layout()->labeltype != LABEL_BIBLIO)
- return false;
+ return lookupChange(pos).type == Change::UNCHANGED;
+}
- bool hasbibitem = !insetlist.empty()
- // Insist on it being in pos 0
- && getChar(0) == Paragraph::META_INSET
- && insetlist.begin()->inset->lyxCode() == Inset::BIBITEM_CODE;
- if (hasbibitem)
- return false;
+bool Paragraph::isInserted(pos_type pos) const
+{
+ return lookupChange(pos).type == Change::INSERTED;
+}
- InsetBibitem * inset(new InsetBibitem(InsetCommandParams("bibitem")));
- insertInset(0, static_cast<Inset *>(inset),
- Change(track_changes ? Change::INSERTED : Change::UNCHANGED));
- return true;
+bool Paragraph::isDeleted(pos_type pos) const
+{
+ return lookupChange(pos).type == Change::DELETED;
+}
+
+
+InsetList const & Paragraph::insetList() const
+{
+ return d->insetlist_;
+}
+
+
+Inset * Paragraph::releaseInset(pos_type pos)
+{
+ Inset * inset = d->insetlist_.release(pos);
+ /// does not honour change tracking!
+ eraseChar(pos, false);
+ return inset;
+}
+
+
+Inset * Paragraph::getInset(pos_type pos)
+{
+ return d->insetlist_.get(pos);
+}
+
+
+Inset const * Paragraph::getInset(pos_type pos) const
+{
+ return d->insetlist_.get(pos);
}
} // namespace lyx