#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;
}
}
if (row_index == pm.rows().size())
pm.rows().push_back(Row());
Row & row = pm.rows()[row_index];
+ row.pit(pit);
row.pos(first);
breakRow(row, right_margin, pit);
setRowHeight(row, pit);
row.setChanged(false);
- 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_;
+ if (row_index || row.endpos() < par.size()
+ || (row.right_boundary() && par.inInset().lyxCode() != CELL_CODE)) {
+ /* 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. In the case
+ * of a display inset, we do nothing when inside a table
+ * cell, because the tabular code is not prepared for
+ * that, and it triggers when using a caption in a
+ * longtable (see bugs #9945 and #9757).
+ */
+ if (dim_.wid < max_width_)
+ dim_.wid = max_width_;
+ }
int const max_row_width = max(dim_.wid, row.width());
computeRowMetrics(pit, row, max_row_width);
first = row.endpos();
pm.rows().push_back(Row());
Row & row = pm.rows()[row_index];
row.pos(first);
- row.endpos(first);
+ breakRow(row, right_margin, pit);
setRowHeight(row, pit);
row.setChanged(false);
int const max_row_width = max(dim_.wid, row.width());
}
-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);
+ }
}
}
pos_type const pos = row.pos();
pos_type const body_pos = par.beginOfBody();
bool const is_rtl = text_->isRTL(par);
+ bool need_new_row = false;
row.clear();
row.left_margin = leftMargin(max_width_, pit, pos);
// 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
// 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) {
+ do {
+ // this can happen for an empty row after a newline
+ if (i >= end)
+ break;
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
} 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
|| (!row.empty() && row.back().inset
&& row.back().inset->display())) {
row.right_boundary(true);
+ need_new_row = par.isNewline(i);
++i;
break;
}
++i;
++fi;
- }
+ } while (i < end && row.width() <= width);
row.finalizeLast();
row.endpos(i);
// End of paragraph marker
- if (lyxrc.paragraph_markers
+ if (lyxrc.paragraph_markers && !need_new_row
&& i == end && size_type(pit + 1) < pars.size()) {
// add a virtual element for the end-of-paragraph
// marker; it is shown on screen, but does not exist
row.addVirtual(end, docstring(1, char_type(0x00B6)), f, Change());
}
- // if the row is too large, try to cut at last separator.
- row.shortenIfNeeded(body_pos, width);
+ // if the row is too large, try to cut at last separator. In case
+ // of success, reset indication that the row was broken abruptly.
+ if (row.shortenIfNeeded(body_pos, width))
+ row.right_boundary(!row.empty() && row.back().endpos == row.endpos());
// make sure that the RTL elements are in reverse ordering
row.reverseRTL(is_rtl);
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());
}
int const xo = origin_.x_;
x -= xo;
+ int offset = 0;
+ CursorSlice rowSlice(const_cast<InsetText &>(text_->inset()));
+ rowSlice.pit() = row.pit();
+ rowSlice.pos() = row.pos();
+
+ // Adapt to cursor row scroll offset if applicable.
+ if (bv_->currentRowSlice() == rowSlice)
+ offset = bv_->horizScrollOffset();
+ x += offset;
+
pos_type pos = row.pos();
boundary = false;
if (row.empty())
* row is larger than the end of its last element.
*/
if (!row.empty() && pos == row.back().endpos
- && row.back().endpos == row.endpos())
- boundary = true;
+ && row.back().endpos == row.endpos()) {
+ Inset const * inset = row.back().inset;
+ if (inset && (inset->lyxCode() == NEWLINE_CODE
+ || inset->lyxCode() == SEPARATOR_CODE))
+ pos = row.back().pos;
+ else
+ boundary = row.right_boundary();
+ }
- x += xo;
+ x += xo - offset;
//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);
boundary = true;
else
--end;
- }
+ } else if (cur.paragraph().isEnvSeparator(end-1))
+ --end;
return text_->setCursor(cur, cur.pit(), end, true, boundary);
}
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];
if (pm.rows().empty())
return;
// Row signature; has row changed since last paint?
if (pi.pain.isDrawingEnabled())
- row.setCrc(pm.computeRowSignature(row, bparams));
+ row.setCrc(pm.computeRowSignature(row, *bv_));
bool row_has_changed = row.changed()
|| rowSlice == bv_->lastRowSlice();
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.