#include "ParagraphParameters.h"
#include "SpellChecker.h"
#include "sgml.h"
+#include "texstream.h"
#include "TextClass.h"
#include "TexRow.h"
#include "Text.h"
#include "support/lstrings.h"
#include "support/textutils.h"
+#include <atomic>
#include <sstream>
#include <vector>
class Paragraph::Private
{
- // Enforce our own "copy" constructor by declaring the standard one and
- // the assignment operator private without implementing them.
- Private(Private const &);
- Private & operator=(Private const &);
+ // Enforce our own "copy" constructor
+ Private(Private const &) = delete;
+ Private & operator=(Private const &) = delete;
+ // Unique ID generator
+ static int make_id();
public:
///
Private(Paragraph * owner, Layout const & layout);
}
-// Initialization of the counter for the paragraph id's,
-//
-// FIXME: There should be a more intelligent way to generate and use the
-// paragraph ids per buffer instead a global static counter for all InsetText
-// in the running program.
-// However, this per-session id is used in LFUN_PARAGRAPH_GOTO to
-// switch to a different buffer, as used in the outliner for instance.
-static int paragraph_id = -1;
+//static
+int Paragraph::Private::make_id()
+{
+ // The id is unique per session across buffers because it is used in
+ // LFUN_PARAGRAPH_GOTO to switch to a different buffer, for instance in the
+ // outliner.
+ // (thread-safe)
+ static atomic_uint next_id(0);
+ return next_id++;
+}
+
Paragraph::Private::Private(Private const & p, Paragraph * owner)
: owner_(owner), inset_owner_(p.inset_owner_), fontlist_(p.fontlist_),
+ id_(make_id()),
params_(p.params_), changes_(p.changes_), insetlist_(p.insetlist_),
begin_of_body_(p.begin_of_body_), text_(p.text_), words_(p.words_),
layout_(p.layout_)
{
- id_ = ++paragraph_id;
requestSpellCheck(p.text_.size());
}
Paragraph::Private::Private(Private const & p, Paragraph * owner,
pos_type beg, pos_type end)
- : owner_(owner), inset_owner_(p.inset_owner_),
+ : owner_(owner), inset_owner_(p.inset_owner_), id_(make_id()),
params_(p.params_), changes_(p.changes_),
insetlist_(p.insetlist_, beg, end),
begin_of_body_(p.begin_of_body_), words_(p.words_),
layout_(p.layout_)
{
- id_ = ++paragraph_id;
if (beg >= pos_type(p.text_.size()))
return;
text_ = p.text_.substr(beg, end - beg);
}
+void Paragraph::addChangesToBuffer(Buffer const & buf) const
+{
+ d->changes_.updateBuffer(buf);
+}
+
+
+bool Paragraph::isChangeUpdateRequired() const
+{
+ return d->changes_.isUpdateRequired();
+}
+
+
bool Paragraph::isDeleted(pos_type start, pos_type end) const
{
LASSERT(start >= 0 && start <= size(), return false);
break;
case '-':
os << '-';
- if (i + 1 < end_pos && text_[i+1] == '-') {
+ if (i + 1 < static_cast<pos_type>(text_.size()) &&
+ (end_pos == -1 || i + 1 < end_pos) &&
+ text_[i+1] == '-') {
// Prevent "--" becoming an endash and "---" becoming
// an emdash.
// Within \ttfamily, "--" is merged to "-" (no endash)
BufferParams const & bp = features.runparams().is_child
? buf.masterParams() : buf.params();
Font f;
- TexRow texrow;
// Using a string stream here circumvents the encoding
// switching machinery of odocstream. Therefore the
// output is wrong if this paragraph contains content
// that needs to switch encoding.
odocstringstream ods;
- otexstream os(ods, texrow);
+ otexstream os(ods);
if (is_command) {
os << '\\' << from_ascii(layout_->latexname());
// we have to provide all the optional arguments here, even though
}
}
string const snippet = to_utf8(ods.str());
- features.addPreambleSnippet(snippet);
+ features.addPreambleSnippet(snippet, true);
}
}
icit->inset->validate(features);
if (layout_->needprotect &&
icit->inset->lyxCode() == FOOT_CODE)
- features.require("footmisc");
+ features.require("NeedLyXFootnoteCode");
}
}
FontSpan Paragraph::fontSpan(pos_type pos) const
{
- LBUFERR(pos < size());
+ LBUFERR(pos <= size());
+
+ if (pos == size())
+ return FontSpan(pos, pos);
pos_type start = 0;
FontList::const_iterator cit = d->fontlist_.begin();
}
-/// Returns the height of the highest font in range
-FontSize Paragraph::highestFontInRange
- (pos_type startpos, pos_type endpos, FontSize def_size) const
-{
- return d->fontlist_.highestInRange(startpos, endpos, def_size);
-}
-
-
char_type Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const
{
char_type c = d->text_[pos];
++column;
// Fully instantiated font
- Font const font = getFont(bparams, i, outerfont);
+ Font const current_font = getFont(bparams, i, outerfont);
Font const last_font = running_font;
// Do we need to close the previous font?
if (open_font &&
- (font != running_font ||
- font.language() != running_font.language()))
+ (current_font != running_font ||
+ current_font.language() != running_font.language()))
{
column += running_font.latexWriteEndChanges(
os, bparams, runparams, basefont,
- (i == body_pos-1) ? basefont : font);
+ (i == body_pos-1) ? basefont : current_font);
running_font = basefont;
open_font = false;
}
string const lang_end_command = runparams.use_polyglossia ?
"\\end{$$lang}" : lyxrc.language_command_end;
if (!running_lang.empty() &&
- font.language()->encoding()->package() == Encoding::CJK) {
+ current_font.language()->encoding()->package() == Encoding::CJK) {
string end_tag = subst(lang_end_command,
"$$lang",
running_lang);
// Switch file encoding if necessary (and allowed)
if (!runparams.pass_thru && !style.pass_thru &&
runparams.encoding->package() != Encoding::none &&
- font.language()->encoding()->package() != Encoding::none) {
+ current_font.language()->encoding()->package() != Encoding::none) {
pair<bool, int> const enc_switch =
switchEncoding(os.os(), bparams, runparams,
- *(font.language()->encoding()));
+ *(current_font.language()->encoding()));
if (enc_switch.first) {
column += enc_switch.second;
- runparams.encoding = font.language()->encoding();
+ runparams.encoding = current_font.language()->encoding();
}
}
char_type const c = d->text_[i];
// Do we need to change font?
- if ((font != running_font ||
- font.language() != running_font.language()) &&
+ if ((current_font != running_font ||
+ current_font.language() != running_font.language()) &&
i != body_pos - 1)
{
odocstringstream ods;
- column += font.latexWriteStartChanges(ods, bparams,
+ column += current_font.latexWriteStartChanges(ods, bparams,
runparams, basefont,
last_font);
- running_font = font;
+ running_font = current_font;
open_font = true;
docstring fontchange = ods.str();
// check whether the fontchange ends with a \\textcolor
// style.pass_thru is false.
if (i != body_pos - 1) {
if (d->simpleTeXBlanks(runparams, os,
- i, column, font, style)) {
+ i, column, current_font, style)) {
// A surrogate pair was output. We
// must not call latexSpecialChar
// in this iteration, since it would output
OutputParams rp = runparams;
rp.free_spacing = style.free_spacing;
- rp.local_font = &font;
+ rp.local_font = ¤t_font;
rp.intitle = style.intitle;
// Two major modes: LaTeX or plain
XHTMLStream & xs,
OutputParams const & runparams,
Font const & outerfont,
+ bool start_paragraph, bool close_paragraph,
pos_type initial) const
{
docstring retval;
Layout const & style = *d->layout_;
- xs.startParagraph(allowEmpty());
+ if (start_paragraph)
+ xs.startDivision(allowEmpty());
FontInfo font_old =
style.labeltype == LABEL_MANUAL ? style.labelfont : style.font;
if (!runparams.for_toc || inset->isInToc()) {
OutputParams np = runparams;
np.local_font = &font;
- if (!inset->getLayout().htmlisblock())
+ // If the paragraph has size 1, then we are in the "special
+ // case" where we do not output the containing paragraph info
+ if (!inset->getLayout().htmlisblock() && size() != 1)
np.html_in_par = true;
retval += inset->xhtml(xs, np);
}
font_old = font.fontInfo();
}
+ // FIXME XHTML
+ // I'm worried about what happens if a branch, say, is itself
+ // wrapped in some font stuff. I think that will not work.
xs.closeFontTags();
- xs.endParagraph();
+ if (close_paragraph)
+ xs.endDivision();
+
return retval;
}