Cursor & cur = const_cast<Cursor &>(bv_->cursor());
// In some cases, we do not know how to record undo
if (&cur.inset() == &text_->inset())
- cur.recordUndo(ATOMIC_UNDO, pit, pit);
+ cur.recordUndo(pit, pit);
int const moveCursor = par.fixBiblio(buffer);
MacroContext mc(&buffer, parPos);
MetricsInfo mi(bv_, font.fontInfo(), w, mc);
ii->inset->metrics(mi, dim);
- Dimension const old_dim = pm.insetDimension(ii->inset);
+ Dimension const & old_dim = pm.insetDimension(ii->inset);
if (old_dim != dim) {
pm.setInsetDimension(ii->inset, dim);
changed = true;
Paragraph const & par = text_->getPar(pit);
- double const w = width - row.right_margin - row.width();
+ int const w = width - row.right_margin - row.width();
// FIXME: put back this assertion when the crash on new doc is solved.
//LASSERT(w >= 0, /**/);
bool const is_rtl = text_->isRTL(par);
if (is_rtl)
- row.x = rightMargin(pit);
+ row.left_margin = rightMargin(pit);
else
- row.x = leftMargin(max_width_, pit, row.pos());
+ row.left_margin = leftMargin(max_width_, pit, row.pos());
// is there a manual margin with a manual label
Layout const & layout = par.layout();
// are there any hfills in the row?
if (int const nh = numberOfHfills(row, par.beginOfBody())) {
if (w > 0)
- hfill = w / double(nh);
+ hfill = double(w) / nh;
// we don't have to look at the alignment if it is ALIGN_LEFT and
// if the row is already larger then the permitted width as then
// we force the LEFT_ALIGN'edness!
* or newline, then stretch it */
if (ns && !row.right_boundary()
&& row.endpos() != par.size()) {
- setSeparatorWidth(row, w / ns);
+ setSeparatorWidth(row, double(w) / ns);
row.dimension().wid = width;
} else if (is_rtl) {
row.dimension().wid = width;
- row.x += w;
+ row.left_margin += w;
}
break;
}
case LYX_ALIGN_RIGHT:
- row.x += w;
+ row.left_margin += w;
break;
case LYX_ALIGN_CENTER:
- row.dimension().wid = width - int(w / 2);
- row.x += w / 2;
+ row.dimension().wid = width - w / 2;
+ row.left_margin += w / 2;
break;
case LYX_ALIGN_LEFT:
case LYX_ALIGN_NONE:
}
}
-#if 0
- if (is_rtl) {
- pos_type body_pos = par.beginOfBody();
- pos_type end = row.endpos();
-
- if (body_pos > 0
- && (body_pos > end || !par.isLineSeparator(body_pos - 1))) {
- row.x += theFontMetrics(text_->labelFont(par)).
- width(layout.labelsep);
- if (body_pos <= end)
- row.x += row.label_hfill;
- }
- }
-#endif
-
// Finally, handle hfill insets
pos_type const endpos = row.endpos();
pos_type body_pos = par.beginOfBody();
Paragraph const & par = text_->getPar(pit);
LBUFERR(par.beginOfBody() > 0 || par.isEnvSeparator(0));
- double w = 0;
+ int w = 0;
Row::const_iterator cit = row.begin();
Row::const_iterator const end = row.end();
// iterate over elements before main body (except the last one,
// which is extra space).
while (cit!= end && cit->endpos < par.beginOfBody()) {
- w += cit->width();
+ w += cit->dim.wid;
++cit;
}
FontMetrics const & fm
= theFontMetrics(text_->labelFont(par));
- return max(0, fm.width(label) - int(w));
+ return max(0, fm.width(label) - w);
}
/** This is the function where the hard work is done. The code here is
* very sensitive to small changes :) Note that part of the
- * intelligence is also in Row::shorten_if_needed
+ * intelligence is also in Row::shortenIfNeeded.
*/
void TextMetrics::breakRow(Row & row, int const right_margin, pit_type const pit) const
{
pos_type const body_pos = par.beginOfBody();
row.clear();
// This make get changed in computeRowMetrics depending on RTL
- row.x = leftMargin(max_width_, pit, pos);
- row.dimension().wid = row.x;
+ row.left_margin = leftMargin(max_width_, pit, pos);
+ row.dimension().wid = row.left_margin;
row.right_margin = right_margin;
if (pos >= end || row.width() > width) {
- row.dimension().wid += right_margin;
row.endpos(end);
return;
}
// if the row is too large, try to cut at last separator.
row.shortenIfNeeded(body_pos, width);
- // if the row ends with a separator that is not at end of
- // paragraph, remove it
- if (!row.empty() && row.back().type == Row::SEPARATOR
- && row.endpos() < par.size())
- row.pop_back();
-
// make sure that the RTL elements are in reverse ordering
row.reverseRTL(text_->isRTL(par));
}
pos_type pos = row.pos();
boundary = false;
if (row.empty())
- x = int(row.x);
- else if (x <= row.x) {
+ x = row.left_margin;
+ else if (x <= row.left_margin) {
pos = row.front().left_pos();
- x = int(row.x);
- } else if (x >= row.width() - row.right_margin) {
+ x = row.left_margin;
+ } else if (x >= row.width()) {
pos = row.back().right_pos();
- x = row.width() - row.right_margin;
+ x = row.width();
} else {
- double w = row.x;
+ double w = row.left_margin;
Row::const_iterator cit = row.begin();
Row::const_iterator cend = row.end();
for ( ; cit != cend; ++cit) {
- if (w <= x && w + cit->width() > x) {
- double x_offset = x - w;
+ if (w <= x && w + cit->full_width() > x) {
+ int x_offset = int(x - w);
pos = cit->x2pos(x_offset);
x = int(x_offset + w);
break;
}
- w += cit->width();
+ w += cit->full_width();
}
if (cit == row.end()) {
pos = row.back().right_pos();
- x = row.width() - row.right_margin;
+ x = row.width();
}
/** This tests for the case where the cursor is placed
* just before a font direction change. See comment on
if (row.empty()
|| (pos == row.begin()->left_pos()
&& pos != row.begin()->right_pos()))
- return int(row.x);
+ return row.left_margin;
Row::const_iterator cit = row.begin();
- double x = row.x;
+ double x = row.left_margin;
for ( ; cit != row.end() ; ++cit) {
/** Look whether the cursor is inside the element's
* span. Note that it is necessary to take the
x += cit->pos2x(pos);
break;
}
- x += cit->width();
+ x += cit->full_width();
}
return int(x);
l_margin += theFontMetrics(buffer.params().getFont()).signedWidth(
tclass.leftmargin());
- if (par.getDepth() != 0) {
+ int depth = par.getDepth();
+ if (depth != 0) {
// find the next level paragraph
pit_type newpar = text_->outerHook(pit);
if (newpar != pit_type(pars.size())) {
if (pars[newpar].layout().isEnvironment()) {
- l_margin = leftMargin(max_width, newpar);
+ int nestmargin = depth * nestMargin();
+ if (text_->isMainText())
+ nestmargin += changebarMargin();
+ l_margin = max(leftMargin(max_width, newpar), nestmargin);
// Remove the parindent that has been added
// if the paragraph was empty.
if (pars[newpar].empty() &&
}
if (!par.params().leftIndent().zero())
- l_margin += par.params().leftIndent().inPixels(max_width);
+ l_margin += par.params().leftIndent().inPixels(max_width, labelfont_metrics.em());
LyXAlignment align;
}
-void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) const
+void TextMetrics::drawParagraph(PainterInfo & pi, pit_type const pit, int const x, int y) const
{
BufferParams const & bparams = bv_->buffer().params();
ParagraphMetrics const & pm = par_metrics_[pit];
for (size_t i = 0; i != nrows; ++i) {
Row const & row = pm.rows()[i];
+ int row_x = x;
if (i)
y += row.ascent();
+ CursorSlice rowSlice(const_cast<InsetText &>(text_->inset()));
+ rowSlice.pit() = pit;
+ rowSlice.pos() = row.pos();
+
bool const inside = (y + row.descent() >= 0
&& y - row.ascent() < ww);
+
+ // Adapt to cursor row scroll offset if applicable.
+ if (bv_->currentRowSlice() == rowSlice)
+ row_x -= bv_->horizScrollOffset();
+
// It is not needed to draw on screen if we are not inside.
pi.pain.setDrawingEnabled(inside && original_drawing_state);
- RowPainter rp(pi, *text_, pit, row, x, y);
+
+ RowPainter rp(pi, *text_, pit, row, row_x, y);
if (selection)
row.setSelectionAndMargins(sel_beg_par, sel_end_par);
}
// Row signature; has row changed since last paint?
- row.setCrc(pm.computeRowSignature(row, bparams));
- bool row_has_changed = row.changed();
+ if (pi.pain.isDrawingEnabled())
+ row.setCrc(pm.computeRowSignature(row, bparams));
+ bool row_has_changed = row.changed()
+ || rowSlice == bv_->lastRowSlice();
// Take this opportunity to spellcheck the row contents.
- if (row_has_changed && lyxrc.spellcheck_continuously) {
+ if (row_has_changed && pi.do_spellcheck && lyxrc.spellcheck_continuously) {
text_->getPar(pit).spellCheck();
}
// Clear background of this row if paragraph background was not
// already cleared because of a full repaint.
if (!pi.full_repaint && row_has_changed) {
- pi.pain.fillRectangle(x, y - row.ascent(),
+ LYXERR(Debug::PAINTING, "Clear rect@("
+ << max(row_x, 0) << ", " << y - row.ascent() << ")="
+ << width() << " x " << row.height());
+ pi.pain.fillRectangle(max(row_x, 0), y - row.ascent(),
width(), row.height(), pi.background_color);
}
LYXERR(Debug::PAINTING, foreword << "pit=" << pit << " row=" << i
<< " row_selection=" << row.selection()
<< " full_repaint=" << pi.full_repaint
- << " row_has_changed=" << row_has_changed);
+ << " row_has_changed=" << row_has_changed
+ << " drawingEnabled=" << pi.pain.isDrawingEnabled());
}
// Backup full_repaint status and force full repaint
rp.paintLast();
if (i == 0 && is_rtl)
rp.paintFirst();
+ rp.paintTooLargeMarks(row_x < 0,
+ row_x + row.width() > bv_->workWidth());
y += row.descent();
// Restore full_repaint status.
projects / lyx.git / blobdiff