int const h = tm.parMetrics(anchor_ref_).height();
offset_ref_ = int((bar * t.paragraphs().size() - anchor_ref_) * h);
updateMetrics(false);
+ buffer_.changed();
}
intl_->keyMapPrim();
}
}
-
+
intl_->getTransManager().translateAndInsert(c, t, cur);
}
break;
}
+ case LFUN_SCREEN_UP:
+ case LFUN_SCREEN_DOWN:
+ flag.enabled(true);
+ break;
+
+ // FIXME: LFUN_SCREEN_DOWN_SELECT should be removed from
+ // everywhere else before this can enabled:
+ case LFUN_SCREEN_UP_SELECT:
+ case LFUN_SCREEN_DOWN_SELECT:
+ flag.enabled(false);
+ break;
+
default:
flag.enabled(false);
}
// if there is an inset at cursor, see whether it
// wants to toggle.
Inset * inset = cur.nextInset();
- if (inset && inset->isActive()) {
- Cursor tmpcur = cur;
- tmpcur.pushLeft(*inset);
- inset->dispatch(tmpcur, tmpcmd);
- if (tmpcur.result().dispatched()) {
- cur.dispatched();
+ if (inset) {
+ if (inset->isActive()) {
+ Cursor tmpcur = cur;
+ tmpcur.pushLeft(*inset);
+ inset->dispatch(tmpcur, tmpcmd);
+ if (tmpcur.result().dispatched()) {
+ cur.dispatched();
+ }
+ } else if (inset->editable() == Inset::IS_EDITABLE) {
+ inset->edit(cur, true);
}
}
// if it did not work, try the underlying inset.
break;
}
+ case LFUN_SCREEN_UP:
+ case LFUN_SCREEN_DOWN: {
+ Point p = bv_funcs::getPos(*this, cur, cur.boundary());
+ if (p.y_ < 0 || p.y_ > height_) {
+ // The cursor is off-screen so recenter before proceeding.
+ center();
+ updateMetrics(false);
+ //FIXME: updateMetrics() does not update paragraph position
+ // This is done at draw() time. So we need a redraw!
+ buffer_.changed();
+ p = bv_funcs::getPos(*this, cur, cur.boundary());
+ }
+ scroll(cmd.action == LFUN_SCREEN_UP? - height_ : height_);
+ cur.reset(buffer_.inset());
+ text_metrics_[&buffer_.text()].editXY(cur, p.x_, p.y_);
+ //FIXME: what to do with cur.x_target()?
+ finishUndo();
+ // The metrics are already up to date. see scroll()
+ updateFlags = Update::None;
+ break;
+ }
+
+ case LFUN_SCREEN_UP_SELECT:
+ case LFUN_SCREEN_DOWN_SELECT: {
+ cur.selHandle(true);
+ size_t initial_depth = cur.depth();
+ Point const p = bv_funcs::getPos(*this, cur, cur.boundary());
+ scroll(cmd.action == LFUN_SCREEN_UP_SELECT? - height_ : height_);
+ // FIXME: We need to verify if the cursor stayed within an inset...
+ //cur.reset(buffer_.inset());
+ text_metrics_[&buffer_.text()].editXY(cur, p.x_, p.y_);
+ finishUndo();
+ while (cur.depth() > initial_depth) {
+ cur.forwardInset();
+ }
+ // FIXME: we need to do a redraw again because of the selection
+ buffer_.changed();
+ updateFlags = Update::Force | Update::FitCursor;
+ break;
+ }
+
default:
updateFlags = Update::None;
}
cmd.y = min(max(cmd.y, -1), height_);
if (cmd.action == LFUN_MOUSE_MOTION && cmd.button() == mouse_button::none) {
+ //FIXME: disabling mouse hover for now as it is causing funny things
+ // on screen.
+ return false;
// Get inset under mouse, if there is one.
Inset const * covering_inset =
}
-void BufferView::scroll(int /*lines*/)
+void BufferView::scroll(int y)
{
-// Text const * t = buffer_.text();
-// int const line_height = defaultRowHeight();
-//
-// // The new absolute coordinate
-// int new_top_y = top_y() + lines * line_height;
-//
-// // Restrict to a valid value
-// new_top_y = std::min(t->height() - 4 * line_height, new_top_y);
-// new_top_y = std::max(0, new_top_y);
-//
-// scrollDocView(new_top_y);
-//
+ if (y > 0)
+ scrollDown(y);
+ else if (y < 0)
+ scrollUp(-y);
+}
+
+
+void BufferView::scrollDown(int offset)
+{
+ Text * text = &buffer_.text();
+ TextMetrics & tm = text_metrics_[text];
+ int ymax = height_ + offset;
+ while (true) {
+ std::pair<pit_type, ParagraphMetrics> const & last = tm.last();
+ int bottom_pos = last.second.position() + last.second.descent();
+ if (last.first == text->paragraphs().size() - 1) {
+ if (bottom_pos <= height_)
+ return;
+ offset = min(offset, bottom_pos - height_);
+ break;
+ }
+ if (bottom_pos > ymax)
+ break;
+ tm.newParMetricsDown();
+ }
+ offset_ref_ += offset;
+ updateMetrics(false);
+ buffer_.changed();
+}
+
+
+void BufferView::scrollUp(int offset)
+{
+ Text * text = &buffer_.text();
+ TextMetrics & tm = text_metrics_[text];
+ int ymin = - offset;
+ while (true) {
+ std::pair<pit_type, ParagraphMetrics> const & first = tm.first();
+ int top_pos = first.second.position() - first.second.ascent();
+ if (first.first == 0) {
+ if (top_pos >= 0)
+ return;
+ offset = min(offset, - top_pos);
+ break;
+ }
+ if (top_pos < ymin)
+ break;
+ tm.newParMetricsUp();
+ }
+ offset_ref_ -= offset;
+ updateMetrics(false);
+ buffer_.changed();
}
{
BOOST_ASSERT(&cur.bv() == this);
- // this event will clear selection so we save selection for
+ // this event will clear selection so we save selection for
// persistent selection
cap::saveSelection(cursor());
void BufferView::updateMetrics(bool singlepar)
{
Text & buftext = buffer_.text();
- pit_type size = int(buftext.paragraphs().size());
+ pit_type const npit = int(buftext.paragraphs().size());
- if (anchor_ref_ > int(buftext.paragraphs().size() - 1)) {
- anchor_ref_ = int(buftext.paragraphs().size() - 1);
+ if (anchor_ref_ > int(npit - 1)) {
+ anchor_ref_ = int(npit - 1);
offset_ref_ = 0;
}
if (!singlepar) {
// Clear out the position cache in case of full screen redraw,
coord_cache_.clear();
-
+
// Clear out paragraph metrics to avoid having invalid metrics
// in the cache from paragraphs not relayouted below
// The complete text metrics will be redone.
TextMetrics & tm = textMetrics(&buftext);
+ pit_type const bottom_pit = cursor_.bottom().pit();
// If the paragraph metrics has changed, we can not
// use the singlepar optimisation.
if (singlepar
// the (main text, not inset!) paragraph containing the cursor.
// (if this paragraph contains insets etc., rebreaking will
// recursively descend)
- && tm.redoParagraph(cursor_.bottom().pit()))
- singlepar = false;
+ && !tm.redoParagraph(bottom_pit)) {
+
+ updateOffsetRef();
+ // collect cursor paragraph iter bounds
+ ParagraphMetrics const & pm = tm.parMetrics(bottom_pit);
+ int y1 = pm.position() - pm.ascent();
+ int y2 = pm.position() + pm.descent();
+ metrics_info_ = ViewMetricsInfo(bottom_pit, bottom_pit, y1, y2,
+ SingleParUpdate, npit);
+ LYXERR(Debug::PAINTING)
+ << BOOST_CURRENT_FUNCTION
+ << "\ny1: " << y1
+ << " y2: " << y2
+ << " pit: " << bottom_pit
+ << " singlepar: " << singlepar
+ << endl;
+ return;
+ }
pit_type const pit = anchor_ref_;
int pit1 = pit;
int pit2 = pit;
- size_t const npit = buftext.paragraphs().size();
// Rebreak anchor paragraph.
- if (!singlepar)
- tm.redoParagraph(pit);
+ tm.redoParagraph(pit);
updateOffsetRef();
while (y1 > 0 && pit1 > 0) {
y1 -= tm.parMetrics(pit1).ascent();
--pit1;
- if (!singlepar)
- tm.redoParagraph(pit1);
+ tm.redoParagraph(pit1);
y1 -= tm.parMetrics(pit1).descent();
}
-
// Take care of ascent of first line
y1 -= tm.parMetrics(pit1).ascent();
while (y2 < height_ && pit2 < int(npit) - 1) {
y2 += tm.parMetrics(pit2).descent();
++pit2;
- if (!singlepar)
- tm.redoParagraph(pit2);
+ tm.redoParagraph(pit2);
y2 += tm.parMetrics(pit2).ascent();
}
// Take care of descent of last line
y2 += tm.parMetrics(pit2).descent();
- // The coordinates of all these paragraphs are correct, cache them
- int y = y1;
- CoordCache::InnerParPosCache & parPos = coord_cache_.parPos()[&buftext];
- for (pit_type pit = pit1; pit <= pit2; ++pit) {
- ParagraphMetrics const & pm = tm.parMetrics(pit);
- y += pm.ascent();
- parPos[pit] = Point(0, y);
- if (singlepar && pit == cursor_.bottom().pit()) {
- // In Single Paragraph mode, collect here the
- // y1 and y2 of the (one) paragraph the cursor is in
- y1 = y - pm.ascent();
- y2 = y + pm.descent();
- }
- y += pm.descent();
- }
-
- if (singlepar) {
- // collect cursor paragraph iter bounds
- pit1 = cursor_.bottom().pit();
- pit2 = cursor_.bottom().pit();
- }
-
- LYXERR(Debug::DEBUG)
+ LYXERR(Debug::PAINTING)
<< BOOST_CURRENT_FUNCTION
- << " y1: " << y1
+ << "\n y1: " << y1
<< " y2: " << y2
<< " pit1: " << pit1
<< " pit2: " << pit2
<< " npit: " << npit
<< " singlepar: " << singlepar
- << "size: " << size
<< endl;
metrics_info_ = ViewMetricsInfo(pit1, pit2, y1, y2,
- singlepar? SingleParUpdate: FullScreenUpdate, size);
+ FullScreenUpdate, npit);
if (lyxerr.debugging(Debug::WORKAREA)) {
LYXERR(Debug::WORKAREA) << "BufferView::updateMetrics" << endl;
el = buf.errorList("Parse");
recordUndo(cursor_);
cap::pasteParagraphList(cursor_, buf.paragraphs(),
- buf.params().getTextClass_ptr(), el);
+ buf.params().getTextClassPtr(), el);
res = _("Document %1$s inserted.");
} else
res = _("Could not insert document %1$s");
// and grey out above (should not happen later)
// lyxerr << "par ascent: " << text.getPar(metrics_info_.p1).ascent() << endl;
- if (metrics_info_.y1 > 0
+ if (metrics_info_.y1 > 0
&& metrics_info_.update_strategy == FullScreenUpdate)
pain.fillRectangle(0, 0, width_, metrics_info_.y1, Color::bottomarea);
// and possibly grey out below
// lyxerr << "par descent: " << text.getPar(metrics_info_.p1).ascent() << endl;
- if (metrics_info_.y2 < height_
+ if (metrics_info_.y2 < height_
&& metrics_info_.update_strategy == FullScreenUpdate)
pain.fillRectangle(0, metrics_info_.y2, width_,
height_ - metrics_info_.y2, Color::bottomarea);