#include "CutAndPaste.h"
#include "HSpace.h"
#include "InsetList.h"
+#include "Language.h"
#include "Layout.h"
#include "LyXRC.h"
#include "MetricsInfo.h"
return n;
}
-
-int numberOfHfills(Row const & row, pos_type const body_pos)
+// FIXME: this needs to be rewritten, probably by merging it into some
+// code that, besides counting, sets the active status of the space
+// inset in the row element.
+int numberOfHfills(Row const & row, ParagraphMetrics const & pm,
+ pos_type const body_pos)
{
int n = 0;
Row::const_iterator cit = row.begin();
Row::const_iterator const end = row.end();
for ( ; cit != end ; ++cit)
if (cit->pos >= body_pos
- && cit->inset && cit->inset->isHfill())
+ && cit->inset && pm.hfillExpansion(row, cit->pos))
++n;
return n;
}
// 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;
}
}
}
-LyXAlignment TextMetrics::getAlign(Paragraph const & par, pos_type const pos) const
+LyXAlignment TextMetrics::getAlign(Paragraph const & par, Row const & row) const
{
Layout const & layout = par.layout();
// handle alignment inside tabular cells
Inset const & owner = text_->inset();
+ bool forced_block = false;
switch (owner.contentAlignment()) {
+ case LYX_ALIGN_BLOCK:
+ // In general block align is the default state, but here it is
+ // an explicit choice. Therefore it should not be overridden
+ // later.
+ forced_block = true;
+ // fall through
case LYX_ALIGN_CENTER:
case LYX_ALIGN_LEFT:
case LYX_ALIGN_RIGHT:
}
// Display-style insets should always be on a centered row
- if (Inset const * inset = par.getInset(pos)) {
+ if (Inset const * inset = par.getInset(row.pos())) {
switch (inset->display()) {
case Inset::AlignLeft:
align = LYX_ALIGN_BLOCK;
}
}
- // Has the user requested we not justify stuff?
- if (!bv_->buffer().params().justification
- && align == LYX_ALIGN_BLOCK)
- align = LYX_ALIGN_LEFT;
+ if (align == LYX_ALIGN_BLOCK) {
+ // If this row has been broken abruptly by a display inset, or
+ // it is the end of the paragraph, or the user requested we
+ // not justify stuff, then don't stretch.
+ // A forced block alignment can only be overridden the 'no
+ // justification on screen' setting.
+ if (((row.right_boundary() || row.endpos() == par.size())
+ && !forced_block)
+ || !bv_->buffer().params().justification)
+ align = text_->isRTL(par) ? LYX_ALIGN_RIGHT : LYX_ALIGN_LEFT;
+ }
return align;
}
row.label_hfill = labelFill(pit, row) / double(nlh);
}
- double hfill = 0;
// are there any hfills in the row?
- if (int const nh = numberOfHfills(row, par.beginOfBody())) {
- if (w > 0)
- 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!
- } else if (int(row.width()) < max_width_) {
- // is it block, flushleft or flushright?
- // set x how you need it
- switch (getAlign(par, row.pos())) {
+ ParagraphMetrics & pm = par_metrics_[pit];
+ int nh = numberOfHfills(row, pm, par.beginOfBody());
+ int hfill = 0;
+ int hfill_rem = 0;
+
+ // We don't have to look at the alignment if the row is already
+ // larger then the permitted width as then we force the
+ // LEFT_ALIGN'edness!
+ if (int(row.width()) >= max_width_)
+ return;
+
+ if (nh == 0) {
+ // Common case : there is no hfill, and the alignment will be
+ // meaningful
+ switch (getAlign(par, row)) {
case LYX_ALIGN_BLOCK: {
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()) {
+ // If we have separators, then stretch the row
+ if (ns) {
row.setSeparatorExtraWidth(double(w) / ns);
- row.dimension().wid = width;
+ row.dimension().wid += w;
} else if (text_->isRTL(par)) {
- row.dimension().wid = width;
row.left_margin += w;
+ row.dimension().wid += w;
}
break;
}
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:
case LYX_ALIGN_DECIMAL:
break;
}
+ return;
}
- // Finally, handle hfill insets
+ hfill = w / nh;
+ hfill_rem = w % nh;
+ row.dimension().wid += w;
+ // Set size of hfill insets
pos_type const endpos = row.endpos();
pos_type body_pos = par.beginOfBody();
if (body_pos > 0
&& (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 -= int(row.label_hfill * (nlh - 1));
- if (!cit->inset || !cit->inset->isHfill())
- continue;
- if (pm.hfillExpansion(row, cit->pos))
- cit->dim.wid = int(cit->pos >= body_pos ?
- max(hfill, 5.0) : row.label_hfill);
- else
- cit->dim.wid = 5;
- // Cache the inset dimension.
- bv_->coordCache().insets().add(cit->inset, cit->dim);
- pm.setInsetDimension(cit->inset, cit->dim);
+ if (cit->inset && pm.hfillExpansion(row, cit->pos)) {
+ if (cit->pos >= body_pos) {
+ cit->dim.wid += hfill;
+ --nh;
+ if (nh == 0)
+ cit->dim.wid += hfill_rem;
+ } else
+ cit->dim.wid += int(row.label_hfill);
+ // Cache the inset dimension.
+ insetCache.add(cit->inset, cit->dim);
+ }
}
}
return;
}
- ParagraphMetrics const & pm = par_metrics_[pit];
ParagraphList const & pars = text_->paragraphs();
#if 0
// 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
} 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
// draw logically behind the previous character
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());
}
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
* 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.
projects / lyx.git / blobdiff