#include "LaTeXFeatures.h"
#include "Color.h"
#include "Length.h"
-#include "LyXFont.h"
+#include "Font.h"
#include "LyXRC.h"
#include "Row.h"
#include "Messages.h"
/////////////////////////////////////////////////////////////////////
class Encoding;
-class LyXLayout;
+class Layout;
class Paragraph::Pimpl {
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);
///
void simpleTeXSpecialChars(Buffer const &, BufferParams const &,
- odocstream &,
- TexRow & texrow, OutputParams const &,
- LyXFont & running_font,
- LyXFont & basefont,
- LyXFont const & outerfont,
+ odocstream &,
+ TexRow & texrow, OutputParams const &,
+ 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_;
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)
{
void Paragraph::Pimpl::insertInset(pos_type pos, Inset * inset,
- Change const & change)
+ Change const & change)
{
BOOST_ASSERT(inset);
BOOST_ASSERT(pos >= 0 && pos <= size());
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
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(),
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;
&& !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) == ':'
odocstream & os,
TexRow & texrow,
OutputParams const & runparams,
- LyXFont & running_font,
- LyXFont & basefont,
- LyXFont const & outerfont,
+ 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)
} 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 (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;
|| inset->lyxCode() == Inset::MATH_CODE
|| inset->lyxCode() == Inset::URL_CODE)
&& running_font.isRightToLeft()) {
- os << "\\L{";
+ if (running_font.language()->lang() == "farsi")
+ os << "\\beginL{}";
+ else
+ os << "\\L{";
close = true;
}
// some insets cannot be inside a font change command
if (open_font && inset->noFontChange()) {
column += running_font.latexWriteEndChanges(
- os, basefont, basefont);
+ os, bparams, runparams,
+ basefont, basefont);
open_font = false;
basefont = owner_->getLayoutFont(bparams, outerfont);
running_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) {
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);
}
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;
{
features.useLanguage(language);
LYXERR(Debug::LATEX) << "Found language "
- << language->babel() << endl;
+ << language->lang() << endl;
}
}
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;
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, Inset * inset,
- Change const & change)
+ Change const & change)
{
pimpl_->insertInset(pos, inset, change);
}
void Paragraph::insertInset(pos_type pos, Inset * inset,
- LyXFont const & font, Change const & change)
+ Font const & font, Change const & change)
{
pimpl_->insertInset(pos, inset, change);
setFont(pos, font);
// 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();
+ Layout_ptr const & lout = layout();
pos_type const body_pos = beginOfBody();
- LyXFont layoutfont;
+ Font layoutfont;
if (pos < body_pos)
layoutfont = lout->labelfont;
else
layoutfont = lout->font;
- LyXFont font = getFontSettings(bparams, pos);
+ Font 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());
}
-docstring Paragraph::expandLabel(LyXLayout_ptr const & layout,
+docstring Paragraph::expandLabel(Layout_ptr 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())
}
-void Paragraph::applyLayout(LyXLayout_ptr const & new_layout)
+void Paragraph::applyLayout(Layout_ptr const & new_layout)
{
layout(new_layout);
params().labelWidthString(docstring());
// 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;
// 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;
+ Layout_ptr 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 = 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) {
+ int const count = switchEncoding(os, bparams,
+ runparams.moving_arg, *(runparams.encoding),
+ *(font.language()->encoding()));
+ if (count > 0) {
+ column += count;
+ 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);
+ column += font.latexWriteStartChanges(os, bparams,
+ runparams, basefont,
+ last_font);
running_font = font;
open_font = true;
}
pimpl_->simpleTeXSpecialChars(buf, bparams, os,
texrow, rp, running_font,
basefont, outerfont, open_font,
- runningChangeType, *style, i, column, c);
+ runningChange, *style, i, column, c);
}
// 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 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);
+ 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);
}
lyx_code != Inset::INCLUDE_CODE &&
lyx_code != Inset::GRAPHICS_CODE &&
lyx_code != Inset::ERT_CODE &&
+ lyx_code != Inset::LISTINGS_CODE &&
lyx_code != Inset::FLOAT_CODE &&
lyx_code != Inset::TABULAR_CODE) {
return false;
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 =
+ Layout_ptr 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) {
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;
}
{
return lyxrc.rtl_support
&& getParLanguage(bparams)->rightToLeft()
- && ownerCode() != Inset::ERT_CODE;
+ && ownerCode() != Inset::ERT_CODE
+ && ownerCode() != Inset::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)
}
-LyXLayout_ptr const & Paragraph::layout() const
+Layout_ptr const & Paragraph::layout() const
{
return layout_;
}
-void Paragraph::layout(LyXLayout_ptr const & new_layout)
+void Paragraph::layout(Layout_ptr const & new_layout)
{
layout_ = new_layout;
}
// 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() == Inset::ERT_CODE || ownerCode() == Inset::LISTINGS_CODE;
}
{
if (layout()->keepempty)
return true;
- return ownerCode() == Inset::ERT_CODE;
+ return ownerCode() == Inset::ERT_CODE || ownerCode() == Inset::LISTINGS_CODE;
}
}
-bool Paragraph::checkBiblio(bool track_changes)
+int Paragraph::checkBiblio(bool track_changes)
{
+ //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.
+
// Add bibitem insets if necessary
if (layout()->labeltype != LABEL_BIBLIO)
- return false;
+ return 0;
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;
+ 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 = insetlist.begin();
+ InsetList::iterator end = insetlist.end();
+ for (; it != end; ++it)
+ if (it->inset->lyxCode() == Inset::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;
+ }
+
+ //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 *>(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")));
+ // 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));
+ Change(track_changes ? Change::INSERTED : Change::UNCHANGED));
- return true;
+ return 1;
}
} // namespace lyx
projects / lyx.git / blobdiff