#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 "LColor.h"
-#include "LyXLength.h"
-#include "LyXFont.h"
+#include "Color.h"
+#include "Layout.h"
+#include "Length.h"
+#include "Font.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"
namespace lyx {
using support::contains;
+using support::prefixIs;
+using support::suffixIs;
using support::rsplit;
+using support::rtrim;
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
class Encoding;
-class LyXLayout;
+class Layout;
class Paragraph::Pimpl {
///
void insertChar(pos_type pos, value_type c, Change const & change);
///
- void insertInset(pos_type pos, InsetBase * inset, 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);
///
- InsetBase * inset_owner;
+ Inset * inset_owner;
/** A font entry covers a range of positions. Notice that the
entries in the list are inserted in random order.
class FontTable {
public:
///
- FontTable(pos_type p, LyXFont const & f)
+ FontTable(pos_type p, Font const & f)
: pos_(p), font_(f)
{}
///
///
void pos(pos_type p) { pos_ = p; }
///
- LyXFont const & font() const { return font_; }
+ Font const & font() const { return font_; }
///
- void font(LyXFont const & f) { font_ = f;}
+ 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 LyXFont::INHERIT_*, it means that the font
+ 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 LyXFont::IGNORE_* and LyXFont::TOGGLE are NOT
+ The values Font::IGNORE_* and Font::TOGGLE are NOT
allowed in these font tables.
*/
- LyXFont font_;
+ Font font_;
};
///
friend class matchFT;
/// 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,
- LyXFont const & font,
- LyXLayout const & style);
+ Font const & font,
+ 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 &,
- LyXFont & running_font,
- LyXFont & basefont,
- LyXFont const & outerfont,
+ 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;
+ Layout const & layout) const;
///
unsigned int id_;
///
ParagraphParameters params;
-private:
+//private:
///
pos_type size() const { return owner_->size(); }
/// match a string against a particular point in the paragraph
/// Who owns us?
Paragraph * owner_;
+
+ ///
+ InsetList insetlist_;
};
inset_owner = p.inset_owner;
fontlist = p.fontlist;
id_ = paragraph_id++;
+ insetlist_ = p.insetlist_;
+ insetlist_.clone();
}
owner_->text_.insert(owner_->text_.begin() + pos, c);
// Update the font table.
- FontTable search_font(pos, LyXFont());
- for (FontList::iterator it
+ FontTable search_font(pos, Font());
+ for (FontList::iterator it
= lower_bound(fontlist.begin(), fontlist.end(), search_font, matchFT());
it != fontlist.end(); ++it)
{
}
// Update the insets
- owner_->insetlist.increasePosAfterPos(pos);
+ insetlist_.increasePosAfterPos(pos);
}
-void Paragraph::Pimpl::insertInset(pos_type pos, InsetBase * inset,
- Change const & change)
+void Paragraph::Pimpl::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);
- // Add a new entry in the insetlist.
- owner_->insetlist.insert(inset, pos);
+ // Add a new entry in the insetlist_.
+ insetlist_.insert(inset, pos);
}
if (trackChanges) {
Change change = 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
// 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);
// Erase entries in the tables.
- FontTable search_font(pos, LyXFont());
+ FontTable search_font(pos, Font());
FontList::iterator it =
lower_bound(fontlist.begin(),
for (; it != fend; ++it)
it->pos(it->pos() - 1);
- // Update the insetlist
- owner_->insetlist.decreasePosAfterPos(pos);
+ // Update the insetlist_
+ insetlist_.decreasePosAfterPos(pos);
return true;
}
bool Paragraph::Pimpl::simpleTeXBlanks(Encoding const & encoding,
- odocstream & os, TexRow & texrow,
- pos_type & i,
+ odocstream & os, TexRow & texrow,
+ pos_type & i,
unsigned int & column,
- LyXFont const & font,
- LyXLayout const & style)
+ Font const & font,
+ 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
// ! . ? : at the end of a line
- && !(font.family() == LyXFont::TYPEWRITER_FAMILY
+ && !(font.family() == Font::TYPEWRITER_FAMILY
&& (getChar(i - 1) == '.'
|| getChar(i - 1) == '?'
|| getChar(i - 1) == ':'
}
+int Paragraph::Pimpl::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 != 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::Pimpl::isTextAt(string const & str, pos_type pos) const
{
pos_type const len = str.length();
BufferParams const & bparams,
odocstream & os,
TexRow & texrow,
- OutputParams const & runparams,
- LyXFont & running_font,
- LyXFont & basefont,
- LyXFont const & outerfont,
+ 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)
// and then split to handle the two modes separately.
switch (c) {
case Paragraph::META_INSET: {
- InsetBase * inset = owner_->getInset(i);
+ Inset * inset = owner_->getInset(i);
// FIXME: remove this check
if (!inset)
break;
// FIXME: move this to InsetNewline::latex
- if (inset->lyxCode() == InsetBase::NEWLINE_CODE) {
+ if (inset->lyxCode() == NEWLINE_CODE) {
// newlines are handled differently here than
// the default in simpleTeXSpecialChars().
if (!style.newline_allowed) {
} else {
if (open_font) {
column += running_font.latexWriteEndChanges(
- os, basefont, basefont);
+ os, bparams, runparams,
+ basefont, basefont);
open_font = false;
}
- if (running_font.family() == LyXFont::TYPEWRITER_FAMILY)
+ if (running_font.family() == Font::TYPEWRITER_FAMILY)
os << '~';
basefont = owner_->getLayoutFont(bparams, outerfont);
break;
}
- // 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 (lookupChange(i).type == Change::DELETED) {
+ if( ++runparams.inDeletedInset == 1)
+ runparams.changeOfDeletedInset = lookupChange(i);
+ }
if (inset->canTrackChanges()) {
- column += Changes::latexMarkChange(os, running_change,
- Change::UNCHANGED, output);
- running_change = Change::UNCHANGED;
+ column += Changes::latexMarkChange(os, bparams, running_change,
+ Change(Change::UNCHANGED));
+ running_change = Change(Change::UNCHANGED);
}
bool close = false;
odocstream::pos_type const len = os.tellp();
- if ((inset->lyxCode() == InsetBase::GRAPHICS_CODE
- || inset->lyxCode() == InsetBase::MATH_CODE
- || inset->lyxCode() == InsetBase::URL_CODE)
+ if ((inset->lyxCode() == GRAPHICS_CODE
+ || inset->lyxCode() == MATH_CODE
+ || inset->lyxCode() == HYPERLINK_CODE)
&& running_font.isRightToLeft()) {
- os << "\\L{";
+ if (running_font.language()->lang() == "farsi")
+ os << "\\beginL{}";
+ else
+ os << "\\L{";
close = true;
}
-#ifdef WITH_WARNINGS
-#warning Bug: we can have an empty font change here!
+// 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)
-#endif
- // some insets cannot be inside a font change command
+ // 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()) {
- column += running_font.latexWriteEndChanges(
- os, basefont, basefont);
- open_font = false;
- basefont = owner_->getLayoutFont(bparams, outerfont);
- running_font = basefont;
+ 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);
- if (close)
- os << '}';
+ if (close) {
+ if (running_font.language()->lang() == "farsi")
+ os << "\\endL{}";
+ else
+ os << '}';
+ }
if (tmp) {
for (int j = 0; j < tmp; ++j) {
} else {
column += os.tellp() - len;
}
+
+ if (lookupChange(i).type == Change::DELETED) {
+ --runparams.inDeletedInset;
+ }
}
break;
break;
}
// Typewriter font also has them
- if (running_font.family() == LyXFont::TYPEWRITER_FAMILY) {
+ if (running_font.family() == Font::TYPEWRITER_FAMILY) {
os.put(c);
break;
}
case '-': // "--" in Typewriter mode -> "-{}-"
if (i <= size() - 2 &&
getChar(i + 1) == '-' &&
- running_font.family() == LyXFont::TYPEWRITER_FAMILY) {
+ running_font.family() == Font::TYPEWRITER_FAMILY) {
os << "-{}";
column += 2;
} else {
// 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() == LyXFont::TYPEWRITER_FAMILY) {
+ if (running_font.family() == Font::TYPEWRITER_FAMILY) {
if (c != '\0') {
os.put(c);
}
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;
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] != '}') {
void Paragraph::Pimpl::validate(LaTeXFeatures & features,
- LyXLayout const & layout) const
+ Layout const & layout) const
{
BufferParams const & bparams = features.bufferParams();
FontList::const_iterator fcit = fontlist.begin();
FontList::const_iterator fend = fontlist.end();
for (; fcit != fend; ++fcit) {
- if (fcit->font().noun() == LyXFont::ON) {
+ if (fcit->font().noun() == Font::ON) {
LYXERR(Debug::LATEX) << "font.noun: "
<< fcit->font().noun()
<< endl;
<< endl;
}
switch (fcit->font().color()) {
- case LColor::none:
- case LColor::inherit:
- case LColor::ignore:
+ 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 LColor::latex:
- case LColor::note:
+ case Color::latex:
+ case Color::note:
break;
default:
features.require("color");
{
features.useLanguage(language);
LYXERR(Debug::LATEX) << "Found language "
- << language->babel() << endl;
+ << language->lang() << endl;
}
}
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() == InsetBase::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().release();
}
// 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().release();
-
layout_ = par.layout();
text_ = par.text_;
begin_of_body_ = par.begin_of_body_;
}
// First write the layout
- os << "\n\\begin_layout " << layout()->name() << '\n';
+ os << "\n\\begin_layout " << to_utf8(layout()->name()) << '\n';
params().write(os);
- LyXFont font1(LyXFont::ALL_INHERIT, bparams.language);
+ Font font1(Font::ALL_INHERIT, bparams.language);
Change running_change = Change(Change::UNCHANGED);
break;
// Write font changes
- LyXFont font2 = getFontSettings(bparams, i);
+ Font font2 = getFontSettings(bparams, i);
if (font2 != font1) {
font2.lyxWriteChanges(font1, os);
column = 0;
switch (c) {
case META_INSET:
{
- InsetBase const * inset = getInset(i);
+ Inset const * inset = getInset(i);
if (inset)
if (inset->directWrite()) {
// international char, let it write
void Paragraph::insert(pos_type start, docstring const & str,
- LyXFont 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));
+ Change::INSERTED : Change::UNCHANGED));
}
void Paragraph::insertChar(pos_type pos, Paragraph::value_type c,
- LyXFont const & font, bool trackChanges)
+ Font const & font, bool trackChanges)
{
pimpl_->insertChar(pos, c, Change(trackChanges ?
- Change::INSERTED : Change::UNCHANGED));
+ Change::INSERTED : Change::UNCHANGED));
setFont(pos, font);
}
void Paragraph::insertChar(pos_type pos, Paragraph::value_type c,
- LyXFont const & font, Change const & change)
+ Font const & font, Change const & change)
{
pimpl_->insertChar(pos, c, change);
setFont(pos, font);
}
-void Paragraph::insertInset(pos_type pos, InsetBase * inset,
- Change const & change)
+void Paragraph::insertInset(pos_type pos, Inset * inset,
+ Change const & change)
{
pimpl_->insertInset(pos, inset, change);
}
-void Paragraph::insertInset(pos_type pos, InsetBase * inset,
- LyXFont const & font, Change const & change)
+void Paragraph::insertInset(pos_type pos, Inset * inset,
+ Font const & font, Change const & change)
{
pimpl_->insertInset(pos, inset, change);
+ // Set the font/language of the inset...
setFont(pos, font);
}
-bool Paragraph::insetAllowed(InsetBase_code code)
+bool Paragraph::insetAllowed(InsetCode code)
{
return !pimpl_->inset_owner || pimpl_->inset_owner->insetAllowed(code);
}
// Gets uninstantiated font setting at position.
-LyXFont const Paragraph::getFontSettings(BufferParams const & bparams,
+Font const Paragraph::getFontSettings(BufferParams const & bparams,
pos_type pos) const
{
if (pos > size()) {
if (pos == size() && !empty())
return getFontSettings(bparams, pos - 1);
- return LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams));
+ return Font(Font::ALL_INHERIT, getParLanguage(bparams));
}
// Gets uninstantiated font setting at position 0
-LyXFont const Paragraph::getFirstFontSettings(BufferParams const & bparams) const
+Font const Paragraph::getFirstFontSettings(BufferParams const & bparams) const
{
if (!empty() && !pimpl_->fontlist.empty())
return pimpl_->fontlist[0].font();
- return LyXFont(LyXFont::ALL_INHERIT, bparams.language);
+ 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)
-LyXFont const Paragraph::getFont(BufferParams const & bparams, pos_type pos,
- LyXFont const & outerfont) const
+Font const Paragraph::getFont(BufferParams const & bparams, pos_type pos,
+ Font const & outerfont) const
{
BOOST_ASSERT(pos >= 0);
- LyXLayout_ptr const & lout = layout();
+ Font font = getFontSettings(bparams, pos);
pos_type const body_pos = beginOfBody();
-
- LyXFont layoutfont;
if (pos < body_pos)
- layoutfont = lout->labelfont;
+ font.realize(layout_->labelfont);
else
- layoutfont = lout->font;
+ font.realize(layout_->font);
- LyXFont font = getFontSettings(bparams, pos);
- font.realize(layoutfont);
font.realize(outerfont);
font.realize(bparams.getFont());
}
-LyXFont const Paragraph::getLabelFont
- (BufferParams const & bparams, LyXFont const & outerfont) const
+Font const Paragraph::getLabelFont
+ (BufferParams const & bparams, Font const & outerfont) const
{
- LyXFont tmpfont = layout()->labelfont;
+ Font tmpfont = layout()->labelfont;
tmpfont.setLanguage(getParLanguage(bparams));
tmpfont.realize(outerfont);
tmpfont.realize(bparams.getFont());
}
-LyXFont const Paragraph::getLayoutFont
- (BufferParams const & bparams, LyXFont const & outerfont) const
+Font const Paragraph::getLayoutFont
+ (BufferParams const & bparams, Font const & outerfont) const
{
- LyXFont tmpfont = layout()->font;
+ Font tmpfont = layout()->font;
tmpfont.setLanguage(getParLanguage(bparams));
tmpfont.realize(outerfont);
tmpfont.realize(bparams.getFont());
/// Returns the height of the highest font in range
-LyXFont_size Paragraph::highestFontInRange
- (pos_type startpos, pos_type endpos, LyXFont_size def_size) const
+Font_size Paragraph::highestFontInRange
+ (pos_type startpos, pos_type endpos, Font_size def_size) const
{
if (pimpl_->fontlist.empty())
return def_size;
break;
}
- LyXFont::FONT_SIZE maxsize = LyXFont::SIZE_TINY;
+ Font::FONT_SIZE maxsize = Font::SIZE_TINY;
for (; cit != end_it; ++cit) {
- LyXFont::FONT_SIZE size = cit->font().size();
- if (size == LyXFont::INHERIT_SIZE)
+ Font::FONT_SIZE size = cit->font().size();
+ if (size == Font::INHERIT_SIZE)
size = def_size;
- if (size > maxsize && size <= LyXFont::SIZE_HUGER)
+ if (size > maxsize && size <= Font::SIZE_HUGER)
maxsize = size;
}
return maxsize;
}
-void Paragraph::setFont(pos_type pos, LyXFont const & font)
+void Paragraph::setFont(pos_type pos, Font const & font)
{
BOOST_ASSERT(pos <= size());
// 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);
+ }
}
// returns -1 if inset not found
-int Paragraph::getPositionOfInset(InsetBase const * inset) const
+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()) {
- InsetBase * inset = insetlist.begin()->inset;
- if (inset->lyxCode() == InsetBase::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(InsetBase::Code code)
+bool noTrivlistCentering(InsetCode code)
{
- return code == InsetBase::FLOAT_CODE || code == InsetBase::WRAP_CODE;
+ return code == FLOAT_CODE || code == WRAP_CODE;
}
string const corrected_env(string const & suffix, string const & env,
- InsetBase::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;
// This one spits out the text of the paragraph
bool Paragraph::simpleTeXOnePar(Buffer const & buf,
BufferParams const & bparams,
- LyXFont const & outerfont,
+ Font const & outerfont,
odocstream & os, TexRow & texrow,
OutputParams const & runparams) const
{
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();
}
// As long as we are in the label, this font is the base font of the
// label. Before the first body character it is set to the base font
// of the body.
- LyXFont 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");
+ Font basefont;
// Maybe we have to create a optional argument.
pos_type body_pos = beginOfBody();
}
// Which font is currently active?
- LyXFont running_font(basefont);
+ Font running_font(basefont);
// 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
+ : pimpl_->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);
// Fully instantiated font
- LyXFont const font = getFont(bparams, i, outerfont);
+ Font const font = getFont(bparams, i, outerfont);
- LyXFont const last_font = running_font;
+ Font const last_font = running_font;
// Do we need to close the previous font?
if (open_font &&
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 == ' ') {
pimpl_->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)) {
- InsetBase const * inset = getInset(i);
- InsetBase::Code lyx_code = inset->lyxCode();
- if (lyx_code != InsetBase::TOC_CODE &&
- lyx_code != InsetBase::INCLUDE_CODE &&
- lyx_code != InsetBase::GRAPHICS_CODE &&
- lyx_code != InsetBase::ERT_CODE &&
- lyx_code != InsetBase::FLOAT_CODE &&
- lyx_code != InsetBase::TABULAR_CODE) {
+ Inset const * inset = getInset(i);
+ 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)) {
- InsetBase const * inset = getInset(i);
- InsetBase::Code lyx_code = inset->lyxCode();
- if (lyx_code == InsetBase::LABEL_CODE) {
+ Inset const * inset = getInset(i);
+ 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))) + "'";
}
pos_type i;
for (i = 0; i < size(); ++i) {
if (isInset(i)) {
- InsetBase const * inset = getInset(i);
+ Inset const * inset = getInset(i);
inset->docbook(buf, os, runparams);
} else {
value_type c = getChar(i);
if (c == ' ')
break;
os << sgml::escapeChar(c);
- }
+ }
}
return i;
}
-bool Paragraph::onlyText(Buffer const & buf, LyXFont const & outerfont, pos_type initial) const
+bool Paragraph::onlyText(Buffer const & buf, Font const & outerfont, pos_type initial) const
{
- LyXFont font_old;
+ Font font_old;
for (pos_type i = initial; i < size(); ++i) {
- LyXFont font = getFont(buf.params(), i, outerfont);
+ Font font = getFont(buf.params(), i, outerfont);
if (isInset(i))
return false;
if (i != initial && font != font_old)
void Paragraph::simpleDocBookOnePar(Buffer const & buf,
odocstream & os,
OutputParams const & runparams,
- LyXFont const & outerfont,
+ Font const & outerfont,
pos_type initial) const
{
bool emph_flag = false;
- LyXLayout_ptr const & style = layout();
- LyXFont font_old =
+ LayoutPtr const & style = layout();
+ Font font_old =
style->labeltype == LABEL_MANUAL ? style->labelfont : style->font;
if (style->pass_thru && !onlyText(buf, outerfont, initial))
// parsing main loop
for (pos_type i = initial; i < size(); ++i) {
- LyXFont font = getFont(buf.params(), i, outerfont);
+ Font font = getFont(buf.params(), i, outerfont);
// handle <emphasis> tag
if (font_old.emph() != font.emph()) {
- if (font.emph() == LyXFont::ON) {
+ if (font.emph() == Font::ON) {
os << "<emphasis>";
emph_flag = true;
} else if (i != initial) {
}
if (isInset(i)) {
- InsetBase const * inset = getInset(i);
+ Inset const * inset = getInset(i);
inset->docbook(buf, os, runparams);
} else {
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() == InsetBase::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() != InsetBase::ERT_CODE;
+ && ownerCode() != ERT_CODE
+ && ownerCode() != LISTINGS_CODE;
}
{
// change language including dummy font change at the end
for (pos_type i = 0; i <= size(); ++i) {
- LyXFont font = getFontSettings(bparams, i);
+ Font font = getFontSettings(bparams, i);
if (font.language() == from) {
font.setLanguage(to);
setFont(i, font);
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(InsetBase * inset)
+void Paragraph::setInsetOwner(Inset * inset)
{
pimpl_->inset_owner = inset;
}
}
-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;
}
-InsetBase * Paragraph::inInset() const
+Inset * Paragraph::inInset() const
{
return pimpl_->inset_owner;
}
-InsetBase::Code Paragraph::ownerCode() const
+InsetCode Paragraph::ownerCode() const
{
return pimpl_->inset_owner
- ? pimpl_->inset_owner->lyxCode() : InsetBase::NO_CODE;
+ ? pimpl_->inset_owner->lyxCode() : NO_CODE;
}
return true;
// for now we just need this, later should we need this in some
- // other way we can always add a function to InsetBase too.
- return ownerCode() == InsetBase::ERT_CODE;
+ // other way we can always add a function to Inset too.
+ return ownerCode() == ERT_CODE || ownerCode() == LISTINGS_CODE;
}
{
if (layout()->keepempty)
return true;
- return ownerCode() == InsetBase::ERT_CODE;
+ return ownerCode() == ERT_CODE || ownerCode() == LISTINGS_CODE;
}
if (!Encodings::is_arabic(c))
return c;
- value_type const prev_char = pos > 0 ? getChar(pos - 1) : ' ';
+ value_type prev_char = ' ';
value_type next_char = ' ';
+ for (pos_type i = pos - 1; i >= 0; --i) {
+ value_type const par_char = getChar(i);
+ if (!Encodings::isComposeChar_arabic(par_char)) {
+ prev_char = par_char;
+ break;
+ }
+ }
+
for (pos_type i = pos + 1, end = size(); i < end; ++i) {
value_type const par_char = getChar(i);
if (!Encodings::isComposeChar_arabic(par_char)) {
}
-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 = !pimpl_->insetlist_.empty()
+ // Insist on it being in pos 0
+ && getChar(0) == Paragraph::META_INSET
+ && pimpl_->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 = pimpl_->insetlist_.begin();
+ InsetList::iterator end = pimpl_->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 *>(pimpl_->insetlist_.begin()->inset);
+ if (!oldkey.empty())
+ inset->setParam("key", oldkey);
+ inset->setParam("label", oldlabel);
+ return -erasedInsetPosition;
}
- // do not expand in some labels
- if (layout()->margintype != MARGIN_MANUAL && pos < beginOfBody())
- return false;
+ //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")));
+ // 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));
- // 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;
+ return 1;
}
-bool Paragraph::checkBiblio(bool track_changes)
+void Paragraph::checkAuthors(AuthorList const & authorList)
{
- // Add bibitem insets if necessary
- if (layout()->labeltype != LABEL_BIBLIO)
- return false;
+ pimpl_->changes_.checkAuthors(authorList);
+}
- bool hasbibitem = !insetlist.empty()
- // Insist on it being in pos 0
- && getChar(0) == Paragraph::META_INSET
- && insetlist.begin()->inset->lyxCode() == InsetBase::BIBITEM_CODE;
- if (hasbibitem)
- return false;
+bool Paragraph::isUnchanged(pos_type pos) const
+{
+ return lookupChange(pos).type == Change::UNCHANGED;
+}
- InsetBibitem * inset(new InsetBibitem(InsetCommandParams("bibitem")));
- insertInset(0, static_cast<InsetBase *>(inset),
- Change(track_changes ? Change::INSERTED : Change::UNCHANGED));
- return true;
+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