#include "CutAndPaste.h"
#include "HSpace.h"
#include "InsetList.h"
+#include "Language.h"
#include "Layout.h"
#include "LyXRC.h"
#include "MetricsInfo.h"
namespace {
-int numberOfSeparators(Row const & row)
-{
- int n = 0;
- Row::const_iterator cit = row.begin();
- Row::const_iterator const end = row.end();
- for ( ; cit != end ; ++cit)
- if (cit->type == Row::SEPARATOR)
- ++n;
- return n;
-}
-
-
-void setSeparatorWidth(Row & row, double w)
-{
- row.separator = w;
- Row::iterator it = row.begin();
- Row::iterator const end = row.end();
- for ( ; it != end ; ++it)
- if (it->type == Row::SEPARATOR)
- it->extra = w;
-}
-
int numberOfLabelHfills(Paragraph const & par, Row const & row)
{
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);
// redo insets
Font const bufferfont = buffer.params().getFont();
+ CoordCache::Insets & insetCache = bv_->coordCache().insets();
InsetList::const_iterator ii = par.insetList().begin();
InsetList::const_iterator iend = par.insetList().end();
for (; ii != iend; ++ii) {
MacroContext mc(&buffer, parPos);
MetricsInfo mi(bv_, font.fontInfo(), w, mc);
ii->inset->metrics(mi, dim);
- Dimension const old_dim = pm.insetDimension(ii->inset);
- if (old_dim != dim) {
- pm.setInsetDimension(ii->inset, dim);
+ if (!insetCache.has(ii->inset) || insetCache.dim(ii->inset) != dim) {
+ insetCache.add(ii->inset, dim);
changed = true;
}
}
breakRow(row, right_margin, pit);
setRowHeight(row, pit);
row.setChanged(false);
- if (row_index || row.endpos() < par.size())
- // If there is more than one row, expand the text to
- // the full allowable width. This setting here is needed
- // for the computeRowMetrics() below.
+ if (row_index || row.right_boundary() || row.endpos() < par.size())
+ // If there is more than one row or the row has been
+ // broken by a display inset or a newline, expand the text
+ // to the full allowable width. This setting here is
+ // needed for the computeRowMetrics() below.
dim_.wid = max_width_;
int const max_row_width = max(dim_.wid, row.width());
computeRowMetrics(pit, row, max_row_width);
}
-int TextMetrics::getAlign(Paragraph const & par, pos_type const pos) const
+LyXAlignment TextMetrics::getAlign(Paragraph const & par, pos_type const pos) const
{
Layout const & layout = par.layout();
- int align;
+ LyXAlignment align;
if (par.params().align() == LYX_ALIGN_LAYOUT)
align = layout.align;
else
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);
- else
- row.x = 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!
// set x how you need it
switch (getAlign(par, row.pos())) {
case LYX_ALIGN_BLOCK: {
- int const ns = numberOfSeparators(row);
+ int const ns = row.countSeparators();
/** If we have separators, and this row has
* not be broken abruptly by a display inset
* or newline, then stretch it */
- if (ns && !row.right_boundary()
+ if (ns && !row.right_boundary()
&& row.endpos() != par.size()) {
- setSeparatorWidth(row, w / ns);
+ row.setSeparatorExtraWidth(double(w) / ns);
row.dimension().wid = width;
- } else if (is_rtl) {
+ } else if (text_->isRTL(par)) {
row.dimension().wid = width;
- row.x += w;
+ row.left_margin += w;
}
break;
}
case LYX_ALIGN_RIGHT:
- row.x += w;
+ row.left_margin += w;
+ row.dimension().wid += w;
break;
case LYX_ALIGN_CENTER:
row.dimension().wid = width - w / 2;
- row.x += w / 2;
+ row.left_margin += w / 2;
+ break;
+ case LYX_ALIGN_LEFT:
+ case LYX_ALIGN_NONE:
+ case LYX_ALIGN_LAYOUT:
+ case LYX_ALIGN_SPECIAL:
+ case LYX_ALIGN_DECIMAL:
break;
}
}
-#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();
&& (body_pos > endpos || !par.isLineSeparator(body_pos - 1)))
body_pos = 0;
ParagraphMetrics & pm = par_metrics_[pit];
+ CoordCache::Insets & insetCache = bv_->coordCache().insets();
Row::iterator cit = row.begin();
Row::iterator const cend = row.end();
for ( ; cit != cend; ++cit) {
if (row.label_hfill && cit->endpos == body_pos
&& cit->type == Row::SPACE)
- cit->dim.wid -= row.label_hfill * (nlh - 1);
+ cit->dim.wid -= int(row.label_hfill * (nlh - 1));
if (!cit->inset || !cit->inset->isHfill())
continue;
if (pm.hfillExpansion(row, cit->pos))
else
cit->dim.wid = 5;
// Cache the inset dimension.
- bv_->coordCache().insets().add(cit->inset, cit->dim);
- pm.setInsetDimension(cit->inset, cit->dim);
+ insetCache.add(cit->inset, cit->dim);
}
}
// 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;
}
/** 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
{
Paragraph const & par = text_->getPar(pit);
pos_type const end = par.size();
pos_type const pos = row.pos();
- int const width = max_width_ - right_margin;
pos_type const body_pos = par.beginOfBody();
+ bool const is_rtl = text_->isRTL(par);
+
row.clear();
- row.dimension().wid = leftMargin(max_width_, pit, pos);
+ row.left_margin = leftMargin(max_width_, pit, pos);
row.right_margin = right_margin;
+ if (is_rtl)
+ swap(row.left_margin, row.right_margin);
+ // Remember that the row width takes into account the left_margin
+ // but not the right_margin.
+ row.dimension().wid = row.left_margin;
+ // the width available for the row.
+ int const width = max_width_ - row.right_margin;
if (pos >= end || row.width() > width) {
- row.dimension().wid += right_margin;
row.endpos(end);
return;
}
- ParagraphMetrics const & pm = par_metrics_[pit];
ParagraphList const & pars = text_->paragraphs();
#if 0
#endif
// check for possible inline completion
- DocIterator const & inlineCompletionPos = bv_->inlineCompletionPos();
- pos_type inlineCompletionLPos = -1;
- if (inlineCompletionPos.inTexted()
- && inlineCompletionPos.text() == text_
- && inlineCompletionPos.pit() == pit) {
- // draw logically behind the previous character
- inlineCompletionLPos = inlineCompletionPos.pos() - 1;
- }
+ DocIterator const & ic_it = bv_->inlineCompletionPos();
+ pos_type ic_pos = -1;
+ if (ic_it.inTexted() && ic_it.text() == text_ && ic_it.pit() == pit)
+ ic_pos = ic_it.pos();
// Now we iterate through until we reach the right margin
// or the end of the par, then build a representation of the row.
pos_type i = pos;
FontIterator fi = FontIterator(*this, par, pit, pos);
- while (i < end && row.width() < width) {
+ while (i < end && row.width() <= width) {
char_type c = par.getChar(i);
// The most special cases are handled first.
if (par.isInset(i)) {
Inset const * ins = par.getInset(i);
- Dimension dim = pm.insetDimension(ins);
+ Dimension dim = bv_->coordCache().insets().dim(ins);
row.add(i, ins, dim, *fi, par.lookupChange(i));
} else if (c == ' ' && i + 1 == body_pos) {
// There is a space at i, but it should not be
// before body_pos. Instead, insert some spacing to
// align text
FontMetrics const & fm = theFontMetrics(text_->labelFont(par));
+ // this is needed to make sure that the row width is correct
+ row.finalizeLast();
int const add = max(fm.width(par.layout().labelsep),
labelEnd(pit) - row.width());
row.addSpace(i, add, *fi, par.lookupChange(i));
- } else if (par.isLineSeparator(i)) {
- // In theory, no inset has this property. If
- // this is done, a new addSeparator which
- // takes an inset as parameter should be
- // added.
- LATTEST(!par.isInset(i));
- row.addSeparator(i, c, *fi, par.lookupChange(i));
} else if (c == '\t')
row.addSpace(i, theFontMetrics(*fi).width(from_ascii(" ")),
*fi, par.lookupChange(i));
- else
+ else {
+ // FIXME: please someone fix the Hebrew/Arabic parenthesis mess!
+ // see also Paragraph::getUChar.
+ if (fi->language()->lang() == "hebrew") {
+ if (c == '(')
+ c = ')';
+ else if (c == ')')
+ c = '(';
+ }
row.add(i, c, *fi, par.lookupChange(i));
+ }
// add inline completion width
- if (inlineCompletionLPos == i &&
- !bv_->inlineCompletion().empty()) {
+ // draw logically behind the previous character
+ if (ic_pos == i + 1 && !bv_->inlineCompletion().empty()) {
+ docstring const comp = bv_->inlineCompletion();
+ size_t const uniqueTo =bv_->inlineCompletionUniqueChars();
Font f = *fi;
- f.fontInfo().setColor(Color_inlinecompletion);
- row.addVirtual(i + 1, bv_->inlineCompletion(),
- f, Change());
+
+ if (uniqueTo > 0) {
+ f.fontInfo().setColor(Color_inlinecompletion);
+ row.addVirtual(i + 1, comp.substr(0, uniqueTo), f, Change());
+ }
+ f.fontInfo().setColor(Color_nonunique_inlinecompletion);
+ row.addVirtual(i + 1, comp.substr(uniqueTo), f, Change());
}
// Handle some situations that abruptly terminate the row
// 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));
+ row.reverseRTL(is_rtl);
+ //LYXERR0("breakrow: row is " << row);
}
int maxdesc = int(fontmetrics.maxDescent() * spacing_val);
// insets may be taller
- ParagraphMetrics const & pm = par_metrics_[pit];
+ CoordCache::Insets const & insetCache = bv_->coordCache().getInsets();
Row::const_iterator cit = row.begin();
Row::const_iterator cend = row.end();
for ( ; cit != cend; ++cit) {
if (cit->inset) {
- Dimension const & dim = pm.insetDimension(cit->inset);
+ Dimension const & dim = insetCache.dim(cit->inset);
maxasc = max(maxasc, dim.ascent());
maxdesc = max(maxdesc, dim.descent());
}
pos_type TextMetrics::getPosNearX(Row const & row, int & x,
bool & boundary) const
{
+ //LYXERR0("getPosNearX(" << x << ") row=" << row);
/// For the main Text, it is possible that this pit is not
/// yet in the CoordCache when moving cursor up.
/// x Paragraph coordinate is always 0 for main text anyway.
pos_type pos = row.pos();
boundary = false;
if (row.empty())
- x = row.x;
- else if (x <= row.x) {
+ x = row.left_margin;
+ else if (x <= row.left_margin) {
pos = row.front().left_pos();
- x = 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 = x_offset + w;
+ 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
*/
else if (pos == cit->endpos
&& cit + 1 != row.end()
- && cit->font.isVisibleRightToLeft() != (cit + 1)->font.isVisibleRightToLeft())
+ && cit->isRTL() != (cit + 1)->isRTL())
boundary = true;
}
/** This tests for the case where the cursor is set at the end
- * of a row which has been broken due to a display inset on
- * next row. This is indicated by Row::right_boundary.
+ * of a row which has been broken due something else than a
+ * separator (a display inset or a forced breaking of the
+ * row). We know that there is a separator when the end of the
+ * row is larger than the end of its last element.
*/
if (!row.empty() && pos == row.back().endpos
&& row.back().endpos == row.endpos())
- boundary = row.right_boundary();
+ boundary = true;
x += xo;
+ //LYXERR0("getPosNearX ==> pos=" << pos << ", boundary=" << boundary);
return pos;
}
cur.setTargetX(x);
// Try to descend recursively inside the inset.
- inset = inset->editXY(cur, x, yy);
+ Inset * edited = inset->editXY(cur, x, yy);
+ if (edited == inset && cur.pos() == it->pos) {
+ // non-editable inset, set cursor after the inset if x is
+ // nearer to that position (bug 9628)
+ CoordCache::Insets const & insetCache = bv_->coordCache().getInsets();
+ Dimension const & dim = insetCache.dim(inset);
+ Point p = insetCache.xy(inset);
+ bool const is_rtl = text_->isRTL(text_->getPar(pit));
+ if (is_rtl) {
+ // "in front of" == "right of"
+ if (abs(p.x_ - x) < abs(p.x_ + dim.wid - x))
+ cur.posForward();
+ } else {
+ // "in front of" == "left of"
+ if (abs(p.x_ + dim.wid - x) < abs(p.x_ - x))
+ cur.posForward();
+ }
+ }
if (cur.top().text() == text_)
cur.setCurrentFont();
- return inset;
+ return edited;
}
InsetList::InsetTable * TextMetrics::checkInsetHit(pit_type pit, int x, int y)
{
Paragraph const & par = text_->paragraphs()[pit];
- ParagraphMetrics const & pm = par_metrics_[pit];
+ CoordCache::Insets const & insetCache = bv_->coordCache().getInsets();
LYXERR(Debug::DEBUG, "x: " << x << " y: " << y << " pit: " << pit);
LYXERR(Debug::DEBUG, "examining inset " << inset);
- if (!bv_->coordCache().getInsets().has(inset)) {
+ if (!insetCache.has(inset)) {
LYXERR(Debug::DEBUG, "inset has no cached position");
return 0;
}
- Dimension const & dim = pm.insetDimension(inset);
- Point p = bv_->coordCache().getInsets().xy(inset);
+ Dimension const & dim = insetCache.dim(inset);
+ Point p = insetCache.xy(inset);
LYXERR(Debug::DEBUG, "xo: " << p.x_ << "..." << p.x_ + dim.wid
<< " yo: " << p.y_ - dim.asc << "..." << p.y_ + dim.des);
}
-int TextMetrics::cursorX(CursorSlice const & sl,
- bool boundary) const
+Row::const_iterator const
+TextMetrics::findRowElement(Row const & row, pos_type const pos,
+ bool const boundary, double & x) const
{
- LASSERT(sl.text() == text_, return 0);
-
- ParagraphMetrics const & pm = par_metrics_[sl.pit()];
- if (pm.rows().empty())
- return 0;
- Row const & row = pm.getRow(sl.pos(), boundary);
- pos_type const pos = sl.pos();
-
/**
* When boundary is true, position i is in the row element (pos, endpos)
* if
*/
int const boundary_corr = (boundary && pos) ? -1 : 0;
+ x = row.left_margin;
+
/** Early return in trivial cases
* 1) the row is empty
* 2) the position is the left-most position of the row; there
- * is a quirck herehowever: if the first element is virtual
+ * is a quirk here however: if the first element is virtual
* (end-of-par marker for example), then we have to look
* closer
*/
if (row.empty()
- || (pos == row.begin()->left_pos()
- && pos != row.begin()->right_pos()))
- return int(row.x);
+ || (pos == row.begin()->left_pos() && !boundary
+ && !row.begin()->isVirtual()))
+ return row.begin();
Row::const_iterator cit = row.begin();
- double x = row.x;
for ( ; cit != row.end() ; ++cit) {
/** Look whether the cursor is inside the element's
* span. Note that it is necessary to take the
- * boundary in account, and to accept virtual
+ * boundary into account, and to accept virtual
* elements, which have pos == endpos.
*/
if (pos + boundary_corr >= cit->pos
- && (pos + boundary_corr < cit->endpos
- || cit->pos == cit->endpos)) {
+ && (pos + boundary_corr < cit->endpos || cit->isVirtual())) {
x += cit->pos2x(pos);
break;
}
- x += cit->width();
+ x += cit->full_width();
}
+ if (cit == row.end())
+ --cit;
+
+ return cit;
+}
+
+
+int TextMetrics::cursorX(CursorSlice const & sl,
+ bool boundary) const
+{
+ LASSERT(sl.text() == text_, return 0);
+
+ ParagraphMetrics const & pm = par_metrics_[sl.pit()];
+ if (pm.rows().empty())
+ return 0;
+ Row const & row = pm.getRow(sl.pos(), boundary);
+ pos_type const pos = sl.pos();
+
+ double x = 0;
+ findRowElement(row, pos, boundary, x);
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 + row.left_x() < 0,
+ row_x + row.right_x() > bv_->workWidth());
y += row.descent();
// Restore full_repaint status.