#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)
MetricsInfo mi(bv_, font.fontInfo(), w, mc);
ii->inset->metrics(mi, dim);
Dimension const old_dim = pm.insetDimension(ii->inset);
- pm.setInsetDimension(ii->inset, dim);
- changed |= (old_dim != dim);
+ if (old_dim != dim) {
+ pm.setInsetDimension(ii->inset, dim);
+ changed = true;
+ }
}
par.setBeginOfBody();
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;
else
align = par.params().align();
+ // handle alignment inside tabular cells
+ Inset const & owner = par.inInset();
+ switch (owner.contentAlignment()) {
+ case LYX_ALIGN_CENTER:
+ case LYX_ALIGN_LEFT:
+ case LYX_ALIGN_RIGHT:
+ if (align == LYX_ALIGN_NONE
+ || align == LYX_ALIGN_BLOCK)
+ align = owner.contentAlignment();
+ break;
+ default:
+ // unchanged (use align)
+ break;
+ }
+
// Display-style insets should always be on a centred row
if (Inset const * inset = par.getInset(row.pos())) {
switch (inset->display()) {
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);
} else {
cur.resetAnchor();
- cur.selection() = true; // to avoid deletion
+ cur.setSelection(true); // to avoid deletion
cursorEnd(cur);
cur.setSelection();
// What is this test for ??? (JMarc)
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
&& align == LYX_ALIGN_BLOCK
&& !par.params().noindent()
// in some insets, paragraphs are never indented
- && !(par.inInset() && par.inInset()->neverIndent())
+ && !par.inInset().neverIndent()
// display style insets are always centered, omit indentation
&& !(!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();
+ // We store the begin and end pos of the selection relative to this par
+ DocIterator sel_beg_par = cur.selectionBegin();
+ DocIterator sel_end_par = cur.selectionEnd();
+
// We care only about visible selection.
if (selection) {
if (pit != sel_beg.pit()) {
- sel_beg.pit() = pit;
- sel_beg.pos() = 0;
+ sel_beg_par.pit() = pit;
+ sel_beg_par.pos() = 0;
}
if (pit != sel_end.pit()) {
- sel_end.pit() = pit;
- sel_end.pos() = sel_end.lastpos();
+ sel_end_par.pit() = pit;
+ sel_end_par.pos() = sel_end_par.lastpos();
}
}
RowPainter rp(pi, *text_, pit, row, bidi, x, y);
if (selection)
- row.setSelection(sel_beg.pos(), sel_end.pos());
+ row.setSelectionAndMargins(sel_beg_par, sel_end_par);
else
row.setSelection(-1, -1);
+
+ // The row knows nothing about the paragraph, so we have to check
+ // whether this row is the first or last and update the margins.
+ if (row.selection()) {
+ if (row.sel_beg == 0)
+ row.begin_margin_sel = sel_beg.pit() < pit;
+ if (row.sel_end == sel_end_par.lastpos())
+ row.end_margin_sel = sel_end.pit() > 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) {
pi.pain.fillRectangle(x, y - row.ascent(),
width(), row.height(), pi.background_color);
}
-
- bool row_selection = row.sel_beg != -1 && row.sel_end != -1;
- 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;
- beg.pit() = pit;
- beg.pos() = row.sel_beg;
- end.pit() = pit;
- end.pos() = row.sel_end;
- drawRowSelection(pi, x, row, beg, end, beg_margin, end_margin);
- }
+
+ if (row.selection())
+ drawRowSelection(pi, x, row, cur, pit);
// Instrumentation for testing row cache (see also
// 12 lines lower):
if (lyxerr.debugging(Debug::PAINTING) && inside
- && (row_selection || pi.full_repaint || row_has_changed)) {
+ && (row.selection() || pi.full_repaint || row_has_changed)) {
string const foreword = text_->isMainText(bv_->buffer()) ?
"main text redraw " : "inset text redraw: ";
LYXERR(Debug::PAINTING, foreword << "pit=" << pit << " row=" << i
- << " row_selection=" << row_selection
+ << " row_selection=" << row.selection()
<< " full_repaint=" << pi.full_repaint
<< " row_has_changed=" << row_has_changed);
}
void TextMetrics::drawRowSelection(PainterInfo & pi, int x, Row const & row,
- DocIterator const & beg, DocIterator const & end,
- bool drawOnBegMargin, bool drawOnEndMargin) const
+ Cursor const & curs, pit_type pit) const
{
+ DocIterator beg = curs.selectionBegin();
+ beg.pit() = pit;
+ beg.pos() = row.sel_beg;
+
+ DocIterator end = curs.selectionEnd();
+ end.pit() = pit;
+ end.pos() = row.sel_end;
+
+ bool const begin_boundary = beg.pos() >= row.endpos();
+ bool const end_boundary = row.sel_end == row.endpos();
+
Buffer & buffer = bv_->buffer();
DocIterator cur = beg;
- int x1 = cursorX(beg.top(), beg.boundary());
- int x2 = cursorX(end.top(), end.boundary());
- int y1 = bv_->getPos(cur, cur.boundary()).y_ - row.ascent();
- int y2 = y1 + row.height();
-
+ cur.boundary(begin_boundary);
+ int x1 = cursorX(beg.top(), begin_boundary);
+ int x2 = cursorX(end.top(), end_boundary);
+ int const y1 = bv_->getPos(cur, cur.boundary()).y_ - row.ascent();
+ int const y2 = y1 + row.height();
+
+ int const rm = text_->isMainText(buffer) ? bv_->rightMargin() : 0;
+ int const lm = text_->isMainText(buffer) ? bv_->leftMargin() : 0;
+
// 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 (row.begin_margin_sel) {
+ if (text_->isRTL(buffer, beg.paragraph())) {
+ pi.pain.fillRectangle(x + x1, y1, width() - rm - x1, y2 - y1,
+ Color_selection);
+ } else {
+ pi.pain.fillRectangle(x + lm, y1, x1 - lm, 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 (row.end_margin_sel) {
+ if (text_->isRTL(buffer, beg.paragraph())) {
+ pi.pain.fillRectangle(x + lm, y1, x2 - lm, y2 - y1,
+ Color_selection);
+ } else {
+ pi.pain.fillRectangle(x + x2, y1, width() - rm - 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 left of boundary -> just jump to right side, but
+ // for RTL boundaries don't, because: abc|DDEEFFghi -> abcDDEEF|Fghi
if (cur.boundary()) {
cur.boundary(false);
} else if (isRTLBoundary(cur.pit(), cur.pos() + 1)) {
- // in front of RTL boundary -> Stay on this side of the boundary because:
- // ab|cDDEEFFghi -> abc|DDEEFFghi
+ // in front of RTL boundary -> Stay on this side of the boundary
+ // because: ab|cDDEEFFghi -> abc|DDEEFFghi
++cur.pos();
cur.boundary(true);
drawNow = true;
} 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