#include "BranchList.h"
#include "Buffer.h"
-#include "buffer_funcs.h"
#include "BufferList.h"
#include "BufferParams.h"
#include "CoordCache.h"
#include "CutAndPaste.h"
#include "DispatchResult.h"
#include "ErrorList.h"
-#include "factory.h"
-#include "FloatList.h"
#include "FuncRequest.h"
#include "FuncStatus.h"
#include "Intl.h"
-#include "InsetIterator.h"
#include "Language.h"
-#include "LaTeXFeatures.h"
#include "LayoutFile.h"
-#include "Length.h"
#include "Lexer.h"
#include "LyX.h"
#include "LyXAction.h"
#include "lyxfind.h"
-#include "Layout.h"
#include "LyXRC.h"
#include "MetricsInfo.h"
#include "Paragraph.h"
-#include "ParagraphParameters.h"
-#include "ParIterator.h"
-#include "RowPainter.h"
#include "Session.h"
#include "Text.h"
-#include "TextClass.h"
#include "TextMetrics.h"
#include "TexRow.h"
#include "TocBackend.h"
-#include "WordLangTuple.h"
#include "insets/InsetBibtex.h"
#include "insets/InsetCitation.h"
#include "insets/InsetCommand.h" // ChangeRefs
-#include "insets/InsetExternal.h"
#include "insets/InsetGraphics.h"
-#include "insets/InsetNote.h"
#include "insets/InsetRef.h"
#include "insets/InsetText.h"
+#include "mathed/InsetMath.h"
#include "mathed/MathData.h"
+#include "mathed/MathRow.h"
#include "frontends/alert.h"
-#include "frontends/Application.h"
+#include "frontends/CaretGeometry.h"
#include "frontends/Delegates.h"
#include "frontends/FontMetrics.h"
#include "frontends/NullPainter.h"
#include "support/convert.h"
#include "support/debug.h"
-#include "support/ExceptionMessage.h"
+#include "support/docstring.h"
#include "support/filetools.h"
#include "support/gettext.h"
#include "support/lassert.h"
+#include "support/Length.h"
#include "support/lstrings.h"
#include "support/lyxlib.h"
-#include "support/Package.h"
#include "support/types.h"
+#include <algorithm>
#include <cerrno>
+#include <cstring>
#include <fstream>
#include <functional>
#include <iterator>
Inset * inset = it.nextInset();
if (inset && inset->lyxCode() == code)
return static_cast<T*>(inset);
- return 0;
+ return nullptr;
}
if (!findNextInset(tmpdit, codes, contents)) {
if (dit.depth() != 1 || dit.pit() != 0 || dit.pos() != 0) {
- Inset * inset = &tmpdit.bottom().inset();
+ inset = &tmpdit.bottom().inset();
tmpdit = doc_iterator_begin(&inset->buffer(), inset);
if (!findNextInset(tmpdit, codes, contents))
return false;
}
-/// Looks for next inset with the given code
-void findInset(DocIterator & dit, InsetCode code, bool same_content)
-{
- findInset(dit, vector<InsetCode>(1, code), same_content);
-}
-
-
/// Moves cursor to the next inset with one of the given codes.
void gotoInset(BufferView * bv, vector<InsetCode> const & codes,
bool same_content)
}
-/// Moves cursor to the next inset with given code.
-void gotoInset(BufferView * bv, InsetCode code, bool same_content)
-{
- gotoInset(bv, vector<InsetCode>(1, code), same_content);
-}
-
-
/// A map from a Text to the associated text metrics
typedef map<Text const *, TextMetrics> TextMetricsCache;
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),
- inlineCompletionUniqueChars_(0),
- last_inset_(0), clickable_inset_(false),
- mouse_position_cache_(),
- bookmark_edit_position_(-1), gui_(0),
- horiz_scroll_offset_(0), repaint_caret_row_(false)
+ cursor_(bv), anchor_pit_(0), anchor_ypos_(0),
+ wh_(0), inlineCompletionUniqueChars_(0),
+ last_inset_(nullptr), mouse_position_cache_(),
+ gui_(nullptr), bookmark_edit_position_(-1),
+ horiz_scroll_offset_(0), clickable_inset_(false)
{
xsel_cache_.set = false;
}
Update::flags update_flags_;
///
CoordCache coord_cache_;
+ ///
+ typedef map<MathData const *, MathRow> MathRows;
+ MathRows math_rows_;
- /// Estimated average par height for scrollbar.
- int wh_;
/// this is used to handle XSelection events in the right manner.
struct {
CursorSlice cursor;
pit_type anchor_pit_;
///
int anchor_ypos_;
+ /// Estimated average par height for scrollbar.
+ int wh_;
///
vector<int> par_height_;
* Not owned, so don't delete.
*/
Inset const * last_inset_;
- /// are we hovering something that we can click
- bool clickable_inset_;
/// position of the mouse at the time of the last mouse move
/// This is used to update the hovering status of inset in
/// cases where the buffer is scrolled, but the mouse didn't move.
Point mouse_position_cache_;
- // cache for id of the paragraph which was edited the last time
- int bookmark_edit_position_;
-
mutable TextMetricsCache text_metrics_;
/// Whom to notify.
/// When the row where the cursor lies is scrolled, this
/// contains the scroll offset
+ // cache for id of the paragraph which was edited the last time
+ int bookmark_edit_position_;
+
int horiz_scroll_offset_;
/// a slice pointing to the start of the row where the cursor
/// is (at last draw time)
CursorSlice current_row_slice_;
- /// a slice pointing to the start of the row where cursor was
- /// 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_;
+ /// are we hovering something that we can click
+ bool clickable_inset_;
+ /// shape of the caret
+ frontend::CaretGeometry caret_geometry_;
};
// 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);
}
+int BufferView::topMargin() const
+{
+ // Original value was 20px at 100dpi. For internal buffers like in
+ // advanced search and replace, a value of 5px is enough.
+ return zoomedPixels(buffer().isInternal() ? 5 : 20);
+}
+
+
+int BufferView::bottomMargin() const
+{
+ return topMargin();
+}
+
+
int BufferView::inPixels(Length const & len) const
{
Font const font = buffer().params().getFont();
}
+MathRow const & BufferView::mathRow(MathData const * cell) const
+{
+ auto it = d->math_rows_.find(cell);
+ LATTEST(it != d->math_rows_.end());
+ return it->second;
+}
+
+
+void BufferView::setMathRow(MathData const * cell, MathRow const & mrow)
+{
+ d->math_rows_[cell] = mrow;
+}
+
+
Buffer & BufferView::buffer()
{
return buffer_;
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;
- // 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.
- flags = flags & ~Update::SinglePar;
+ /* 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();
// First check whether the metrics and inset positions should be updated
if (flags & Update::Force) {
updateMetrics(flags);
}
+ // Detect whether we can only repaint a single paragraph (if we
+ // are not already redrawing all).
+ // We handle this before FitCursor because the later will require
+ // correct metrics at cursor position.
+ if (!(flags & Update::ForceDraw)
+ && (flags & Update::SinglePar)
+ && !singleParUpdate())
+ updateMetrics(flags);
+
// Then make sure that the screen contains the cursor if needed
if (flags & Update::FitCursor) {
if (needsFitCursor()) {
- scrollToCursor(d->cursor_, false);
+ // First try to make the selection start visible
+ // (which is just the cursor when there is no selection)
+ scrollToCursor(d->cursor_.selectionBegin(), false);
// Metrics have to be recomputed (maybe again)
- updateMetrics(flags);
+ updateMetrics();
+ // Is the cursor visible? (only useful if cursor is at end of selection)
+ if (needsFitCursor()) {
+ // then try to make cursor visible instead
+ scrollToCursor(d->cursor_, false);
+ // Metrics have to be recomputed (maybe again)
+ updateMetrics(flags);
+ }
}
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;
LYXERR(Debug::PAINTING, "Cumulative flags: " << flagsAsString(flags));
// Now compute the update strategy
- // Possibly values in flag are None, Decoration, ForceDraw
+ // Possibly values in flag are None, SinglePar, Decoration, ForceDraw
LATTEST((d->update_flags_ & ~(Update::None | Update::SinglePar
| Update::Decoration | Update::ForceDraw)) == 0);
-void BufferView::scrollDocView(int const value, bool update)
+void BufferView::scrollDocView(int const pixels, bool update)
{
// The scrollbar values are relative to the top of the screen, therefore the
// offset is equal to the target value.
// No scrolling at all? No need to redraw anything
- if (value == 0)
+ if (pixels == 0)
return;
// If the offset is less than 2 screen height, prefer to scroll instead.
- if (abs(value) <= 2 * height_) {
- d->anchor_ypos_ -= value;
+ if (abs(pixels) <= 2 * height_) {
+ d->anchor_ypos_ -= pixels;
processUpdateFlags(Update::Force);
return;
}
// cut off at the top
- if (value <= d->scrollbarParameters_.min) {
+ if (pixels <= d->scrollbarParameters_.min) {
DocIterator dit = doc_iterator_begin(&buffer_);
showCursor(dit, false, update);
LYXERR(Debug::SCROLLING, "scroll to top");
}
// cut off at the bottom
- if (value >= d->scrollbarParameters_.max) {
+ if (pixels >= d->scrollbarParameters_.max) {
DocIterator dit = doc_iterator_end(&buffer_);
dit.backwardPos();
showCursor(dit, false, update);
pit_type i = 0;
for (; i != int(d->par_height_.size()); ++i) {
par_pos += d->par_height_[i];
- if (par_pos >= value)
+ if (par_pos >= pixels)
break;
}
- if (par_pos < value) {
+ if (par_pos < pixels) {
// It seems we didn't find the correct pit so stay on the safe side and
// scroll to bottom.
LYXERR0("scrolling position not found!");
DocIterator dit = doc_iterator_begin(&buffer_);
dit.pit() = i;
- LYXERR(Debug::SCROLLING, "value = " << value << " -> scroll to pit " << i);
+ LYXERR(Debug::SCROLLING, "pixels = " << pixels << " -> scroll to pit " << i);
showCursor(dit, false, update);
}
void BufferView::saveBookmark(unsigned int idx)
{
+ if (buffer().isInternal())
+ return;
+
// tentatively save bookmark, id and pos will be used to
// acturately locate a bookmark in a 'live' lyx session.
// pit and pos will be updated with bottom level pit/pos
// when lyx exits.
- if (!buffer_.isInternal()) {
- theSession().bookmarks().save(
- buffer_.fileName(),
- d->cursor_.bottom().pit(),
- d->cursor_.bottom().pos(),
- d->cursor_.paragraph().id(),
- d->cursor_.pos(),
- idx
- );
- if (idx)
- // emit message signal.
- message(_("Save bookmark"));
- }
+ theSession().bookmarks().save(
+ buffer_.fileName(),
+ d->cursor_.bottom().pit(),
+ d->cursor_.bottom().pos(),
+ d->cursor_.paragraph().id(),
+ d->cursor_.pos(),
+ idx
+ );
+ if (idx)
+ // emit message signal.
+ message(_("Save bookmark"));
}
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;
if (height_ == 0)
return false;
- LYXERR(Debug::SCROLLING, "recentering!");
+ if (recenter)
+ LYXERR(Debug::SCROLLING, "recentering and scrolling to cursor");
+ else
+ LYXERR(Debug::SCROLLING, "scrolling to cursor");
CursorSlice const & bot = dit.bottom();
TextMetrics & tm = d->text_metrics_[bot.text()];
pos_type const max_pit = pos_type(bot.text()->paragraphs().size() - 1);
- int bot_pit = bot.pit();
+ pos_type bot_pit = bot.pit();
if (bot_pit > max_pit) {
// FIXME: Why does this happen?
LYXERR0("bottom pit is greater that max pit: "
int offset = coordOffset(dit).y_;
int ypos = pm.position() + offset;
Dimension const & row_dim =
- pm.getRow(cs.pos(), dit.boundary()).dimension();
+ pm.getRow(cs.pos(), dit.boundary()).dim();
int scrolled = 0;
if (recenter)
scrolled = scroll(ypos - height_/2);
d->anchor_pit_ = bot_pit;
CursorSlice const & cs = dit.innerTextSlice();
Dimension const & row_dim =
- pm.getRow(cs.pos(), dit.boundary()).dimension();
+ pm.getRow(cs.pos(), dit.boundary()).dim();
if (recenter)
d->anchor_ypos_ = height_/2;
void BufferView::makeDocumentClass()
{
DocumentClassConstPtr olddc = buffer_.params().documentClassPtr();
- buffer_.params().makeDocumentClass();
+ buffer_.params().makeDocumentClass(buffer_.isClone(), buffer_.isInternal());
updateDocumentClass(olddc);
}
break;
case LFUN_FILE_INSERT_PLAINTEXT_PARA:
case LFUN_FILE_INSERT_PLAINTEXT: {
- docstring const fname = cmd.argument();
+ docstring const & fname = cmd.argument();
if (!FileName::isAbsolute(to_utf8(fname))) {
flag.message(_("Absolute filename expected."));
return false;
case LFUN_WORD_FIND_FORWARD:
case LFUN_WORD_FIND_BACKWARD:
case LFUN_WORD_REPLACE:
- case LFUN_BUFFER_ANONYMIZE:
case LFUN_MARK_OFF:
case LFUN_MARK_ON:
case LFUN_MARK_TOGGLE:
flag.setEnabled(true);
break;
+ case LFUN_GRAPHICS_UNIFY:
+ flag.setEnabled(cur.countInsetsInSelection(GRAPHICS_CODE)>1);
+ break;
+
case LFUN_WORD_FINDADV: {
FindAndReplaceOptions opt;
istringstream iss(to_utf8(cmd.argument()));
break;
}
+ case LFUN_COPY:
+ flag.setEnabled(cur.selection());
+ break;
+
default:
return false;
}
Inset * BufferView::editedInset(string const & name) const
{
map<string, Inset *>::const_iterator it = d->edited_insets_.find(name);
- return it == d->edited_insets_.end() ? 0 : it->second;
+ return it == d->edited_insets_.end() ? nullptr : it->second;
}
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();
// We need to find out if the bibliography information
// has changed. See bug #11055.
// So these should not be references...
- LayoutModuleList const engines = buffer().params().citeEngine();
+ string const engine = buffer().params().citeEngine();
CiteEngineType const enginetype = buffer().params().citeEngineType();
- if (!cur.textUndo())
+ if (!cur.undoAction())
dr.setMessage(_("No further undo information"));
else {
dr.screenUpdate(Update::Force | Update::FitCursor);
dr.forceBufferUpdate();
- if (buffer().params().citeEngine() != engines ||
+ if (buffer().params().citeEngine() != engine ||
buffer().params().citeEngineType() != enginetype)
buffer().invalidateCiteLabels();
}
// We need to find out if the bibliography information
// has changed. See bug #11055.
// So these should not be references...
- LayoutModuleList const engines = buffer().params().citeEngine();
+ string const engine = buffer().params().citeEngine();
CiteEngineType const enginetype = buffer().params().citeEngineType();
- if (!cur.textRedo())
+ if (!cur.redoAction())
dr.setMessage(_("No further redo information"));
else {
dr.screenUpdate(Update::Force | Update::FitCursor);
dr.forceBufferUpdate();
- if (buffer().params().citeEngine() != engines ||
+ if (buffer().params().citeEngine() != engine ||
buffer().params().citeEngineType() != enginetype)
buffer().invalidateCiteLabels();
}
break;
case LFUN_BOOKMARK_SAVE:
+ dr.screenUpdate(Update::Force);
saveBookmark(convert<unsigned int>(to_utf8(cmd.argument())));
break;
for (Buffer * b = &buffer_; i == 0 || b != &buffer_;
b = theBufferList().next(b)) {
- Cursor cur(*this);
- cur.setCursor(b->getParFromID(id));
- if (cur.atEnd()) {
+ Cursor curs(*this);
+ curs.setCursor(b->getParFromID(id));
+ if (curs.atEnd()) {
LYXERR(Debug::INFO, "No matching paragraph found! [" << id << "].");
++i;
continue;
}
- LYXERR(Debug::INFO, "Paragraph " << cur.paragraph().id()
+ LYXERR(Debug::INFO, "Paragraph " << curs.paragraph().id()
<< " found in buffer `"
<< b->absFileName() << "'.");
bool success;
if (str_id_end.empty() || str_pos_end.empty()) {
// Set the cursor
- cur.pos() = pos;
- mouseSetCursor(cur);
+ curs.pos() = pos;
+ mouseSetCursor(curs);
success = true;
} else {
int const id_end = convert<int>(str_id_end);
}
case LFUN_NOTE_NEXT:
- gotoInset(this, NOTE_CODE, false);
+ 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: {
- vector<InsetCode> tmp;
- tmp.push_back(LABEL_CODE);
- tmp.push_back(REF_CODE);
- gotoInset(this, tmp, true);
+ gotoInset(this, { LABEL_CODE, REF_CODE }, 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;
}
case LFUN_CHANGE_NEXT:
findNextChange(this);
+ if (cur.inset().isTable())
+ // In tables, there might be whole changed rows or columns
+ cur.dispatch(cmd);
// FIXME: Move this LFUN to Buffer so that we don't have to do this:
dr.screenUpdate(Update::Force | Update::FitCursor);
break;
case LFUN_CHANGE_PREVIOUS:
findPreviousChange(this);
+ if (cur.inset().isTable())
+ // In tables, there might be whole changed rows or columns
+ cur.dispatch(cmd);
// FIXME: Move this LFUN to Buffer so that we don't have to do this:
dr.screenUpdate(Update::Force | Update::FitCursor);
break;
}
break;
- case LFUN_ALL_CHANGES_ACCEPT:
+ case LFUN_ALL_CHANGES_ACCEPT: {
// select complete document
cur.reset();
cur.selHandle(true);
buffer_.text().cursorBottom(cur);
// accept everything in a single step to support atomic undo
+ // temporarily disable track changes in order to end with really
+ // no new (e.g., DPSM-caused) changes (see #7487)
+ bool const track = buffer_.params().track_changes;
+ buffer_.params().track_changes = false;
buffer_.text().acceptOrRejectChanges(cur, Text::ACCEPT);
+ buffer_.params().track_changes = track;
cur.resetAnchor();
// FIXME: Move this LFUN to Buffer so that we don't have to do this:
dr.screenUpdate(Update::Force | Update::FitCursor);
dr.forceBufferUpdate();
break;
+ }
- case LFUN_ALL_CHANGES_REJECT:
+ case LFUN_ALL_CHANGES_REJECT: {
// select complete document
cur.reset();
cur.selHandle(true);
buffer_.text().cursorBottom(cur);
// reject everything in a single step to support atomic undo
- // Note: reject does not work recursively; the user may have to repeat the operation
+ // temporarily disable track changes in order to end with really
+ // no new (e.g., DPSM-caused) changes (see #7487)
+ bool const track = buffer_.params().track_changes;
+ buffer_.params().track_changes = false;
buffer_.text().acceptOrRejectChanges(cur, Text::REJECT);
+ buffer_.params().track_changes = track;
cur.resetAnchor();
// FIXME: Move this LFUN to Buffer so that we don't have to do this:
dr.screenUpdate(Update::Force | Update::FitCursor);
dr.forceBufferUpdate();
break;
+ }
case LFUN_WORD_FIND_FORWARD:
case LFUN_WORD_FIND_BACKWARD: {
bool found = lyxfind(this, FuncRequest(LFUN_WORD_FIND, data));
if (found)
dr.screenUpdate(Update::Force | Update::FitCursor);
+ else
+ dr.setMessage(_("Search string not found!"));
break;
}
}
if (lyxfind(this, req))
dr.screenUpdate(Update::Force | Update::FitCursor);
+ else
+ dr.setMessage(_("Search string not found!"));
d->search_request_cache_ = req;
break;
}
case LFUN_WORD_REPLACE: {
- bool has_deleted = false;
- if (cur.selection()) {
- DocIterator beg = cur.selectionBegin();
- DocIterator end = cur.selectionEnd();
- if (beg.pit() == end.pit()) {
- for (pos_type p = beg.pos() ; p < end.pos() ; ++p) {
- if (!cur.inMathed() && cur.paragraph().isDeleted(p)) {
- has_deleted = true;
- break;
- }
- }
- }
- }
- if (lyxreplace(this, cmd, has_deleted)) {
+ if (lyxreplace(this, cmd)) {
dr.forceBufferUpdate();
dr.screenUpdate(Update::Force | Update::FitCursor);
}
+ else
+ dr.setMessage(_("Search string not found!"));
break;
}
- case LFUN_BUFFER_ANONYMIZE: {
- for(char c = '0'; c <='Z'; c++) {
- odocstringstream ss;
- ss << "a\n" << c << "\n0 0 1 1 0";
- lyx::dispatch(FuncRequest(LFUN_WORD_REPLACE, ss.str()));
- }
- }
-
case LFUN_WORD_FINDADV: {
FindAndReplaceOptions opt;
istringstream iss(to_utf8(cmd.argument()));
case LFUN_BIBTEX_DATABASE_ADD: {
Cursor tmpcur = cur;
- findInset(tmpcur, BIBTEX_CODE, false);
+ findInset(tmpcur, { BIBTEX_CODE }, false);
InsetBibtex * inset = getInsetByCode<InsetBibtex>(tmpcur,
BIBTEX_CODE);
if (inset) {
case LFUN_BIBTEX_DATABASE_DEL: {
Cursor tmpcur = cur;
- findInset(tmpcur, BIBTEX_CODE, false);
+ findInset(tmpcur, { BIBTEX_CODE }, false);
InsetBibtex * inset = getInsetByCode<InsetBibtex>(tmpcur,
BIBTEX_CODE);
if (inset) {
break;
}
+ case LFUN_GRAPHICS_UNIFY: {
+
+ cur.recordUndoFullBuffer();
+
+ DocIterator from, to;
+ from = cur.selectionBegin();
+ to = cur.selectionEnd();
+
+ string const newId = cmd.getArg(0);
+ bool fetchId = newId.empty(); //if we wait for groupId from first graphics inset
+
+ InsetGraphicsParams grp_par;
+ if (!fetchId)
+ InsetGraphics::string2params(graphics::getGroupParams(buffer_, newId), buffer_, grp_par);
+
+ if (!from.nextInset()) //move to closest inset
+ from.forwardInset();
+
+ while (!from.empty() && from < to) {
+ Inset * inset = from.nextInset();
+ if (!inset)
+ break;
+ InsetGraphics * ig = inset->asInsetGraphics();
+ if (ig) {
+ InsetGraphicsParams inspar = ig->getParams();
+ if (fetchId) {
+ grp_par = inspar;
+ fetchId = false;
+ } else {
+ grp_par.filename = inspar.filename;
+ ig->setParams(grp_par);
+ }
+ }
+ from.forwardInset();
+ }
+ dr.screenUpdate(Update::Force); //needed if triggered from context menu
+ break;
+ }
+
case LFUN_STATISTICS: {
DocIterator from, to;
if (cur.selection()) {
// 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: {
// an arbitrary number to limit number of iterations
const int max_iter = 100000;
int iterations = 0;
- Cursor & cur = d->cursor_;
- Cursor const savecur = cur;
- cur.reset();
- if (!cur.nextInset())
- cur.forwardInset();
- cur.beginUndoGroup();
- while(cur && iterations < max_iter) {
- Inset * const ins = cur.nextInset();
+ Cursor & curs = d->cursor_;
+ Cursor const savecur = curs;
+ curs.reset();
+ if (!curs.nextInset())
+ curs.forwardInset();
+ curs.beginUndoGroup();
+ while(curs && iterations < max_iter) {
+ Inset * const ins = curs.nextInset();
if (!ins)
break;
docstring insname = ins->layoutName();
while (!insname.empty()) {
if (insname == name || name == from_utf8("*")) {
- cur.recordUndo();
+ curs.recordUndo();
lyx::dispatch(fr, dr);
++iterations;
break;
insname = insname.substr(0, i);
}
// if we did not delete the inset, skip it
- if (!cur.nextInset() || cur.nextInset() == ins)
- cur.forwardInset();
+ if (!curs.nextInset() || curs.nextInset() == ins)
+ curs.forwardInset();
}
- cur = savecur;
- cur.fixIfBroken();
+ curs = savecur;
+ curs.fixIfBroken();
/** This is a dummy undo record only to remember the cursor
* that has just been set; this will be used on a redo action
* (see ticket #10097)
* FIXME: a better fix would be to have a way to set the
* cursor value directly, but I am not sure it is worth it.
*/
- cur.recordUndo();
- cur.endUndoGroup();
+ curs.recordUndo();
+ curs.endUndoGroup();
dr.screenUpdate(Update::Force);
dr.forceBufferUpdate();
icp["key"] = from_utf8(arg);
if (!opt1.empty())
icp["before"] = from_utf8(opt1);
+ icp["literal"] =
+ from_ascii(InsetCitation::last_literal ? "true" : "false");
string icstr = InsetCommand::params2string(icp);
FuncRequest fr(LFUN_INSET_INSERT, icstr);
lyx::dispatch(fr);
break;
}
+ case LFUN_COPY:
+ cap::copySelection(cur);
+ cur.message(_("Copy"));
+ break;
+
default:
// OK, so try the Buffer itself...
buffer_.dispatch(cmd, dr);
}
-docstring const BufferView::requestSelection()
+docstring BufferView::requestSelection()
{
Cursor & cur = d->cursor_;
TextMetrics & tm = d->text_metrics_[&text];
Inset * inset = tm.checkInsetHit(x, y);
if (!inset)
- return 0;
+ return nullptr;
if (!inset->descendable(*this))
// No need to go further down if the inset is not
if (d->last_inset_) {
// Remove the hint on the last hovered inset (if any).
need_redraw |= d->last_inset_->setMouseHover(this, false);
- d->last_inset_ = 0;
+ d->last_inset_ = nullptr;
}
if (covering_inset && covering_inset->setMouseHover(this, true)) {
LYXERR0("Wrong last_inset!");
LATTEST(false);
}
- d->last_inset_ = 0;
+ d->last_inset_ = nullptr;
}
}
-int BufferView::scroll(int y)
+int BufferView::scroll(int pixels)
{
- if (y > 0)
- return scrollDown(y);
- if (y < 0)
- return scrollUp(-y);
+ if (pixels > 0)
+ return scrollDown(pixels);
+ if (pixels < 0)
+ return scrollUp(-pixels);
return 0;
}
-int BufferView::scrollDown(int offset)
+int BufferView::scrollDown(int pixels)
{
Text * text = &buffer_.text();
TextMetrics & tm = d->text_metrics_[text];
- int const ymax = height_ + offset;
+ int const ymax = height_ + pixels;
while (true) {
pair<pit_type, ParagraphMetrics const *> last = tm.last();
int bottom_pos = last.second->position() + last.second->descent();
if (last.first + 1 == int(text->paragraphs().size())) {
if (bottom_pos <= height_)
return 0;
- offset = min(offset, bottom_pos - height_);
+ pixels = min(pixels, bottom_pos - height_);
break;
}
if (bottom_pos > ymax)
break;
tm.newParMetricsDown();
}
- d->anchor_ypos_ -= offset;
- return -offset;
+ d->anchor_ypos_ -= pixels;
+ return -pixels;
}
-int BufferView::scrollUp(int offset)
+int BufferView::scrollUp(int pixels)
{
Text * text = &buffer_.text();
TextMetrics & tm = d->text_metrics_[text];
- int ymin = - offset;
+ int ymin = - pixels;
while (true) {
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 0;
- offset = min(offset, - top_pos);
+ pixels = min(pixels, - top_pos);
break;
}
if (top_pos < ymin)
break;
tm.newParMetricsUp();
}
- d->anchor_ypos_ += offset;
- return offset;
+ d->anchor_ypos_ += pixels;
+ return pixels;
}
void BufferView::gotoLabel(docstring const & label)
{
+ FuncRequest action;
+ bool have_inactive = false;
for (Buffer const * buf : buffer().allRelatives()) {
// find label
for (TocItem const & item : *buf->tocBackend().toc("label")) {
- if (label == item.str()) {
+ if (label == item.str() && item.isOutput()) {
lyx::dispatch(item.action());
return;
}
+ // If we find an inactive label, save it for the case
+ // that no active one is there
+ if (label == item.str() && !have_inactive) {
+ have_inactive = true;
+ action = item.action();
+ }
}
}
+ // We only found an inactive label. Go there.
+ if (have_inactive)
+ lyx::dispatch(action);
}
LBUFERR(t);
TextMetricsCache::iterator tmc_it = d->text_metrics_.find(t);
if (tmc_it == d->text_metrics_.end()) {
- tmc_it = d->text_metrics_.insert(
- make_pair(t, TextMetrics(this, const_cast<Text *>(t)))).first;
+ tmc_it = d->text_metrics_.emplace(std::piecewise_construct,
+ std::forward_as_tuple(t),
+ std::forward_as_tuple(this, const_cast<Text *>(t))).first;
}
return tmc_it->second;
}
return false;
bool need_anchor_change = false;
- bool changed = d->cursor_.text()->deleteEmptyParagraphMechanism(cur, old,
+ bool changed = Text::deleteEmptyParagraphMechanism(cur, old,
need_anchor_change);
if (need_anchor_change)
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.parMetrics(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);
// Clear out the position cache in case of full screen redraw,
d->coord_cache_.clear();
+ d->math_rows_.clear();
// Clear out paragraph metrics to avoid having invalid metrics
// in the cache from paragraphs not relayouted below
// Rebreak anchor paragraph.
tm.redoParagraph(d->anchor_pit_);
- ParagraphMetrics & anchor_pm = tm.par_metrics_[d->anchor_pit_];
+ ParagraphMetrics & anchor_pm = tm.parMetrics(d->anchor_pit_);
// position anchor
if (d->anchor_pit_ == 0) {
pit_type pit1 = d->anchor_pit_ - 1;
for (; pit1 >= 0 && y1 >= 0; --pit1) {
tm.redoParagraph(pit1);
- ParagraphMetrics & pm = tm.par_metrics_[pit1];
+ ParagraphMetrics & pm = tm.parMetrics(pit1);
y1 -= pm.descent();
// Save the paragraph position in the cache.
pm.setPosition(y1);
pit_type pit2 = d->anchor_pit_ + 1;
for (; pit2 < npit && y2 <= height_; ++pit2) {
tm.redoParagraph(pit2);
- ParagraphMetrics & pm = tm.par_metrics_[pit2];
+ ParagraphMetrics & pm = tm.parMetrics(pit2);
y2 += pm.ascent();
// Save the paragraph position in the cache.
pm.setPosition(y2);
}
-void BufferView::insertLyXFile(FileName const & fname)
+void BufferView::insertLyXFile(FileName const & fname, bool const ignorelang)
{
LASSERT(d->cursor_.inTexted(), return);
ErrorList & el = buffer_.errorList("Parse");
// Copy the inserted document error list into the current buffer one.
el = buf.errorList("Parse");
+ ParagraphList & pars = buf.paragraphs();
+ if (ignorelang)
+ // set main language of imported file to context language
+ buf.changeLanguage(buf.language(), d->cursor_.getFont().language());
buffer_.undo().recordUndo(d->cursor_);
- cap::pasteParagraphList(d->cursor_, buf.paragraphs(),
+ cap::pasteParagraphList(d->cursor_, pars,
buf.params().documentClassPtr(), el);
res = _("Document %1$s inserted.");
} else {
}
-void BufferView::caretPosAndHeight(Point & p, int & h) const
+void BufferView::caretPosAndDim(Point & p, Dimension & dim) const
{
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();
- h = asc + des;
+ if (cur.inMathed()) {
+ MathRow const & mrow = mathRow(&cur.cell());
+ dim = mrow.caret_dim;
+ } else {
+ Font const font = cur.real_current_font;
+ frontend::FontMetrics const & fm = theFontMetrics(font);
+ dim.wid = fm.lineWidth();
+ dim.asc = fm.maxAscent();
+ dim.des = fm.maxDescent();
+ }
+ if (lyxrc.cursor_width > 0)
+ dim.wid = lyxrc.cursor_width;
+
p = getPos(cur);
- p.y_ -= asc;
+ // center fat carets horizontally
+ p.x_ -= dim.wid / 2;
+ // p is top-left
+ p.y_ -= dim.asc;
+}
+
+
+void BufferView::buildCaretGeometry(bool complet)
+{
+ Point p;
+ Dimension dim;
+ caretPosAndDim(p, dim);
+
+ Cursor const & cur = d->cursor_;
+ Font const & realfont = cur.real_current_font;
+ frontend::FontMetrics const & fm = theFontMetrics(realfont.fontInfo());
+ bool const isrtl = realfont.isVisibleRightToLeft();
+ int const dir = isrtl ? -1 : 1;
+
+ frontend::CaretGeometry & cg = d->caret_geometry_;
+ cg.shapes.clear();
+
+ // The caret itself, slanted for italics in text edit mode except
+ // for selections because the selection rect does not slant
+ bool const slant = fm.italic() && cur.inTexted() && !cur.selection();
+ double const slope = slant ? fm.italicSlope() : 0;
+ cg.shapes.push_back(
+ {{iround(p.x_ + dim.asc * slope), p.y_},
+ {iround(p.x_ - dim.des * slope), p.y_ + dim.height()},
+ {iround(p.x_ + dir * dim.wid - dim.des * slope), p.y_ + dim.height()},
+ {iround(p.x_ + dir * dim.wid + dim.asc * slope), p.y_}}
+ );
+
+ // The language indicator _| (if needed)
+ Language const * doclang = buffer().params().language;
+ if (!((realfont.language() == doclang && isrtl == doclang->rightToLeft())
+ || realfont.language() == latex_language)) {
+ int const lx = dim.height() / 3;
+ int const xx = iround(p.x_ - dim.des * slope);
+ int const yy = p.y_ + dim.height();
+ cg.shapes.push_back(
+ {{xx, yy - dim.wid},
+ {xx + dir * (dim.wid + lx - 1), yy - dim.wid},
+ {xx + dir * (dim.wid + lx - 1), yy},
+ {xx, yy}}
+ );
+ }
+
+ // The completion triangle |> (if needed)
+ if (complet) {
+ int const m = p.y_ + dim.height() / 2;
+ int const d = dim.height() / 8;
+ // offset for slanted carret
+ int const sx = iround((dim.asc - (dim.height() / 2 - d)) * slope);
+ // starting position x
+ int const xx = p.x_ + dir * dim.wid + sx;
+ cg.shapes.push_back(
+ {{xx, m - d},
+ {xx + dir * d, m},
+ {xx, m + d},
+ {xx, m + d - dim.wid},
+ {xx + dir * d - dim.wid, m},
+ {xx, m - d + dim.wid}}
+ );
+ }
+
+ // compute extremal x values
+ cg.left = 1000000;
+ cg.right = -1000000;
+ cg.top = 1000000;
+ cg.bottom = -1000000;
+ for (auto const & shape : cg.shapes)
+ for (Point const & p : shape) {
+ cg.left = min(cg.left, p.x_);
+ cg.right = max(cg.right, p.x_);
+ cg.top = min(cg.top, p.y_);
+ cg.bottom = max(cg.bottom, p.y_);
+ }
}
-bool BufferView::cursorInView(Point const & p, int h) const
+frontend::CaretGeometry const & BufferView::caretGeometry() const
{
- Cursor const & cur = cursor();
+ return d->caret_geometry_;
+}
+
+
+bool BufferView::caretInView() const
+{
+ if (!paragraphVisible(cursor()))
+ return false;
+ Point p;
+ Dimension dim;
+ caretPosAndDim(p, dim);
+
// does the cursor touch the screen ?
- if (p.y_ + h < 0 || p.y_ >= workHeight() || !paragraphVisible(cur))
+ if (p.y_ + dim.height() < 0 || p.y_ >= workHeight())
return false;
return true;
}
}
-bool BufferView::hadHorizScrollOffset(Text const * text,
- pit_type pit, pos_type pos) const
-{
- return !d->last_row_slice_.empty()
- && &text->inset() == d->last_row_slice_.inset().asInsetText()
- && pit == d->last_row_slice_.pit()
- && pos == d->last_row_slice_.pos();
-}
-
-
void BufferView::setCurrentRowSlice(CursorSlice const & rowSlice)
{
// nothing to do if the cursor was already on this row
- if (d->current_row_slice_ == rowSlice) {
- d->last_row_slice_ = CursorSlice();
+ if (d->current_row_slice_ == rowSlice)
return;
- }
// if the (previous) current row was scrolled, we have to
// remember it in order to repaint it next time.
- if (d->horiz_scroll_offset_ != 0)
- d->last_row_slice_ = d->current_row_slice_;
- else
- d->last_row_slice_ = CursorSlice();
+ if (d->horiz_scroll_offset_ != 0) {
+ // search the old row in cache and mark it changed
+ for (auto & tm_pair : d->text_metrics_) {
+ if (&tm_pair.first->inset() == rowSlice.inset().asInsetText()) {
+ tm_pair.second.setRowChanged(rowSlice.pit(), rowSlice.pos());
+ // We found it, no need to continue.
+ break;
+ }
+ }
+ }
// Since we changed row, the scroll offset is not valid anymore
d->horiz_scroll_offset_ = 0;
}
-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();
<< d->horiz_scroll_offset_ << " to " << offset);
if (d->update_strategy_ == NoScreenUpdate
- && (offset != d->horiz_scroll_offset_
- || !d->last_row_slice_.empty())) {
+ && offset != d->horiz_scroll_offset_) {
// FIXME: if one uses SingleParUpdate, then home/end
// will not work on long rows. Why?
d->update_strategy_ = FullScreenUpdate;
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();
// however, the different coordinates of insets and paragraphs
// needs to be updated.
LYXERR(Debug::PAINTING, "Strategy: NoScreenUpdate");
- pi.full_repaint = false;
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);
}
: "\t\t *** END DRAWING ***"));
// The scrollbar needs an update.
+ // FIXME: does it always? see ticket #11947.
updateScrollbar();
// Normalize anchor for next time
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();
+ Cursor cur(d->cursor_);
+ while (cur.depth() > 1) {
+ if (!cur.inTexted())
+ break;
+ TextMetrics const & tm = textMetrics(cur.text());
+ if (d->caret_geometry_.left >= tm.origin().x_
+ && d->caret_geometry_.right <= tm.origin().x_ + tm.dim().width())
+ break;
+ cur.pop();
+ }
+ cur.textRow().changed(true);
+ }
}
}
-size_t const & BufferView::inlineCompletionUniqueChars() const
+size_t BufferView::inlineCompletionUniqueChars() const
{
return d->inlineCompletionUniqueChars_;
}
projects / lyx.git / blobdiff