#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 <boost/assert.hpp>
+#include <cstdlib>
+#include "support/lassert.h"
using namespace std;
TextMetrics::TextMetrics(BufferView * bv, Text * text)
: bv_(bv), text_(text)
{
- BOOST_ASSERT(bv_);
+ LASSERT(bv_, /**/);
max_width_ = bv_->workWidth();
dim_.wid = max_width_;
dim_.asc = 10;
bool TextMetrics::metrics(MetricsInfo & mi, Dimension & dim, int min_width)
{
- BOOST_ASSERT(mi.base.textwidth);
+ LASSERT(mi.base.textwidth, /**/);
max_width_ = mi.base.textwidth;
// backup old dimension.
Dimension const old_dim = dim_;
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_;
Font TextMetrics::displayFont(pit_type pit, pos_type pos) const
{
- BOOST_ASSERT(pos >= 0);
+ LASSERT(pos >= 0, /**/);
ParagraphList const & pars = text_->paragraphs();
Paragraph const & par = pars[pit];
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();
}
<< " the context is better then.");
updateLabels(bv_->buffer());
parPos = text_->macrocontextPosition();
- BOOST_ASSERT(!parPos.empty());
+ LASSERT(!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_;
double w = width - row.width();
// FIXME: put back this assertion when the crash on new doc is solved.
- //BOOST_ASSERT(w >= 0);
+ //LASSERT(w >= 0, /**/);
//lyxerr << "\ndim_.wid " << dim_.wid << endl;
//lyxerr << "row.width() " << row.width() << endl;
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);
}
Paragraph const & par = text_->getPar(pit);
pos_type last = par.beginOfBody();
- BOOST_ASSERT(last > 0);
+ LASSERT(last > 0, /**/);
// -1 because a label ends with a space that is in the label
--last;
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
left_side = true;
}
- BOOST_ASSERT(vc <= end); // This shouldn't happen.
+ LASSERT(vc <= end, /**/); // This shouldn't happen.
boundary = false;
// This (rtl_support test) is not needed, but gives
// upDownInText() while in selection mode.
ParagraphMetrics const & pm = parMetrics(pit);
- BOOST_ASSERT(row < int(pm.rows().size()));
+ LASSERT(row < int(pm.rows().size()), /**/);
bool bound = false;
Row const & r = pm.rows()[row];
return r.pos() + getColumnNearX(pit, r, x, bound);
// y is screen coordinate
pit_type TextMetrics::getPitNearY(int y)
{
- BOOST_ASSERT(!text_->paragraphs().empty());
+ LASSERT(!text_->paragraphs().empty(), /**/);
LYXERR(Debug::DEBUG, "y: " << y << " cache size: " << par_metrics_.size());
// look for highest numbered paragraph with y coordinate less than given y
ParagraphMetrics const & pm = par_metrics_[pit];
int yy = pm.position() - pm.ascent();
- BOOST_ASSERT(!pm.rows().empty());
+ LASSERT(!pm.rows().empty(), /**/);
RowList::const_iterator rit = pm.rows().begin();
RowList::const_iterator rlast = pm.rows().end();
--rlast;
cur.bv().coordCache().dump();
}
pit_type pit = getPitNearY(y);
- BOOST_ASSERT(pit != -1);
+ LASSERT(pit != -1, /**/);
Row const & row = getRowNearY(y, pit);
bool bound = false;
// This should be just before or just behind the
// cursor position set above.
- BOOST_ASSERT((pos != 0 && inset == insetBefore)
- || inset == pars[pit].getInset(pos));
+ LASSERT((pos != 0 && inset == insetBefore)
+ || inset == pars[pit].getInset(pos), /**/);
// Make sure the cursor points to the position before
// this inset.
void TextMetrics::setCursorFromCoordinates(Cursor & cur, int const x, int const y)
{
- BOOST_ASSERT(text_ == cur.text());
+ LASSERT(text_ == cur.text(), /**/);
pit_type pit = getPitNearY(y);
ParagraphMetrics const & pm = par_metrics_[pit];
" pit: " << pit << " yy: " << yy);
int r = 0;
- BOOST_ASSERT(pm.rows().size());
+ LASSERT(pm.rows().size(), /**/);
for (; r < int(pm.rows().size()) - 1; ++r) {
Row const & row = pm.rows()[r];
if (int(yy + row.height()) > y)
Inset * TextMetrics::checkInsetHit(int x, int y)
{
pit_type pit = getPitNearY(y);
- BOOST_ASSERT(pit != -1);
+ LASSERT(pit != -1, /**/);
Paragraph const & par = text_->paragraphs()[pit];
ParagraphMetrics const & pm = par_metrics_[pit];
int TextMetrics::cursorX(CursorSlice const & sl,
bool boundary) const
{
- BOOST_ASSERT(sl.text() == text_);
+ LASSERT(sl.text() == text_, /**/);
pit_type const pit = sl.pit();
Paragraph const & par = text_->paragraphs()[pit];
ParagraphMetrics const & pm = par_metrics_[pit];
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;
}
bool TextMetrics::cursorHome(Cursor & cur)
{
- BOOST_ASSERT(text_ == cur.text());
+ LASSERT(text_ == cur.text(), /**/);
ParagraphMetrics const & pm = par_metrics_[cur.pit()];
Row const & row = pm.getRow(cur.pos(),cur.boundary());
return text_->setCursor(cur, cur.pit(), row.pos());
bool TextMetrics::cursorEnd(Cursor & cur)
{
- BOOST_ASSERT(text_ == cur.text());
+ LASSERT(text_ == cur.text(), /**/);
// if not on the last row of the par, put the cursor before
// the final space exept if I have a spanning inset or one string
// is so long that we force a break.
void TextMetrics::deleteLineForward(Cursor & cur)
{
- BOOST_ASSERT(text_ == cur.text());
+ LASSERT(text_ == cur.text(), /**/);
if (cur.lastpos() == 0) {
// Paragraph is empty, so we just go forward
text_->cursorForward(cur);
int TextMetrics::leftMargin(int max_width, pit_type pit) const
{
- BOOST_ASSERT(pit >= 0);
- BOOST_ASSERT(pit < int(text_->paragraphs().size()));
+ LASSERT(pit >= 0, /**/);
+ LASSERT(pit < int(text_->paragraphs().size()), /**/);
return leftMargin(max_width, pit, text_->paragraphs()[pit].size());
}
{
ParagraphList const & pars = text_->paragraphs();
- BOOST_ASSERT(pit >= 0);
- BOOST_ASSERT(pit < int(pars.size()));
+ LASSERT(pit >= 0, /**/);
+ LASSERT(pit < int(pars.size()), /**/);
Paragraph const & par = pars[pit];
- BOOST_ASSERT(pos >= 0);
- BOOST_ASSERT(pos <= par.size());
+ LASSERT(pos >= 0, /**/);
+ LASSERT(pos <= par.size(), /**/);
Buffer const & buffer = bv_->buffer();
//lyxerr << "TextMetrics::leftMargin: pit: " << pit << " pos: " << pos << endl;
DocumentClass const & tclass = buffer.params().documentClass();
if (pars[newpar].layout().isEnvironment()) {
l_margin = leftMargin(max_width, newpar);
}
- if (tclass.isDefaultLayout(par.layout())
- || tclass.isEmptyLayout(par.layout())) {
+ if (tclass.isDefaultLayout(par.layout())
+ || tclass.isPlainLayout(par.layout())) {
if (pars[newpar].params().noindent())
parindent.erase();
else
&& !(!par.empty()
&& par.isInset(pos)
&& par.getInset(pos)->display())
- && ((tclass.isDefaultLayout(par.layout())
- || tclass.isEmptyLayout(par.layout()))
+ && (!(tclass.isDefaultLayout(par.layout())
+ || tclass.isPlainLayout(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) {
if (row_selection) {
DocIterator beg = bv_->cursor().selectionBegin();
DocIterator end = bv_->cursor().selectionEnd();
- bool const beg_margin = beg.pit() < pit && i == 0;
- bool const end_margin = end.pit() > pit && i == nrows - 1;
+ // FIXME (not here): pit is not updated when extending
+ // a selection to a new row with cursor right/left
+ bool const beg_margin = beg.pit() < pit;
+ bool const end_margin = end.pit() > pit;
beg.pit() = pit;
beg.pos() = row.sel_beg;
end.pit() = pit;
end.pos() = row.sel_end;
+ if (end.pos() == row.endpos()) {
+ // selection goes till the end of the row.
+ end.boundary(true);
+ }
drawRowSelection(pi, x, row, beg, end, beg_margin, end_margin);
}
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()))
- pi.pain.fillRectangle(x + x1, y1, width() - x1, y2 - y1, Color_selection);
- else
- pi.pain.fillRectangle(x, y1, x1, y2 - y1, Color_selection);
+ if (text_->isRTL(buffer, beg.paragraph())) {
+ int lm = bv_->leftMargin();
+ pi.pain.fillRectangle(x + x1, y1, width() - lm - x1, y2 - y1, Color_selection);
+ } else {
+ int rm = bv_->rightMargin();
+ pi.pain.fillRectangle(rm, y1, x1 - rm, 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 (text_->isRTL(buffer, beg.paragraph())) {
+ int rm = bv_->rightMargin();
+ pi.pain.fillRectangle(x + rm, y1, x2 - rm, y2 - y1, Color_selection);
+ } else {
+ int lm = bv_->leftMargin();
+ pi.pain.fillRectangle(x + x2, y1, width() - lm - 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;
}
projects / lyx.git / blobdiff