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;
}
int TextMetrics::rightMargin(ParagraphMetrics const & pm) const
{
- return main_text_? pm.rightMargin(*bv_) : 0;
+ return text_->isMainText() ? pm.rightMargin(*bv_) : 0;
}
int TextMetrics::rightMargin(pit_type const pit) const
{
- return main_text_? par_metrics_[pit].rightMargin(*bv_) : 0;
+ return text_->isMainText() ? par_metrics_[pit].rightMargin(*bv_) : 0;
}
pm.reset(par);
Buffer & buffer = bv_->buffer();
- main_text_ = (text_ == &buffer.text());
bool changed = false;
// Check whether there are InsetBibItems that need fixing
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());
}
// are there any hfills in the row?
- int nh = numberOfHfills(row, par.beginOfBody());
+ 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
- // * we use hfills, or
- // * the row is already larger then the permitted width as then we
- // force the LEFT_ALIGN'edness!
- if (nh > 0) {
- hfill = w / nh;
- hfill_rem = w % nh;
- row.dimension().wid += w;
- } else if (nh == 0 && int(row.width()) < max_width_) {
- // is it block, flushleft or flushright?
- // set x how you need it
+ // 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();
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();
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)) {
+ if (cit->inset && pm.hfillExpansion(row, cit->pos)) {
if (cit->pos >= body_pos) {
cit->dim.wid += hfill;
--nh;
cit->dim.wid += hfill_rem;
} else
cit->dim.wid += int(row.label_hfill);
+ // Cache the inset dimension.
+ insetCache.add(cit->inset, cit->dim);
}
- // 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;
- }
-
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)) {
|| (!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(false);
// make sure that the RTL elements are in reverse ordering
row.reverseRTL(is_rtl);
FontInfo labelfont = text_->labelFont(par);
- FontMetrics const & labelfont_metrics = theFontMetrics(labelfont);
- FontMetrics const & fontmetrics = theFontMetrics(font);
+ FontMetrics const & lfm = theFontMetrics(labelfont);
+ FontMetrics const & fm = theFontMetrics(font);
// these are minimum values
double const spacing_val = layout.spacing.getValue()
* text_->spacing(par);
//lyxerr << "spacing_val = " << spacing_val << endl;
- int maxasc = int(fontmetrics.maxAscent() * spacing_val);
- int maxdesc = int(fontmetrics.maxDescent() * spacing_val);
+ int maxasc = int(fm.maxAscent() * spacing_val);
+ int maxdesc = int(fm.maxDescent() * spacing_val);
// insets may be taller
CoordCache::Insets const & insetCache = bv_->coordCache().getInsets();
&& (!layout.isParagraphGroup() || text_->isFirstInSequence(pit))
&& !par.labelString().empty()) {
labeladdon = int(
- labelfont_metrics.maxHeight()
+ lfm.maxHeight()
* layout.spacing.getValue()
* text_->spacing(par)
+ (layout.topsep + layout.labelbottomsep) * dh);
// following code in another method specially tailored for the
// main Text. The following test is thus bogus.
// Top and bottom margin of the document (only at top-level)
- if (main_text_ && topBottomSpace) {
+ if (text_->isMainText() && topBottomSpace) {
if (pit == 0 && row.pos() == 0)
maxasc += 20;
if (pit + 1 == pit_type(pars.size()) &&
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;
}
boundary = true;
else
--end;
- }
+ } else if (cur.paragraph().isEnvSeparator(end-1))
+ --end;
return text_->setCursor(cur, cur.pit(), end, true, boundary);
}
text_->cursorForward(cur);
} else {
cur.resetAnchor();
- cur.setSelection(true); // to avoid deletion
+ cur.selection(true); // to avoid deletion
cursorEnd(cur);
cur.setSelection();
// What is this test for ??? (JMarc)
//lyxerr << "TextMetrics::leftMargin: pit: " << pit << " pos: " << pos << endl;
DocumentClass const & tclass = buffer.params().documentClass();
Layout const & layout = par.layout();
+ FontMetrics const & bfm = theFontMetrics(buffer.params().getFont());
docstring parindent = layout.parindent;
if (text_->isMainText())
l_margin += bv_->leftMargin();
- l_margin += theFontMetrics(buffer.params().getFont()).signedWidth(
- tclass.leftmargin());
+ l_margin += bfm.signedWidth(tclass.leftmargin());
int depth = par.getDepth();
if (depth != 0) {
buffer.params().paragraph_separation ==
BufferParams::ParagraphIndentSeparation) {
docstring pi = pars[newpar].layout().parindent;
- l_margin -= theFontMetrics(
- buffer.params().getFont()).signedWidth(pi);
+ l_margin -= bfm.signedWidth(pi);
}
}
if (tclass.isDefaultLayout(par.layout())
}
FontInfo const labelfont = text_->labelFont(par);
- FontMetrics const & labelfont_metrics = theFontMetrics(labelfont);
+ FontMetrics const & lfm = theFontMetrics(labelfont);
switch (layout.margintype) {
case MARGIN_DYNAMIC:
if (!layout.leftmargin.empty()) {
- l_margin += theFontMetrics(buffer.params().getFont()).signedWidth(
- layout.leftmargin);
+ l_margin += bfm.signedWidth(layout.leftmargin);
}
if (!par.labelString().empty()) {
- l_margin += labelfont_metrics.signedWidth(layout.labelindent);
- l_margin += labelfont_metrics.width(par.labelString());
- l_margin += labelfont_metrics.width(layout.labelsep);
+ l_margin += lfm.signedWidth(layout.labelindent);
+ l_margin += lfm.width(par.labelString());
+ l_margin += lfm.width(layout.labelsep);
}
break;
case MARGIN_MANUAL: {
- l_margin += labelfont_metrics.signedWidth(layout.labelindent);
+ l_margin += lfm.signedWidth(layout.labelindent);
// The width of an empty par, even with manual label, should be 0
if (!par.empty() && pos >= par.beginOfBody()) {
if (!par.getLabelWidthString().empty()) {
docstring labstr = par.getLabelWidthString();
- l_margin += labelfont_metrics.width(labstr);
- l_margin += labelfont_metrics.width(layout.labelsep);
+ l_margin += lfm.width(labstr);
+ l_margin += lfm.width(layout.labelsep);
}
}
break;
}
case MARGIN_STATIC: {
- l_margin += theFontMetrics(buffer.params().getFont()).
- signedWidth(layout.leftmargin) * 4 / (par.getDepth() + 4);
+ l_margin += bfm.signedWidth(layout.leftmargin) * 4
+ / (par.getDepth() + 4);
break;
}
if (layout.labeltype == LABEL_MANUAL) {
// if we are at position 0, we are never in the body
if (pos > 0 && pos >= par.beginOfBody())
- l_margin += labelfont_metrics.signedWidth(layout.leftmargin);
+ l_margin += lfm.signedWidth(layout.leftmargin);
else
- l_margin += labelfont_metrics.signedWidth(layout.labelindent);
+ l_margin += lfm.signedWidth(layout.labelindent);
} else if (pos != 0
// Special case to fix problems with
// theorems (JMarc)
|| (layout.labeltype == LABEL_STATIC
&& layout.latextype == LATEX_ENVIRONMENT
&& !text_->isFirstInSequence(pit))) {
- l_margin += labelfont_metrics.signedWidth(layout.leftmargin);
+ l_margin += lfm.signedWidth(layout.leftmargin);
} else if (!layout.labelIsAbove()) {
- l_margin += labelfont_metrics.signedWidth(layout.labelindent);
- l_margin += labelfont_metrics.width(layout.labelsep);
- l_margin += labelfont_metrics.width(par.labelString());
+ l_margin += lfm.signedWidth(layout.labelindent);
+ l_margin += lfm.width(layout.labelsep);
+ l_margin += lfm.width(par.labelString());
}
break;
for ( ; rit != end; ++rit)
if (rit->fill() < minfill)
minfill = rit->fill();
- l_margin += theFontMetrics(buffer.params().getFont()).signedWidth(layout.leftmargin);
+ l_margin += bfm.signedWidth(layout.leftmargin);
l_margin += minfill;
#endif
// also wrong, but much shorter.
}
if (!par.params().leftIndent().zero())
- l_margin += par.params().leftIndent().inPixels(max_width, labelfont_metrics.em());
+ l_margin += par.params().leftIndent().inPixels(max_width, lfm.em());
LyXAlignment align;
// the indentation set in the document
// settings
if (buffer.params().getIndentation().asLyXCommand() == "default")
- l_margin += theFontMetrics(
- buffer.params().getFont()).signedWidth(parindent);
+ l_margin += bfm.signedWidth(parindent);
else
l_margin += buffer.params().getIndentation().inPixels(*bv_);
}