#include <config.h>
-#include <ctime>
-#include <unistd.h>
-#include <sys/wait.h>
-#include <locale.h>
-
#ifdef __GNUG__
#pragma implementation
#endif
#include "lyxscreen.h"
#include "lyxtext.h"
#include "lyxrow.h"
+#include "paragraph.h"
#include "LyXView.h"
#include "commandtags.h"
#include "lyxfunc.h"
#include "lyx_gui_misc.h"
#include "lyxrc.h"
#include "intl.h"
-#include "support/LAssert.h"
-#include "support/lstrings.h"
-#include "frontends/Dialogs.h"
-#include "insets/insetbib.h"
-#include "insets/insettext.h"
-/// added for Dispatch functions
+// added for Dispatch functions
#include "lyx_cb.h"
-#include "frontends/FileDialog.h"
#include "lyx_main.h"
#include "FloatList.h"
-#include "support/filetools.h"
-#include "support/lyxfunctional.h"
+#include "gettext.h"
+#include "ParagraphParameters.h"
+#include "undo_funcs.h"
+#include "lyxtextclasslist.h"
+
+#include "frontends/Dialogs.h"
+#include "frontends/Alert.h"
+#include "frontends/FileDialog.h"
+
+#include "insets/insetbib.h"
+#include "insets/insettext.h"
#include "insets/inseturl.h"
#include "insets/insetlatexaccent.h"
#include "insets/insettoc.h"
#include "insets/insetcaption.h"
#include "insets/insetfloatlist.h"
#include "insets/insetspecialchar.h"
-#include "gettext.h"
-#include "ParagraphParameters.h"
-#include "undo_funcs.h"
+
#include "mathed/formulabase.h"
-extern LyXTextClass::size_type current_layout;
+#include "support/LAssert.h"
+#include "support/lstrings.h"
+#include "support/filetools.h"
+#include "support/lyxfunctional.h"
+
+#include <ctime>
+#include <unistd.h>
+#include <sys/wait.h>
+#include <clocale>
+
+
+extern lyx::layout_type current_layout;
using std::vector;
using std::find_if;
using std::min;
using SigC::slot;
+using lyx::pos_type;
+using lyx::layout_type;
+using lyx::textclass_type;
+
/* the selection possible is needed, that only motion events are
* used, where the bottom press event was on the drawing area too */
bool selection_possible = false;
.connect(slot(this, &BufferView::Pimpl::tripleClick));
workarea_.workAreaKeyPress
.connect(slot(this, &BufferView::Pimpl::workAreaKeyPress));
+ workarea_.selectionRequested
+ .connect(slot(this, &BufferView::Pimpl::selectionRequested));
+ workarea_.selectionLost
+ .connect(slot(this, &BufferView::Pimpl::selectionLost));
cursor_timeout.timeout.connect(slot(this,
&BufferView::Pimpl::cursorToggle));
Paragraph * selendpar = 0;
UpdatableInset * the_locking_inset = 0;
- Paragraph::size_type pos = 0;
- Paragraph::size_type selstartpos = 0;
- Paragraph::size_type selendpos = 0;
+ pos_type pos = 0;
+ pos_type selstartpos = 0;
+ pos_type selendpos = 0;
bool selection = false;
bool mark_set = false;
bv_->theLockingInset(the_locking_inset);
}
bv_->text->first = screen_->topCursorVisible(bv_->text);
+#if 0
buffer_->resizeInsets(bv_);
+#endif
// this will scroll the screen such that the cursor becomes visible
updateScrollbar();
redraw();
}
long const text_height = bv_->text->height;
+ long const work_height = workarea_.height();
+ if (text_height <= work_height) {
+ workarea_.setScrollbarBounds(0.0, 0.0);
+ current_scrollbar_value = bv_->text->first;
+ workarea_.setScrollbar(current_scrollbar_value, 1.0);
+ return;
+ }
+
double const lineh = bv_->text->defaultHeight();
double const slider_size =
(text_height == 0) ? 1.0 : 1.0 / double(text_height);
-
- static long old_text_height = 0;
- static double old_lineh = 0;
- static double old_slider_size = 0;
+
+ static long old_text_height;
+ static double old_lineh;
+ static double old_slider_size;
if (text_height != old_text_height) {
- workarea_.setScrollbarBounds(0, text_height - workarea_.height());
+ workarea_.setScrollbarBounds(0.0,
+ text_height - work_height);
old_text_height = text_height;
}
if (lineh != old_lineh) {
if (!buffer_) return;
current_scrollbar_value = long(value);
+
if (current_scrollbar_value < 0)
current_scrollbar_value = 0;
bv_->text->setSelection(bv_);
screen_->toggleToggle(bv_->text, bv_);
fitCursor();
-#if 0
- screen_->showCursor(bv_->text, bv_);
-#else
showCursor();
-#endif
}
// Single-click on work area
void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
- unsigned int button)
+ unsigned int button)
{
if (!buffer_ || !screen_.get()) return;
- Inset * inset_hit = checkInsetHit(bv_->text, xpos, ypos, button);
+ Inset * inset_hit = checkInsetHit(bv_->text, xpos, ypos);
// ok ok, this is a hack.
if (button == 4 || button == 5) {
otherwise give the event to the inset */
if (inset_hit == bv_->theLockingInset()) {
bv_->theLockingInset()->
- insetButtonPress(bv_,
- xpos, ypos,
- button);
+ insetButtonPress(bv_,xpos, ypos,button);
return;
} else {
bv_->unlockInset(bv_->theLockingInset());
screen_->toggleSelection(bv_->text, bv_);
bv_->text->clearSelection();
bv_->text->fullRebreak(bv_);
-#if 0
- screen_->update(bv_->text, bv_);
-#else
update();
-#endif
updateScrollbar();
// Single left click in math inset?
- if ((inset_hit != 0) &&
- (inset_hit->editable()==Inset::HIGHLY_EDITABLE)) {
+ if (isHighlyEditableInset(inset_hit)) {
// Highly editable inset, like math
UpdatableInset * inset = static_cast<UpdatableInset *>(inset_hit);
selection_possible = false;
{
// select a word
if (!buffer_)
- return;
+ return;
LyXText * text = bv_->getLyXText();
if (text->bv_owner && bv_->theLockingInset())
- return;
+ return;
if (screen_.get() && button == 1) {
- if (text->bv_owner) {
- screen_->hideCursor();
- screen_->toggleSelection(text, bv_);
- text->selectWord(bv_, LyXText::WHOLE_WORD_STRICT);
- screen_->toggleSelection(text, bv_, false);
- } else {
- text->selectWord(bv_, LyXText::WHOLE_WORD_STRICT);
- }
- /* This will fit the cursor on the screen
- * if necessary */
- update(text, BufferView::SELECT|BufferView::FITCUR);
+ if (text->bv_owner) {
+ screen_->hideCursor();
+ screen_->toggleSelection(text, bv_);
+ text->selectWord(bv_, LyXText::WHOLE_WORD_STRICT);
+ screen_->toggleSelection(text, bv_, false);
+ } else {
+ text->selectWord(bv_, LyXText::WHOLE_WORD_STRICT);
+ }
+ /* This will fit the cursor on the screen
+ * if necessary */
+ update(text, BufferView::SELECT|BufferView::FITCUR);
}
}
void BufferView::Pimpl::tripleClick(int /*x*/, int /*y*/, unsigned int button)
{
// select a line
- if (buffer_)
+ if (!buffer_)
return;
LyXText * text = bv_->getLyXText();
return;
if (screen_.get() && (button == 1)) {
- screen_->hideCursor();
- screen_->toggleSelection(text, bv_);
+ if (text->bv_owner) {
+ screen_->hideCursor();
+ screen_->toggleSelection(text, bv_);
+ }
text->cursorHome(bv_);
text->selection.cursor = text->cursor;
text->cursorEnd(bv_);
text->setSelection(bv_);
- screen_->toggleSelection(text, bv_, false);
+ if (text->bv_owner) {
+ screen_->toggleSelection(text, bv_, false);
+ }
/* This will fit the cursor on the screen
* if necessary */
update(text, BufferView::SELECT|BufferView::FITCUR);
}
+void BufferView::Pimpl::selectionRequested()
+{
+ if (!available())
+ return;
+
+ string const sel(bv_->getLyXText()->selectionAsString(bv_->buffer(),
+ false));
+ if (!sel.empty()) {
+ workarea_.putClipboard(sel);
+ }
+}
+
+
+void BufferView::Pimpl::selectionLost()
+{
+ hideCursor();
+ toggleSelection();
+ bv_->getLyXText()->clearSelection();
+ showCursor();
+}
+
+
void BufferView::Pimpl::enterView()
{
if (active() && available()) {
// If we hit an inset, we have the inset coordinates in these
// and inset_hit points to the inset. If we do not hit an
// inset, inset_hit is 0, and inset_x == x, inset_y == y.
- Inset * inset_hit = checkInsetHit(bv_->text, x, y, button);
+ Inset * inset_hit = checkInsetHit(bv_->text, x, y);
if (bv_->theLockingInset()) {
// We are in inset locking mode.
if (button == 2)
return;
+ // finish selection
+ if (button == 1) {
+ workarea_.haveSelection(bv_->getLyXText()->selection.set());
+ }
+
setState();
owner_->showState();
+ owner_->updateMenubar();
+ owner_->updateToolbar();
// Did we hit an editable inset?
if (inset_hit) {
// Inset like error, notes and figures
selection_possible = false;
+ // if we reach this point with a selection, it
+ // must mean we are currently selecting.
+ // But we don't want to open the inset
+ // because that is annoying for the user.
+ // So just pretend we didn't hit it.
+ // this is OK because a "kosher" ButtonRelease
+ // will follow a ButtonPress that clears
+ // the selection.
+ // Note this also fixes selection drawing
+ // problems if we end up opening an inset
+ if (bv_->getLyXText()->selection.set())
+ return;
+
// CHECK fix this proper in 0.13
+ // well, maybe 13.0 !!!!!!!!!
// Following a ref shouldn't issue
// a push on the undo-stack
owner_->message(inset_hit->editMessage());
- if (inset_hit->editable()==Inset::HIGHLY_EDITABLE) {
+ if (isHighlyEditableInset(inset_hit)) {
// Highly editable inset, like math
UpdatableInset *inset = (UpdatableInset *)inset_hit;
inset->insetButtonRelease(bv_, x, y, button);
return;
}
-#ifdef WITH_WARNINGS
-#warning variable c is set but never used. What is it good for?? (JMarc)
-#endif
- // check whether we want to open a float
- if (bv_->text) {
- bool hit = false;
- char c = ' ';
- if (bv_->text->cursor.pos() <
- bv_->text->cursor.par()->size()) {
- c = bv_->text->cursor.par()->
- getChar(bv_->text->cursor.pos());
- }
- if (bv_->text->cursor.pos() - 1 >= 0) {
- c = bv_->text->cursor.par()->
- getChar(bv_->text->cursor.pos() - 1);
- }
- if (hit == true) {
- selection_possible = false;
- return;
- }
- }
-
// Maybe we want to edit a bibitem ale970302
if (bv_->text->cursor.par()->bibkey && x < 20 +
bibitemMaxWidth(bv_, textclasslist.
}
-/*
- * Returns an inset if inset was hit. 0 otherwise.
- * If hit, the coordinates are changed relative to the inset.
- * Otherwise coordinates are not changed, and false is returned.
- */
-Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y,
- unsigned int /* button */)
+Box BufferView::Pimpl::insetDimensions(LyXText const & text,
+ LyXCursor const & cursor) const
+{
+ Paragraph /*const*/ & par = *cursor.par();
+ pos_type const pos = cursor.pos();
+
+ lyx::Assert(par.getInset(pos));
+
+ Inset const & inset(*par.getInset(pos));
+
+ LyXFont const & font = text.getFont(buffer_, &par, pos);
+
+ int const width = inset.width(bv_, font);
+ int const inset_x = font.isVisibleRightToLeft()
+ ? (cursor.x() - width) : cursor.x();
+
+ return Box(
+ inset_x + inset.scroll(),
+ inset_x + width,
+ cursor.y() - inset.ascent(bv_, font),
+ cursor.y() + inset.descent(bv_, font));
+}
+
+
+Inset * BufferView::Pimpl::checkInset(LyXText const & text,
+ LyXCursor const & cursor,
+ int & x, int & y) const
+{
+ pos_type const pos(cursor.pos());
+ Paragraph /*const*/ & par(*cursor.par());
+
+ if (pos >= par.size() || !par.isInset(pos)) {
+ return 0;
+ }
+
+ Inset /*const*/ * inset = par.getInset(pos);
+
+ if (!isEditableInset(inset)) {
+ return 0;
+ }
+
+ Box b(insetDimensions(text, cursor));
+
+ if (!b.contained(x, y)) {
+ lyxerr[Debug::GUI] << "Missed inset at x,y " << x << "," << y
+ << " box " << b << endl;
+ return 0;
+ }
+
+ text.setCursor(bv_, &par, pos, true);
+
+ x -= b.x1;
+ // The origin of an inset is on the baseline
+ y -= (text.cursor.y());
+
+ return inset;
+}
+
+
+Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y)
{
if (!screen_.get())
return 0;
int y_tmp = y + text->first;
-
+
LyXCursor cursor;
text->setCursorFromCoordinates(bv_, cursor, x, y_tmp);
- text->setCursor(bv_, cursor, cursor.par(),cursor.pos(),true);
-
-
- if (cursor.pos() < cursor.par()->size()
- && cursor.par()->getChar(cursor.pos()) == Paragraph::META_INSET
- && cursor.par()->getInset(cursor.pos())
- && cursor.par()->getInset(cursor.pos())->editable()) {
+
+ Inset * inset(checkInset(*text, cursor, x, y_tmp));
- // Check whether the inset really was hit
- Inset * tmpinset = cursor.par()->getInset(cursor.pos());
- LyXFont font = text->getFont(buffer_,
- cursor.par(), cursor.pos());
- int const width = tmpinset->width(bv_, font);
- int const inset_x = font.isVisibleRightToLeft()
- ? cursor.x() - width : cursor.x();
- int const start_x = inset_x + tmpinset->scroll();
- int const end_x = inset_x + width;
-
- if (x > start_x && x < end_x
- && y_tmp > cursor.y() - tmpinset->ascent(bv_, font)
- && y_tmp < cursor.y() + tmpinset->descent(bv_, font)) {
- text->setCursor(bv_, cursor.par(),cursor.pos(), true);
- x = x - start_x;
- // The origin of an inset is on the baseline
- y = y_tmp - (text->cursor.y());
- return tmpinset;
- }
+ if (inset) {
+ y = y_tmp;
+ return inset;
+ }
+
+ // look at previous position
+
+ if (cursor.pos() == 0) {
+ return 0;
}
- if ((cursor.pos() - 1 >= 0) &&
- (cursor.par()->getChar(cursor.pos()-1) == Paragraph::META_INSET) &&
- (cursor.par()->getInset(cursor.pos() - 1)) &&
- (cursor.par()->getInset(cursor.pos() - 1)->editable())) {
- Inset * tmpinset = cursor.par()->getInset(cursor.pos()-1);
- LyXFont font = text->getFont(buffer_, cursor.par(),
- cursor.pos() - 1);
- int const width = tmpinset->width(bv_, font);
- int const inset_x = font.isVisibleRightToLeft()
- ? cursor.x() : cursor.x() - width;
- int const start_x = inset_x + tmpinset->scroll();
- int const end_x = inset_x + width;
-
- if (x > start_x && x < end_x
- && y_tmp > cursor.y() - tmpinset->ascent(bv_, font)
- && y_tmp < cursor.y() + tmpinset->descent(bv_, font)) {
-#if 0
- if (move_cursor && (tmpinset != bv_->theLockingInset()))
-#endif
- text->setCursor(bv_, cursor.par(),
- cursor.pos() - 1, true);
- x = x - start_x;
- // The origin of an inset is on the baseline
- y = y_tmp - (text->cursor.y());
- return tmpinset;
- }
+ // move back one
+ text->setCursor(bv_, cursor, cursor.par(), cursor.pos() - 1, true);
+
+ inset = checkInset(*text, cursor, x, y_tmp);
+ if (inset) {
+ y = y_tmp;
}
- return 0;
+ return inset;
}
LyXText::text_status st = bv_->text->status();
screen_->update(bv_->text, bv_);
bool fitc = false;
- while(bv_->text->status() == LyXText::CHANGED_IN_DRAW) {
+ while (bv_->text->status() == LyXText::CHANGED_IN_DRAW) {
if (bv_->text->fullRebreak(bv_)) {
st = LyXText::NEED_MORE_REFRESH;
bv_->text->setCursor(bv_, bv_->text->cursor.par(),
if (clip.empty()) return;
if (asPara) {
- bv_->text->insertStringAsParagraphs(bv_, clip);
+ bv_->getLyXText()->insertStringAsParagraphs(bv_, clip);
} else {
- bv_->text->insertStringAsLines(bv_, clip);
+ bv_->getLyXText()->insertStringAsLines(bv_, clip);
}
update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
}
string initpath = lyxrc.document_path;
if (available()) {
- string const trypath = owner_->buffer()->filepath;
+ string const trypath = owner_->buffer()->filePath();
// If directory is writeable, use this as default.
if (IsDirWriteable(trypath))
initpath = trypath;
FileDialog fileDlg(bv_->owner(),
_("Select LyX document to insert"),
LFUN_FILE_INSERT,
- make_pair(string(_("Documents")),
+ make_pair(string(_("Documents|#o#O")),
string(lyxrc.document_path)),
- make_pair(string(_("Examples")),
+ make_pair(string(_("Examples|#E#e")),
string(AddPath(system_lyxdir, "examples"))));
FileDialog::Result result =
case LFUN_PASTESELECTION:
{
bool asPara = false;
- if (argument == "paragraph") asPara = true;
+ if (argument == "paragraph")
+ asPara = true;
pasteClipboard(asPara);
}
break;
break;
case LFUN_FILE_INSERT:
- {
MenuInsertLyXFile(argument);
- }
- break;
+ break;
case LFUN_FILE_INSERT_ASCII_PARA:
InsertAsciiFile(bv_, argument, true);
// Derive layout number from given argument (string)
// and current buffer's textclass (number). */
- LyXTextClassList::ClassList::size_type tclass =
- buffer_->params.textclass;
- pair <bool, LyXTextClass::size_type> layout =
+ textclass_type tclass = buffer_->params.textclass;
+ pair <bool, layout_type> layout =
textclasslist.NumberOfLayout(tclass, argument);
// If the entry is obsolete, use the new one instead.
if (layout.first) {
- string obs = textclasslist.Style(tclass,layout.second)
+ string obs = textclasslist.Style(tclass, layout.second)
.obsoleted_by();
if (!obs.empty())
- layout =
- textclasslist.NumberOfLayout(tclass, obs);
+ layout = textclasslist.NumberOfLayout(tclass, obs);
}
// see if we found the layout number:
case LFUN_INSERT_LABEL:
MenuInsertLabel(bv_, argument);
break;
-
+
case LFUN_REF_INSERT:
if (argument.empty()) {
InsetCommandParams p("ref");
if (!label.empty()) {
//bv_->savePosition(0);
if (!bv_->gotoLabel(label))
- WriteAlert(_("Error"),
+ Alert::alert(_("Error"),
_("Couldn't find this label"),
_("in current document."));
}
if (is_rtl)
lt->cursorLeft(bv_, false);
if (lt->cursor.pos() < lt->cursor.par()->size()
- && lt->cursor.par()->getChar(lt->cursor.pos())
- == Paragraph::META_INSET
- && lt->cursor.par()->getInset(lt->cursor.pos())
- && lt->cursor.par()->getInset(lt->cursor.pos())->editable() == Inset::HIGHLY_EDITABLE){
+ && lt->cursor.par()->isInset(lt->cursor.pos())
+ && isHighlyEditableInset(lt->cursor.par()->getInset(lt->cursor.pos()))) {
Inset * tmpinset = lt->cursor.par()->getInset(lt->cursor.pos());
owner_->getLyXFunc()->setMessage(tmpinset->editMessage());
if (is_rtl)
lt->cursorLeft(bv_, false);
if ((is_rtl || cur != lt->cursor) && // only if really moved!
lt->cursor.pos() < lt->cursor.par()->size() &&
- (lt->cursor.par()->getChar(lt->cursor.pos()) ==
- Paragraph::META_INSET) &&
- lt->cursor.par()->getInset(lt->cursor.pos()) &&
- (lt->cursor.par()->getInset(lt->cursor.pos())->editable()
- == Inset::HIGHLY_EDITABLE))
- {
+ lt->cursor.par()->isInset(lt->cursor.pos()) &&
+ isHighlyEditableInset(lt->cursor.par()->getInset(lt->cursor.pos()))) {
Inset * tmpinset = lt->cursor.par()->getInset(lt->cursor.pos());
owner_->getLyXFunc()->setMessage(tmpinset->editMessage());
if (is_rtl)
if (cursor.par()->params().spaceTop() == VSpace(VSpace::NONE)) {
lt->setParagraph
(bv_,
- cursor.par()->params().lineTop(),
+ cursor.par()->params().lineTop(),
cursor.par()->params().lineBottom(),
- cursor.par()->params().pagebreakTop(),
+ cursor.par()->params().pagebreakTop(),
cursor.par()->params().pagebreakBottom(),
VSpace(VSpace::DEFSKIP), cursor.par()->params().spaceBottom(),
- cursor.par()->params().spacing(),
- cursor.par()->params().align(),
+ cursor.par()->params().spacing(),
+ cursor.par()->params().align(),
cursor.par()->params().labelWidthString(), 1);
//update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
}
case LFUN_CHARATCURSOR:
{
- Paragraph::size_type pos = bv_->getLyXText()->cursor.pos();
+ pos_type pos = bv_->getLyXText()->cursor.pos();
if (pos < bv_->getLyXText()->cursor.par()->size())
owner_->getLyXFunc()->setMessage(
tostr(bv_->getLyXText()->cursor.par()->getChar(pos)));
mathDispatchMathMode(bv_, argument);
break;
+ case LFUN_GREEK: // Insert a single greek letter
+ mathDispatchGreek(bv_, argument);
+ break;
+
case LFUN_CITATION_INSERT:
{
InsetCommandParams p;
update(lt, BufferView::SELECT|BufferView::FITCUR);
InsetSpecialChar * new_inset =
new InsetSpecialChar(kind);
- insertInset(new_inset);
- // Ok, what happens here if we are unable to insert
- // the inset? Leak it?
+ if (!insertInset(new_inset))
+ delete new_inset;
}
}
void BufferView::Pimpl::smartQuote()
{
+ LyXText const * lt = bv_->getLyXText();
+ Paragraph const * par = lt->cursor.par();
+ pos_type pos = lt->cursor.pos();
char c;
- LyXText * lt = bv_->getLyXText();
- if (lt->cursor.pos())
- c = lt->cursor.par()->getChar(lt->cursor.pos() - 1);
- else
+ if (!pos
+ || (par->isInset(pos - 1)
+ && par->getInset(pos - 1)->isSpace()))
c = ' ';
+ else
+ c = par->getChar(pos - 1);
+
hideCursor();
LyXLayout const & style = textclasslist.Style(
- bv_->buffer()->params.textclass,
- lt->cursor.par()->getLayout());
+ bv_->buffer()->params.textclass, par->getLayout());
if (style.pass_thru ||
(!insertInset(new InsetQuotes(c, bv_->buffer()->params))))
- Dispatch(LFUN_SELFINSERT, "\"");
+ bv_->owner()->getLyXFunc()->dispatch(LFUN_SELFINSERT, "\"");
}
update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
}
- pair<bool, LyXTextClass::size_type> lres =
- textclasslist.NumberOfLayout(buffer_->params
- .textclass, lout);
- LyXTextClass::size_type lay;
+ pair<bool, layout_type> lres =
+ textclasslist.NumberOfLayout(buffer_->params .textclass, lout);
+ layout_type lay = 0;
if (lres.first != false) {
// layout found
lay = lres.second;
return;
}
} else if (bv_->theLockingInset()->updateInsetInInset(bv_, inset)) {
- if (bv_->text->updateInset(bv_,
- bv_->theLockingInset())) {
+ if (bv_->text->updateInset(bv_, bv_->theLockingInset())) {
update();
if (mark_dirty){
buffer_->markDirty();
beforeChange(bv_->text);
update(bv_->text, BufferView::SELECT|BufferView::FITCUR);
+ LyXCursor const & cursor = bv_->text->cursor;
+
string contents;
if (same_content &&
- bv_->text->cursor.par()->getChar(bv_->text->cursor.pos()) == Paragraph::META_INSET) {
- Inset const * inset = bv_->text->cursor.par()->getInset(bv_->text->cursor.pos());
+ cursor.par()->isInset(cursor.pos())) {
+ Inset const * inset = cursor.par()->getInset(cursor.pos());
if (find(codes.begin(), codes.end(), inset->lyxCode())
!= codes.end())
contents =
static_cast<InsetCommand const *>(inset)->getContents();
}
+
if (!bv_->text->gotoNextInset(bv_, codes, contents)) {
if (bv_->text->cursor.pos()
- || bv_->text->cursor.par() != bv_->text->firstParagraph()) {
+ || bv_->text->cursor.par() != bv_->text->ownerParagraph()) {
LyXCursor tmp = bv_->text->cursor;
- bv_->text->cursor.par(bv_->text->firstParagraph());
+ bv_->text->cursor.par(bv_->text->ownerParagraph());
bv_->text->cursor.pos(0);
if (!bv_->text->gotoNextInset(bv_, codes, contents)) {
bv_->text->cursor = tmp;
projects / lyx.git / blobdiff