#include "Language.h"
#include "LaTeXFeatures.h"
#include "Color.h"
-#include "LyXLength.h"
-#include "LyXFont.h"
+#include "Length.h"
+#include "Font.h"
#include "LyXRC.h"
#include "Row.h"
#include "Messages.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::suffixIs;
using support::rsplit;
/////////////////////////////////////////////////////////////////////
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);
///
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
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, 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());
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) == ':'
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() == Inset::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() == Inset::GRAPHICS_CODE
+ || 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;
}
-#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);
}
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;
}
}
if (icit->inset) {
icit->inset->validate(features);
if (layout.needprotect &&
- icit->inset->lyxCode() == InsetBase::FOOT_CODE)
+ icit->inset->lyxCode() == Inset::FOOT_CODE)
features.require("NeedLyXFootnoteCode");
}
}
}
// 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);
+ // ... as well as the font/language of the text inside the inset
+ // FIXME: This is far from perfect. It basically overrides work being done
+ // in the InsetText constructor. Also, it doesn't work for Tables
+ // (precisely because each cell's font/language is set in the Table's
+ // constructor, so by now it's too late). The long-term solution should
+ // be moving current_font into Cursor, and getting rid of all this...
+ // (see http://thread.gmane.org/gmane.editors.lyx.devel/88869/focus=88944)
+ if (inset->asTextInset()) {
+ inset->asTextInset()->text_.current_font = font;
+ inset->asTextInset()->text_.real_current_font = font;
+ }
}
-bool Paragraph::insetAllowed(InsetBase_code code)
+bool Paragraph::insetAllowed(Inset_code 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();
+ 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())
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);
+ docstring label = expandLabel(tclass[parent], bparams);
fmt = docstring(fmt, 0, i) + label + docstring(fmt, j + 1, docstring::npos);
}
}
}
-void Paragraph::applyLayout(LyXLayout_ptr const & new_layout)
+void Paragraph::applyLayout(Layout_ptr 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();
InsetBibitem * Paragraph::bibitem() const
{
if (!insetlist.empty()) {
- InsetBase * inset = insetlist.begin()->inset;
- if (inset->lyxCode() == InsetBase::BIBITEM_CODE)
+ Inset * inset = insetlist.begin()->inset;
+ if (inset->lyxCode() == Inset::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(Inset::Code code)
{
- return code == InsetBase::FLOAT_CODE || code == InsetBase::WRAP_CODE;
+ return code == Inset::FLOAT_CODE || code == Inset::WRAP_CODE;
}
string const corrected_env(string const & suffix, string const & env,
- InsetBase::Code code)
+ Inset::Code 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;
+ 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 = 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);
+ Inset::Code lyx_code = inset->lyxCode();
+ if (lyx_code != Inset::TOC_CODE &&
+ lyx_code != Inset::INCLUDE_CODE &&
+ lyx_code != Inset::GRAPHICS_CODE &&
+ lyx_code != Inset::ERT_CODE &&
+ lyx_code != Inset::LISTINGS_CODE &&
+ lyx_code != Inset::FLOAT_CODE &&
+ lyx_code != Inset::TABULAR_CODE) {
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);
+ Inset::Code lyx_code = inset->lyxCode();
+ if (lyx_code == Inset::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 =
+ 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) {
}
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::isNewline(pos_type pos) const
{
return isInset(pos)
- && getInset(pos)->lyxCode() == InsetBase::NEWLINE_CODE;
+ && getInset(pos)->lyxCode() == Inset::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;
}
{
return lyxrc.rtl_support
&& getParLanguage(bparams)->rightToLeft()
- && ownerCode() != InsetBase::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)
}
-void Paragraph::setInsetOwner(InsetBase * inset)
+void Paragraph::setInsetOwner(Inset * inset)
{
pimpl_->inset_owner = 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;
}
-InsetBase * Paragraph::inInset() const
+Inset * Paragraph::inInset() const
{
return pimpl_->inset_owner;
}
-InsetBase::Code Paragraph::ownerCode() const
+Inset::Code Paragraph::ownerCode() const
{
return pimpl_->inset_owner
- ? pimpl_->inset_owner->lyxCode() : InsetBase::NO_CODE;
+ ? pimpl_->inset_owner->lyxCode() : Inset::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() == Inset::ERT_CODE || ownerCode() == Inset::LISTINGS_CODE;
}
{
if (layout()->keepempty)
return true;
- return ownerCode() == InsetBase::ERT_CODE;
+ return ownerCode() == Inset::ERT_CODE || ownerCode() == Inset::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::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() == InsetBase::BIBITEM_CODE;
+ && 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")));
- insertInset(0, static_cast<InsetBase *>(inset),
- Change(track_changes ? Change::INSERTED : Change::UNCHANGED));
+ // 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));
- return true;
+ return 1;
+}
+
+
+void Paragraph::checkAuthors(AuthorList const & authorList)
+{
+ pimpl_->changes_.checkAuthors(authorList);
}
} // namespace lyx
projects / lyx.git / blobdiff