#include "insets/InsetRef.h"
#include "insets/InsetText.h"
-#include "mathed/InsetMath.h"
+#include "mathed/InsetMathNest.h"
+#include "mathed/InsetMathRef.h"
#include "mathed/MathData.h"
#include "mathed/MathRow.h"
#include "frontends/NullPainter.h"
#include "frontends/Painter.h"
#include "frontends/Selection.h"
+#include "frontends/Clipboard.h"
#include "support/convert.h"
#include "support/debug.h"
*/
frontend::GuiBufferViewDelegate * gui_;
- /// cache search string for simple search
- docstring search_request_cache_;
-
///
map<string, Inset *> edited_insets_;
}
+docstring const & BufferView::searchRequestCache() const
+{
+ return theClipboard().getFindBuffer();
+}
+
+
+void BufferView::setSearchRequestCache(docstring const & text)
+{
+ bool casesensitive;
+ bool matchword;
+ bool forward;
+ bool wrap;
+ bool instant;
+ bool onlysel;
+ docstring const search = string2find(text, casesensitive, matchword,
+ forward, wrap, instant, onlysel);
+ theClipboard().setFindBuffer(search);
+}
+
+
bool BufferView::needsFitCursor() const
{
if (cursorStatus(d->cursor_) == CUR_INSIDE) {
// Get inset under mouse, if there is one.
Inset const * covering_inset = getCoveringInset(buffer_.text(), x, y);
- if (covering_inset)
+ if (covering_inset) {
+ if (covering_inset->asInsetMath()) {
+ CoordCache::Insets const & inset_cache =
+ coordCache().getInsets();
+ Inset const * inner_inset = mathContextMenu(
+ covering_inset->asInsetMath()->asNestInset(),
+ inset_cache, x, y);
+ if (inner_inset)
+ return inner_inset->contextMenu(*this, x, y);
+ }
return covering_inset->contextMenu(*this, x, y);
+ }
return buffer_.inset().contextMenu(*this, x, y);
}
+Inset const * BufferView::mathContextMenu(InsetMathNest const * inset,
+ CoordCache::Insets const & inset_cache, int x, int y) const
+{
+ for (size_t i = 0; i < inset->nargs(); ++i) {
+ MathData const & ar = inset->cell(i);
+ for (size_t j = 0; j < ar.size(); ++j) {
+ string const name = lyxerr.debugging(Debug::MATHED)
+ ? insetName(ar[j].nucleus()->lyxCode())
+ : string();
+ LYXERR(Debug::MATHED, "Examining inset: " << name);
+ if (!ar[j].nucleus()->contextMenuName().empty()) {
+ if (inset_cache.covers(ar[j].nucleus(), x, y)) {
+ LYXERR(Debug::MATHED, "Hit inset: "
+ << name);
+ return ar[j].nucleus();
+ }
+ }
+ InsetMathNest const * imn =
+ ar[j].nucleus()->asNestInset();
+ if (imn) {
+ Inset const * inner =
+ mathContextMenu(imn, inset_cache, x, y);
+ if (inner)
+ return inner;
+ }
+ }
+ }
+ return nullptr;
+}
+
void BufferView::scrollDocView(int const pixels, bool update)
{
// restoration is inaccurate. If a bookmark was within an inset,
// it will be restored to the left of the outmost inset that contains
// the bookmark.
- if (bottom_pit < int(buffer_.paragraphs().size())) {
+ if (!success && bottom_pit < int(buffer_.paragraphs().size())) {
dit = doc_iterator_begin(&buffer_);
dit.pit() = bottom_pit;
bool BufferView::scrollToCursor(DocIterator const & dit, bool const recenter)
{
- // We are not properly started yet, delay until resizing is
- // done.
+ // We are not properly started yet, delay until resizing is done.
if (height_ == 0)
return false;
if (recenter)
- LYXERR(Debug::SCROLLING, "recentering and scrolling to cursor");
+ LYXERR(Debug::SCROLLING, "recentering and scrolling to cursor");
else
- LYXERR(Debug::SCROLLING, "scrolling to cursor");
+ LYXERR(Debug::SCROLLING, "scrolling to cursor");
CursorSlice const & bot = dit.bottom();
- TextMetrics & tm = d->text_metrics_[bot.text()];
+ TextMetrics & tm = textMetrics(bot.text());
pos_type const max_pit = pos_type(bot.text()->paragraphs().size() - 1);
pos_type bot_pit = bot.pit();
LBUFERR(!pm.rows().empty());
// FIXME: smooth scrolling doesn't work in mathed.
CursorSlice const & cs = dit.innerTextSlice();
- int offset = coordOffset(dit).y_;
- int ypos = pm.position() + offset;
- Row const & row = pm.getRow(cs.pos(), dit.boundary());
- Dimension row_dim = row.dim();
- // FIXME: the will not be necessary anymore if Row has both a
- // dim() which is its full dimension and a contentsDim() which
- // is the dimension of the text only.
- if (&row == &pm.rows().front())
- row_dim.asc = pm.ascent();
- if (&row == &pm.rows().back())
- row_dim.des = pm.descent();
+ int const ypos = pm.position() + coordOffset(dit).y_;
+ ParagraphMetrics const & inner_pm =
+ textMetrics(cs.text()).parMetrics(cs.pit());
+ Dimension const & row_dim =
+ inner_pm.getRow(cs.pos(), dit.boundary()).dim();
int scrolled = 0;
if (recenter)
scrolled = scroll(ypos - height_/2);
// If the top part of the row falls of the screen, we scroll
// up to align the top of the row with the top of the screen.
else if (ypos - row_dim.ascent() < 0 && ypos < height_) {
- int ynew = row_dim.ascent();
+ int const ynew = row_dim.ascent();
scrolled = scrollUp(ynew - ypos);
}
// If the bottom of the row falls of the screen, we scroll down.
else if (ypos + row_dim.descent() > height_ && ypos > 0) {
- int ynew = height_ - row_dim.descent();
+ int const ynew = height_ - row_dim.descent();
scrolled = scrollDown(ypos - ynew);
}
tm.redoParagraph(bot_pit);
ParagraphMetrics const & pm = tm.parMetrics(bot_pit);
- int offset = coordOffset(dit).y_;
+ int const offset = coordOffset(dit).y_;
d->anchor_pit_ = bot_pit;
CursorSlice const & cs = dit.innerTextSlice();
+ ParagraphMetrics const & inner_pm =
+ textMetrics(cs.text()).parMetrics(cs.pit());
Dimension const & row_dim =
- pm.getRow(cs.pos(), dit.boundary()).dim();
+ inner_pm.getRow(cs.pos(), dit.boundary()).dim();
if (recenter)
d->anchor_ypos_ = height_/2;
case LFUN_LABEL_GOTO:
flag.setEnabled(!cmd.argument().empty()
- || getInsetByCode<InsetRef>(cur, REF_CODE));
+ || getInsetByCode<InsetRef>(cur, REF_CODE)
+ || getInsetByCode<InsetMathRef>(cur, MATH_REF_CODE));
break;
case LFUN_CHANGES_MERGE:
// eventually call LFUN_PARAGRAPH_GOTO, but it seems best
// to have it here.
dr.screenUpdate(Update::Force | Update::FitCursor);
+ } else {
+ InsetMathRef * minset =
+ getInsetByCode<InsetMathRef>(cur, MATH_REF_CODE);
+ if (minset)
+ lyx::dispatch(FuncRequest(LFUN_LABEL_GOTO,
+ minset->getTarget()));
}
break;
}
docstring searched_string;
if (!cmd.argument().empty()) {
- d->search_request_cache_ = cmd.argument();
+ setSearchRequestCache(cmd.argument());
searched_string = cmd.argument();
} else {
- searched_string = d->search_request_cache_;
+ searched_string = searchRequestCache();
}
if (searched_string.empty())
break;
- bool casesensitive;
- bool matchword;
- bool forward;
- docstring const search = string2find(searched_string, casesensitive, matchword, forward);
docstring const data =
- find2string(search, casesensitive, matchword, act == LFUN_WORD_FIND_FORWARD);
+ find2string(searched_string, false, false,
+ act == LFUN_WORD_FIND_FORWARD, false, false, false);
bool found = lyxfind(this, FuncRequest(LFUN_WORD_FIND, data));
if (found)
dr.screenUpdate(Update::Force | Update::FitCursor);
case LFUN_WORD_FIND: {
docstring arg = cmd.argument();
- if (arg.empty() && !d->search_request_cache_.empty())
- arg = d->search_request_cache_;
+ if (arg.empty())
+ arg = searchRequestCache();
if (arg.empty()) {
lyx::dispatch(FuncRequest(LFUN_DIALOG_SHOW, "findreplace"));
break;
else
dr.setMessage(_("Search string not found!"));
- d->search_request_cache_ = arg;
+ setSearchRequestCache(arg);
break;
}
case LFUN_SEARCH_STRING_SET: {
docstring pattern = cmd.argument();
if (!pattern.empty()) {
- d->search_request_cache_ = pattern;
+ setSearchRequestCache(pattern);
break;
}
if (cur.selection())
cur.selection(false);
cur.pos() = spos;
}
- d->search_request_cache_ = pattern;
+ setSearchRequestCache(pattern);
break;
}