#include "CoordCache.h"
#include "Cursor.h"
#include "CutAndPaste.h"
-#include "FontIterator.h"
#include "FuncRequest.h"
#include "InsetList.h"
#include "Layout.h"
#include "frontends/Painter.h"
#include "support/debug.h"
-
+#include <cstdlib>
#include <boost/assert.hpp>
using namespace std;
dim_.wid = min_width;
pit_type const npar = text_->paragraphs().size();
if (npar > 1)
- // If there is more than one row, expand the text to
+ // If there is more than one row, expand the text to
// the full allowable width.
dim_.wid = max_width_;
FontInfo const & lf = lab ? layout.labelfont : layout.font;
FontInfo rlf = lab ? layout.reslabelfont : layout.resfont;
-
+
// In case the default family has been customized
if (lf.family() == INHERIT_FAMILY)
rlf.setFamily(params.getFont().fontInfo().family());
}
// The uncommon case need not be optimized as much
- FontInfo const & layoutfont = pos < body_pos ?
+ FontInfo const & layoutfont = pos < body_pos ?
layout.labelfont : layout.font;
Font font = par.getFontSettings(params, pos);
int correction = 0;
if (boundary && sl.pos() > 0)
correction = -1;
-
+
return displayFont(sl.pit(), sl.pos() + correction).isVisibleRightToLeft();
}
BOOST_ASSERT(!parPos.empty());
parPos.pit() = pit;
}
-
+
// redo insets
// FIXME: We should always use getFont(), see documentation of
// noFontChange() in Inset.h.
// position already initialized?
if (!parPos.empty()) {
parPos.pos() = ii->pos;
-
- // A macro template would normally not be visible
- // by itself. But the tex macro semantics allow
+
+ // A macro template would normally not be visible
+ // by itself. But the tex macro semantics allow
// recursion, so we artifically take the context
// after the macro template to simulate this.
if (ii->inset->lyxCode() == MATHMACRO_CODE)
Dimension dim;
pos_type end = rowBreakPoint(width, pit, first);
if (row_index || end < par.size())
- // If there is more than one row, expand the text to
+ // If there is more than one row, expand the text to
// the full allowable width. This setting here is needed
// for the computeRowMetrics() below.
dim_.wid = max_width_;
InsetList::const_iterator iend = par.insetList().end();
for ( ; ii != iend; ++ii) {
if (ii->pos >= endpos || ii->pos < row.pos()
- || ii->inset->lyxCode() != HFILL_CODE)
+ || (ii->inset->lyxCode() != SPACE_CODE ||
+ !ii->inset->isStretchableSpace()))
continue;
Dimension dim = row.dimension();
if (pm.hfillExpansion(row, ii->pos))
max(hfill, 5.0) : row.label_hfill);
else
dim.wid = 5;
- // Cache the inset dimension.
+ // Cache the inset dimension.
bv_->coordCache().insets().add(ii->inset, dim);
pm.setInsetDimension(ii->inset, dim);
}
return leftMargin(max_width_, pit);
}
+namespace {
+
+/**
+ * Calling Text::getFont is slow. While rebreaking we scan a
+ * paragraph from left to right calling getFont for every char. This
+ * simple class address this problem by hidding an optimization trick
+ * (not mine btw -AB): the font is reused in the whole font span. The
+ * class handles transparently the "hidden" (not part of the fontlist)
+ * label font (as getFont does).
+ **/
+class FontIterator
+{
+public:
+ ///
+ FontIterator(TextMetrics const & tm,
+ Paragraph const & par, pit_type pit, pos_type pos)
+ : tm_(tm), par_(par), pit_(pit), pos_(pos),
+ font_(tm.displayFont(pit, pos)),
+ endspan_(par.fontSpan(pos).last),
+ bodypos_(par.beginOfBody())
+ {}
+
+ ///
+ Font const & operator*() const { return font_; }
+
+ ///
+ FontIterator & operator++()
+ {
+ ++pos_;
+ if (pos_ > endspan_ || pos_ == bodypos_) {
+ font_ = tm_.displayFont(pit_, pos_);
+ endspan_ = par_.fontSpan(pos_).last;
+ }
+ return *this;
+ }
+
+ ///
+ Font * operator->() { return &font_; }
+
+private:
+ ///
+ TextMetrics const & tm_;
+ ///
+ Paragraph const & par_;
+ ///
+ pit_type pit_;
+ ///
+ pos_type pos_;
+ ///
+ Font font_;
+ ///
+ pos_type endspan_;
+ ///
+ pos_type bodypos_;
+};
+
+} // anon namespace
pit_type TextMetrics::rowBreakPoint(int width, pit_type const pit,
pit_type pos) const
pos_type const row_pos = row.pos();
pos_type const end = row.endpos();
- // Spaces at logical line breaks in bidi text must be skipped during
+ // Spaces at logical line breaks in bidi text must be skipped during
// cursor positioning. However, they may appear visually in the middle
// of a row; they must be skipped, wherever they are...
// * logically "abc_[HEBREW_\nHEBREW]"
// it's in the last row of a paragraph; see skipped_sep_vpos declaration
if (end > 0 && end < par.size() && par.isSeparator(end - 1))
skipped_sep_vpos = bidi.log2vis(end - 1);
-
+
// Inline completion RTL special case row_pos == cursor_pos:
// "__|b" => cursor_pos is right of __
if (row_pos == inlineCompletionVPos && row_pos == cursor_vpos) {
if (font.isRightToLeft() && completion.length() > 0)
x += theFontMetrics(font.fontInfo()).width(completion);
}
-
+
for (pos_type vpos = row_pos; vpos < cursor_vpos; ++vpos) {
// Skip the separator which is at the logical end of the row
if (vpos == skipped_sep_vpos)
// Inline completion RTL case:
// "a__|b", __ of b => non-boundary a-pos is right of __
- if (vpos + 1 == inlineCompletionVPos
+ if (vpos + 1 == inlineCompletionVPos
&& (vpos + 1 < cursor_vpos || !boundary_correction)) {
font = displayFont(pit, vpos + 1);
docstring const & completion = bv_->inlineCompletion();
if (font.isRightToLeft() && completion.length() > 0)
x += theFontMetrics(font.fontInfo()).width(completion);
}
-
+
// Inline completion LTR case:
// "b|__a", __ of b => non-boundary a-pos is in front of __
if (vpos == inlineCompletionVPos
if (!font.isRightToLeft() && completion.length() > 0)
x += theFontMetrics(font.fontInfo()).width(completion);
}
-
+
if (par.isSeparator(pos) && pos >= body_pos)
x += row.separator;
}
if (pars[newpar].layout().isEnvironment()) {
l_margin = leftMargin(max_width, newpar);
}
- if (tclass.isDefaultLayout(par.layout())
+ if (tclass.isDefaultLayout(par.layout())
|| tclass.isEmptyLayout(par.layout())) {
if (pars[newpar].params().noindent())
parindent.erase();
&& !(!par.empty()
&& par.isInset(pos)
&& par.getInset(pos)->display())
- && ((tclass.isDefaultLayout(par.layout())
+ && ((tclass.isDefaultLayout(par.layout())
|| tclass.isEmptyLayout(par.layout()))
|| buffer.params().paragraph_separation == BufferParams::ParagraphIndentSeparation)
)
bool selection = cur.selection()
// This is our text.
&& cur.text() == text_
- // if the anchor is outside, this is not our selection
+ // if the anchor is outside, this is not our selection
&& cur.anchor().text() == text_
&& pit >= sel_beg.pit() && pit <= sel_end.pit();
// Row signature; has row changed since last paint?
row.setCrc(pm.computeRowSignature(row, bparams));
bool row_has_changed = row.changed();
-
+
// Don't paint the row if a full repaint has not been requested
// and if it has not changed.
if (!pi.full_repaint && !row_has_changed) {
int x2 = cursorX(end.top(), end.boundary());
int y1 = bv_->getPos(cur, cur.boundary()).y_ - row.ascent();
int y2 = y1 + row.height();
-
+
// draw the margins
if (drawOnBegMargin) {
if (text_->isRTL(buffer, beg.paragraph()))
else
pi.pain.fillRectangle(x, y1, x1, y2 - y1, Color_selection);
}
-
+
if (drawOnEndMargin) {
if (text_->isRTL(buffer, beg.paragraph()))
pi.pain.fillRectangle(x, y1, x2, y2 - y1, Color_selection);
else
pi.pain.fillRectangle(x + x2, y1, width() - x2, y2 - y1, Color_selection);
}
-
+
// if we are on a boundary from the beginning, it's probably
// a RTL boundary and we jump to the other side directly as this
// segement is 0-size and confuses the logic below
if (cur.boundary())
cur.boundary(false);
-
+
// go through row and draw from RTL boundary to RTL boundary
while (cur < end) {
bool drawNow = false;
-
+
// simplified cursorForward code below which does not
// descend into insets and which does not go into the
// next line. Compare the logic with the original cursorForward
-
+
// if left of boundary -> just jump to right side
// but for RTL boundaries don't, because: abc|DDEEFFghi -> abcDDEEF|Fghi
if (cur.boundary()) {
} else {
// move right
++cur.pos();
-
+
// line end?
if (cur.pos() == row.endpos())
cur.boundary(true);
}
-
+
if (x1 == -1) {
// the previous segment was just drawn, now the next starts
x1 = cursorX(cur.top(), cur.boundary());
}
-
+
if (!(cur < end) || drawNow) {
x2 = cursorX(cur.top(), cur.boundary());
pi.pain.fillRectangle(x + min(x1,x2), y1, abs(x2 - x1), y2 - y1,
Color_selection);
-
- // reset x1, so it is set again next round (which will be on the
+
+ // reset x1, so it is set again next round (which will be on the
// right side of a boundary or at the selection end)
x1 = -1;
}
}
-void TextMetrics::completionPosAndDim(Cursor const & cur, int & x, int & y,
+void TextMetrics::completionPosAndDim(Cursor const & cur, int & x, int & y,
Dimension & dim) const
{
Cursor const & bvcur = cur.bv().cursor();
-
+
// get word in front of cursor
docstring word = text_->previousWord(bvcur.top());
DocIterator wordStart = bvcur;
wordStart.pos() -= word.length();
-
+
// get position on screen of the word start and end
Point lxy = cur.bv().getPos(wordStart, false);
Point rxy = cur.bv().getPos(bvcur, bvcur.boundary());
-
+
// calculate dimensions of the word
dim = rowHeight(bvcur.pit(), wordStart.pos(), bvcur.pos(), false);
dim.wid = abs(rxy.x_ - lxy.x_);
-
+
// calculate position of word
y = lxy.y_;
x = min(rxy.x_, lxy.x_);
-
+
//lyxerr << "wid=" << dim.width() << " x=" << x << " y=" << y << " lxy.x_=" << lxy.x_ << " rxy.x_=" << rxy.x_ << " word=" << word << std::endl;
//lyxerr << " wordstart=" << wordStart << " bvcur=" << bvcur << " cur=" << cur << std::endl;
}