#include "TextMetrics.h"
+#include "Bidi.h"
#include "Buffer.h"
#include "buffer_funcs.h"
#include "BufferParams.h"
#include "BufferView.h"
-#include "bufferview_funcs.h"
-#include "Color.h"
#include "CoordCache.h"
+#include "Cursor.h"
#include "CutAndPaste.h"
#include "debug.h"
#include "FontIterator.h"
#include "FuncRequest.h"
+#include "InsetList.h"
+#include "Layout.h"
#include "Length.h"
#include "LyXRC.h"
#include "MetricsInfo.h"
#include "ParIterator.h"
#include "rowpainter.h"
#include "Text.h"
-#include "Undo.h"
+#include "TextClass.h"
#include "VSpace.h"
+#include "mathed/MacroTable.h"
+#include "mathed/MathMacroTemplate.h"
+
#include "frontends/FontMetrics.h"
#include "frontends/Painter.h"
#include <boost/current_function.hpp>
+using std::make_pair;
using std::max;
using std::min;
using std::endl;
+using std::pair;
namespace lyx {
}
+bool TextMetrics::has(pit_type pit) const
+{
+ return par_metrics_.find(pit) != par_metrics_.end();
+}
+
+
ParagraphMetrics const & TextMetrics::parMetrics(pit_type pit) const
{
return const_cast<TextMetrics *>(this)->parMetrics(pit, true);
}
-ParagraphMetrics & TextMetrics::parMetrics(pit_type pit,
- bool redo)
+
+pair<pit_type, ParagraphMetrics const *> TextMetrics::first() const
+{
+ ParMetricsCache::const_iterator it = par_metrics_.begin();
+ return make_pair(it->first, &it->second);
+}
+
+
+pair<pit_type, ParagraphMetrics const *> TextMetrics::last() const
+{
+ ParMetricsCache::const_reverse_iterator it = par_metrics_.rbegin();
+ return make_pair(it->first, &it->second);
+}
+
+
+ParagraphMetrics & TextMetrics::parMetrics(pit_type pit, bool redo)
{
ParMetricsCache::iterator pmc_it = par_metrics_.find(pit);
if (pmc_it == par_metrics_.end()) {
pmc_it = par_metrics_.insert(
- std::make_pair(pit, ParagraphMetrics(text_->getPar(pit)))).first;
+ make_pair(pit, ParagraphMetrics(text_->getPar(pit)))).first;
}
- if (pmc_it->second.rows().empty() && redo) {
+ if (pmc_it->second.rows().empty() && redo)
redoParagraph(pit);
- }
return pmc_it->second;
}
-bool TextMetrics::metrics(MetricsInfo & mi, Dimension & dim)
+int TextMetrics::parPosition(pit_type pit) const
+{
+ if (pit < par_metrics_.begin()->first)
+ return -1000000;
+ if (pit > par_metrics_.rbegin()->first)
+ return +1000000;
+
+ return par_metrics_[pit].position();
+}
+
+
+bool TextMetrics::metrics(MetricsInfo & mi, Dimension & dim, int min_width)
{
BOOST_ASSERT(mi.base.textwidth);
max_width_ = mi.base.textwidth;
Dimension const old_dim = dim_;
// reset dimension.
dim_ = Dimension();
- size_t npar = text_->paragraphs().size();
+ dim_.wid = min_width;
+ pit_type const npar = text_->paragraphs().size();
if (npar > 1)
// If there is more than one row, expand the text to
// the full allowable width.
}
+void TextMetrics::applyOuterFont(Font & font) const
+{
+ Font lf(font_);
+ lf.fontInfo().reduce(bv_->buffer().params().getFont().fontInfo());
+ lf.fontInfo().realize(font.fontInfo());
+ lf.setLanguage(font.language());
+ font = lf;
+}
+
+
+Font TextMetrics::getDisplayFont(pit_type pit, pos_type pos) const
+{
+ BOOST_ASSERT(pos >= 0);
+
+ ParagraphList const & pars = text_->paragraphs();
+ Paragraph const & par = pars[pit];
+ LayoutPtr const & layout = par.layout();
+ Buffer const & buffer = bv_->buffer();
+ // FIXME: broken?
+ BufferParams const & params = buffer.params();
+ pos_type const body_pos = par.beginOfBody();
+
+ // We specialize the 95% common case:
+ if (!par.getDepth()) {
+ Font f = par.getFontSettings(params, pos);
+ if (!text_->isMainText(buffer))
+ applyOuterFont(f);
+ bool lab = layout->labeltype == LABEL_MANUAL && pos < body_pos;
+
+ FontInfo const & lf = lab ? layout->labelfont : layout->font;
+ FontInfo rlf = lab ? layout->reslabelfont : layout->resfont;
+
+ // In case the default family has been customized
+ if (lf.family() == INHERIT_FAMILY)
+ rlf.setFamily(params.getFont().fontInfo().family());
+ f.fontInfo().realize(rlf);
+ return f;
+ }
+
+ // The uncommon case need not be optimized as much
+ FontInfo const & layoutfont = pos < body_pos ?
+ layout->labelfont : layout->font;
+
+ Font font = par.getFontSettings(params, pos);
+ font.fontInfo().realize(layoutfont);
+
+ if (!text_->isMainText(buffer))
+ applyOuterFont(font);
+
+ // Realize against environment font information
+ // NOTE: the cast to pit_type should be removed when pit_type
+ // changes to a unsigned integer.
+ if (pit < pit_type(pars.size()))
+ font.fontInfo().realize(outerFont(pit, pars).fontInfo());
+
+ // Realize with the fonts of lesser depth.
+ font.fontInfo().realize(params.getFont().fontInfo());
+
+ return font;
+}
+
+
+bool TextMetrics::isRTL(CursorSlice const & sl, bool boundary) const
+{
+ if (!lyxrc.rtl_support || !sl.text())
+ return false;
+
+ int correction = 0;
+ if (boundary && sl.pos() > 0)
+ correction = -1;
+
+ return getDisplayFont(sl.pit(), sl.pos() + correction).isVisibleRightToLeft();
+}
+
+
+bool TextMetrics::isRTLBoundary(pit_type pit, pos_type pos) const
+{
+ if (!lyxrc.rtl_support)
+ return false;
+
+ // no RTL boundary at line start
+ if (pos == 0)
+ return false;
+
+ Paragraph const & par = text_->getPar(pit);
+
+ bool left = getDisplayFont(pit, pos - 1).isVisibleRightToLeft();
+ bool right;
+ if (pos == par.size())
+ right = par.isRTL(bv_->buffer().params());
+ else
+ right = getDisplayFont(pit, pos).isVisibleRightToLeft();
+ return left != right;
+}
+
+
+bool TextMetrics::isRTLBoundary(pit_type pit, pos_type pos,
+ Font const & font) const
+{
+ if (!lyxrc.rtl_support)
+ return false;
+
+ Paragraph const & par = text_->getPar(pit);
+ bool left = font.isVisibleRightToLeft();
+ bool right;
+ if (pos == par.size())
+ right = par.isRTL(bv_->buffer().params());
+ else
+ right = getDisplayFont(pit, pos).isVisibleRightToLeft();
+ return left != right;
+}
+
+
bool TextMetrics::redoParagraph(pit_type const pit)
{
Paragraph & par = text_->getPar(pit);
// when layout is set; when material is pasted.
int const moveCursor = par.checkBiblio(buffer.params().trackChanges);
if (moveCursor > 0)
- const_cast<Cursor &>(bv_->cursor()).posRight();
+ const_cast<Cursor &>(bv_->cursor()).posForward();
else if (moveCursor < 0) {
Cursor & cursor = const_cast<Cursor &>(bv_->cursor());
if (cursor.pos() >= -moveCursor)
- cursor.posLeft();
+ cursor.posBackward();
}
// Optimisation: this is used in the next two loops
// FIXME: We should always use getFont(), see documentation of
// noFontChange() in Inset.h.
Font const bufferfont = buffer.params().getFont();
- InsetList::const_iterator ii = par.insetlist.begin();
- InsetList::const_iterator iend = par.insetlist.end();
+ MacroContext mc(buffer, par);
+ InsetList::const_iterator ii = par.insetList().begin();
+ InsetList::const_iterator iend = par.insetList().end();
for (; ii != iend; ++ii) {
- Dimension old_dim = ii->inset->dimension();
+ // the macro must come here, _before_ the metric call, because
+ // the macro should see itself to detect recursions. To find out
+ // whether the macro definition is a redefinition it will look
+ // at the MacroData::redefinition_. So it doesn't get confused
+ // by the already existing macro definition of itself in the
+ // macro context.
+ if (ii->inset->lyxCode() == MATHMACRO_CODE) {
+ // get macro data
+ MathMacroTemplate const & macroTemplate
+ = static_cast<MathMacroTemplate const &>(*ii->inset);
+
+ // valid?
+ if (macroTemplate.validMacro()) {
+ MacroData macro = macroTemplate.asMacroData();
+
+ // redefinition?
+ macro.setRedefinition(mc.has(macroTemplate.name()));
+
+ // register macro (possibly overwrite the previous one of this paragraph)
+ mc.insert(macroTemplate.name(), macro);
+ }
+ }
+
+ // do the metric calculation
Dimension dim;
int const w = max_width_ - leftMargin(max_width_, pit, ii->pos)
- right_margin;
Font const & font = ii->inset->noFontChange() ?
- bufferfont : text_->getFont(buffer, par, ii->pos);
- MetricsInfo mi(bv_, font, w);
- changed |= ii->inset->metrics(mi, dim);
+ bufferfont : getDisplayFont(pit, ii->pos);
+ MetricsInfo mi(bv_, font.fontInfo(), w, mc);
+ ii->inset->metrics(mi, dim);
+ Dimension const old_dim = pm.insetDimension(ii->inset);
+ pm.setInsetDimension(ii->inset, dim);
changed |= (old_dim != dim);
}
+ Cursor const & cur = bv_->cursor();
+ DocIterator sel_beg = cur.selectionBegin();
+ DocIterator sel_end = cur.selectionEnd();
+ bool selection = cur.selection()
+ // This is out text.
+ && cur.text() == text_
+ // if the anchor is outside, this is not our selection
+ && cur.anchor().text() == text_
+ && pit >= sel_beg.pit() && pit <= sel_end.pit();
+
+ // We care only about visible selection.
+ if (selection) {
+ if (pit != sel_beg.pit()) {
+ sel_beg.pit() = pit;
+ sel_beg.pos() = 0;
+ }
+ if (pit != sel_end.pit()) {
+ sel_end.pit() = pit;
+ sel_end.pos() = sel_end.lastpos();
+ }
+ }
+
par.setBeginOfBody();
pos_type first = 0;
size_t row_index = 0;
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().
+ // for the computeRowMetrics() below.
dim_.wid = max_width_;
+ dim = rowHeight(pit, first, end);
dim.wid = rowWidth(right_margin, pit, first, end);
- boost::tie(dim.asc, dim.des) = rowHeight(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);
+ if (selection)
+ row.setSelection(sel_beg.pos(), sel_end.pos());
+ else
+ row.setSelection(-1, -1);
row.setDimension(dim);
- computeRowMetrics(pit, row);
+ int const max_row_width = max(dim_.wid, dim.wid);
+ computeRowMetrics(pit, row, max_row_width);
pm.computeRowSignature(row, bparams);
first = end;
++row_index;
// 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;
+ Dimension dim = rowHeight(pit, first, first);
dim.wid = rowWidth(right_margin, pit, first, first);
- boost::tie(dim.asc, dim.des) = rowHeight(pit, first, first);
if (row_index == pm.rows().size())
pm.rows().push_back(Row());
Row & row = pm.rows()[row_index];
row.pos(first);
row.endpos(first);
row.setDimension(dim);
- computeRowMetrics(pit, row);
+ int const max_row_width = max(dim_.wid, dim.wid);
+ computeRowMetrics(pit, row, max_row_width);
pm.computeRowSignature(row, bparams);
pm.dim().des += dim.height();
}
void TextMetrics::computeRowMetrics(pit_type const pit,
- Row & row) const
+ Row & row, int width) const
{
row.label_hfill = 0;
Buffer & buffer = bv_->buffer();
Paragraph const & par = text_->getPar(pit);
- double w = dim_.wid - row.width();
+ double w = width - row.width();
// FIXME: put back this assertion when the crash on new doc is solved.
//BOOST_ASSERT(w >= 0);
// 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()) {
- case Inset::AlignLeft:
- align = LYX_ALIGN_BLOCK;
- break;
- case Inset::AlignCenter:
- align = LYX_ALIGN_CENTER;
- break;
- case Inset::Inline:
- case Inset::AlignRight:
- // unchanged (use align)
- break;
- }
+ if (row.pos() < par.size() && par.isInset(row.pos())) {
+ switch(par.getInset(row.pos())->display()) {
+ case Inset::AlignLeft:
+ align = LYX_ALIGN_BLOCK;
+ break;
+ case Inset::AlignCenter:
+ align = LYX_ALIGN_CENTER;
+ break;
+ case Inset::Inline:
+ case Inset::AlignRight:
+ // unchanged (use align)
+ break;
+ }
}
switch (align) {
}
-namespace {
-
// this needs special handling - only newlines count as a break point
-pos_type addressBreakPoint(pos_type i, Paragraph const & par)
+static pos_type addressBreakPoint(pos_type i, Paragraph const & par)
{
pos_type const end = par.size();
return end;
}
-};
-
int TextMetrics::labelEnd(pit_type const pit) const
{
// pixel width since last breakpoint
int chunkwidth = 0;
- FontIterator fi = FontIterator(buffer, *text_, par, pos);
+ FontIterator fi = FontIterator(*this, par, pit, pos);
pos_type point = end;
pos_type i = pos;
for ( ; i < end; ++i, ++fi) {
point = i;
else
point = i + 1;
-
}
// exit on last registered breakpoint:
break;
pos_type i = first;
if (i < end) {
- FontIterator fi = FontIterator(buffer, *text_, par, i);
+ FontIterator fi = FontIterator(*this, par, pit, i);
for ( ; i < end; ++i, ++fi) {
if (body_pos > 0 && i == body_pos) {
FontMetrics const & fm = theFontMetrics(
}
-boost::tuple<int, int> TextMetrics::rowHeight(pit_type const pit, pos_type const first,
+Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first,
pos_type const end) const
{
Paragraph const & par = text_->getPar(pit);
// start with so we don't have to do the assignment below too
// often.
Buffer const & buffer = bv_->buffer();
- Font font = text_->getFont(buffer, par, first);
- Font::FONT_SIZE const tmpsize = font.size();
- font = text_->getLayoutFont(buffer, pit);
- Font::FONT_SIZE const size = font.size();
- font.setSize(tmpsize);
+ Font font = getDisplayFont(pit, first);
+ FontSize const tmpsize = font.fontInfo().size();
+ font.fontInfo() = text_->getLayoutFont(buffer, pit);
+ FontSize const size = font.fontInfo().size();
+ font.fontInfo().setSize(tmpsize);
- Font labelfont = text_->getLabelFont(buffer, par);
+ FontInfo labelfont = text_->getLabelFont(buffer, par);
FontMetrics const & labelfont_metrics = theFontMetrics(labelfont);
FontMetrics const & fontmetrics = theFontMetrics(font);
int maxdesc = int(fontmetrics.maxDescent() * spacing_val);
// insets may be taller
- InsetList::const_iterator ii = par.insetlist.begin();
- InsetList::const_iterator iend = par.insetlist.end();
+ ParagraphMetrics const & pm = par_metrics_[pit];
+ InsetList::const_iterator ii = par.insetList().begin();
+ InsetList::const_iterator iend = par.insetList().end();
for ( ; ii != iend; ++ii) {
+ Dimension const & dim = pm.insetDimension(ii->inset);
if (ii->pos >= first && ii->pos < end) {
- maxasc = max(maxasc, ii->inset->ascent());
- maxdesc = max(maxdesc, ii->inset->descent());
+ maxasc = max(maxasc, dim.ascent());
+ maxdesc = max(maxdesc, dim.descent());
}
}
// cosmetic error for now.
int labeladdon = 0;
- Font::FONT_SIZE maxsize =
+ FontSize maxsize =
par.highestFontInRange(first, end, size);
- if (maxsize > font.size()) {
+ if (maxsize > font.fontInfo().size()) {
// use standard paragraph font with the maximal size
- Font maxfont = font;
+ FontInfo maxfont = font.fontInfo();
maxfont.setSize(maxsize);
FontMetrics const & maxfontmetrics = theFontMetrics(maxfont);
maxasc = max(maxasc, maxfontmetrics.maxAscent());
// some parskips VERY EASY IMPLEMENTATION
if (bufparams.paragraph_separation
== BufferParams::PARSEP_SKIP
- && par.ownerCode() != Inset::ERT_CODE
- && par.ownerCode() != Inset::LISTINGS_CODE
+ && par.ownerCode() != ERT_CODE
+ && par.ownerCode() != LISTINGS_CODE
&& pit > 0
&& ((layout->isParagraph() && par.getDepth() == 0)
|| (pars[pit - 1].layout()->isParagraph()
maxdesc += 20;
}
- return boost::make_tuple(maxasc + labeladdon, maxdesc);
+ return Dimension(0, maxasc + labeladdon, maxdesc);
}
/// For the main Text, it is possible that this pit is not
/// yet in the CoordCache when moving cursor up.
/// x Paragraph coordinate is always 0 for main text anyway.
- int const xo = main_text_? 0 : bv_->coordCache().get(text_, pit).x_;
+ int const xo = origin_.x_;
x -= xo;
Paragraph const & par = text_->getPar(pit);
ParagraphMetrics const & pm = par_metrics_[pit];
bool const rtl = (bidi.level(c) % 2 == 1);
if (left_side == rtl) {
++c;
- boundary = text_->isRTLBoundary(buffer, par, c);
+ boundary = isRTLBoundary(pit, c);
}
}
pos_type TextMetrics::x2pos(pit_type pit, int row, int x) const
{
- ParagraphMetrics const & pm = par_metrics_[pit];
- BOOST_ASSERT(!pm.rows().empty());
+ // We play safe and use parMetrics(pit) to make sure the
+ // ParagraphMetrics will be redone and OK to use if needed.
+ // Otherwise we would use an empty ParagraphMetrics in
+ // upDownInText() while in selection mode.
+ ParagraphMetrics const & pm = parMetrics(pit);
+
BOOST_ASSERT(row < int(pm.rows().size()));
bool bound = false;
Row const & r = pm.rows()[row];
}
+void TextMetrics::newParMetricsDown()
+{
+ pair<pit_type, ParagraphMetrics> const & last = *par_metrics_.rbegin();
+ pit_type const pit = last.first + 1;
+ if (pit == int(text_->paragraphs().size()))
+ return;
+
+ // do it and update its position.
+ redoParagraph(pit);
+ par_metrics_[pit].setPosition(last.second.position()
+ + last.second.descent());
+}
+
+
+void TextMetrics::newParMetricsUp()
+{
+ pair<pit_type, ParagraphMetrics> const & first = *par_metrics_.begin();
+ if (first.first == 0)
+ return;
+
+ pit_type const pit = first.first - 1;
+ // do it and update its position.
+ redoParagraph(pit);
+ par_metrics_[pit].setPosition(first.second.position()
+ - first.second.ascent());
+}
+
// y is screen coordinate
pit_type TextMetrics::getPitNearY(int y)
{
BOOST_ASSERT(!text_->paragraphs().empty());
- BOOST_ASSERT(bv_->coordCache().getParPos().find(text_) != bv_->coordCache().getParPos().end());
- CoordCache::InnerParPosCache const & cc = bv_->coordCache().getParPos().find(text_)->second;
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": y: " << y << " cache size: " << cc.size()
- << endl;
+ LYXERR(Debug::DEBUG, BOOST_CURRENT_FUNCTION
+ << ": y: " << y << " cache size: " << par_metrics_.size());
// look for highest numbered paragraph with y coordinate less than given y
pit_type pit = 0;
int yy = -1;
- CoordCache::InnerParPosCache::const_iterator it = cc.begin();
- CoordCache::InnerParPosCache::const_iterator et = cc.end();
- CoordCache::InnerParPosCache::const_iterator last = et; last--;
+ ParMetricsCache::const_iterator it = par_metrics_.begin();
+ ParMetricsCache::const_iterator et = par_metrics_.end();
+ ParMetricsCache::const_iterator last = et; last--;
- ParagraphMetrics const & pm = par_metrics_[it->first];
+ ParagraphMetrics const & pm = it->second;
// If we are off-screen (before the visible part)
if (y < 0
// and even before the first paragraph in the cache.
- && y < it->second.y_ - int(pm.ascent())) {
+ && y < it->second.position() - int(pm.ascent())) {
// and we are not at the first paragraph in the inset.
if (it->first == 0)
return 0;
pit = it->first - 1;
// rebreak it and update the CoordCache.
redoParagraph(pit);
- bv_->coordCache().parPos()[text_][pit] =
- Point(0, it->second.y_ - pm.descent());
+ par_metrics_[pit].setPosition(it->second.position() - pm.descent());
return pit;
}
// If we are off-screen (after the visible part)
if (y > bv_->workHeight()
// and even after the first paragraph in the cache.
- && y >= last->second.y_ + int(pm_last.descent())) {
+ && y >= last->second.position() + int(pm_last.descent())) {
pit = last->first + 1;
// and we are not at the last paragraph in the inset.
if (pit == int(text_->paragraphs().size()))
// then this is the paragraph we are looking for.
// rebreak it and update the CoordCache.
redoParagraph(pit);
- bv_->coordCache().parPos()[text_][pit] =
- Point(0, last->second.y_ + pm_last.ascent());
+ par_metrics_[pit].setPosition(last->second.position() + pm_last.ascent());
return pit;
}
for (; it != et; ++it) {
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
+ LYXERR(Debug::DEBUG, BOOST_CURRENT_FUNCTION
<< " examining: pit: " << it->first
- << " y: " << it->second.y_
- << endl;
+ << " y: " << it->second.position());
ParagraphMetrics const & pm = par_metrics_[it->first];
- if (it->first >= pit && int(it->second.y_) - int(pm.ascent()) <= y) {
+ if (it->first >= pit && int(it->second.position()) - int(pm.ascent()) <= y) {
pit = it->first;
- yy = it->second.y_;
+ yy = it->second.position();
}
}
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": found best y: " << yy << " for pit: " << pit
- << endl;
+ LYXERR(Debug::DEBUG, BOOST_CURRENT_FUNCTION
+ << ": found best y: " << yy << " for pit: " << pit);
return pit;
}
{
ParagraphMetrics const & pm = par_metrics_[pit];
- int yy = bv_->coordCache().get(text_, pit).y_ - pm.ascent();
+ int yy = pm.position() - pm.ascent();
BOOST_ASSERT(!pm.rows().empty());
RowList::const_iterator rit = pm.rows().begin();
- RowList::const_iterator const rlast = boost::prior(pm.rows().end());
+ RowList::const_iterator rlast = pm.rows().end();
+ --rlast;
for (; rit != rlast; yy += rit->height(), ++rit)
if (yy + rit->height() > y)
break;
if (!inset) {
// Either we deconst editXY or better we move current_font
// and real_current_font to Cursor
- text_->setCurrentFont(cur);
+ // FIXME: what is needed now that current_font and real_current_font
+ // are transferred?
+ cur.setCurrentFont();
return 0;
}
inset = inset->editXY(cur, x, y);
if (cur.top().text() == text_)
- text_->setCurrentFont(cur);
+ cur.setCurrentFont();
return inset;
}
ParagraphMetrics const & pm = par_metrics_[pit];
- int yy = bv_->coordCache().get(text_, pit).y_ - pm.ascent();
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": x: " << x
- << " y: " << y
- << " pit: " << pit
- << " yy: " << yy << endl;
+ int yy = pm.position() - pm.ascent();
+ LYXERR(Debug::DEBUG, BOOST_CURRENT_FUNCTION
+ << ": x: " << x << " y: " << y << " pit: " << pit << " yy: " << yy);
int r = 0;
BOOST_ASSERT(pm.rows().size());
Row const & row = pm.rows()[r];
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": row " << r
- << " from pos: " << row.pos()
- << endl;
+ LYXERR(Debug::DEBUG, BOOST_CURRENT_FUNCTION
+ << ": row " << r << " from pos: " << row.pos());
bool bound = false;
int xx = x;
pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound);
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": setting cursor pit: " << pit
- << " pos: " << pos
- << endl;
+ LYXERR(Debug::DEBUG, BOOST_CURRENT_FUNCTION
+ << ": setting cursor pit: " << pit << " pos: " << pos);
text_->setCursor(cur, pit, pos, true, bound);
// remember new position.
BOOST_ASSERT(pit != -1);
Paragraph const & par = text_->paragraphs()[pit];
+ ParagraphMetrics const & pm = par_metrics_[pit];
+
+ LYXERR(Debug::DEBUG, BOOST_CURRENT_FUNCTION
+ << ": x: " << x << " y: " << y << " pit: " << pit);
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": x: " << x
- << " y: " << y
- << " pit: " << pit
- << endl;
- InsetList::const_iterator iit = par.insetlist.begin();
- InsetList::const_iterator iend = par.insetlist.end();
+ InsetList::const_iterator iit = par.insetList().begin();
+ InsetList::const_iterator iend = par.insetList().end();
for (; iit != iend; ++iit) {
Inset * inset = iit->inset;
-#if 1
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": examining inset " << inset << endl;
-
- if (bv_->coordCache().getInsets().has(inset))
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": xo: " << inset->xo(*bv_) << "..."
- << inset->xo(*bv_) + inset->width()
- << " yo: " << inset->yo(*bv_) - inset->ascent()
- << "..."
- << inset->yo(*bv_) + inset->descent()
- << endl;
- else
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": inset has no cached position" << endl;
-#endif
- if (inset->covers(*bv_, x, y)) {
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": Hit inset: " << inset << endl;
+
+ LYXERR(Debug::DEBUG, BOOST_CURRENT_FUNCTION
+ << ": examining inset " << inset);
+
+ if (!bv_->coordCache().getInsets().has(inset)) {
+ LYXERR(Debug::DEBUG, BOOST_CURRENT_FUNCTION
+ << ": inset has no cached position");
+ return 0;
+ }
+
+ Dimension const & dim = pm.insetDimension(inset);
+ Point p = bv_->coordCache().getInsets().xy(inset);
+
+ LYXERR(Debug::DEBUG, BOOST_CURRENT_FUNCTION
+ << ": 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) {
+ LYXERR(Debug::DEBUG, BOOST_CURRENT_FUNCTION
+ << ": Hit inset: " << inset);
return inset;
}
}
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << ": No inset hit. " << endl;
+
+ LYXERR(Debug::DEBUG, BOOST_CURRENT_FUNCTION << ": No inset hit. ");
return 0;
}
// Use font span to speed things up, see above
if (pos < font_span.first || pos > font_span.last) {
font_span = par.fontSpan(pos);
- font = text_->getFont(buffer, par, pos);
+ font = getDisplayFont(pit, pos);
}
x += pm.singleWidth(pos, font);
// see correction above
if (boundary_correction) {
- if (text_->isRTL(buffer, sl, boundary))
+ if (isRTL(sl, boundary))
x -= singleWidth(pit, ppos);
else
x += singleWidth(pit, ppos);
// simplest solution is to move to the previous row instead.
cur.dispatch(FuncRequest(cur.selection()? LFUN_UP_SELECT: LFUN_UP));
- finishUndo();
+ cur.finishUndo();
cur.updateFlags(Update::Force | Update::FitCursor);
}
cur.dispatch(
FuncRequest(cur.selection()? LFUN_DOWN_SELECT: LFUN_DOWN));
- finishUndo();
+ cur.finishUndo();
cur.updateFlags(Update::Force | Update::FitCursor);
}
{
BOOST_ASSERT(text_ == cur.text());
if (cur.lastpos() == 0) {
- // Paragraph is empty, so we just go to the right
- text_->cursorRight(cur);
+ // Paragraph is empty, so we just go forward
+ text_->cursorForward(cur);
} else {
cur.resetAnchor();
cur.selection() = true; // to avoid deletion
&& pit > 0 && pars[pit - 1].layout()->nextnoindent)
parindent.erase();
- Font const labelfont = text_->getLabelFont(buffer, par);
+ FontInfo const labelfont = text_->getLabelFont(buffer, par);
FontMetrics const & labelfont_metrics = theFontMetrics(labelfont);
switch (layout->margintype) {
int TextMetrics::singleWidth(pit_type pit, pos_type pos) const
{
- Buffer const & buffer = bv_->buffer();
ParagraphMetrics const & pm = par_metrics_[pit];
- return pm.singleWidth(pos, text_->getFont(buffer, text_->getPar(pit), pos));
+ return pm.singleWidth(pos, getDisplayFont(pit, pos));
}
if (par_metrics_.empty())
return;
- ParMetricsCache::const_iterator it = par_metrics_.begin();
- ParMetricsCache::const_iterator const end = par_metrics_.end();
+ origin_.x_ = x;
+ origin_.y_ = y;
+
+ ParMetricsCache::iterator it = par_metrics_.begin();
+ ParMetricsCache::iterator const pm_end = par_metrics_.end();
y -= it->second.ascent();
- for (; it != end; ++it) {
+ for (; it != pm_end; ++it) {
ParagraphMetrics const & pmi = it->second;
y += pmi.ascent();
- drawParagraph(pi, it->first, x, y);
+ pit_type const pit = it->first;
+ // Save the paragraph position in the cache.
+ it->second.setPosition(y);
+ drawParagraph(pi, pit, x, y);
y += pmi.descent();
}
}
// lyxerr << " paintPar: pit: " << pit << " at y: " << y << endl;
int const ww = bv_->workHeight();
- bv_->coordCache().parPos()[text_][pit] = Point(x, y);
-
ParagraphMetrics const & pm = par_metrics_[pit];
if (pm.rows().empty())
return;
Bidi bidi;
+ bool const original_drawing_state = pi.pain.isDrawingEnabled();
+
y -= rb->ascent();
for (RowList::const_iterator rit = rb; rit != re; ++rit) {
y += rit->ascent();
bool const inside = (y + rit->descent() >= 0
&& y - rit->ascent() < ww);
// it is not needed to draw on screen if we are not inside.
- pi.pain.setDrawingEnabled(inside);
+ pi.pain.setDrawingEnabled(inside && original_drawing_state);
RowPainter rp(pi, *text_, pit, *rit, bidi, x, y);
// Row signature; has row changed since last paint?
bool row_has_changed = rit->changed();
- if (!pi.full_repaint && !row_has_changed) {
+ bool row_selection = rit->sel_beg != -1 && rit->sel_end != -1;
+
+ if (!row_selection && !pi.full_repaint && !row_has_changed) {
// Paint the only the insets if the text itself is
// unchanged.
rp.paintOnlyInsets();
// changed.
// Clear background of this row
// (if paragraph background was not cleared)
- if (!pi.full_repaint && row_has_changed) {
+ if (row_selection || (!pi.full_repaint && row_has_changed)) {
pi.pain.fillRectangle(x, y - rit->ascent(),
- width(), rit->height(),
- text_->backgroundColor());
+ width(), rit->height(), pi.background_color);
+ }
+ if (row_selection) {
+ DocIterator beg = bv_->cursor().selectionBegin();
+ DocIterator end = bv_->cursor().selectionEnd();
+ bool const beg_margin = beg.pit() < pit;
+ bool const end_margin = end.pit() > pit;
+ beg.pit() = pit;
+ beg.pos() = rit->sel_beg;
+ end.pit() = pit;
+ end.pos() = rit->sel_end;
+ drawRowSelection(pi, x, *rit, beg, end, beg_margin, end_margin);
}
// Instrumentation for testing row cache (see also
// 12 lines lower):
if (lyxerr.debugging(Debug::PAINTING)) {
if (text_->isMainText(bv_->buffer()))
- LYXERR(Debug::PAINTING) << "\n{" <<
- pi.full_repaint << row_has_changed << "}";
+ LYXERR(Debug::PAINTING, "\n{" << inside <<
+ pi.full_repaint << row_has_changed << "}");
else
- LYXERR(Debug::PAINTING) << "[" <<
- pi.full_repaint << row_has_changed << "]";
+ LYXERR(Debug::PAINTING, "[" << inside <<
+ pi.full_repaint << row_has_changed << "]");
}
// Backup full_repaint status and force full repaint
pi.full_repaint = tmp;
}
// Re-enable screen drawing for future use of the painter.
- pi.pain.setDrawingEnabled(true);
+ pi.pain.setDrawingEnabled(original_drawing_state);
//LYXERR(Debug::PAINTING) << "." << endl;
}
-// only used for inset right now. should also be used for main text
-void TextMetrics::drawSelection(PainterInfo & pi, int x, int) const
-{
- Cursor & cur = bv_->cursor();
- if (!cur.selection())
- return;
- if (!ptr_cmp(cur.text(), text_))
- return;
-
- LYXERR(Debug::DEBUG)
- << BOOST_CURRENT_FUNCTION
- << "draw selection at " << x
- << endl;
-
- DocIterator beg = cur.selectionBegin();
- DocIterator end = cur.selectionEnd();
-
- // the selection doesn't touch the visible screen?
- if (bv_funcs::status(bv_, beg) == bv_funcs::CUR_BELOW
- || bv_funcs::status(bv_, end) == bv_funcs::CUR_ABOVE)
- return;
-
- if (beg.pit() < par_metrics_.begin()->first)
- beg.pit() = par_metrics_.begin()->first;
- if (end.pit() > par_metrics_.rbegin()->first)
- end.pit() = par_metrics_.rbegin()->first;
-
- ParagraphMetrics const & pm1 = par_metrics_[beg.pit()];
- ParagraphMetrics const & pm2 = par_metrics_[end.pit()];
- Row const & row1 = pm1.getRow(beg.pos(), beg.boundary());
- Row const & row2 = pm2.getRow(end.pos(), end.boundary());
-
- // clip above
- int middleTop;
- bool const clipAbove =
- (bv_funcs::status(bv_, beg) == bv_funcs::CUR_ABOVE);
- if (clipAbove)
- middleTop = 0;
- else
- middleTop = bv_funcs::getPos(*bv_, beg, beg.boundary()).y_ + row1.descent();
-
- // clip below
- int middleBottom;
- bool const clipBelow =
- (bv_funcs::status(bv_, end) == bv_funcs::CUR_BELOW);
- if (clipBelow)
- middleBottom = bv_->workHeight();
- else
- middleBottom = bv_funcs::getPos(*bv_, end, end.boundary()).y_ - row2.ascent();
-
- // start and end in the same line?
- if (!(clipAbove || clipBelow) && &row1 == &row2)
- // then only draw this row's selection
- drawRowSelection(pi, x, row1, beg, end, false, false);
- else {
- if (!clipAbove) {
- // get row end
- DocIterator begRowEnd = beg;
- begRowEnd.pos() = row1.endpos();
- begRowEnd.boundary(true);
-
- // draw upper rectangle
- drawRowSelection(pi, x, row1, beg, begRowEnd, false, true);
- }
-
- if (middleTop < middleBottom) {
- // draw middle rectangle
- pi.pain.fillRectangle(x, middleTop, width(), middleBottom - middleTop,
- Color::selection);
- }
-
- if (!clipBelow) {
- // get row begin
- DocIterator endRowBeg = end;
- endRowBeg.pos() = row2.pos();
- endRowBeg.boundary(false);
-
- // draw low rectangle
- drawRowSelection(pi, x, row2, endRowBeg, end, true, false);
- }
- }
-}
-
-
void TextMetrics::drawRowSelection(PainterInfo & pi, int x, Row const & row,
DocIterator const & beg, DocIterator const & end,
bool drawOnBegMargin, bool drawOnEndMargin) const
DocIterator cur = beg;
int x1 = cursorX(beg.top(), beg.boundary());
int x2 = cursorX(end.top(), end.boundary());
- int y1 = bv_funcs::getPos(*bv_, cur, cur.boundary()).y_ - row.ascent();
+ int y1 = bv_->getPos(cur, cur.boundary()).y_ - row.ascent();
int y2 = y1 + row.height();
// draw the margins
if (drawOnBegMargin) {
if (text_->isRTL(buffer, beg.paragraph()))
- pi.pain.fillRectangle(x + x1, y1, width() - x1, y2 - y1, Color::selection);
+ pi.pain.fillRectangle(x + x1, y1, width() - x1, y2 - y1, Color_selection);
else
- pi.pain.fillRectangle(x, y1, x1, y2 - y1, Color::selection);
+ pi.pain.fillRectangle(x, y1, x1, y2 - y1, Color_selection);
}
if (drawOnEndMargin) {
if (text_->isRTL(buffer, beg.paragraph()))
- pi.pain.fillRectangle(x, y1, x2, y2 - y1, Color::selection);
+ pi.pain.fillRectangle(x, y1, x2, y2 - y1, Color_selection);
else
- pi.pain.fillRectangle(x + x2, y1, width() - x2, y2 - y1, Color::selection);
+ pi.pain.fillRectangle(x + x2, y1, width() - x2, y2 - y1, Color_selection);
}
// if we are on a boundary from the beginning, it's probably
while (cur < end) {
bool drawNow = false;
- // simplified cursorRight code below which does not
+ // simplified cursorForward code below which does not
// descend into insets and which does not go into the
- // next line. Compare the logic with the original cursorRight
+ // next line. Compare the logic with the original cursorForward
// if left of boundary -> just jump to right side
// but for RTL boundaries don't, because: abc|DDEEFFghi -> abcDDEEF|Fghi
if (cur.boundary()) {
cur.boundary(false);
- } else if (text_->isRTLBoundary(buffer, cur.paragraph(), cur.pos() + 1)) {
+ } else if (isRTLBoundary(cur.pit(), cur.pos() + 1)) {
// in front of RTL boundary -> Stay on this side of the boundary because:
// ab|cDDEEFFghi -> abc|DDEEFFghi
++cur.pos();
if (!(cur < end) || drawNow) {
x2 = cursorX(cur.top(), cur.boundary());
pi.pain.fillRectangle(x + min(x1,x2), y1, abs(x2 - x1), y2 - y1,
- Color::selection);
+ Color_selection);
// reset x1, so it is set again next round (which will be on the
// right side of a boundary or at the selection end)
int defaultRowHeight()
{
- return int(theFontMetrics(Font(Font::ALL_SANE)).maxHeight() * 1.2);
+ return int(theFontMetrics(sane_font).maxHeight() * 1.2);
}
} // namespace lyx