#include "CoordCache.h"
#include "Cursor.h"
#include "CutAndPaste.h"
-#include "support/debug.h"
#include "FontIterator.h"
#include "FuncRequest.h"
#include "InsetList.h"
#include "frontends/FontMetrics.h"
#include "frontends/Painter.h"
+#include "support/debug.h"
+
using namespace std;
namespace lyx {
int TextMetrics::rightMargin(ParagraphMetrics const & pm) const
{
- return main_text_? pm.rightMargin(bv_->buffer()) : 0;
+ return main_text_? pm.rightMargin(*bv_) : 0;
}
int TextMetrics::rightMargin(pit_type const pit) const
{
- return main_text_? par_metrics_[pit].rightMargin(bv_->buffer()) : 0;
+ return main_text_? par_metrics_[pit].rightMargin(*bv_) : 0;
}
DocIterator parPos = text_->macrocontextPosition();
if (!parPos.empty())
parPos.pit() = pit;
-
+ else {
+ LYXERR(Debug::INFO, "MacroContext not initialised!"
+ << " Going through the buffer again and hope"
+ << " the context is better then.");
+ updateLabels(bv_->buffer());
+ parPos = text_->macrocontextPosition();
+ BOOST_ASSERT(!parPos.empty());
+ parPos.pit() = pit;
+ }
+
// redo insets
// FIXME: We should always use getFont(), see documentation of
// noFontChange() in Inset.h.
align = par.params().align();
// Display-style insets should always be on a centred row
- // The test on par.size() is to catch zero-size pars, which
- // would trigger the assert in Paragraph::getInset().
- //inset = par.size() ? par.getInset(row.pos()) : 0;
- if (row.pos() < par.size() && par.isInset(row.pos())) {
- switch(par.getInset(row.pos())->display()) {
+ if (Inset const * inset = par.getInset(row.pos())) {
+ switch (inset->display()) {
case Inset::AlignLeft:
align = LYX_ALIGN_BLOCK;
break;
pos_type const body_pos = par.beginOfBody();
+ // 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;
+ }
// Now we iterate through until we reach the right margin
// or the end of the par, then choose the possible break
for ( ; i < end; ++i, ++fi) {
int thiswidth = pm.singleWidth(i, *fi);
+ // add inline completion width
+ if (inlineCompletionLPos == i) {
+ docstring const & completion = bv_->inlineCompletion();
+ if (completion.length() > 0)
+ thiswidth += theFontMetrics(*fi).width(completion);
+ }
+
// add the auto-hfill from label end to the body
if (body_pos && i == body_pos) {
FontMetrics const & fm = theFontMetrics(
point = i + 1;
break;
}
+ Inset const * inset = 0;
// Break before...
if (i + 1 < end) {
- if (par.isInset(i + 1) && par.getInset(i + 1)->display()) {
+ if ((inset = par.getInset(i + 1)) && inset->display()) {
point = i + 1;
break;
}
// ...and after.
- if (par.isInset(i) && par.getInset(i)->display()) {
+ if ((inset = par.getInset(i)) && inset->display()) {
point = i + 1;
break;
}
}
- if (!par.isInset(i) || par.getInset(i)->isChar()) {
+ inset = par.getInset(i);
+ if (!inset || inset->isChar()) {
// some insets are line separators too
if (par.isLineSeparator(i)) {
// register breakpoint:
int w = leftMargin(max_width_, pit, first);
int label_end = labelEnd(pit);
+ // 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;
w = max(w, label_end);
}
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);
+ }
}
}
Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first,
- pos_type const end) const
+ pos_type const end, bool topBottomSpace) const
{
Paragraph const & par = text_->getPar(pit);
// get the maximum ascent and the maximum descent
ParagraphList const & pars = text_->paragraphs();
// is it a top line?
- if (first == 0) {
+ if (first == 0 && topBottomSpace) {
BufferParams const & bufparams = buffer.params();
// some parskips VERY EASY IMPLEMENTATION
if (bufparams.paragraph_separation
|| layout->labeltype == LABEL_BIBLIO
|| layout->labeltype == LABEL_CENTERED_TOP_ENVIRONMENT)
&& isFirstInSequence(pit, pars)
- && !par.getLabelstring().empty())
+ && !par.labelString().empty())
{
labeladdon = int(
labelfont_metrics.maxHeight()
}
// is it a bottom line?
- if (end >= par.size()) {
+ if (end >= par.size() && topBottomSpace) {
// add the layout spaces, for example before and after
// a section, or between the items of a itemize or enumerate
// environment
// 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_) {
+ if (main_text_ && topBottomSpace) {
if (pit == 0 && first == 0)
maxasc += 20;
if (pit + 1 == pit_type(pars.size()) &&
bool const rtl = lastrow ? text_->isRTL(buffer, par) : false;
if (lastrow &&
((rtl && left_side && vc == row.pos() && x < tmpx - 5) ||
- (!rtl && !left_side && vc == end && x > tmpx + 5)))
- c = end;
- else if (vc == row.pos()) {
+ (!rtl && !left_side && vc == end && x > tmpx + 5))) {
+ if (!par.isNewline(end - 1))
+ c = end;
+ } else if (vc == row.pos()) {
c = bidi.vis2log(vc);
if (bidi.level(c) % 2 == 1)
++c;
(body_pos > end || !par.isLineSeparator(body_pos - 1)))
body_pos = 0;
+ // check for possible inline completion in this row
+ DocIterator const & inlineCompletionPos = bv_->inlineCompletionPos();
+ pos_type inlineCompletionVPos = -1;
+ if (inlineCompletionPos.inTexted()
+ && inlineCompletionPos.text() == text_
+ && inlineCompletionPos.pit() == pit
+ && inlineCompletionPos.pos() >= row_pos
+ && inlineCompletionPos.pos() <= end) {
+ // draw logically behind the previous character
+ inlineCompletionVPos = bidi.log2vis(inlineCompletionPos.pos() - 1);
+ }
+
// Use font span to speed things up, see below
FontSpan font_span;
Font font;
if (end > 0 && end < par.size() && par.isSeparator(end - 1))
skipped_sep_vpos = bidi.log2vis(end - 1);
+ // Inline completion RTL special case row_pos == cursor_pos:
+ // "__|b" => cursor_pos is right of __
+ if (row_pos == inlineCompletionVPos && row_pos == cursor_vpos) {
+ font = getDisplayFont(pit, row_pos + 1);
+ docstring const & completion = bv_->inlineCompletion();
+ if (font.isRightToLeft() && completion.length() > 0)
+ x += theFontMetrics(font.fontInfo()).width(completion);
+ }
+
for (pos_type vpos = row_pos; vpos < cursor_vpos; ++vpos) {
// Skip the separator which is at the logical end of the row
if (vpos == skipped_sep_vpos)
x += pm.singleWidth(pos, font);
+ // Inline completion RTL case:
+ // "a__|b", __ of b => non-boundary a-pos is right of __
+ if (vpos + 1 == inlineCompletionVPos
+ && (vpos + 1 < cursor_vpos || !boundary_correction)) {
+ font = getDisplayFont(pit, vpos + 1);
+ docstring const & completion = bv_->inlineCompletion();
+ if (font.isRightToLeft() && completion.length() > 0)
+ x += theFontMetrics(font.fontInfo()).width(completion);
+ }
+
+ // Inline completion LTR case:
+ // "b|__a", __ of b => non-boundary a-pos is in front of __
+ if (vpos == inlineCompletionVPos
+ && (vpos + 1 < cursor_vpos || boundary_correction)) {
+ font = getDisplayFont(pit, vpos);
+ docstring const & completion = bv_->inlineCompletion();
+ if (!font.isRightToLeft() && completion.length() > 0)
+ x += theFontMetrics(font.fontInfo()).width(completion);
+ }
+
if (par.isSeparator(pos) && pos >= body_pos)
x += row.separator;
}
text_->deleteWordForward(cur);
else
cap::cutSelection(cur, true, false);
- checkBufferStructure(cur.buffer(), cur);
+ cur.checkBufferStructure();
}
}
int l_margin = 0;
if (text_->isMainText(buffer))
- l_margin += changebarMargin();
+ l_margin += bv_->leftMargin();
l_margin += theFontMetrics(buffer.params().getFont()).signedWidth(
tclass.leftmargin());
if (pars[newpar].layout()->isEnvironment()) {
l_margin = leftMargin(max_width, newpar);
}
+ //FIXME Should this check for emptyLayout() as well?
if (par.layout() == tclass.defaultLayout()) {
if (pars[newpar].params().noindent())
parindent.erase();
l_margin += theFontMetrics(buffer.params().getFont()).signedWidth(
layout->leftmargin);
}
- if (!par.getLabelstring().empty()) {
+ if (!par.labelString().empty()) {
l_margin += labelfont_metrics.signedWidth(layout->labelindent);
- l_margin += labelfont_metrics.width(par.getLabelstring());
+ l_margin += labelfont_metrics.width(par.labelString());
l_margin += labelfont_metrics.width(layout->labelsep);
}
break;
LABEL_CENTERED_TOP_ENVIRONMENT) {
l_margin += labelfont_metrics.signedWidth(layout->labelindent);
l_margin += labelfont_metrics.width(layout->labelsep);
- l_margin += labelfont_metrics.width(par.getLabelstring());
+ l_margin += labelfont_metrics.width(par.labelString());
}
break;
|| layout->labeltype == LABEL_TOP_ENVIRONMENT
|| layout->labeltype == LABEL_CENTERED_TOP_ENVIRONMENT
|| (layout->labeltype == LABEL_STATIC
- && layout->latextype == LATEX_ENVIRONMENT
+ && layout->latextype == LATEX_ENVIRONMENT
&& !isFirstInSequence(pit, pars)))
&& align == LYX_ALIGN_BLOCK
&& !par.params().noindent()
&& !(!par.empty()
&& par.isInset(pos)
&& par.getInset(pos)->display())
- && (par.layout() != tclass.defaultLayout()
+ && (par.layout() != tclass.defaultLayout() //should this check emptyLayout()?
|| buffer.params().paragraph_separation ==
BufferParams::PARSEP_INDENT))
{