#include "CoordCache.h"
#include "Cursor.h"
#include "CutAndPaste.h"
-#include "HSpace.h"
#include "InsetList.h"
#include "Language.h"
#include "Layout.h"
#include "insets/InsetText.h"
-#include "mathed/MathMacroTemplate.h"
+#include "mathed/InsetMathMacroTemplate.h"
#include "frontends/FontMetrics.h"
#include "frontends/Painter.h"
}
-}
+} // namespace
/////////////////////////////////////////////////////////////////////
//
parPos.pos()++;
}
+ // If there is an end of paragraph marker, its size should be
+ // substracted to the available width. The logic here is
+ // almost the same as in breakRow, remember keep them in sync.
+ int eop = 0;
+ if (lyxrc.paragraph_markers && ii->pos + 1 == par.size()
+ && size_type(pit + 1) < text_->paragraphs().size()) {
+ Font f(text_->layoutFont(pit));
+ // ΒΆ U+00B6 PILCROW SIGN
+ eop = theFontMetrics(f).width(char_type(0x00B6));
+ }
+
// do the metric calculation
Dimension dim;
- int const w = max_width_ - leftMargin(max_width_, pit, ii->pos)
- - right_margin;
+ int const w = max_width_ - leftMargin(pit, ii->pos)
+ - right_margin - eop;
Font const & font = ii->inset->inheritFont() ?
displayFont(pit, ii->pos) : bufferfont;
MacroContext mc(&buffer, parPos);
// specially tailored for the main text.
// Top and bottom margin of the document (only at top-level)
if (text_->isMainText()) {
+ // original value was 20px, which is 0.2in at 100dpi
+ int const margin = Length(0.2, Length::IN).inPixels(0);
if (pit == 0) {
- pm.rows().front().dimension().asc += 20;
- /* coverity[copy_paste_error]: coverity thinks that we
- * should update pm.dim().asc below, but all the rows
- * heights are actually counted as part of the paragraph metric
- * descent see loop above).
+ pm.rows().front().dimension().asc += margin;
+ /* coverity thinks that we should update pm.dim().asc
+ * below, but all the rows heights are actually counted as
+ * part of the paragraph metric descent see loop above).
*/
- pm.dim().des += 20;
+ // coverity[copy_paste_error]
+ pm.dim().des += margin;
}
ParagraphList const & pars = text_->paragraphs();
if (pit + 1 == pit_type(pars.size())) {
- pm.rows().back().dimension().des += 20;
- pm.dim().des += 20;
+ pm.rows().back().dimension().des += margin;
+ pm.dim().des += margin;
}
}
row.dimension().wid += w;
}
break;
+ case LYX_ALIGN_LEFT:
+ // a displayed inset that is flushed
+ if (Inset const * inset = par.getInset(row.pos())) {
+ row.left_margin += inset->indent(*bv_);
+ row.dimension().wid += inset->indent(*bv_);
+ }
+ break;
case LYX_ALIGN_RIGHT:
- row.left_margin += w;
- row.dimension().wid += w;
+ if (Inset const * inset = par.getInset(row.pos())) {
+ int const new_w = max(w - inset->indent(*bv_), 0);
+ row.left_margin += new_w;
+ row.dimension().wid += new_w;
+ } else {
+ row.left_margin += w;
+ row.dimension().wid += w;
+ }
break;
case LYX_ALIGN_CENTER:
row.dimension().wid += w / 2;
row.left_margin += w / 2;
break;
- case LYX_ALIGN_LEFT:
case LYX_ALIGN_NONE:
case LYX_ALIGN_LAYOUT:
case LYX_ALIGN_SPECIAL:
if (text_->getPar(pit).layout().margintype != MARGIN_MANUAL)
return 0;
// return the beginning of the body
- return leftMargin(max_width_, pit);
+ return leftMargin(pit);
}
namespace {
pos_type bodypos_;
};
-} // anon namespace
+} // namespace
/** This is the function where the hard work is done. The code here is
* very sensitive to small changes :) Note that part of the
bool need_new_row = false;
row.clear();
- row.left_margin = leftMargin(max_width_, row.pit(), pos);
+ row.left_margin = leftMargin(row.pit(), pos);
row.right_margin = right_margin;
if (is_rtl)
swap(row.left_margin, row.right_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 need_new_row;
- }
-
#if 0
//FIXME: As long as leftMargin() is not correctly implemented for
// MARGIN_RIGHT_ADDRESS_BOX, we should also not do this here.
// or the end of the par, then build a representation of the row.
pos_type i = pos;
FontIterator fi = FontIterator(*this, par, row.pit(), pos);
- do {
- // this can happen for an empty row after a newline
- if (i >= end)
- break;
+ while (i < end && (i == pos || row.width() <= width)) {
char_type c = par.getChar(i);
// The most special cases are handled first.
if (par.isInset(i)) {
++i;
++fi;
- } while (i < end && row.width() <= width);
+ }
row.finalizeLast();
row.endpos(i);
- // End of paragraph marker
+ // End of paragraph marker. The logic here is almost the
+ // same as in redoParagraph, remember keep them in sync.
ParagraphList const & pars = text_->paragraphs();
if (lyxrc.paragraph_markers && !need_new_row
&& i == end && size_type(row.pit() + 1) < pars.size()) {
// if the row is too large, try to cut at last separator. In case
// of success, reset indication that the row was broken abruptly.
- int const next_width = max_width_ - leftMargin(max_width_, row.pit(), row.endpos())
+ int const next_width = max_width_ - leftMargin(row.pit(), row.endpos())
- rightMargin(row.pit());
- row.shortenIfNeeded(body_pos, width, next_width);
+ if (row.shortenIfNeeded(body_pos, width, next_width))
+ row.flushed(false);
row.right_boundary(!row.empty() && row.endpos() < end
&& row.back().endpos == row.endpos());
// Last row in paragraph is flushed
// returns the column near the specified x-coordinate of the row
// x is set to the real beginning of this column
pos_type TextMetrics::getPosNearX(Row const & row, int & x,
- bool & boundary, bool const select) const
+ bool & boundary) const
{
//LYXERR0("getPosNearX(" << x << ") row=" << row);
/// For the main Text, it is possible that this pit is not
for ( ; cit != cend; ++cit) {
if (w <= x && w + cit->full_width() > x) {
int x_offset = int(x - w);
- pos = cit->x2pos(x_offset, select);
+ pos = cit->x2pos(x_offset);
x = int(x_offset + w);
break;
}
* how boundary helps here.
*/
else if (pos == cit->endpos
- && cit + 1 != row.end()
- && cit->isRTL() != (cit + 1)->isRTL())
+ && ((!cit->isRTL() && cit + 1 != row.end()
+ && (cit + 1)->isRTL())
+ || (cit->isRTL() && cit != row.begin()
+ && !(cit - 1)->isRTL())))
boundary = true;
}
}
pit_type pit = getPitNearY(y);
LASSERT(pit != -1, return 0);
-
- int yy = y; // is modified by getPitAndRowNearY
- Row const & row = getPitAndRowNearY(yy, pit, assert_in_view, up);
-
+ Row const & row = getPitAndRowNearY(y, pit, assert_in_view, up);
cur.pit() = pit;
// Do we cover an inset?
- InsetList::InsetTable * it = checkInsetHit(pit, x, yy);
+ InsetList::InsetTable * it = checkInsetHit(pit, x, y);
if (!it) {
// No inset, set position in the text
bool bound = false; // is modified by getPosNearX
- int xx = x; // is modified by getPosNearX
- cur.pos() = getPosNearX(row, xx, bound);
+ cur.pos() = getPosNearX(row, x, bound);
cur.boundary(bound);
cur.setCurrentFont();
- cur.setTargetX(xx);
+ cur.setTargetX(x);
return 0;
}
cur.setTargetX(x);
// Try to descend recursively inside the inset.
- Inset * edited = inset->editXY(cur, x, yy);
- if (edited == inset && cur.pos() == it->pos) {
+ Inset * edited = inset->editXY(cur, x, y);
+ // FIXME: it is not clear that the test on position is needed
+ // Remove it if/when semantics of editXY is clarified
+ if (cur.text() == text_ && 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();
- }
+ bool bound = false; // is modified by getPosNearX
+ cur.pos() = getPosNearX(row, x, bound);
+ cur.boundary(bound);
+ cur.setCurrentFont();
+ cur.setTargetX(x);
}
if (cur.top().text() == text_)
}
-void TextMetrics::setCursorFromCoordinates(Cursor & cur, int const x,
- int const y, bool const select)
+void TextMetrics::setCursorFromCoordinates(Cursor & cur, int const x, int const y)
{
LASSERT(text_ == cur.text(), return);
pit_type const pit = getPitNearY(y);
bool bound = false;
int xx = x;
- pos_type const pos = getPosNearX(row, xx, bound, select);
+ pos_type const pos = getPosNearX(row, xx, bound);
LYXERR(Debug::DEBUG, "setting cursor pit: " << pit << " pos: " << pos);
}
-int TextMetrics::leftMargin(int max_width, pit_type pit) const
+int TextMetrics::leftMargin(pit_type pit) const
{
- return leftMargin(max_width, pit, text_->paragraphs()[pit].size());
+ return leftMargin(pit, text_->paragraphs()[pit].size());
}
-int TextMetrics::leftMargin(int max_width,
- pit_type const pit, pos_type const pos) const
+int TextMetrics::leftMargin(pit_type const pit, pos_type const pos) const
{
ParagraphList const & pars = text_->paragraphs();
int nestmargin = depth * nestMargin();
if (text_->isMainText())
nestmargin += changebarMargin();
- l_margin = max(leftMargin(max_width, newpar), nestmargin);
+ l_margin = max(leftMargin(newpar), nestmargin);
// Remove the parindent that has been added
// if the paragraph was empty.
if (pars[newpar].empty() &&
ParagraphMetrics const & pm = par_metrics_[pit];
RowList::const_iterator rit = pm.rows().begin();
RowList::const_iterator end = pm.rows().end();
- int minfill = max_width;
+ int minfill = max_width_;
for ( ; rit != end; ++rit)
if (rit->fill() < minfill)
minfill = rit->fill();
l_margin += minfill;
#endif
// also wrong, but much shorter.
- l_margin += max_width / 2;
+ l_margin += max_width_ / 2;
break;
}
}
if (!par.params().leftIndent().zero())
- l_margin += par.params().leftIndent().inPixels(max_width, lfm.em());
+ l_margin += par.params().leftIndent().inPixels(max_width_, lfm.em());
LyXAlignment align = par.getAlign();
// 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())
+ && par.isInset(pos)
+ && par.getInset(pos)->display())
&& (!(tclass.isDefaultLayout(par.layout())
- || tclass.isPlainLayout(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
- if (buffer.params().getIndentation().asLyXCommand() == "default")
- l_margin += bfm.signedWidth(parindent);
- else
- l_margin += buffer.params().getIndentation().inPixels(*bv_);
- }
+ /* use the parindent of the layout when the default
+ * indentation is used otherwise use the indentation set in
+ * the document settings
+ */
+ if (buffer.params().getParIndent().empty())
+ l_margin += bfm.signedWidth(parindent);
+ else
+ l_margin += buffer.params().getParIndent().inPixels(max_width_, bfm.em());
+ }
return l_margin;
}
projects / lyx.git / blobdiff