#include "CoordCache.h"
#include "Cursor.h"
#include "CutAndPaste.h"
-#include "Encoding.h"
#include "HSpace.h"
#include "InsetList.h"
#include "Layout.h"
-#include "Length.h"
#include "LyXRC.h"
#include "MetricsInfo.h"
#include "ParagraphParameters.h"
-#include "ParIterator.h"
#include "rowpainter.h"
#include "Text.h"
#include "TextClass.h"
#include "VSpace.h"
-#include "WordLangTuple.h"
#include "insets/InsetText.h"
-#include "mathed/MacroTable.h"
#include "mathed/MathMacroTemplate.h"
#include "frontends/FontMetrics.h"
#include "frontends/Painter.h"
#include "support/debug.h"
-#include "support/docstring_list.h"
-#include "support/gettext.h"
#include "support/lassert.h"
#include <cstdlib>
using frontend::FontMetrics;
-static int numberOfSeparators(Paragraph const & par, Row const & row)
+namespace {
+
+int numberOfSeparators(Row const & row)
{
- pos_type const first = max(row.pos(), par.beginOfBody());
- pos_type const last = row.endpos() - 1;
int n = 0;
- for (pos_type p = first; p < last; ++p) {
- if (par.isSeparator(p))
+ Row::const_iterator cit = row.begin();
+ Row::const_iterator const end = row.end();
+ for ( ; cit != end ; ++cit)
+ if (cit->isSeparator())
++n;
- }
return n;
}
-static int numberOfLabelHfills(Paragraph const & par, Row const & row)
+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->isSeparator())
+ it->extra = w;
+}
+
+
+int numberOfLabelHfills(Paragraph const & par, Row const & row)
{
pos_type last = row.endpos() - 1;
pos_type first = row.pos();
}
-static int numberOfHfills(Paragraph const & par, Row const & row)
+int numberOfHfills(Row const & row, pos_type const body_pos)
{
- pos_type const last = row.endpos();
- pos_type first = row.pos();
-
- // hfill *DO* count at the beginning of paragraphs!
- if (first) {
- while (first < last && par.isHfill(first))
- ++first;
- }
-
- first = max(first, par.beginOfBody());
-
int n = 0;
- for (pos_type p = first; p < last; ++p) {
- if (par.isHfill(p))
+ 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())
++n;
- }
return n;
}
+}
+
/////////////////////////////////////////////////////////////////////
//
// TextMetrics
pos_type first = 0;
size_t row_index = 0;
// maximum pixel width of a row
- int width = max_width_ - right_margin; // - leftMargin(max_width_, pit, row);
do {
- Dimension dim;
- pos_type end = rowBreakPoint(width, pit, first);
- if (row_index || end < 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.
- dim_.wid = max_width_;
-
- dim = rowHeight(pit, first, end);
- dim.wid = rowWidth(right_margin, pit, first, end);
if (row_index == pm.rows().size())
pm.rows().push_back(Row());
Row & row = pm.rows()[row_index];
- row.setChanged(false);
row.pos(first);
- row.endpos(end);
- row.setDimension(dim);
- int const max_row_width = max(dim_.wid, dim.wid);
+ 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.
+ dim_.wid = max_width_;
+ int const max_row_width = max(dim_.wid, row.width());
computeRowMetrics(pit, row, max_row_width);
- first = end;
+ first = row.endpos();
++row_index;
- pm.dim().wid = max(pm.dim().wid, dim.wid);
- pm.dim().des += dim.height();
+ pm.dim().wid = max(pm.dim().wid, row.width());
+ pm.dim().des += row.height();
} while (first < par.size());
if (row_index < pm.rows().size())
// Make sure that if a par ends in newline, there is one more row
// under it
if (first > 0 && par.isNewline(first - 1)) {
- Dimension dim = rowHeight(pit, first, first);
- dim.wid = rowWidth(right_margin, pit, first, first);
if (row_index == pm.rows().size())
pm.rows().push_back(Row());
Row & row = pm.rows()[row_index];
- row.setChanged(false);
row.pos(first);
row.endpos(first);
- row.setDimension(dim);
- int const max_row_width = max(dim_.wid, dim.wid);
+ setRowHeight(row, pit);
+ row.setChanged(false);
+ int const max_row_width = max(dim_.wid, row.width());
computeRowMetrics(pit, row, max_row_width);
- pm.dim().des += dim.height();
+ pm.dim().des += row.height();
}
pm.dim().asc += pm.rows()[0].ascent();
}
+int TextMetrics::getAlign(Paragraph const & par, pos_type const pos) const
+{
+ Layout const & layout = par.layout();
+
+ int align;
+ if (par.params().align() == LYX_ALIGN_LAYOUT)
+ align = layout.align;
+ else
+ align = par.params().align();
+
+ // handle alignment inside tabular cells
+ Inset const & owner = text_->inset();
+ switch (owner.contentAlignment()) {
+ case LYX_ALIGN_CENTER:
+ case LYX_ALIGN_LEFT:
+ case LYX_ALIGN_RIGHT:
+ if (align == LYX_ALIGN_NONE || align == LYX_ALIGN_BLOCK)
+ align = owner.contentAlignment();
+ break;
+ default:
+ // unchanged (use align)
+ break;
+ }
+
+ // Display-style insets should always be on a centered row
+ if (Inset const * inset = par.getInset(pos)) {
+ switch (inset->display()) {
+ case Inset::AlignLeft:
+ align = LYX_ALIGN_BLOCK;
+ break;
+ case Inset::AlignCenter:
+ align = LYX_ALIGN_CENTER;
+ break;
+ case Inset::Inline:
+ // unchanged (use align)
+ break;
+ case Inset::AlignRight:
+ align = LYX_ALIGN_RIGHT;
+ break;
+ }
+ }
+
+ // Has the user requested we not justify stuff?
+ if (!bv_->buffer().params().justification
+ && align == LYX_ALIGN_BLOCK)
+ align = LYX_ALIGN_LEFT;
+
+ return align;
+}
+
+
void TextMetrics::computeRowMetrics(pit_type const pit,
Row & row, int width) const
{
// is there a manual margin with a manual label
Layout const & layout = par.layout();
+ int nlh = 0;
if (layout.margintype == MARGIN_MANUAL
&& layout.labeltype == LABEL_MANUAL) {
/// We might have real hfills in the label part
- int nlh = numberOfLabelHfills(par, row);
+ nlh = numberOfLabelHfills(par, row);
// A manual label par (e.g. List) has an auto-hfill
// between the label text and the body of the
double hfill = 0;
// are there any hfills in the row?
- if (int const nh = numberOfHfills(par, row)) {
+ if (int const nh = numberOfHfills(row, par.beginOfBody())) {
if (w > 0)
hfill = w / double(nh);
// we don't have to look at the alignment if it is ALIGN_LEFT and
} else if (int(row.width()) < max_width_) {
// is it block, flushleft or flushright?
// set x how you need it
- int align;
- if (par.params().align() == LYX_ALIGN_LAYOUT)
- align = layout.align;
- else
- align = par.params().align();
-
- // handle alignment inside tabular cells
- Inset const & owner = text_->inset();
- switch (owner.contentAlignment()) {
- case LYX_ALIGN_CENTER:
- case LYX_ALIGN_LEFT:
- case LYX_ALIGN_RIGHT:
- if (align == LYX_ALIGN_NONE
- || align == LYX_ALIGN_BLOCK)
- align = owner.contentAlignment();
- break;
- default:
- // unchanged (use align)
- break;
- }
-
- // Display-style insets should always be on a centered row
- if (Inset const * inset = par.getInset(row.pos())) {
- switch (inset->display()) {
- case Inset::AlignLeft:
- align = LYX_ALIGN_BLOCK;
- break;
- case Inset::AlignCenter:
- align = LYX_ALIGN_CENTER;
- break;
- case Inset::Inline:
- // unchanged (use align)
- break;
- case Inset::AlignRight:
- align = LYX_ALIGN_RIGHT;
- break;
- }
- }
-
- // Has the user requested we not justify stuff?
- if (!bv_->buffer().params().justification
- && align == LYX_ALIGN_BLOCK)
- align = LYX_ALIGN_LEFT;
+ int const align = getAlign(par, row.pos());
switch (align) {
case LYX_ALIGN_BLOCK: {
- int const ns = numberOfSeparators(par, row);
+ int const ns = numberOfSeparators(row);
bool disp_inset = false;
if (row.endpos() < par.size()) {
Inset const * in = par.getInset(row.endpos());
// If we have separators, this is not the last row of a
// par, does not end in newline, and is not row above a
// display inset... then stretch it
- if (ns
- && row.endpos() < par.size()
+ if (ns && row.endpos() < par.size()
&& !par.isNewline(row.endpos() - 1)
- && !disp_inset
- ) {
- row.separator = w / ns;
+ && !disp_inset) {
+ setSeparatorWidth(row, w / ns);
//lyxerr << "row.separator " << row.separator << endl;
//lyxerr << "ns " << ns << endl;
} else if (is_rtl) {
}
}
+#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)))
- {
+ && (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
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 > endpos || !par.isLineSeparator(body_pos - 1)))
body_pos = 0;
ParagraphMetrics & pm = par_metrics_[pit];
- InsetList::const_iterator ii = par.insetList().begin();
- InsetList::const_iterator iend = par.insetList().end();
- for ( ; ii != iend; ++ii) {
- if (ii->pos >= endpos || ii->pos < row.pos()
- || (ii->inset->lyxCode() != SPACE_CODE ||
- !ii->inset->isStretchableSpace()))
+ 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::Element::SPACE)
+ cit->dim.wid -= row.label_hfill * (nlh - 1);
+ if (!cit->inset || !cit->inset->isHfill())
continue;
- Dimension dim = row.dimension();
- if (pm.hfillExpansion(row, ii->pos))
- dim.wid = int(ii->pos >= body_pos ?
- max(hfill, 5.0) : row.label_hfill);
+ if (pm.hfillExpansion(row, cit->pos))
+ cit->dim.wid = int(cit->pos >= body_pos ?
+ max(hfill, 5.0) : row.label_hfill);
else
- dim.wid = 5;
+ cit->dim.wid = 5;
// Cache the inset dimension.
- bv_->coordCache().insets().add(ii->inset, dim);
- pm.setInsetDimension(ii->inset, dim);
+ bv_->coordCache().insets().add(cit->inset, cit->dim);
+ pm.setInsetDimension(cit->inset, cit->dim);
}
}
int TextMetrics::labelFill(pit_type const pit, Row const & row) const
{
Paragraph const & par = text_->getPar(pit);
-
- pos_type last = par.beginOfBody();
- LBUFERR(last > 0);
-
- // -1 because a label ends with a space that is in the label
- --last;
-
- // a separator at this end does not count
- if (par.isLineSeparator(last))
- --last;
+ LBUFERR(par.beginOfBody() > 0);
int w = 0;
- for (pos_type i = row.pos(); i <= last; ++i)
- w += singleWidth(pit, i);
+ Row::const_iterator cit = row.begin();
+ Row::const_iterator const end = row.end();
+ // iterate over elements before main body (except the last one,
+ // which is extra space).
+ while (cit!= end && cit->endpos < par.beginOfBody()) {
+ w += cit->width();
+ ++cit;
+ }
docstring const & label = par.params().labelWidthString();
if (label.empty())
#if 0
-// Not used, see TextMetrics::rowBreakPoint.
+// Not used, see TextMetrics::breakRow
// this needs special handling - only newlines count as a break point
static pos_type addressBreakPoint(pos_type i, Paragraph const & par)
{
} // anon namespace
-pos_type TextMetrics::rowBreakPoint(int const width, pit_type const pit,
- pos_type const pos) const
+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();
- if (pos == end || width < 0)
- return end;
+ pos_type const pos = row.pos();
+ int const width = max_width_ - right_margin;
+ pos_type const body_pos = par.beginOfBody();
+ row.clear();
+ row.dimension().wid = leftMargin(max_width_, pit, pos);
+
+ 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();
return addressBreakPoint(pos, par);
#endif
-
// check for possible inline completion
DocIterator const & inlineCompletionPos = bv_->inlineCompletionPos();
pos_type inlineCompletionLPos = -1;
inlineCompletionLPos = inlineCompletionPos.pos() - 1;
}
- int const left = leftMargin(max_width_, pit, pos);
- pos_type const body_pos = par.beginOfBody();
- int x = left;
- pos_type point = end;
-
- FontIterator fi = FontIterator(*this, par, pit, pos);
- // Accumulator for character strings
- docstring chunkstr;
- Font chunkfont = *fi;
-
// Now we iterate through until we reach the right margin
- // or the end of the par, then choose the possible break
- // nearest that.
-
+ // or the end of the par, then build a representation of the row.
pos_type i = pos;
- for ( ; i < end; ++i, ++fi) {
- // Add the chunk width when it is finished
- if (par.isInset(i) || *fi != chunkfont
- || (body_pos && i == body_pos)) {
- x += theFontMetrics(chunkfont).width(chunkstr);
- chunkstr.clear();
- chunkfont = *fi;
- }
-
+ FontIterator fi = FontIterator(*this, par, pit, pos);
+ while (i < end && row.width() < width) {
char_type c = par.getChar(i);
- Language const * language = fi->language();
// The most special cases are handled first.
if (par.isInset(i)) {
- x += pm.insetDimension(par.getInset(i)).wid;
+ Inset const * ins = par.getInset(i);
+ Dimension dim = pm.insetDimension(ins);
+ row.add(i, ins, dim, *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')
- chunkstr += " ";
- else if (language->rightToLeft()) {
- if (language->lang() == "arabic_arabtex" ||
- language->lang() == "arabic_arabi" ||
- language->lang() == "farsi") {
- if (!Encodings::isArabicComposeChar(c))
- chunkstr += par.transformChar(c, i);
- } else if (language->lang() == "hebrew" &&
- !Encodings::isHebrewComposeChar(c)) {
- chunkstr+= c;
- }
- } else
- chunkstr += c;
+ row.addSpace(i, theFontMetrics(*fi).width(from_ascii(" ")),
+ *fi, par.lookupChange(i));
+ else
+ row.add(i, c, *fi, par.lookupChange(i));
+ // end of paragraph marker
if (lyxrc.paragraph_markers
- && i == end - 1 && size_type(pit + 1) < pars.size())
+ && i == end - 1 && size_type(pit + 1) < pars.size()) {
// enlarge the last character to hold the end-of-par marker
- chunkstr += char_type(0x00B6);
+ Font f(text_->layoutFont(pit));
+ f.fontInfo().setColor(Color_paragraphmarker);
+ row.add(i, char_type(0x00B6), f, Change());
+ }
// add inline completion width
- if (inlineCompletionLPos == i)
- chunkstr += bv_->inlineCompletion();
-
- // add the auto-hfill from label end to the body
- if (body_pos && i == body_pos) {
- FontMetrics const & fm = theFontMetrics(
- text_->labelFont(par));
- int add = fm.width(par.layout().labelsep);
- //if (par.isLineSeparator(i - 1))
- // add -= singleWidth(pit, i - 1);
-
- add = max(add, labelEnd(pit) - x);
- x += add;
+ if (inlineCompletionLPos == i &&
+ !bv_->inlineCompletion().empty()) {
+ Font f = *fi;
+ f.fontInfo().setColor(Color_inlinecompletion);
+ row.addCompletion(i + 1, bv_->inlineCompletion(),
+ f, Change());
}
- if (par.isNewline(i)) {
- point = i + 1;
- break;
- }
+ // Handle some situations that abruptly terminate the row
+ // - A newline inset
+ // - Before a display inset
+ // - After a display inset
Inset const * inset = 0;
- // Break before...
- if (i + 1 < end) {
- if ((inset = par.getInset(i + 1)) && inset->display()) {
- point = i + 1;
- break;
- }
- // ...and after.
- if ((inset = par.getInset(i)) && inset->display()) {
- point = i + 1;
- break;
- }
+ if (par.isNewline(i)
+ || (i + 1 < end && (inset = par.getInset(i + 1))
+ && inset->display())
+ || (!row.empty() && row.back().inset
+ && row.back().inset->display())) {
+ ++i;
+ break;
}
- if (par.isLineSeparator(i)) {
- x += theFontMetrics(chunkfont).width(chunkstr);
- chunkstr.clear();
- chunkfont = *fi;
- if (x >= width) {
- // exit on last registered breakpoint:
- break;
+ ++i;
+ ++fi;
+
+ // add the auto-hfill from label end to the body
+ if (body_pos && i == body_pos) {
+ FontMetrics const & fm = theFontMetrics(text_->labelFont(par));
+ pos_type j = i;
+ if (!row.empty() && row.back().isSeparator()) {
+ row.pop_back();
+ --j;
}
- // register breakpoint:
- point = i + 1;
+ int const add = max(fm.width(par.layout().labelsep),
+ labelEnd(pit) - row.width());
+ row.addSpace(j, add, *fi, par.lookupChange(i));
}
- }
- if (i == end) {
- x += theFontMetrics(chunkfont).width(chunkstr);
- // maybe found one, but the par is short enough.
- if (x < width)
- point = end;
}
- // manual labels cannot be broken in LaTeX. But we
- // want to make our on-screen rendering of footnotes
- // etc. still break
- if (body_pos && point < body_pos)
- point = body_pos;
-
- return point;
-}
+ row.finalizeLast();
+ row.endpos(i);
+ // if the row is too large, try to cut at last separator.
+ if (row.width() >= width)
+ row.separate_back(body_pos);
+ // if the row ends with a separator that is not at end of
+ // paragraph, remove it
+ if (!row.empty() && row.back().isSeparator()
+ && row.endpos() < par.size())
+ row.pop_back();
-int TextMetrics::rowWidth(int right_margin, pit_type const pit,
- pos_type const first, pos_type const end) const
-{
- // get the pure distance
- ParagraphMetrics const & pm = par_metrics_[pit];
- Paragraph const & par = text_->getPar(pit);
- int w = leftMargin(max_width_, pit, first);
- int label_end = labelEnd(pit);
+ // make sure that the RtL elements are in reverse ordering
+ row.reverseRtL();
- // 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;
- }
-
- pos_type const body_pos = par.beginOfBody();
- pos_type i = first;
-
- if (i < end) {
- FontIterator fi = FontIterator(*this, par, pit, i);
- for ( ; i < end; ++i, ++fi) {
- if (body_pos > 0 && i == body_pos) {
- FontMetrics const & fm = theFontMetrics(
- text_->labelFont(par));
- w += fm.width(par.layout().labelsep);
- if (par.isLineSeparator(i - 1))
- w -= singleWidth(pit, i - 1);
- w = max(w, label_end);
- }
-
- // a line separator at the end of a line (but not at the end of a
- // paragraph) will not be drawn and should therefore not count for
- // the row width.
- if (!par.isLineSeparator(i) || i != end - 1 || end == par.size())
- w += pm.singleWidth(i, *fi);
-
- // add inline completion width
- if (inlineCompletionLPos == i) {
- docstring const & completion = bv_->inlineCompletion();
- if (completion.length() > 0)
- w += theFontMetrics(*fi).width(completion);
- }
- }
- }
-
- // count the paragraph end marker.
- if (end == par.size() && lyxrc.paragraph_markers) {
- ParagraphList const & pars_ = text_->paragraphs();
- if (size_type(pit + 1) < pars_.size()) {
- // enlarge the last character to hold the
- // end-of-par marker
- docstring const s(1, char_type(0x00B6));
- Font f;
- w += theFontMetrics(f).width(s);
- }
- }
-
- if (body_pos > 0 && body_pos >= end) {
- FontMetrics const & fm = theFontMetrics(
- text_->labelFont(par));
- w += fm.width(par.layout().labelsep);
- if (end > 0 && par.isLineSeparator(end - 1))
- w -= singleWidth(pit, end - 1);
- w = max(w, label_end);
- }
-
- return w + right_margin;
+ row.dimension().wid += right_margin;
}
-Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first,
- pos_type const end, bool topBottomSpace) const
+void TextMetrics::setRowHeight(Row & row, pit_type const pit,
+ bool topBottomSpace) const
{
Paragraph const & par = text_->getPar(pit);
// get the maximum ascent and the maximum descent
// start with so we don't have to do the assignment below too
// often.
Buffer const & buffer = bv_->buffer();
- Font font = displayFont(pit, first);
+ Font font = displayFont(pit, row.pos());
FontSize const tmpsize = font.fontInfo().size();
font.fontInfo() = text_->layoutFont(pit);
FontSize const size = font.fontInfo().size();
InsetList::const_iterator ii = par.insetList().begin();
InsetList::const_iterator iend = par.insetList().end();
for ( ; ii != iend; ++ii) {
- if (ii->pos >= first && ii->pos < end) {
+ if (ii->pos >= row.pos() && ii->pos < row.endpos()) {
Dimension const & dim = pm.insetDimension(ii->inset);
maxasc = max(maxasc, dim.ascent());
maxdesc = max(maxdesc, dim.descent());
int labeladdon = 0;
FontSize maxsize =
- par.highestFontInRange(first, end, size);
+ par.highestFontInRange(row.pos(), row.endpos(), size);
if (maxsize > font.fontInfo().size()) {
// use standard paragraph font with the maximal size
FontInfo maxfont = font.fontInfo();
Inset const & inset = text_->inset();
// is it a top line?
- if (first == 0 && topBottomSpace) {
+ if (row.pos() == 0 && topBottomSpace) {
BufferParams const & bufparams = buffer.params();
// some parskips VERY EASY IMPLEMENTATION
if (bufparams.paragraph_separation == BufferParams::ParagraphSkipSeparation
// special code for the top label
if (layout.labelIsAbove()
&& (!layout.isParagraphGroup() || text_->isFirstInSequence(pit))
- && !par.labelString().empty())
- {
+ && !par.labelString().empty()) {
labeladdon = int(
labelfont_metrics.maxHeight()
* layout.spacing.getValue()
&& prevpar.getLabelWidthString()
== par.getLabelWidthString()) {
layoutasc = layout.itemsep * dh;
- } else if (pit != 0 || first != 0) {
+ } else if (pit != 0 || row.pos() != 0) {
if (layout.topsep > 0)
layoutasc = layout.topsep * dh;
}
}
// is it a bottom line?
- if (end >= par.size() && topBottomSpace) {
+ if (row.endpos() >= par.size() && topBottomSpace) {
// add the layout spaces, for example before and after
// a section, or between the items of a itemize or enumerate
// environment
double unusual = 0;
cpit = text_->depthHook(cpit, pars[nextpit].getDepth());
if (pars[cpit].layout() != pars[nextpit].layout()
- || pars[nextpit].getLabelWidthString() != pars[cpit].getLabelWidthString())
- {
+ || pars[nextpit].getLabelWidthString() != pars[cpit].getLabelWidthString())
unusual = pars[cpit].layout().bottomsep * dh;
- }
layoutdesc = max(unusual, usual);
} else if (pars[cpit].getDepth() == pars[nextpit].getDepth()) {
if (pars[cpit].layout() != pars[nextpit].layout()
// main Text. The following test is thus bogus.
// Top and bottom margin of the document (only at top-level)
if (main_text_ && topBottomSpace) {
- if (pit == 0 && first == 0)
+ if (pit == 0 && row.pos() == 0)
maxasc += 20;
if (pit + 1 == pit_type(pars.size()) &&
- end == par.size() &&
- !(end > 0 && par.isNewline(end - 1)))
+ row.endpos() == par.size() &&
+ !(row.endpos() > 0 && par.isNewline(row.endpos() - 1)))
maxdesc += 20;
}
- return Dimension(0, maxasc + labeladdon, maxdesc);
+ row.dimension().asc = maxasc + labeladdon;
+ row.dimension().des = maxdesc;
}
bidi.computeTables(par, buffer, row);
pos_type vc = row.pos();
- pos_type end = row.endpos();
+ pos_type const end = row.endpos();
pos_type c = 0;
Layout const & layout = par.layout();
LYXERR(Debug::DEBUG, "xo: " << p.x_ << "..." << p.x_ + dim.wid
<< " yo: " << p.y_ - dim.asc << "..." << p.y_ + dim.des);
- if (x >= p.x_
- && x <= p.x_ + dim.wid
- && y >= p.y_ - dim.asc
- && y <= p.y_ + dim.des) {
+ if (x >= p.x_ && x <= p.x_ + dim.wid
+ && y >= p.y_ - dim.asc && y <= p.y_ + dim.des) {
LYXERR(Debug::DEBUG, "Hit inset: " << inset);
return const_cast<InsetList::InsetTable *>(&(*iit));
}
{
LASSERT(sl.text() == text_, return 0);
pit_type const pit = sl.pit();
+ pos_type ppos = sl.pos();
+
Paragraph const & par = text_->paragraphs()[pit];
ParagraphMetrics const & pm = par_metrics_[pit];
if (pm.rows().empty())
return 0;
+ Row const & row = pm.getRow(sl.pos(), boundary);
+
+ double x = row.x;
+
+ /**
+ * When boundary is true, position is on the row element (pos, endpos)
+ * if
+ * pos < ppos <= endpos
+ * whereas, when boundary is false, the test is
+ * pos <= ppos < endpos
+ * The correction below allows to handle both cases.
+ */
+ int const boundary_corr = (boundary && ppos) ? -1 : 0;
+
+ if (row.empty()
+ || (row.begin()->font.isRightToLeft()
+ && ppos == row.begin()->endpos))
+ return int(x);
+
+ Row::const_iterator cit = row.begin();
+ for ( ; cit != row.end() ; ++cit) {
+ // lyxerr << "ppos=" << ppos << "(" << boundary_corr << ")"
+ // << ", x=" << x << " " << *cit << endl;
+ // lyxerr << "test1=" << (ppos + boundary_corr >= cit->pos)
+ // << " test2=" << ( ppos + boundary_corr < best->endpos) <<endl;
+ if (ppos + boundary_corr >= cit->pos
+ && ppos + boundary_corr < cit->endpos) {
+ x += cit->pos2x(ppos);
+ break;
+ }
+ x += cit->width();
+ }
+
+ if (cit == row.end()
+ && (row.back().font.isRightToLeft() || ppos != row.back().endpos))
+ lyxerr << "NOT FOUND!"
+ << "ppos=" << ppos << "(" << boundary_corr << ")" << "\n"
+ << row;
- pos_type ppos = sl.pos();
// Correct position in front of big insets
bool const boundary_correction = ppos != 0 && boundary;
if (boundary_correction)
--ppos;
- Row const & row = pm.getRow(sl.pos(), boundary);
-
pos_type cursor_vpos = 0;
Buffer const & buffer = bv_->buffer();
- double x = row.x;
+ double x2 = row.x;
Bidi bidi;
bidi.computeTables(par, buffer, row);
if (size_type(pit + 1) < pars_.size()) {
FontInfo f;
docstring const s = docstring(1, char_type(0x00B6));
- x += theFontMetrics(f).width(s);
+ x2 += theFontMetrics(f).width(s);
}
}
font = displayFont(pit, row_pos + 1);
docstring const & completion = bv_->inlineCompletion();
if (font.isRightToLeft() && completion.length() > 0)
- x += theFontMetrics(font.fontInfo()).width(completion);
+ x2 += theFontMetrics(font.fontInfo()).width(completion);
}
for (pos_type vpos = row_pos; vpos < cursor_vpos; ++vpos) {
if (body_pos > 0 && pos == body_pos - 1) {
FontMetrics const & labelfm = theFontMetrics(
text_->labelFont(par));
- x += row.label_hfill + labelfm.width(par.layout().labelsep);
+ x2 += row.label_hfill + labelfm.width(par.layout().labelsep);
if (par.isLineSeparator(body_pos - 1))
- x -= singleWidth(pit, body_pos - 1);
+ x2 -= singleWidth(pit, body_pos - 1);
}
// Use font span to speed things up, see above
font = displayFont(pit, pos);
}
- x += pm.singleWidth(pos, font);
+ x2 += pm.singleWidth(pos, font);
// Inline completion RTL case:
// "a__|b", __ of b => non-boundary a-pos is right of __
font = displayFont(pit, vpos + 1);
docstring const & completion = bv_->inlineCompletion();
if (font.isRightToLeft() && completion.length() > 0)
- x += theFontMetrics(font.fontInfo()).width(completion);
+ x2 += theFontMetrics(font.fontInfo()).width(completion);
}
// Inline completion LTR case:
font = displayFont(pit, vpos);
docstring const & completion = bv_->inlineCompletion();
if (!font.isRightToLeft() && completion.length() > 0)
- x += theFontMetrics(font.fontInfo()).width(completion);
+ x2 += theFontMetrics(font.fontInfo()).width(completion);
}
if (par.isSeparator(pos) && pos >= body_pos)
- x += row.separator;
+ x2 += row.separator;
}
// see correction above
if (boundary_correction) {
if (isRTL(sl, boundary))
- x -= singleWidth(pit, ppos);
+ x2 -= singleWidth(pit, ppos);
else
- x += singleWidth(pit, ppos);
+ x2 += singleWidth(pit, ppos);
}
+ if (x2 != x) {
+ lyxerr << "cursorX: x2=" << x2 << ", x=" << x;
+ if (cit == row.end())
+ lyxerr << "Element not found for "
+ << ppos - boundary_corr << "(" << boundary_corr << ")";
+ else
+ lyxerr << " in [" << cit->pos << "/"
+ << ppos - boundary_corr << "(" << boundary_corr << ")"
+ << "/" << cit->endpos << "] of " << *cit << "\n";
+ lyxerr << row <<endl;
+ }
+
+
return int(x);
}
// set the correct parindent
if (pos == 0
&& (layout.labeltype == LABEL_NO_LABEL
- || layout.labeltype == LABEL_ABOVE
- || layout.labeltype == LABEL_CENTERED
- || (layout.labeltype == LABEL_STATIC
- && layout.latextype == LATEX_ENVIRONMENT
- && !text_->isFirstInSequence(pit)))
+ || layout.labeltype == LABEL_ABOVE
+ || layout.labeltype == LABEL_CENTERED
+ || (layout.labeltype == LABEL_STATIC
+ && layout.latextype == LATEX_ENVIRONMENT
+ && !text_->isFirstInSequence(pit)))
&& (align == LYX_ALIGN_BLOCK || align == LYX_ALIGN_LEFT)
&& !par.params().noindent()
// in some insets, paragraphs are never indented
&& !text_->inset().neverIndent()
// display style insets are always centered, omit indentation
&& !(!par.empty()
- && par.isInset(pos)
- && par.getInset(pos)->display())
- && (!(tclass.isDefaultLayout(par.layout())
- || tclass.isPlainLayout(par.layout()))
+ && par.isInset(pos)
+ && par.getInset(pos)->display())
+ && (!(tclass.isDefaultLayout(par.layout())
+ || tclass.isPlainLayout(par.layout()))
|| buffer.params().paragraph_separation
- == BufferParams::ParagraphIndentSeparation)
- )
- {
- // use the parindent of the layout when the default indentation is
- // used otherwise use the indentation set in the document settings
+ == BufferParams::ParagraphIndentSeparation)) {
+ // use the parindent of the layout when the
+ // default indentation is used otherwise use
+ // the indentation set in the document
+ // settings
if (buffer.params().getIndentation().asLyXCommand() == "default")
l_margin += theFontMetrics(
buffer.params().getFont()).signedWidth(parindent);
Point rxy = cur.bv().getPos(bvcur);
// calculate dimensions of the word
- dim = rowHeight(bvcur.pit(), wordStart.pos(), bvcur.pos(), false);
+ Row row;
+ row.pos(wordStart.pos());
+ row.endpos(bvcur.pos());
+ setRowHeight(row, bvcur.pit(), false);
+ dim = row.dimension();
dim.wid = abs(rxy.x_ - lxy.x_);
// calculate position of word
projects / lyx.git / blobdiff