{}
-void LyXText::init(BufferView * bview)
+void LyXText::init(BufferView * bv)
{
- bv_owner = bview;
+ bv_owner = bv;
ParagraphList::iterator const beg = paragraphs().begin();
ParagraphList::iterator const end = paragraphs().end();
current_font = getFont(beg, 0);
redoParagraphs(beg, end);
- setCursorIntern(0, 0);
- anchor() = cursor();
+ bv->cursor().resetAnchor();
updateCounters();
}
}
-InsetOld * LyXText::getInset() const
-{
- ParagraphList::iterator pit = cursorPar();
- pos_type const pos = cursor().pos();
-
- if (pos < pit->size() && pit->isInset(pos)) {
- return pit->getInset(pos);
- }
- return 0;
-}
-
-
-bool LyXText::toggleInset()
-{
- InsetOld * inset = getInset();
- // is there an editable inset at cursor position?
- if (!isEditableInset(inset))
- return false;
- //bv()->owner()->message(inset->editMessage());
-
- // do we want to keep this?? (JMarc)
- if (!isHighlyEditableInset(inset))
- recUndo(cursor().par());
-
- if (inset->isOpen())
- inset->close();
- else
- inset->open();
- return true;
-}
-
-
// used in setLayout
// Asger is not sure we want to do this...
void LyXText::makeFontEntriesLayoutSpecific(BufferParams const & params,
// return past-the-last paragraph influenced by a layout change on pit
-ParagraphList::iterator
-LyXText::undoSpan(ParagraphList::iterator pit)
+ParagraphList::iterator LyXText::undoSpan(ParagraphList::iterator pit)
{
ParagraphList::iterator end = paragraphs().end();
ParagraphList::iterator nextpit = boost::next(pit);
bv()->owner()->dispatch(FuncRequest(LFUN_HOME));
bv()->owner()->dispatch(FuncRequest(LFUN_ENDSEL));
bv()->owner()->dispatch(FuncRequest(LFUN_CUT));
- InsetOld * inset = new InsetEnvironment(params, layout);
+ InsetBase * inset = new InsetEnvironment(params, layout);
if (bv()->insertInset(inset)) {
//inset->edit(bv());
//bv()->owner()->dispatch(FuncRequest(LFUN_PASTE));
return;
}
- ParagraphList::iterator start = getPar(selStart().par());
- ParagraphList::iterator end = boost::next(getPar(selEnd().par()));
+ ParagraphList::iterator start =
+ getPar(bv()->cursor().selBegin().par());
+ ParagraphList::iterator end =
+ boost::next(getPar(bv()->cursor().selEnd().par()));
ParagraphList::iterator endpit = setLayout(start, end, layout);
redoParagraphs(start, endpit);
ParagraphList::iterator & beg,
ParagraphList::iterator & end)
{
- if (!text.selection.set()) {
+ if (!text.bv()->cursor().selection()) {
beg = text.cursorPar();
end = boost::next(beg);
} else {
- beg = text.getPar(text.selStart());
- end = boost::next(text.getPar(text.selEnd()));
+ beg = text.getPar(text.bv()->cursor().selBegin());
+ end = boost::next(text.getPar(text.bv()->cursor().selEnd()));
}
}
// set font over selection and make a total rebreak of those paragraphs
void LyXText::setFont(LyXFont const & font, bool toggleall)
{
+ LCursor & cur = bv()->cursor();
// if there is no selection just set the current_font
- if (!selection.set()) {
+ if (!cur.selection()) {
// Determine basis font
LyXFont layoutfont;
if (cursor().pos() < cursorPar()->beginOfBody())
}
// ok we have a selection.
- recUndo(selStart().par(), selEnd().par());
+ recUndo(cur.selBegin().par(), cur.selEnd().par());
freezeUndo();
- ParagraphList::iterator beg = getPar(selStart().par());
- ParagraphList::iterator end = getPar(selEnd().par());
+ ParagraphList::iterator beg = getPar(cur.selBegin().par());
+ ParagraphList::iterator end = getPar(cur.selEnd().par());
- PosIterator pos(¶graphs(), beg, selStart().pos());
- PosIterator posend(¶graphs(), end, selEnd().pos());
+ PosIterator pos(¶graphs(), beg, cur.selBegin().pos());
+ PosIterator posend(¶graphs(), end, cur.selEnd().pos());
BufferParams const & params = bv()->buffer()->params();
}
-// important for the screen
-
-
// the cursor set functions have a special mechanism. When they
-// realize, that you left an empty paragraph, they will delete it.
-
-// need the selection cursor:
-void LyXText::setSelection()
-{
- TextCursor::setSelection();
-}
-
-
-void LyXText::clearSelection()
-{
- TextCursor::clearSelection();
-
- // reset this in the bv()!
- if (bv() && bv()->text())
- bv()->unsetXSel();
-}
-
+// realize you left an empty paragraph, they will delete it.
void LyXText::cursorHome()
{
// Implicit selections are cleared afterwards
//and cursor is set to the original position.
if (implicitSelection) {
- clearSelection();
+ bv()->cursor().clearSelection();
cursor() = resetCursor;
- anchor() = cursor();
+ bv()->cursor().resetAnchor();
}
}
string LyXText::getStringToIndex()
{
+ LCursor & cur = bv()->cursor();
// Try implicit word selection
// If there is a change in the language the implicit word selection
// is disabled.
selectWordWhenUnderCursor(lyx::PREVIOUS_WORD);
string idxstring;
- if (!selection.set())
+ if (!cur.selection())
bv()->owner()->message(_("Nothing to index!"));
- else if (selStart().par() != selEnd().par())
+ else if (cur.selBegin().par() != cur.selEnd().par())
bv()->owner()->message(_("Cannot index more than one paragraph!"));
else
idxstring = selectionAsString(*bv()->buffer(), false);
// Reset cursors to their original position.
cursor() = reset_cursor;
- anchor() = cursor();
+ cur.resetAnchor();
// Clear the implicit selection.
if (implicitSelection)
- clearSelection();
+ cur.clearSelection();
return idxstring;
}
void LyXText::setParagraph(Spacing const & spacing, LyXAlignment align,
string const & labelwidthstring, bool noindent)
{
+ LCursor & cur = bv()->cursor();
// make sure that the depth behind the selection are restored, too
- ParagraphList::iterator undopit = undoSpan(getPar(selEnd()));
- recUndo(selStart().par(), parOffset(undopit) - 1);
+ ParagraphList::iterator undopit = undoSpan(getPar(cur.selEnd()));
+ recUndo(cur.selBegin().par(), parOffset(undopit) - 1);
- ParagraphList::reverse_iterator pit(getPar(selEnd().par()));
- ParagraphList::reverse_iterator beg(getPar(selStart().par()));
+ ParagraphList::reverse_iterator pit(getPar(cur.selEnd().par()));
+ ParagraphList::reverse_iterator beg(getPar(cur.selBegin().par()));
for (--pit; pit != beg; ++pit) {
ParagraphParameters & params = pit->params();
params.noindent(noindent);
}
- redoParagraphs(getPar(selStart()), undopit);
+ redoParagraphs(getPar(cur.selBegin()), undopit);
}
if (layout->labeltype == LABEL_SENSITIVE) {
ParagraphList::iterator end = paragraphs().end();
ParagraphList::iterator tmppit = pit;
- InsetOld * in = 0;
+ InsetBase * in = 0;
bool isOK = false;
while (tmppit != end && tmppit->inInset()
// the single '=' is intended below
&& (in = tmppit->inInset()->owner()))
{
- if (in->lyxCode() == InsetOld::FLOAT_CODE ||
- in->lyxCode() == InsetOld::WRAP_CODE) {
+ if (in->lyxCode() == InsetBase::FLOAT_CODE ||
+ in->lyxCode() == InsetBase::WRAP_CODE) {
isOK = true;
break;
} else {
if (isOK) {
string type;
- if (in->lyxCode() == InsetOld::FLOAT_CODE)
+ if (in->lyxCode() == InsetBase::FLOAT_CODE)
type = static_cast<InsetFloat*>(in)->params().type;
- else if (in->lyxCode() == InsetOld::WRAP_CODE)
+ else if (in->lyxCode() == InsetBase::WRAP_CODE)
type = static_cast<InsetWrap*>(in)->params().type;
else
BOOST_ASSERT(false);
}
-void LyXText::insertInset(InsetOld * inset)
+void LyXText::insertInset(InsetBase * inset)
{
if (!cursorPar()->insetAllowed(inset->lyxCode()))
return;
void LyXText::cutSelection(bool doclear, bool realcut)
{
+ LCursor & cur = bv()->cursor();
// Stuff what we got on the clipboard. Even if there is no selection.
// There is a problem with having the stuffing here in that the
bv()->stuffClipboard(selectionAsString(*bv()->buffer(), true));
// This doesn't make sense, if there is no selection
- if (!selection.set())
+ if (!cur.selection())
return;
- // OK, we have a selection. This is always between selStart()
- // and selEnd()
+ // OK, we have a selection. This is always between cur.selBegin()
+ // and cur.selEnd()
// make sure that the depth behind the selection are restored, too
- ParagraphList::iterator begpit = getPar(selStart().par());
- ParagraphList::iterator endpit = getPar(selEnd().par());
+ ParagraphList::iterator begpit = getPar(cur.selBegin().par());
+ ParagraphList::iterator endpit = getPar(cur.selEnd().par());
ParagraphList::iterator undopit = undoSpan(endpit);
- recUndo(selStart().par(), parOffset(undopit) - 1);
+ recUndo(cur.selBegin().par(), parOffset(undopit) - 1);
- int endpos = selEnd().pos();
+ int endpos = cur.selEnd().pos();
BufferParams const & bufparams = bv()->buffer()->params();
boost::tie(endpit, endpos) = realcut ?
CutAndPaste::cutSelection(bufparams,
paragraphs(),
begpit , endpit,
- selStart().pos(), endpos,
+ cur.selBegin().pos(), endpos,
bufparams.textclass,
doclear)
: CutAndPaste::eraseSelection(bufparams,
paragraphs(),
begpit, endpit,
- selStart().pos(), endpos,
+ cur.selBegin().pos(), endpos,
doclear);
// sometimes necessary
if (doclear)
cursor().par(parOffset(endpit));
// need a valid cursor. (Lgb)
- clearSelection();
+ cur.clearSelection();
updateCounters();
}
void LyXText::copySelection()
{
+ LCursor & cur = bv()->cursor();
// stuff the selection onto the X clipboard, from an explicit copy request
bv()->stuffClipboard(selectionAsString(*bv()->buffer(), true));
// this doesnt make sense, if there is no selection
- if (!selection.set())
+ if (!cur.selection())
return;
- // ok we have a selection. This is always between selStart()
+ // ok we have a selection. This is always between cur.selBegin()
// and sel_end cursor
// copy behind a space if there is one
- while (getPar(selStart())->size() > selStart().pos()
- && getPar(selStart())->isLineSeparator(selStart().pos())
- && (selStart().par() != selEnd().par()
- || selStart().pos() < selEnd().pos()))
- selStart().pos(selStart().pos() + 1);
-
- CutAndPaste::copySelection(getPar(selStart().par()),
- getPar(selEnd().par()),
- selStart().pos(),
- selEnd().pos(),
+ while (getPar(cur.selBegin())->size() > cur.selBegin().pos()
+ && getPar(cur.selBegin())->isLineSeparator(cur.selBegin().pos())
+ && (cur.selBegin().par() != cur.selEnd().par()
+ || cur.selBegin().pos() < cur.selEnd().pos()))
+ cur.selBegin().pos(cur.selBegin().pos() + 1);
+
+ CutAndPaste::copySelection(getPar(cur.selBegin().par()),
+ getPar(cur.selEnd().par()),
+ cur.selBegin().pos(),
+ cur.selEnd().pos(),
bv()->buffer()->params().textclass);
}
void LyXText::pasteSelection(size_t sel_index)
{
+ LCursor & cur = bv()->cursor();
// this does not make sense, if there is nothing to paste
if (!CutAndPaste::checkPastePossible())
return;
redoParagraphs(cursorPar(), endpit);
- clearSelection();
-
- anchor() = cursor();
+ cur.clearSelection();
+ cur.resetAnchor();
setCursor(ppp.first, ppp.second);
- setSelection();
+ cur.setSelection();
updateCounters();
}
if (!length)
return;
- anchor() = cursor();
+ LCursor & cur = bv()->cursor();
+ cur.resetAnchor();
while (length--)
cursorRight(true);
- setSelection();
+ cur.setSelection();
}
// simple replacing. The font of the first selected character is used
void LyXText::replaceSelectionWithString(string const & str)
{
- recUndo(cursor().par());
+ LCursor & cur = bv()->cursor();
+ recUndo(cur.par());
freezeUndo();
// Get font setting before we cut
- pos_type pos = selEnd().pos();
- LyXFont const font = getPar(selStart())
+ pos_type pos = cur.selEnd().pos();
+ LyXFont const font = getPar(cur.selBegin())
->getFontSettings(bv()->buffer()->params(),
- selStart().pos());
+ cur.selBegin().pos());
// Insert the new string
string::const_iterator cit = str.begin();
string::const_iterator end = str.end();
for (; cit != end; ++cit) {
- getPar(selEnd())->insertChar(pos, (*cit), font);
+ getPar(cur.selEnd())->insertChar(pos, (*cit), font);
++pos;
}
// needed to insert the selection
void LyXText::insertStringAsLines(string const & str)
{
+ LCursor & cur = bv()->cursor();
ParagraphList::iterator pit = cursorPar();
pos_type pos = cursor().pos();
ParagraphList::iterator endpit = boost::next(cursorPar());
-
- recUndo(cursor().par());
+ recordUndo(cur, Undo::ATOMIC);
// only to be sure, should not be neccessary
- clearSelection();
-
+ cur.clearSelection();
bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
redoParagraphs(cursorPar(), endpit);
- anchor() = cursor();
+ cur.resetAnchor();
setCursor(pit, pos);
- setSelection();
+ cur.setSelection();
}
if (paragraphs().begin()->rows.empty())
return;
- // get the cursor y position in text
-
- ParagraphList::iterator pit = getPar(par);
- Row const & row = *pit->getRow(pos);
+ // now some strict checking
+ Paragraph & para = *getPar(par);
+ Row const & row = *para.getRow(pos);
pos_type const end = row.endpos();
// None of these should happen, but we're scaredy-cats
pos = 0;
cur.pos(0);
BOOST_ASSERT(false);
- } else if (pos > pit->size()) {
+ } else if (pos > para.size()) {
lyxerr << "dont like 1, pos: " << pos
- << " size: " << pit->size()
+ << " size: " << para.size()
<< " row.pos():" << row.pos()
<< " paroffset: " << par << endl;
pos = 0;
BOOST_ASSERT(false);
} else if (pos < row.pos()) {
lyxerr << "dont like 3 please report pos:" << pos
- << " size: " << pit->size()
+ << " size: " << para.size()
<< " row.pos():" << row.pos()
<< " paroffset: " << par << endl;
pos = row.pos();
pos_type pos, bool setfont, bool boundary)
{
setCursor(cursor(), par, pos, boundary);
- bv()->x_target(cursorX() + xo_);
+ bv()->cursor().x_target() = cursorX(cursor());
if (setfont)
setCurrentFont();
}
void LyXText::setCurrentFont()
{
- pos_type pos = cursor().pos();
+ LCursor & cur = bv()->cursor();
+ pos_type pos = cur.pos();
ParagraphList::iterator pit = cursorPar();
if (cursor().boundary() && pos > 0)
pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
Row const & row, int & x, bool & boundary) const
{
+ x -= xo_;
double tmpx = row.x();
double fill_separator = row.fill_separator();
double fill_hfill = row.fill_hfill();
// check for empty row
if (vc == end) {
- x = int(tmpx);
+ x = int(tmpx) + xo_;
return 0;
}
// If lastrow is false, we don't need to compute
// the value of rtl.
- bool const rtl = (lastrow)
+ bool const rtl = lastrow
? pit->isRightToLeftPar(bv()->buffer()->params())
: false;
if (lastrow &&
c = end - 1;
}
- c -= row.pos();
- x = int(tmpx);
- return c;
+ x = int(tmpx) + xo_;
+ return c - row.pos();
}
ParagraphList::iterator pit;
Row const & row = *getRowNearY(y, pit);
bool bound = false;
- pos_type const column = getColumnNearX(pit, row, x, bound);
- cur.par(parOffset(pit));
- cur.pos(row.pos() + column);
- cur.boundary(bound);
+ pos_type const pos = row.pos() + getColumnNearX(pit, row, x, bound);
+ cur.par() = parOffset(pit);
+ cur.pos() = pos;
+ cur.boundary() = bound;
+}
+
+
+// x,y are absolute screen coordinates
+void LyXText::edit(LCursor & cur, int x, int y)
+{
+ int xx = x; // is modified by getColumnNearX
+ ParagraphList::iterator pit;
+ Row const & row = *getRowNearY(y, pit);
+ bool bound = false;
+ pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound);
+ cur.par() = parOffset(pit);
+ cur.pos() = pos;
+ cur.boundary() = bound;
+
+ // try to descend into nested insets
+ InsetBase * inset = checkInsetHit(x, y);
+ if (inset) {
+ // This should be just before or just behind the cursor position
+ // set above.
+ BOOST_ASSERT((pos != 0 && inset == pit->getInset(pos - 1))
+ || inset == pit->getInset(pos));
+ // Make sure the cursor points to the position before this inset.
+ if (inset == pit->getInset(pos - 1))
+ --cur.pos();
+ inset->edit(cur, x, y);
+ }
}
{
if (cursor().pos() == cursorPar()->size())
return false;
- InsetOld * inset = cursorPar()->getInset(cursor().pos());
+ InsetBase * inset = cursorPar()->getInset(cursor().pos());
if (!isHighlyEditableInset(inset))
return false;
- inset->edit(bv(), front);
+ inset->edit(bv()->cursor(), front);
return true;
}
return DispatchResult(true, true);
cursorRight(true);
if (!selecting)
- clearSelection();
+ bv()->cursor().clearSelection();
return DispatchResult(true);
}
return DispatchResult(false, FINISHED);
cursorLeft(true);
if (!selecting)
- clearSelection();
+ bv()->cursor().clearSelection();
if (activate_inset && checkAndActivateInset(front))
return DispatchResult(true, true);
return DispatchResult(true);
DispatchResult LyXText::moveUp()
{
- if (cursorPar() == firstPar() && cursorRow() == firstRow())
+ LCursor & cur = bv()->cursor();
+ if (cur.par() == 0 && cursorRow() == firstRow())
return DispatchResult(false, FINISHED_UP);
cursorUp(false);
- clearSelection();
+ cur.clearSelection();
return DispatchResult(true);
}
DispatchResult LyXText::moveDown()
{
- if (cursorPar() == lastPar() && cursorRow() == lastRow())
+ LCursor & cur = bv()->cursor();
+ if (cur.par() == cur.lastpar() && cursorRow() == lastRow())
return DispatchResult(false, FINISHED_DOWN);
cursorDown(false);
- clearSelection();
+ cur.clearSelection();
return DispatchResult(true);
}
bool LyXText::cursorLeft(bool internal)
{
- if (cursor().pos() > 0) {
- bool boundary = cursor().boundary();
- setCursor(cursor().par(), cursor().pos() - 1, true, false);
+ LCursor & cur = bv()->cursor();
+ if (cur.pos() > 0) {
+ bool boundary = cur.boundary();
+ setCursor(cur.par(), cur.pos() - 1, true, false);
if (!internal && !boundary &&
- bidi.isBoundary(*bv()->buffer(), *cursorPar(), cursor().pos() + 1))
- setCursor(cursor().par(), cursor().pos() + 1, true, true);
+ bidi.isBoundary(*bv()->buffer(), cur.paragraph(), cur.pos() + 1))
+ setCursor(cur.par(), cur.pos() + 1, true, true);
return true;
}
- if (cursor().par() != 0) {
+ if (cur.par() != 0) {
// steps into the paragraph above
- setCursor(cursor().par() - 1, boost::prior(cursorPar())->size());
+ setCursor(cur.par() - 1, boost::prior(cursorPar())->size());
return true;
}
bool LyXText::cursorRight(bool internal)
{
- if (!internal && cursor().boundary()) {
- setCursor(cursor().par(), cursor().pos(), true, false);
+ LCursor & cur = bv()->cursor();
+ if (!internal && cur.boundary()) {
+ setCursor(cur.par(), cur.pos(), true, false);
return true;
}
- if (cursor().pos() != cursorPar()->size()) {
- setCursor(cursor().par(), cursor().pos() + 1, true, false);
- if (!internal && bidi.isBoundary(*bv()->buffer(), *cursorPar(),
- cursor().pos()))
- setCursor(cursor().par(), cursor().pos(), true, true);
+ if (cur.pos() != cur.lastpos()) {
+ setCursor(cur.par(), cur.pos() + 1, true, false);
+ if (!internal && bidi.isBoundary(*bv()->buffer(), cur.paragraph(),
+ cur.pos()))
+ setCursor(cur.par(), cur.pos(), true, true);
return true;
}
- if (cursor().par() + 1 != int(paragraphs().size())) {
- setCursor(cursor().par() + 1, 0);
+ if (cur.par() + 1 != int(paragraphs().size())) {
+ setCursor(cur.par() + 1, 0);
return true;
}
void LyXText::cursorUp(bool selecting)
{
+ LCursor & cur = bv()->cursor();
Row const & row = *cursorRow();
- int x = bv()->x_target() - xo_;
- int y = cursorY() - row.baseline() - 1;
+ int x = cur.x_target();
+ int y = cursorY(cur.current()) - row.baseline() - 1;
setCursorFromCoordinates(x, y);
if (!selecting) {
- int y_abs = y + yo_ - bv()->top_y();
- InsetOld * inset_hit = checkInsetHit(bv()->x_target(), y_abs);
+ InsetBase * inset_hit = checkInsetHit(cur.x_target(), y);
if (inset_hit && isHighlyEditableInset(inset_hit))
- inset_hit->edit(bv(), bv()->x_target(), y_abs);
+ inset_hit->edit(cur, cur.x_target(), y);
}
}
void LyXText::cursorDown(bool selecting)
{
+ LCursor & cur = bv()->cursor();
Row const & row = *cursorRow();
- int x = bv()->x_target() - xo_;
- int y = cursorY() - row.baseline() + row.height() + 1;
+ int x = cur.x_target();
+ int y = cursorY(cur.current()) - row.baseline() + row.height() + 1;
setCursorFromCoordinates(x, y);
if (!selecting) {
- int y_abs = y + yo_ - bv()->top_y();
- InsetOld * inset_hit = checkInsetHit(bv()->x_target(), y_abs);
+ InsetBase * inset_hit = checkInsetHit(cur.x_target(), y);
if (inset_hit && isHighlyEditableInset(inset_hit))
- inset_hit->edit(bv(), bv()->x_target(), y_abs);
+ inset_hit->edit(cur, cur.x_target(), y);
}
}
// check also if we don't want to set the cursor on a spot behind the
// pagragraph because we erased the last character.
- if (cur.pos() > getPar(cur)->size())
- cur.pos(getPar(cur)->size());
+ if (cur.pos() > cur.lastpos())
+ cur.pos() = cur.lastpos();
}
bool LyXText::deleteEmptyParagraphMechanism(CursorSlice const & old_cursor)
{
+#warning Disabled as it crashes after the cursor data shift... (Andre)
+ return false;
+
// Would be wrong to delete anything if we have a selection.
- if (selection.set())
+ if (bv()->cursor().selection())
return false;
// Don't do anything if the cursor is invalid
if (old_cursor.par() == -1)
return false;
+#if 0
// We allow all kinds of "mumbo-jumbo" when freespacing.
ParagraphList::iterator const old_pit = getPar(old_cursor);
if (old_pit->isFreeSpacing())
if (selection_position_was_oldcursor_position) {
// correct selection
- anchor() = cursor();
+ bv()->resetAnchor();
}
}
if (old_pit->stripLeadingSpaces()) {
redoParagraph(old_pit);
- anchor() = cursor();
+ bv()->resetAnchor();
}
return false;
+#endif
}
void LyXText::recUndo(paroffset_type first, paroffset_type last) const
{
- recordUndo(Undo::ATOMIC, this, first, last);
+ recordUndo(bv()->cursor(), Undo::ATOMIC, first, last);
}
void LyXText::recUndo(lyx::paroffset_type par) const
{
- recordUndo(Undo::ATOMIC, this, par, par);
+ recordUndo(bv()->cursor(), Undo::ATOMIC, par, par);
}
}
+bool LyXText::toggleInset()
+{
+ InsetBase * inset = bv()->cursor().nextInset();
+ // is there an editable inset at cursor position?
+ if (!isEditableInset(inset))
+ return false;
+ //bv()->owner()->message(inset->editMessage());
+
+ // do we want to keep this?? (JMarc)
+ if (!isHighlyEditableInset(inset))
+ recUndo(cursor().par());
+
+ if (inset->isOpen())
+ inset->close();
+ else
+ inset->open();
+ return true;
+}
+
+
int defaultRowHeight()
{
return int(font_metrics::maxHeight(LyXFont(LyXFont::ALL_SANE)) * 1.2);
projects / lyx.git / blobdiff