#include "insets/InsetText.h"
#include "mathed/MathData.h"
+#include "mathed/InsetMathNest.h"
#include "frontends/alert.h"
#include "frontends/Application.h"
struct BufferView::Private
{
- Private(BufferView & bv) : update_strategy_(FullScreenUpdate),
+ Private(BufferView & bv) :
+ update_strategy_(FullScreenUpdate),
update_flags_(Update::Force),
wh_(0), cursor_(bv),
anchor_pit_(0), anchor_ypos_(0),
last_inset_(0), clickable_inset_(false),
mouse_position_cache_(),
bookmark_edit_position_(-1), gui_(0),
- horiz_scroll_offset_(0), repaint_caret_row_(false)
+ horiz_scroll_offset_(0),
+ caret_ascent_(0), caret_descent_(0)
{
xsel_cache_.set = false;
}
/// at previous draw event
CursorSlice last_row_slice_;
- /// a slice pointing to where the cursor has been drawn after the current
- /// draw() call.
- CursorSlice caret_slice_;
- /// indicates whether the caret slice needs to be repainted in this draw() run.
- bool repaint_caret_row_;
+ // The vertical size of the blinking caret. Only used for math
+ // Using it for text could be bad when undo restores the cursor
+ // current font, since the caret size could become wrong.
+ int caret_ascent_;
+ int caret_descent_;
};
// That is to say, if a cursor is in a nested inset, it will be
// restore to the left of the top level inset.
LastFilePosSection::FilePos fp;
+ fp.file = buffer_.fileName();
fp.pit = d->cursor_.bottom().pit();
fp.pos = d->cursor_.bottom().pos();
- theSession().lastFilePos().save(buffer_.fileName(), fp);
+ theSession().lastFilePos().save(fp);
if (d->last_inset_)
d->last_inset_->setMouseHover(this, false);
return string((flags & Update::FitCursor) ? "FitCursor " : "")
+ ((flags & Update::Force) ? "Force " : "")
+ ((flags & Update::ForceDraw) ? "ForceDraw " : "")
- + ((flags & Update::SinglePar) ? "SinglePar " : "");
+ + ((flags & Update::SinglePar) ? "SinglePar " : "")
+ + ((flags & Update::Decoration) ? "Decoration " : "");
}
}
if (flags == Update::None)
return;
+ /* FIXME We would like to avoid doing this here, since it is very
+ * expensive and is called in updateBuffer already. However, even
+ * inserting a plain character can invalidate the overly fragile
+ * tables of child documents built by updateMacros. Some work is
+ * needed to avoid doing that when not necessary.
+ */
+ buffer_.updateMacros();
+
// SinglePar is ignored for now (this should probably change). We
// set it ourselves below, at the price of always rebreaking the
// paragraph at cursor. This can be expensive for large tables.
updateMetrics(flags);
}
+ // Detect whether we can only repaint a single paragraph.
+ // We handle this before FitCursor because the later will require
+ // correct metrics at cursor position.
+ if (!(flags & Update::ForceDraw)) {
+ if (singleParUpdate())
+ flags = flags | Update::SinglePar;
+ else
+ updateMetrics(flags);
+ }
+
// Then make sure that the screen contains the cursor if needed
if (flags & Update::FitCursor) {
if (needsFitCursor()) {
flags = flags & ~Update::FitCursor;
}
- // Finally detect whether we can only repaint a single paragraph
- if (!(flags & Update::ForceDraw)) {
- if (singleParUpdate())
- flags = flags | Update::SinglePar;
- else
- updateMetrics(flags);
- }
-
// Add flags to the the update flags. These will be reset to None
// after the redraw is actually done
d->update_flags_ = d->update_flags_ | flags;
d->cursor_.setCurrentFont();
// Do not forget to reset the anchor (see #9912)
d->cursor_.resetAnchor();
- processUpdateFlags(Update::FitCursor);
+ processUpdateFlags(Update::Force | Update::FitCursor);
}
return success;
break;
case LFUN_GRAPHICS_UNIFY:
- flag.setEnabled(cur.selection());
+ flag.setEnabled(cur.countInsetsInSelection(GRAPHICS_CODE)>1);
break;
case LFUN_WORD_FINDADV: {
break;
}
+ case LFUN_COPY:
+ flag.setEnabled(cur.selection());
+ break;
+
default:
return false;
}
void BufferView::editInset(string const & name, Inset * inset)
{
- d->edited_insets_[name] = inset;
+ if (inset)
+ d->edited_insets_[name] = inset;
+ else
+ d->edited_insets_.erase(name);
}
// without calling recordUndo. Fix this before using
// recordUndoBufferParams().
cur.recordUndoFullBuffer();
- buffer_.params().setBaseClass(argument);
+ buffer_.params().setBaseClass(argument, buffer_.layoutPos());
makeDocumentClass();
dr.screenUpdate(Update::Force);
dr.forceBufferUpdate();
case LFUN_LAYOUT_RELOAD: {
LayoutFileIndex bc = buffer_.params().baseClassID();
LayoutFileList::get().reset(bc);
- buffer_.params().setBaseClass(bc);
+ buffer_.params().setBaseClass(bc, buffer_.layoutPos());
makeDocumentClass();
dr.screenUpdate(Update::Force);
dr.forceBufferUpdate();
case LFUN_NOTE_NEXT:
gotoInset(this, NOTE_CODE, false);
+ // FIXME: if SinglePar is changed to act on the inner
+ // paragraph, this will not be OK anymore. The update is
+ // useful for auto-open collapsible insets.
+ dr.screenUpdate(Update::SinglePar | Update::FitCursor);
break;
case LFUN_REFERENCE_NEXT: {
tmp.push_back(LABEL_CODE);
tmp.push_back(REF_CODE);
gotoInset(this, tmp, true);
+ // FIXME: if SinglePar is changed to act on the inner
+ // paragraph, this will not be OK anymore. The update is
+ // useful for auto-open collapsible insets.
+ dr.screenUpdate(Update::SinglePar | Update::FitCursor);
break;
}
InsetBibtex * inset = getInsetByCode<InsetBibtex>(tmpcur,
BIBTEX_CODE);
if (inset) {
- if (inset->addDatabase(cmd.argument()))
+ if (inset->addDatabase(cmd.argument())) {
dr.forceBufferUpdate();
+ }
}
break;
}
// At least one complete cell is selected and inset is a table.
// Select all cells
cur.idx() = 0;
+ cur.pit() = 0;
cur.pos() = 0;
cur.resetAnchor();
cur.selection(true);
cur.idx() = cur.lastidx();
+ cur.pit() = cur.lastpit();
cur.pos() = cur.lastpos();
} else {
// select current cell
}
+ case LFUN_UNICODE_INSERT: {
+ if (cmd.argument().empty())
+ break;
+
+ FuncCode code = cur.inset().currentMode() == Inset::MATH_MODE ?
+ LFUN_MATH_INSERT : LFUN_SELF_INSERT;
+ int i = 0;
+ while (true) {
+ docstring const arg = from_utf8(cmd.getArg(i));
+ if (arg.empty())
+ break;
+ if (!isHex(arg)) {
+ LYXERR0("Not a hexstring: " << arg);
+ ++i;
+ continue;
+ }
+ char_type c = hexToInt(arg);
+ if (c >= 32 && c < 0x10ffff) {
+ LYXERR(Debug::KEY, "Inserting c: " << c);
+ lyx::dispatch(FuncRequest(code, docstring(1, c)));
+ }
+ ++i;
+ }
+ break;
+ }
+
+
// This would be in Buffer class if only Cursor did not
// require a bufferview
case LFUN_INSET_FORALL: {
break;
}
+ case LFUN_COPY:
+ // With multi-cell table content, we pass down to the inset
+ if (cur.inTexted() && cur.selection()
+ && cur.selectionBegin().idx() != cur.selectionEnd().idx()) {
+ buffer_.dispatch(cmd, dr);
+ dispatched = dr.dispatched();
+ break;
+ }
+ cap::copySelection(cur);
+ cur.message(_("Copy"));
+ break;
+
default:
// OK, so try the Buffer itself...
buffer_.dispatch(cmd, dr);
void BufferView::gotoLabel(docstring const & label)
{
+ FuncRequest action;
+ bool have_inactive = false;
ListOfBuffers bufs = buffer().allRelatives();
ListOfBuffers::iterator it = bufs.begin();
for (; it != bufs.end(); ++it) {
Toc::const_iterator toc_it = toc->begin();
Toc::const_iterator end = toc->end();
for (; toc_it != end; ++toc_it) {
- if (label == toc_it->str()) {
+ if (label == toc_it->str() && toc_it->isOutput()) {
lyx::dispatch(toc_it->action());
return;
}
+ // If we find an inactive label, save it for the case
+ // that no active one is there
+ if (label == toc_it->str() && !have_inactive) {
+ have_inactive = true;
+ action = toc_it->action();
+ }
}
}
+ // We only found an inactive label. Go there.
+ if (have_inactive)
+ lyx::dispatch(action);
}
Text & buftext = buffer_.text();
pit_type const bottom_pit = d->cursor_.bottom().pit();
TextMetrics & tm = textMetrics(&buftext);
- int old_height = tm.parMetrics(bottom_pit).height();
+ Dimension const old_dim = tm.parMetrics(bottom_pit).dim();
// make sure inline completion pointer is ok
if (d->inlineCompletionPos_.fixIfBroken())
// (if this paragraph contains insets etc., rebreaking will
// recursively descend)
tm.redoParagraph(bottom_pit);
- ParagraphMetrics const & pm = tm.parMetrics(bottom_pit);
- if (pm.height() != old_height)
+ ParagraphMetrics & pm = tm.par_metrics_[bottom_pit];
+ if (pm.height() != old_dim.height()) {
// Paragraph height has changed so we cannot proceed to
// the singlePar optimisation.
return false;
+ }
+ // Since position() points to the baseline of the first row, we
+ // may have to update it. See ticket #11601 for an example where
+ // the height does not change but the ascent does.
+ pm.setPosition(pm.position() - old_dim.ascent() + pm.ascent());
tm.updatePosCache(bottom_pit);
}
+void BufferView::setCaretAscentDescent(int asc, int des)
+{
+ d->caret_ascent_ = asc;
+ d->caret_descent_ = des;
+}
+
+
void BufferView::caretPosAndHeight(Point & p, int & h) const
{
+ int asc, des;
Cursor const & cur = cursor();
- Font const font = cur.real_current_font;
- frontend::FontMetrics const & fm = theFontMetrics(font);
- int const asc = fm.maxAscent();
- int const des = fm.maxDescent();
+ if (cur.inMathed()) {
+ asc = d->caret_ascent_;
+ des = d->caret_descent_;
+ } else {
+ Font const font = cur.real_current_font;
+ frontend::FontMetrics const & fm = theFontMetrics(font);
+ asc = fm.maxAscent();
+ des = fm.maxDescent();
+ }
h = asc + des;
p = getPos(cur);
p.y_ -= asc;
}
-bool BufferView::cursorInView(Point const & p, int h) const
+bool BufferView::caretInView() const
{
- Cursor const & cur = cursor();
+ if (!paragraphVisible(cursor()))
+ return false;
+ Point p;
+ int h;
+ caretPosAndHeight(p, h);
+
// does the cursor touch the screen ?
- if (p.y_ + h < 0 || p.y_ >= workHeight() || !paragraphVisible(cur))
+ if (p.y_ + h < 0 || p.y_ >= workHeight())
return false;
return true;
}
}
-namespace {
-
-bool sliceInRow(CursorSlice const & cs, Text const * text, Row const & row)
-{
- /* The normal case is the last line. The previous line takes care
- * of empty rows (e.g. empty paragraphs). Cursor boundary issues
- * are taken care of when setting caret_slice_ in
- * BufferView::draw.
- */
- return !cs.empty() && cs.text() == text && cs.pit() == row.pit()
- && ((row.pos() == row.endpos() && row.pos() == cs.pos())
- || (row.pos() <= cs.pos() && cs.pos() < row.endpos()));
-}
-
-}
-
-
-bool BufferView::needRepaint(Text const * text, Row const & row) const
-{
- return d->repaint_caret_row_ && sliceInRow(d->caret_slice_, text, row);
-}
-
-
void BufferView::checkCursorScrollOffset()
{
CursorSlice rowSlice = d->cursor_.bottom();
int const y = tm.first().second->position();
PainterInfo pi(this, pain);
- /** A repaint of the previous caret row is needed if there is
- * caret painted on screen and either
- * 1/ a new caret has to be painted at a place different from
- * the existing one;
- * 2/ there is no need for a caret anymore.
- */
- d->repaint_caret_row_ = !d->caret_slice_.empty() &&
- ((paint_caret && d->cursor_.top() != d->caret_slice_)
- || ! paint_caret);
-
// Check whether the row where the cursor lives needs to be scrolled.
// Update the drawing strategy if needed.
checkCursorScrollOffset();
if (pain.isNull()) {
pi.full_repaint = true;
tm.draw(pi, 0, y);
- } else if (d->repaint_caret_row_) {
+ } else {
pi.full_repaint = false;
tm.draw(pi, 0, y);
}
d->update_flags_ = Update::None;
}
- // Remember what has just been done for the next draw() step
+ // If a caret has to be painted, mark its text row as dirty to
+ //make sure that it will be repainted on next redraw.
+ /* FIXME: investigate whether this can be avoided when the cursor did not
+ * move at all
+ */
if (paint_caret) {
- d->caret_slice_ = d->cursor_.top();
- if (d->caret_slice_.pos() > 0
- && (d->cursor_.boundary()
- || d->caret_slice_.pos() == d->caret_slice_.lastpos()))
- --d->caret_slice_.pos();
- } else
- d->caret_slice_ = CursorSlice();
+ Row const & caret_row = d->cursor_.textRow();
+ caret_row.changed(true);
+ }
}