#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)
{
// 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);
// 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.left_margin = rightMargin(pit);
- else
- row.left_margin = leftMargin(max_width_, pit, row.pos());
-
// is there a manual margin with a manual label
Layout const & layout = par.layout();
// 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()
&& row.endpos() != par.size()) {
- setSeparatorWidth(row, double(w) / ns);
- row.dimension().wid = width;
- } else if (is_rtl) {
- row.dimension().wid = width;
+ row.setSeparatorExtraWidth(double(w) / ns);
+ row.dimension().wid += w;
+ } else if (text_->isRTL(par)) {
row.left_margin += w;
+ row.dimension().wid += w;
}
break;
}
case LYX_ALIGN_RIGHT:
row.left_margin += w;
+ row.dimension().wid += w;
break;
case LYX_ALIGN_CENTER:
- row.dimension().wid = width - w / 2;
+ row.dimension().wid += w / 2;
row.left_margin += w / 2;
break;
case LYX_ALIGN_LEFT:
&& (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) {
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);
}
}
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();
- // This make get changed in computeRowMetrics depending on RTL
row.left_margin = leftMargin(max_width_, pit, pos);
- row.dimension().wid = row.left_margin;
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.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
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
row.shortenIfNeeded(body_pos, width);
// 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.
*/
else if (pos == cit->endpos
&& cit + 1 != row.end()
- && cit->font.isVisibleRightToLeft() != (cit + 1)->font.isVisibleRightToLeft())
+ && cit->isRTL() != (cit + 1)->isRTL())
boundary = true;
}
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 row.left_margin;
+ || (pos == row.begin()->left_pos() && !boundary
+ && !row.begin()->isVirtual()))
+ return row.begin();
Row::const_iterator cit = row.begin();
- 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
- * 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->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);
+
}
rp.paintLast();
if (i == 0 && is_rtl)
rp.paintFirst();
- rp.paintTooLargeMarks(row_x < 0,
- row_x + row.width() > bv_->workWidth());
+ rp.paintTooLargeMarks(row_x + row.left_x() < 0,
+ row_x + row.right_x() > bv_->workWidth());
y += row.descent();
// Restore full_repaint status.