#include "CoordCache.h"
#include "Cursor.h"
#include "CutAndPaste.h"
-#include "FontIterator.h"
#include "FuncRequest.h"
#include "InsetList.h"
#include "Layout.h"
#include "support/debug.h"
#include <cstdlib>
-#include <boost/assert.hpp>
+#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_;
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];
<< " the context is better then.");
updateLabels(bv_->buffer());
parPos = text_->macrocontextPosition();
- BOOST_ASSERT(!parPos.empty());
+ LASSERT(!parPos.empty(), /**/);
parPos.pit() = pit;
}
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();
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()) {
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];
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();
l_margin = leftMargin(max_width, newpar);
}
if (tclass.isDefaultLayout(par.layout())
- || tclass.isEmptyLayout(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)
)
{
&& 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));
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
// 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;
projects / lyx.git / blobdiff