#include "BufferView.h"
#include "Bullet.h"
#include "counters.h"
+#include "cursor.h"
#include "CutAndPaste.h"
#include "debug.h"
+#include "dispatchresult.h"
#include "errorlist.h"
#include "Floating.h"
#include "FloatList.h"
#include "funcrequest.h"
#include "gettext.h"
#include "language.h"
+#include "LColor.h"
#include "lyxrc.h"
#include "lyxrow.h"
#include "lyxrow_funcs.h"
#include "paragraph.h"
#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
+#include "PosIterator.h"
#include "undo.h"
#include "vspace.h"
using std::string;
-LyXText::LyXText(BufferView * bv, InsetText * inset, bool ininset,
- ParagraphList & paragraphs)
- : height(0), width(0), anchor_y_(0),
- inset_owner(inset), the_locking_inset(0), bv_owner(bv),
- in_inset_(ininset), paragraphs_(¶graphs)
-{
-}
+LyXText::LyXText(BufferView * bv, bool in_inset)
+ : height(0), width(0), textwidth_(bv ? bv->workWidth() : 100),
+ background_color_(LColor::background),
+ bv_owner(bv), in_inset_(in_inset), xo_(0), yo_(0)
+{}
-void LyXText::init(BufferView * bview)
+void LyXText::init(BufferView * bv)
{
- bv_owner = bview;
+ bv_owner = bv;
- ParagraphList::iterator const beg = ownerParagraphs().begin();
- ParagraphList::iterator const end = ownerParagraphs().end();
+ ParagraphList::iterator const beg = paragraphs().begin();
+ ParagraphList::iterator const end = paragraphs().end();
for (ParagraphList::iterator pit = beg; pit != end; ++pit)
pit->rows.clear();
width = 0;
height = 0;
- anchor_y_ = 0;
-
current_font = getFont(beg, 0);
redoParagraphs(beg, end);
- setCursorIntern(0, 0);
- selection.cursor = cursor;
+ bv->cursor().resetAnchor();
updateCounters();
}
LyXLayout_ptr const & layout = pit->layout();
#warning broken?
BufferParams const & params = bv()->buffer()->params();
- pos_type const body_pos = pit->beginningOfBody();
+ pos_type const body_pos = pit->beginOfBody();
// We specialize the 95% common case:
if (!pit->getDepth()) {
LyXFont f = pit->getFontSettings(params, pos);
- if (pit->inInset())
- pit->inInset()->getDrawFont(f);
+ if (in_inset_)
+ f.realize(font_);
if (layout->labeltype == LABEL_MANUAL && pos < body_pos)
return f.realize(layout->reslabelfont);
else
LyXFont font = pit->getFontSettings(params, pos);
font.realize(layoutfont);
- if (pit->inInset())
- pit->inInset()->getDrawFont(font);
+ if (in_inset_)
+ font.realize(font_);
// Realize with the fonts of lesser depth.
- //font.realize(outerFont(pit, ownerParagraphs()));
+ //font.realize(outerFont(pit, paragraphs()));
font.realize(defaultfont_);
return font;
LyXFont font = layout->font;
// Realize with the fonts of lesser depth.
- //font.realize(outerFont(pit, ownerParagraphs()));
+ //font.realize(outerFont(pit, paragraphs()));
font.realize(defaultfont_);
return font;
LyXFont font = layout->labelfont;
// Realize with the fonts of lesser depth.
- font.realize(outerFont(pit, ownerParagraphs()));
+ font.realize(outerFont(pit, paragraphs()));
font.realize(defaultfont_);
return font;
}
-void LyXText::setCharFont(ParagraphList::iterator pit,
- pos_type pos, LyXFont const & fnt,
- bool toggleall)
-{
- BufferParams const & params = bv()->buffer()->params();
- LyXFont font = getFont(pit, pos);
- font.update(fnt, params.language, toggleall);
- // Let the insets convert their font
- if (pit->isInset(pos)) {
- InsetOld * inset = pit->getInset(pos);
- if (isEditableInset(inset)) {
- static_cast<UpdatableInset *>(inset)
- ->setFont(bv(), fnt, toggleall, true);
- }
- }
-
- // Plug through to version below:
- setCharFont(pit, pos, font);
-}
-
-
void LyXText::setCharFont(
ParagraphList::iterator pit, pos_type pos, LyXFont const & fnt)
{
// Get concrete layout font to reduce against
LyXFont layoutfont;
- if (pos < pit->beginningOfBody())
+ if (pos < pit->beginOfBody())
layoutfont = layout->labelfont;
else
layoutfont = layout->font;
if (pit->getDepth()) {
ParagraphList::iterator tp = pit;
while (!layoutfont.resolved() &&
- tp != ownerParagraphs().end() &&
+ tp != paragraphs().end() &&
tp->getDepth()) {
- tp = outerHook(tp, ownerParagraphs());
- if (tp != ownerParagraphs().end())
+ tp = outerHook(tp, paragraphs());
+ if (tp != paragraphs().end())
layoutfont.realize(tp->layout()->font);
}
}
}
-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;
-}
-
-
-void LyXText::toggleInset()
-{
- InsetOld * inset = getInset();
- // is there an editable inset at cursor position?
- if (!isEditableInset(inset)) {
- // No, try to see if we are inside a collapsable inset
- if (inset_owner && inset_owner->owner()
- && inset_owner->owner()->isOpen()) {
- bv()->unlockInset(inset_owner->owner());
- inset_owner->owner()->close(bv());
- bv()->getLyXText()->cursorRight(bv());
- }
- return;
- }
- //bv()->owner()->message(inset->editMessage());
-
- // do we want to keep this?? (JMarc)
- if (!isHighlyEditableInset(inset))
- recUndo(cursor.par());
-
- if (inset->isOpen())
- inset->close(bv());
- else
- inset->open(bv());
-
- bv()->updateInset(inset);
-}
-
-
-/* used in setlayout */
+// used in setLayout
// Asger is not sure we want to do this...
void LyXText::makeFontEntriesLayoutSpecific(BufferParams const & params,
Paragraph & par)
LyXFont layoutfont;
for (pos_type pos = 0; pos < psize; ++pos) {
- if (pos < par.beginningOfBody())
+ if (pos < par.beginOfBody())
layoutfont = layout->labelfont;
else
layoutfont = layout->font;
}
-ParagraphList::iterator
-LyXText::setLayout(LyXCursor & cur, LyXCursor & sstart_cur,
- LyXCursor & send_cur,
- string const & layout)
+// return past-the-last paragraph influenced by a layout change on pit
+ParagraphList::iterator LyXText::undoSpan(ParagraphList::iterator pit)
{
- ParagraphList::iterator endpit = boost::next(getPar(send_cur));
- ParagraphList::iterator undoendpit = endpit;
- ParagraphList::iterator pars_end = ownerParagraphs().end();
-
- if (endpit != pars_end && endpit->getDepth()) {
- while (endpit != pars_end && endpit->getDepth()) {
- ++endpit;
- undoendpit = endpit;
- }
- } else if (endpit != pars_end) {
- // because of parindents etc.
- ++endpit;
+ ParagraphList::iterator end = paragraphs().end();
+ ParagraphList::iterator nextpit = boost::next(pit);
+ if (nextpit == end)
+ return nextpit;
+ //because of parindents
+ if (!pit->getDepth())
+ return boost::next(nextpit);
+ //because of depth constrains
+ for (; nextpit != end; ++pit, ++nextpit) {
+ if (!pit->getDepth())
+ break;
}
+ return nextpit;
+}
- recUndo(sstart_cur.par(), parOffset(undoendpit) - 1);
- // ok we have a selection. This is always between sstart_cur
- // and sel_end cursor
- cur = sstart_cur;
- ParagraphList::iterator pit = getPar(sstart_cur);
- ParagraphList::iterator epit = boost::next(getPar(send_cur));
+ParagraphList::iterator
+LyXText::setLayout(ParagraphList::iterator start,
+ ParagraphList::iterator end,
+ string const & layout)
+{
+ BOOST_ASSERT(start != end);
+ ParagraphList::iterator undopit = undoSpan(boost::prior(end));
+ recUndo(parOffset(start), parOffset(undopit) - 1);
BufferParams const & bufparams = bv()->buffer()->params();
LyXLayout_ptr const & lyxlayout =
bufparams.getLyXTextClass()[layout];
- do {
+ for (ParagraphList::iterator pit = start; pit != end; ++pit) {
pit->applyLayout(lyxlayout);
makeFontEntriesLayoutSpecific(bufparams, *pit);
- pit->params().spaceTop(lyxlayout->fill_top ?
- VSpace(VSpace::VFILL)
- : VSpace(VSpace::NONE));
- pit->params().spaceBottom(lyxlayout->fill_bottom ?
- VSpace(VSpace::VFILL)
- : VSpace(VSpace::NONE));
if (lyxlayout->margintype == MARGIN_MANUAL)
pit->setLabelWidthString(lyxlayout->labelstring());
- cur.par(std::distance(ownerParagraphs().begin(), pit));
- ++pit;
- } while (pit != epit);
+ }
- return endpit;
+ return undopit;
}
// set layout over selection and make a total rebreak of those paragraphs
void LyXText::setLayout(string const & layout)
{
- LyXCursor tmpcursor = cursor; // store the current cursor
-
- // if there is no selection just set the layout
- // of the current paragraph
- if (!selection.set()) {
- selection.start = cursor; // dummy selection
- selection.end = cursor;
- }
-
// special handling of new environment insets
BufferParams const & params = bv()->buffer()->params();
LyXLayout_ptr const & lyxlayout = params.getLyXTextClass()[layout];
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));
- }
- else
+ } else
delete inset;
return;
}
- ParagraphList::iterator endpit = setLayout(cursor, selection.start,
- selection.end, layout);
- redoParagraphs(getPar(selection.start), endpit);
+ 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);
- // we have to reset the selection, because the
- // geometry could have changed
- setCursor(selection.start.par(), selection.start.pos(), false);
- selection.cursor = cursor;
- setCursor(selection.end.par(), selection.end.pos(), false);
+ redoParagraphs(start, endpit);
updateCounters();
- clearSelection();
- setSelection();
- setCursor(tmpcursor.par(), tmpcursor.pos(), true);
}
-bool LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type, bool test_only)
-{
- ParagraphList::iterator pit = cursorPar();
- ParagraphList::iterator end = cursorPar();
- ParagraphList::iterator start = pit;
+namespace {
- if (selection.set()) {
- pit = getPar(selection.start);
- end = getPar(selection.end);
- start = pit;
- }
- ParagraphList::iterator pastend = boost::next(end);
+void getSelectionSpan(LyXText & text,
+ ParagraphList::iterator & beg,
+ ParagraphList::iterator & end)
+{
+ if (!text.bv()->cursor().selection()) {
+ beg = text.cursorPar();
+ end = boost::next(beg);
+ } else {
+ beg = text.getPar(text.bv()->cursor().selBegin());
+ end = boost::next(text.getPar(text.bv()->cursor().selEnd()));
+ }
+}
- if (!test_only)
- recUndo(parOffset(start), parOffset(end));
- bool changed = false;
+bool changeDepthAllowed(bv_funcs::DEPTH_CHANGE type,
+ Paragraph const & par,
+ int max_depth)
+{
+ if (par.layout()->labeltype == LABEL_BIBLIO)
+ return false;
+ int const depth = par.params().depth();
+ if (type == bv_funcs::INC_DEPTH && depth < max_depth)
+ return true;
+ if (type == bv_funcs::DEC_DEPTH && depth > 0)
+ return true;
+ return false;
+}
- int prev_after_depth = 0;
-#warning parlist ... could be nicer ?
- if (start != ownerParagraphs().begin()) {
- prev_after_depth = boost::prior(start)->getMaxDepthAfter();
- }
- while (true) {
- int const depth = pit->params().depth();
- if (type == bv_funcs::INC_DEPTH) {
- if (depth < prev_after_depth
- && pit->layout()->labeltype != LABEL_BIBLIO) {
- changed = true;
- if (!test_only)
- pit->params().depth(depth + 1);
- }
- } else if (depth) {
- changed = true;
- if (!test_only)
- pit->params().depth(depth - 1);
- }
+}
- prev_after_depth = pit->getMaxDepthAfter();
- if (pit == end) {
- break;
- }
+bool LyXText::changeDepthAllowed(bv_funcs::DEPTH_CHANGE type)
+{
+ ParagraphList::iterator beg, end;
+ getSelectionSpan(*this, beg, end);
+ int max_depth = 0;
+ if (beg != paragraphs().begin())
+ max_depth = boost::prior(beg)->getMaxDepthAfter();
- ++pit;
+ for (ParagraphList::iterator pit = beg; pit != end; ++pit) {
+ if (::changeDepthAllowed(type, *pit, max_depth))
+ return true;
+ max_depth = pit->getMaxDepthAfter();
}
+ return false;
+}
- if (test_only)
- return changed;
- redoParagraphs(start, pastend);
+void LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type)
+{
+ ParagraphList::iterator beg, end;
+ getSelectionSpan(*this, beg, end);
+
+ recUndo(parOffset(beg), parOffset(end) - 1);
- // We need to actually move the text->cursor. I don't
- // understand why ...
- LyXCursor tmpcursor = cursor;
+ int max_depth = 0;
+ if (beg != paragraphs().begin())
+ max_depth = boost::prior(beg)->getMaxDepthAfter();
- // we have to reset the visual selection because the
- // geometry could have changed
- if (selection.set()) {
- setCursor(selection.start.par(), selection.start.pos());
- selection.cursor = cursor;
- setCursor(selection.end.par(), selection.end.pos());
+ for (ParagraphList::iterator pit = beg; pit != end; ++pit) {
+ if (::changeDepthAllowed(type, *pit, max_depth)) {
+ int const depth = pit->params().depth();
+ if (type == bv_funcs::INC_DEPTH)
+ pit->params().depth(depth + 1);
+ else
+ pit->params().depth(depth - 1);
+ }
+ max_depth = pit->getMaxDepthAfter();
}
-
// this handles the counter labels, and also fixes up
// depth values for follow-on (child) paragraphs
updateCounters();
-
- setSelection();
- setCursor(tmpcursor.par(), tmpcursor.pos());
-
- return changed;
}
// 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()->beginningOfBody()) {
+ if (cursor().pos() < cursorPar()->beginOfBody())
layoutfont = getLabelFont(cursorPar());
- } else {
+ else
layoutfont = getLayoutFont(cursorPar());
- }
+
// Update current font
real_current_font.update(font,
bv()->buffer()->params().language,
return;
}
- LyXCursor tmpcursor = cursor; // store the current cursor
+ // ok we have a selection.
+ recUndo(cur.selBegin().par(), cur.selEnd().par());
+ freezeUndo();
- // ok we have a selection. This is always between sel_start_cursor
- // and sel_end cursor
+ ParagraphList::iterator beg = getPar(cur.selBegin().par());
+ ParagraphList::iterator end = getPar(cur.selEnd().par());
+
+ PosIterator pos(¶graphs(), beg, cur.selBegin().pos());
+ PosIterator posend(¶graphs(), end, cur.selEnd().pos());
- recUndo(selection.start.par(), selection.end.par());
- freezeUndo();
- cursor = selection.start;
- while (cursor.par() != selection.end.par() ||
- cursor.pos() < selection.end.pos())
- {
- if (cursor.pos() < cursorPar()->size()) {
- // an open footnote should behave like a closed one
- setCharFont(cursorPar(), cursor.pos(), font, toggleall);
- cursor.pos(cursor.pos() + 1);
- } else {
- cursor.pos(0);
- cursor.par(cursor.par() + 1);
- }
+ BufferParams const & params = bv()->buffer()->params();
+
+ for (; pos != posend; ++pos) {
+ LyXFont f = getFont(pos.pit(), pos.pos());
+ f.update(font, params.language, toggleall);
+ setCharFont(pos.pit(), pos.pos(), f);
}
+
unFreezeUndo();
- redoParagraph(getPar(selection.start));
-
- // we have to reset the selection, because the
- // geometry could have changed, but we keep
- // it for user convenience
- setCursor(selection.start.par(), selection.start.pos());
- selection.cursor = cursor;
- setCursor(selection.end.par(), selection.end.pos());
- setSelection();
- setCursor(tmpcursor.par(), tmpcursor.pos(), true,
- tmpcursor.boundary());
+ redoParagraphs(beg, ++end);
}
-// 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_owner!
- if (bv_owner && bv_owner->text)
- bv_owner->text->xsel_cache.set(false);
-}
-
+// realize you left an empty paragraph, they will delete it.
void LyXText::cursorHome()
{
- setCursor(cursorPar(), cursorRow()->pos());
+ ParagraphList::iterator cpit = cursorPar();
+ setCursor(cpit, cpit->getRow(cursor().pos())->pos());
}
void LyXText::cursorEnd()
{
- setCursor(cursorPar(), cursorRow()->end() - 1);
+ ParagraphList::iterator cpit = cursorPar();
+ pos_type end = cpit->getRow(cursor().pos())->endpos();
+ // if not on the last row of the par, put the cursor before
+ // the final space
+ setCursor(cpit, end == cpit->size() ? end : end - 1);
}
void LyXText::cursorTop()
{
- setCursor(ownerParagraphs().begin(), 0);
+ setCursor(paragraphs().begin(), 0);
}
void LyXText::cursorBottom()
{
ParagraphList::iterator lastpit =
- boost::prior(ownerParagraphs().end());
+ boost::prior(paragraphs().end());
setCursor(lastpit, lastpit->size());
}
// If the mask is completely neutral, tell user
if (font == LyXFont(LyXFont::ALL_IGNORE)) {
// Could only happen with user style
- bv()->owner()->message(_("No font change defined. Use Character under the Layout menu to define font change."));
+ bv()->owner()->message(_("No font change defined. "
+ "Use Character under the Layout menu to define font change."));
return;
}
// Try implicit word selection
// If there is a change in the language the implicit word selection
// is disabled.
- LyXCursor resetCursor = cursor;
- bool implicitSelection = (font.language() == ignore_language
- && font.number() == LyXFont::IGNORE)
- ? selectWordWhenUnderCursor(lyx::WHOLE_WORD_STRICT) : false;
+ CursorSlice resetCursor = cursor();
+ bool implicitSelection =
+ font.language() == ignore_language
+ && font.number() == LyXFont::IGNORE
+ && selectWordWhenUnderCursor(lyx::WHOLE_WORD_STRICT);
// Set font
setFont(font, toggleall);
// Implicit selections are cleared afterwards
//and cursor is set to the original position.
if (implicitSelection) {
- clearSelection();
- cursor = resetCursor;
- setCursor(cursorPar(), cursor.pos());
- selection.cursor = cursor;
+ bv()->cursor().clearSelection();
+ cursor() = resetCursor;
+ 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.
- LyXCursor const reset_cursor = cursor;
+ CursorSlice const reset_cursor = cursor();
bool const implicitSelection =
selectWordWhenUnderCursor(lyx::PREVIOUS_WORD);
string idxstring;
- if (!selection.set())
+ if (!cur.selection())
bv()->owner()->message(_("Nothing to index!"));
- else if (selection.start.par() != selection.end.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;
- setCursor(cursorPar(), cursor.pos());
- selection.cursor = cursor;
+ cursor() = reset_cursor;
+ cur.resetAnchor();
// Clear the implicit selection.
if (implicitSelection)
- clearSelection();
+ cur.clearSelection();
return idxstring;
}
-// the DTP switches for paragraphs. LyX will store them in the first
+// the DTP switches for paragraphs(). LyX will store them in the first
// physical paragraph. When a paragraph is broken, the top settings rest,
// the bottom settings are given to the new one. So I can make sure,
-// they do not duplicate themself and you cannnot make dirty things with
+// they do not duplicate themself and you cannot play dirty tricks with
// them!
-void LyXText::setParagraph(bool line_top, bool line_bottom,
- bool pagebreak_top, bool pagebreak_bottom,
- VSpace const & space_top,
- VSpace const & space_bottom,
- Spacing const & spacing,
- LyXAlignment align,
- string const & labelwidthstring,
- bool noindent)
-{
- LyXCursor tmpcursor = cursor;
- if (!selection.set()) {
- selection.start = cursor;
- selection.end = cursor;
- }
-
+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 endpit = boost::next(getPar(selection.end));
- ParagraphList::iterator undoendpit = endpit;
- ParagraphList::iterator pars_end = ownerParagraphs().end();
-
- if (endpit != pars_end && endpit->getDepth()) {
- while (endpit != pars_end && endpit->getDepth()) {
- ++endpit;
- undoendpit = endpit;
- }
- } else if (endpit != pars_end) {
- // because of parindents etc.
- ++endpit;
- }
-
- recUndo(selection.start.par(), parOffset(undoendpit) - 1);
+ ParagraphList::iterator undopit = undoSpan(getPar(cur.selEnd()));
+ recUndo(cur.selBegin().par(), parOffset(undopit) - 1);
+ ParagraphList::reverse_iterator pit(getPar(cur.selEnd().par()));
+ ParagraphList::reverse_iterator beg(getPar(cur.selBegin().par()));
- int tmppit = selection.end.par();
-
- while (tmppit != selection.start.par() - 1) {
- setCursor(tmppit, 0);
-
- ParagraphList::iterator const pit = cursorPar();
+ for (--pit; pit != beg; ++pit) {
ParagraphParameters & params = pit->params();
-
- params.lineTop(line_top);
- params.lineBottom(line_bottom);
- params.pagebreakTop(pagebreak_top);
- params.pagebreakBottom(pagebreak_bottom);
- params.spaceTop(space_top);
- params.spaceBottom(space_bottom);
params.spacing(spacing);
+
// does the layout allow the new alignment?
LyXLayout_ptr const & layout = pit->layout();
}
pit->setLabelWidthString(labelwidthstring);
params.noindent(noindent);
- --tmppit;
}
- redoParagraphs(getPar(selection.start), endpit);
-
- clearSelection();
- setCursor(selection.start.par(), selection.start.pos());
- selection.cursor = cursor;
- setCursor(selection.end.par(), selection.end.pos());
- setSelection();
- setCursor(tmpcursor.par(), tmpcursor.pos());
- if (inset_owner)
- bv()->updateInset(inset_owner);
+ redoParagraphs(getPar(cur.selBegin()), undopit);
}
-namespace {
-
string expandLabel(LyXTextClass const & textclass,
LyXLayout_ptr const & layout, bool appendix)
{
}
+namespace {
+
void incrementItemDepth(ParagraphList::iterator pit,
ParagraphList::iterator first_pit)
{
int const cur_labeltype = pit->layout()->labeltype;
- if (cur_labeltype != LABEL_ENUMERATE &&
- cur_labeltype != LABEL_ITEMIZE)
+ if (cur_labeltype != LABEL_ENUMERATE && cur_labeltype != LABEL_ITEMIZE)
return;
int const cur_depth = pit->getDepth();
BufferParams const & bufparams = buf.params();
LyXTextClass const & textclass = bufparams.getLyXTextClass();
LyXLayout_ptr const & layout = pit->layout();
- ParagraphList::iterator first_pit = ownerParagraphs().begin();
+ ParagraphList::iterator first_pit = paragraphs().begin();
Counters & counters = textclass.counters();
// Always reset
// the caption hack:
if (layout->labeltype == LABEL_SENSITIVE) {
- ParagraphList::iterator end = ownerParagraphs().end();
+ 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);
}
-// Updates all counters. Paragraphs with changed label string will be rebroken
+// Updates all counters.
void LyXText::updateCounters()
{
// start over
bv()->buffer()->params().getLyXTextClass().counters().reset();
- ParagraphList::iterator beg = ownerParagraphs().begin();
- ParagraphList::iterator end = ownerParagraphs().end();
+ bool update_pos = false;
+
+ ParagraphList::iterator beg = paragraphs().begin();
+ ParagraphList::iterator end = paragraphs().end();
for (ParagraphList::iterator pit = beg; pit != end; ++pit) {
string const oldLabel = pit->params().labelString();
-
size_t maxdepth = 0;
if (pit != beg)
maxdepth = boost::prior(pit)->getMaxDepthAfter();
// setCounter can potentially change the labelString.
setCounter(*bv()->buffer(), pit);
-
string const & newLabel = pit->params().labelString();
-
- if (oldLabel != newLabel)
- redoParagraph(pit);
+ if (oldLabel != newLabel) {
+ redoParagraphInternal(pit);
+ update_pos = true;
+ }
+
}
+ if (update_pos)
+ updateParPositions();
}
-void LyXText::insertInset(InsetOld * inset)
+void LyXText::insertInset(InsetBase * inset)
{
if (!cursorPar()->insetAllowed(inset->lyxCode()))
return;
- recUndo(cursor.par());
+
+ recUndo(cursor().par());
freezeUndo();
- cursorPar()->insertInset(cursor.pos(), inset);
+ cursorPar()->insertInset(cursor().pos(), inset);
// Just to rebreak and refresh correctly.
// The character will not be inserted a second time
insertChar(Paragraph::META_INSET);
// If we enter a highly editable inset the cursor should be before
- // the inset. After an Undo LyX tries to call inset->edit(...)
+ // the inset. After an undo LyX tries to call inset->edit(...)
// and fails if the cursor is behind the inset and getInset
// does not return the inset!
if (isHighlyEditableInset(inset))
cursorLeft(true);
+
unFreezeUndo();
}
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 selection.start
- // and selection.end
+ // 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 endpit = boost::next(getPar(selection.end.par()));
- ParagraphList::iterator undoendpit = endpit;
- ParagraphList::iterator pars_end = ownerParagraphs().end();
+ ParagraphList::iterator begpit = getPar(cur.selBegin().par());
+ ParagraphList::iterator endpit = getPar(cur.selEnd().par());
+ ParagraphList::iterator undopit = undoSpan(endpit);
+ recUndo(cur.selBegin().par(), parOffset(undopit) - 1);
- if (endpit != pars_end && endpit->getDepth()) {
- while (endpit != pars_end && endpit->getDepth()) {
- ++endpit;
- undoendpit = endpit;
- }
- } else if (endpit != pars_end) {
- // because of parindents etc.
- ++endpit;
- }
-
- recUndo(selection.start.par(), parOffset(undoendpit) - 1);
-
- endpit = getPar(selection.end.par());
- int endpos = selection.end.pos();
+ int endpos = cur.selEnd().pos();
BufferParams const & bufparams = bv()->buffer()->params();
boost::tie(endpit, endpos) = realcut ?
CutAndPaste::cutSelection(bufparams,
- ownerParagraphs(),
- getPar(selection.start.par()), endpit,
- selection.start.pos(), endpos,
+ paragraphs(),
+ begpit , endpit,
+ cur.selBegin().pos(), endpos,
bufparams.textclass,
doclear)
: CutAndPaste::eraseSelection(bufparams,
- ownerParagraphs(),
- getPar(selection.start.par()), endpit,
- selection.start.pos(), endpos,
+ paragraphs(),
+ begpit, endpit,
+ cur.selBegin().pos(), endpos,
doclear);
// sometimes necessary
if (doclear)
- getPar(selection.start.par())->stripLeadingSpaces();
+ begpit->stripLeadingSpaces();
- redoParagraphs(getPar(selection.start.par()), boost::next(endpit));
+ redoParagraphs(begpit, undopit);
// cutSelection can invalidate the cursor so we need to set
// it anew. (Lgb)
// we prefer the end for when tracking changes
- cursor.pos(endpos);
- cursor.par(parOffset(endpit));
+ cursor().pos(endpos);
+ cursor().par(parOffset(endpit));
// need a valid cursor. (Lgb)
- clearSelection();
-
- setCursor(cursorPar(), cursor.pos());
- selection.cursor = cursor;
+ 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 selection.start
+ // 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(selection.start)->size() > selection.start.pos()
- && getPar(selection.start)->isLineSeparator(selection.start.pos())
- && (selection.start.par() != selection.end.par()
- || selection.start.pos() < selection.end.pos()))
- selection.start.pos(selection.start.pos() + 1);
-
- CutAndPaste::copySelection(getPar(selection.start.par()),
- getPar(selection.end.par()),
- selection.start.pos(), selection.end.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;
- recUndo(cursor.par());
+ recUndo(cursor().par());
ParagraphList::iterator endpit;
PitPosPair ppp;
boost::tie(ppp, endpit) =
CutAndPaste::pasteSelection(*bv()->buffer(),
- ownerParagraphs(),
- cursorPar(), cursor.pos(),
+ paragraphs(),
+ cursorPar(), cursor().pos(),
bv()->buffer()->params().textclass,
sel_index, el);
bufferErrors(*bv()->buffer(), el);
redoParagraphs(cursorPar(), endpit);
- setCursor(cursor.par(), cursor.pos());
- clearSelection();
-
- selection.cursor = cursor;
+ cur.clearSelection();
+ cur.resetAnchor();
setCursor(ppp.first, ppp.second);
- setSelection();
+ cur.setSelection();
updateCounters();
}
if (!length)
return;
- selection.cursor = cursor;
+ LCursor & cur = bv()->cursor();
+ cur.resetAnchor();
while (length--)
- cursorRight(bv());
- setSelection();
+ cursorRight(true);
+ 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();
- if (!selection.set()) { // create a dummy selection
- selection.end = cursor;
- selection.start = cursor;
- }
-
// Get font setting before we cut
- pos_type pos = selection.end.pos();
- LyXFont const font = getPar(selection.start)
+ pos_type pos = cur.selEnd().pos();
+ LyXFont const font = getPar(cur.selBegin())
->getFontSettings(bv()->buffer()->params(),
- selection.start.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(selection.end)->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();
+ 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);
- setCursor(cursorPar(), cursor.pos());
- selection.cursor = cursor;
+ cur.resetAnchor();
setCursor(pit, pos);
- setSelection();
+ cur.setSelection();
}
-// turns double-CR to single CR, others where converted into one
-// blank. Then InsertStringAsLines is called
+// turn double CR to single CR, others are converted into one
+// blank. Then insertStringAsLines is called
void LyXText::insertStringAsParagraphs(string const & str)
{
string linestr(str);
if (linestr[i] == '\n') {
if (newline_inserted) {
// we know that \r will be ignored by
- // InsertStringA. Of course, it is a dirty
+ // insertStringAsLines. Of course, it is a dirty
// trick, but it works...
linestr[i - 1] = '\r';
linestr[i] = '\n';
}
-bool LyXText::setCursor(paroffset_type par, pos_type pos, bool setfont, bool boundary)
+bool LyXText::setCursor(paroffset_type par, pos_type pos, bool setfont,
+ bool boundary)
{
- LyXCursor old_cursor = cursor;
+ CursorSlice old_cursor = cursor();
setCursorIntern(par, pos, setfont, boundary);
return deleteEmptyParagraphMechanism(old_cursor);
}
-void LyXText::redoCursor()
-{
-#warning maybe the same for selections?
- setCursor(cursor, cursor.par(), cursor.pos(), cursor.boundary());
-}
-
-
-void LyXText::setCursor(LyXCursor & cur, paroffset_type par,
+void LyXText::setCursor(CursorSlice & cur, paroffset_type par,
pos_type pos, bool boundary)
{
- BOOST_ASSERT(par != int(ownerParagraphs().size()));
+ BOOST_ASSERT(par != int(paragraphs().size()));
cur.par(par);
cur.pos(pos);
cur.boundary(boundary);
// no rows, no fun...
- if (ownerParagraphs().begin()->rows.empty())
+ if (paragraphs().begin()->rows.empty())
return;
- // get the cursor y position in text
-
- ParagraphList::iterator pit = getPar(par);
- Row const & row = *getRow(*pit, pos);
- int y = pit->y + row.y_offset();
-
- // y is now the beginning of the cursor row
- y += row.baseline();
- // y is now the cursor baseline
- cur.y(y);
-
- pos_type last = lastPos(*pit, row);
+ // 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
- if (pos > pit->size()) {
- lyxerr << "dont like 1, pos: " << pos << " size: " << pit->size() << endl;
+ if (pos < 0) {
+ lyxerr << "dont like -1" << endl;
+ pos = 0;
+ cur.pos(0);
+ BOOST_ASSERT(false);
+ } else if (pos > para.size()) {
+ lyxerr << "dont like 1, pos: " << pos
+ << " size: " << para.size()
+ << " row.pos():" << row.pos()
+ << " paroffset: " << par << endl;
pos = 0;
cur.pos(0);
- } else if (pos > last + 1) {
+ BOOST_ASSERT(false);
+ } else if (pos > end) {
lyxerr << "dont like 2 please report" << endl;
// This shouldn't happen.
- pos = last + 1;
+ pos = end;
cur.pos(pos);
+ BOOST_ASSERT(false);
} else if (pos < row.pos()) {
- lyxerr << "dont like 3 please report" << endl;
+ lyxerr << "dont like 3 please report pos:" << pos
+ << " size: " << para.size()
+ << " row.pos():" << row.pos()
+ << " paroffset: " << par << endl;
pos = row.pos();
cur.pos(pos);
+ BOOST_ASSERT(false);
}
-
- // now get the cursors x position
- float x = getCursorX(pit, row, pos, last, boundary);
- cur.x(int(x));
- cur.x_fix(cur.x());
-}
-
-
-float LyXText::getCursorX(ParagraphList::iterator pit, Row const & row,
- pos_type pos, pos_type last, bool boundary) const
-{
- pos_type cursor_vpos = 0;
- double x = row.x();
- double fill_separator = row.fill_separator();
- double fill_hfill = row.fill_hfill();
- double fill_label_hfill = row.fill_label_hfill();
- pos_type const row_pos = row.pos();
-
- if (last < row_pos)
- cursor_vpos = row_pos;
- else if (pos > last && !boundary)
- cursor_vpos = (pit->isRightToLeftPar(bv()->buffer()->params()))
- ? row_pos : last + 1;
- else if (pos > row_pos && (pos > last || boundary))
- // Place cursor after char at (logical) position pos - 1
- cursor_vpos = (bidi_level(pos - 1) % 2 == 0)
- ? log2vis(pos - 1) + 1 : log2vis(pos - 1);
- else
- // Place cursor before char at (logical) position pos
- cursor_vpos = (bidi_level(pos) % 2 == 0)
- ? log2vis(pos) : log2vis(pos) + 1;
-
- pos_type body_pos = pit->beginningOfBody();
- if (body_pos > 0 &&
- (body_pos - 1 > last || !pit->isLineSeparator(body_pos - 1)))
- body_pos = 0;
-
- for (pos_type vpos = row_pos; vpos < cursor_vpos; ++vpos) {
- pos_type pos = vis2log(vpos);
- if (body_pos > 0 && pos == body_pos - 1) {
- x += fill_label_hfill +
- font_metrics::width(
- pit->layout()->labelsep, getLabelFont(pit));
- if (pit->isLineSeparator(body_pos - 1))
- x -= singleWidth(pit, body_pos - 1);
- }
-
- if (hfillExpansion(*pit, row, pos)) {
- x += singleWidth(pit, pos);
- if (pos >= body_pos)
- x += fill_hfill;
- else
- x += fill_label_hfill;
- } else if (pit->isSeparator(pos)) {
- x += singleWidth(pit, pos);
- if (pos >= body_pos)
- x += fill_separator;
- } else
- x += singleWidth(pit, pos);
- }
- return x;
}
void LyXText::setCursorIntern(paroffset_type par,
pos_type pos, bool setfont, bool boundary)
{
- setCursor(cursor, par, pos, boundary);
+ setCursor(cursor(), par, pos, boundary);
+ 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)
+ if (cursor().boundary() && pos > 0)
--pos;
if (pos > 0) {
--pos;
else // potentional bug... BUG (Lgb)
if (pit->isSeparator(pos)) {
- if (pos > cursorRow()->pos() &&
- bidi_level(pos) % 2 ==
- bidi_level(pos - 1) % 2)
+ if (pos > pit->getRow(pos)->pos() &&
+ bidi.level(pos) % 2 ==
+ bidi.level(pos - 1) % 2)
--pos;
else if (pos + 1 < pit->size())
++pos;
current_font = pit->getFontSettings(bufparams, pos);
real_current_font = getFont(pit, pos);
- if (cursor.pos() == pit->size() &&
- isBoundary(*bv()->buffer(), *pit, cursor.pos()) &&
- !cursor.boundary()) {
+ if (cursor().pos() == pit->size() &&
+ bidi.isBoundary(*bv()->buffer(), *pit, cursor().pos()) &&
+ !cursor().boundary()) {
Language const * lang =
pit->getParLanguage(bufparams);
current_font.setLanguage(lang);
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();
double fill_label_hfill = row.fill_label_hfill();
pos_type vc = row.pos();
- pos_type last = lastPos(*pit, row);
+ pos_type end = row.endpos();
pos_type c = 0;
LyXLayout_ptr const & layout = pit->layout();
bool left_side = false;
- pos_type body_pos = pit->beginningOfBody();
+ pos_type body_pos = pit->beginOfBody();
double last_tmpx = tmpx;
if (body_pos > 0 &&
- (body_pos - 1 > last ||
- !pit->isLineSeparator(body_pos - 1)))
+ (body_pos > end || !pit->isLineSeparator(body_pos - 1)))
body_pos = 0;
// check for empty row
- if (!pit->size()) {
- x = int(tmpx);
+ if (vc == end) {
+ x = int(tmpx) + xo_;
return 0;
}
- while (vc <= last && tmpx <= x) {
- c = vis2log(vc);
+ while (vc < end && tmpx <= x) {
+ c = bidi.vis2log(vc);
last_tmpx = tmpx;
if (body_pos > 0 && c == body_pos - 1) {
tmpx += fill_label_hfill +
left_side = true;
}
- if (vc > last + 1) // This shouldn't happen.
- vc = last + 1;
+ BOOST_ASSERT(vc <= end); // This shouldn't happen.
boundary = false;
// This (rtl_support test) is not needed, but gives
// some speedup if rtl_support == false
- bool const lastrow = lyxrc.rtl_support && row.end() == pit->size();
+ bool const lastrow = lyxrc.rtl_support && row.endpos() == pit->size();
// 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 &&
((rtl && left_side && vc == row.pos() && x < tmpx - 5) ||
- (!rtl && !left_side && vc == last + 1 && x > tmpx + 5)))
- c = last + 1;
+ (!rtl && !left_side && vc == end && x > tmpx + 5)))
+ c = end;
else if (vc == row.pos()) {
- c = vis2log(vc);
- if (bidi_level(c) % 2 == 1)
+ c = bidi.vis2log(vc);
+ if (bidi.level(c) % 2 == 1)
++c;
} else {
- c = vis2log(vc - 1);
- bool const rtl = (bidi_level(c) % 2 == 1);
+ c = bidi.vis2log(vc - 1);
+ bool const rtl = (bidi.level(c) % 2 == 1);
if (left_side == rtl) {
++c;
- boundary = isBoundary(*bv()->buffer(), *pit, c);
+ boundary = bidi.isBoundary(*bv()->buffer(), *pit, c);
}
}
- if (row.pos() <= last && c > last && pit->isNewline(last)) {
- if (bidi_level(last) % 2 == 0)
- tmpx -= singleWidth(pit, last);
+ if (row.pos() < end && c >= end && pit->isNewline(end - 1)) {
+ if (bidi.level(end -1) % 2 == 0)
+ tmpx -= singleWidth(pit, end - 1);
else
- tmpx += singleWidth(pit, last);
- c = last;
+ tmpx += singleWidth(pit, end - 1);
+ c = end - 1;
}
- c -= row.pos();
- x = int(tmpx);
- return c;
+ x = int(tmpx) + xo_;
+ return c - row.pos();
}
void LyXText::setCursorFromCoordinates(int x, int y)
{
- LyXCursor old_cursor = cursor;
- setCursorFromCoordinates(cursor, x, y);
+ CursorSlice old_cursor = cursor();
+ setCursorFromCoordinates(cursor(), x, y);
setCurrentFont();
deleteEmptyParagraphMechanism(old_cursor);
}
-void LyXText::setCursorFromCoordinates(LyXCursor & cur, int x, int y)
+// x,y are coordinates relative to this LyXText
+void LyXText::setCursorFromCoordinates(CursorSlice & cur, int x, int y)
{
- // Get the row first.
ParagraphList::iterator pit;
Row const & row = *getRowNearY(y, pit);
- y = pit->y + row.y_offset();
+ bool bound = false;
+ 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 column = getColumnNearX(pit, row, x, bound);
- cur.par(parOffset(pit));
- cur.pos(row.pos() + column);
- cur.x(x);
- cur.y(y + row.baseline());
+ 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);
+ }
+}
+
+
+bool LyXText::checkAndActivateInset(bool front)
+{
+ if (cursor().pos() == cursorPar()->size())
+ return false;
+ InsetBase * inset = cursorPar()->getInset(cursor().pos());
+ if (!isHighlyEditableInset(inset))
+ return false;
+ inset->edit(bv()->cursor(), front);
+ return true;
+}
+
+
+DispatchResult LyXText::moveRight()
+{
+ if (cursorPar()->isRightToLeftPar(bv()->buffer()->params()))
+ return moveLeftIntern(false, true, false);
+ else
+ return moveRightIntern(true, true, false);
+}
+
+
+DispatchResult LyXText::moveLeft()
+{
+ if (cursorPar()->isRightToLeftPar(bv()->buffer()->params()))
+ return moveRightIntern(true, true, false);
+ else
+ return moveLeftIntern(false, true, false);
+}
+
- cur.boundary(bound);
+DispatchResult LyXText::moveRightIntern(bool front, bool activate_inset, bool selecting)
+{
+ ParagraphList::iterator c_par = cursorPar();
+ if (boost::next(c_par) == paragraphs().end()
+ && cursor().pos() >= c_par->size())
+ return DispatchResult(false, FINISHED_RIGHT);
+ if (activate_inset && checkAndActivateInset(front))
+ return DispatchResult(true, true);
+ cursorRight(true);
+ if (!selecting)
+ bv()->cursor().clearSelection();
+ return DispatchResult(true);
}
-void LyXText::cursorLeft(bool internal)
+DispatchResult LyXText::moveLeftIntern(bool front,
+ bool activate_inset, bool selecting)
{
- if (cursor.pos() > 0) {
- bool boundary = cursor.boundary();
- setCursor(cursor.par(), cursor.pos() - 1, true, false);
+ if (cursor().par() == 0 && cursor().pos() <= 0)
+ return DispatchResult(false, FINISHED);
+ cursorLeft(true);
+ if (!selecting)
+ bv()->cursor().clearSelection();
+ if (activate_inset && checkAndActivateInset(front))
+ return DispatchResult(true, true);
+ return DispatchResult(true);
+}
+
+
+DispatchResult LyXText::moveUp()
+{
+ LCursor & cur = bv()->cursor();
+ if (cur.par() == 0 && cursorRow() == firstRow())
+ return DispatchResult(false, FINISHED_UP);
+ cursorUp(false);
+ cur.clearSelection();
+ return DispatchResult(true);
+}
+
+
+DispatchResult LyXText::moveDown()
+{
+ LCursor & cur = bv()->cursor();
+ if (cur.par() == cur.lastpar() && cursorRow() == lastRow())
+ return DispatchResult(false, FINISHED_DOWN);
+ cursorDown(false);
+ cur.clearSelection();
+ return DispatchResult(true);
+}
+
+
+bool LyXText::cursorLeft(bool internal)
+{
+ LCursor & cur = bv()->cursor();
+ if (cur.pos() > 0) {
+ bool boundary = cur.boundary();
+ setCursor(cur.par(), cur.pos() - 1, true, false);
if (!internal && !boundary &&
- isBoundary(*bv()->buffer(), *cursorPar(), cursor.pos() + 1))
- setCursor(cursor.par(), cursor.pos() + 1, true, true);
- } else if (cursor.par() != 0) {
+ bidi.isBoundary(*bv()->buffer(), cur.paragraph(), cur.pos() + 1))
+ setCursor(cur.par(), cur.pos() + 1, true, true);
+ return true;
+ }
+
+ 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;
}
+
+ return false;
}
-void LyXText::cursorRight(bool internal)
+bool LyXText::cursorRight(bool internal)
{
- bool const at_end = (cursor.pos() == cursorPar()->size());
- bool const at_newline = !at_end &&
- cursorPar()->isNewline(cursor.pos());
+ LCursor & cur = bv()->cursor();
+ if (!internal && cur.boundary()) {
+ setCursor(cur.par(), cur.pos(), true, false);
+ return 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 (!internal && cursor.boundary() && !at_newline)
- setCursor(cursor.par(), cursor.pos(), true, false);
- else if (!at_end) {
- setCursor(cursor.par(), cursor.pos() + 1, true, false);
- if (!internal &&
- isBoundary(*bv()->buffer(), *cursorPar(), cursor.pos()))
- setCursor(cursor.par(), cursor.pos(), true, true);
- } else if (cursor.par() + 1 != int(ownerParagraphs().size()))
- setCursor(cursor.par() + 1, 0);
+ if (cur.par() + 1 != int(paragraphs().size())) {
+ setCursor(cur.par() + 1, 0);
+ return true;
+ }
+
+ return false;
}
void LyXText::cursorUp(bool selecting)
{
-#if 1
- int x = cursor.x_fix();
- int y = cursor.y() - cursorRow()->baseline() - 1;
+ LCursor & cur = bv()->cursor();
+ Row const & row = *cursorRow();
+ int x = cur.x_target();
+ int y = cursorY(cur.current()) - row.baseline() - 1;
setCursorFromCoordinates(x, y);
+
if (!selecting) {
- int topy = bv_owner->top_y();
- int y1 = cursor.y() - topy;
- int y2 = y1;
- y -= topy;
- InsetOld * inset_hit = checkInsetHit(x, y1);
- if (inset_hit && isHighlyEditableInset(inset_hit)) {
- inset_hit->dispatch(
- FuncRequest(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none));
- }
+ InsetBase * inset_hit = checkInsetHit(cur.x_target(), y);
+ if (inset_hit && isHighlyEditableInset(inset_hit))
+ inset_hit->edit(cur, cur.x_target(), y);
}
-#else
- lyxerr << "cursorUp: y " << cursor.y() << " bl: " <<
- cursorRow()->baseline() << endl;
- setCursorFromCoordinates(cursor.x_fix(),
- cursor.y() - cursorRow()->baseline() - 1);
-#endif
}
void LyXText::cursorDown(bool selecting)
{
-#if 1
- int x = cursor.x_fix();
- int y = cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1;
+ LCursor & cur = bv()->cursor();
+ Row const & row = *cursorRow();
+ int x = cur.x_target();
+ int y = cursorY(cur.current()) - row.baseline() + row.height() + 1;
setCursorFromCoordinates(x, y);
+
if (!selecting) {
- int topy = bv_owner->top_y();
- int y1 = cursor.y() - topy;
- int y2 = y1;
- y -= topy;
- InsetOld * inset_hit = checkInsetHit(x, y1);
- if (inset_hit && isHighlyEditableInset(inset_hit)) {
- FuncRequest cmd(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none);
- inset_hit->dispatch(cmd);
- }
+ InsetBase * inset_hit = checkInsetHit(cur.x_target(), y);
+ if (inset_hit && isHighlyEditableInset(inset_hit))
+ inset_hit->edit(cur, cur.x_target(), y);
}
-#else
- setCursorFromCoordinates(cursor.x_fix(),
- cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1);
-#endif
}
void LyXText::cursorUpParagraph()
{
- if (cursor.pos() > 0)
- setCursor(cursorPar(), 0);
- else if (cursorPar() != ownerParagraphs().begin())
- setCursor(boost::prior(cursorPar()), 0);
+ ParagraphList::iterator cpit = cursorPar();
+ if (cursor().pos() > 0)
+ setCursor(cpit, 0);
+ else if (cpit != paragraphs().begin())
+ setCursor(boost::prior(cpit), 0);
}
void LyXText::cursorDownParagraph()
{
- ParagraphList::iterator par = cursorPar();
- ParagraphList::iterator next_par = boost::next(par);
+ ParagraphList::iterator pit = cursorPar();
+ ParagraphList::iterator next_pit = boost::next(pit);
- if (next_par != ownerParagraphs().end())
- setCursor(next_par, 0);
+ if (next_pit != paragraphs().end())
+ setCursor(next_pit, 0);
else
- setCursor(par, par->size());
+ setCursor(pit, pit->size());
}
// fix the cursor `cur' after a characters has been deleted at `where'
// position. Called by deleteEmptyParagraphMechanism
-void LyXText::fixCursorAfterDelete(LyXCursor & cur, LyXCursor const & where)
+void LyXText::fixCursorAfterDelete(CursorSlice & cur, CursorSlice const & where)
{
// if cursor is not in the paragraph where the delete occured,
// do nothing
// 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());
-
- // recompute row et al. for this cursor
- setCursor(cur, cur.par(), cur.pos(), cur.boundary());
+ if (cur.pos() > cur.lastpos())
+ cur.pos() = cur.lastpos();
}
-bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
+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())
Copy and Paste to hopefully do some sensible things.
There are still some small problems that can lead to
double spaces stored in the document file or space at
- the beginning of paragraphs. This happens if you have
+ the beginning of paragraphs(). This happens if you have
the cursor between to spaces and then save. Or if you
cut and paste and the selection have a space at the
beginning and then save right after the paste. I am
// MISSING
// If the pos around the old_cursor were spaces, delete one of them.
- if (old_cursor.par() != cursor.par()
- || old_cursor.pos() != cursor.pos()) {
+ if (old_cursor.par() != cursor().par()
+ || old_cursor.pos() != cursor().pos()) {
// Only if the cursor has really moved
if (old_cursor.pos() > 0
#warning This will not work anymore when we have multiple views of the same buffer
// In this case, we will have to correct also the cursors held by
// other bufferviews. It will probably be easier to do that in a more
-// automated way in LyXCursor code. (JMarc 26/09/2001)
+// automated way in CursorSlice code. (JMarc 26/09/2001)
#endif
// correct all cursors held by the LyXText
- fixCursorAfterDelete(cursor, old_cursor);
- fixCursorAfterDelete(selection.cursor, old_cursor);
- fixCursorAfterDelete(selection.start, old_cursor);
- fixCursorAfterDelete(selection.end, old_cursor);
+ fixCursorAfterDelete(cursor(), old_cursor);
+ fixCursorAfterDelete(anchor(), old_cursor);
return false;
}
}
// don't delete anything if this is the ONLY paragraph!
- if (ownerParagraphs().size() == 1)
+ if (paragraphs().size() == 1)
return false;
// Do not delete empty paragraphs with keepempty set.
return false;
// only do our magic if we changed paragraph
- if (old_cursor.par() == cursor.par())
+ if (old_cursor.par() == cursor().par())
return false;
// record if we have deleted a paragraph
// we can't possibly have deleted a paragraph before this point
bool deleted = false;
- if (old_pit->empty() ||
- (old_pit->size() == 1 && old_pit->isLineSeparator(0))) {
+ if (old_pit->empty()
+ || (old_pit->size() == 1 && old_pit->isLineSeparator(0))) {
// ok, we will delete something
- LyXCursor tmpcursor;
+ CursorSlice tmpcursor;
deleted = true;
bool selection_position_was_oldcursor_position =
- selection.cursor.par() == old_cursor.par()
- && selection.cursor.pos() == old_cursor.pos();
+ anchor().par() == old_cursor.par()
+ && anchor().pos() == old_cursor.pos();
- tmpcursor = cursor;
- cursor = old_cursor; // that undo can restore the right cursor position
+ tmpcursor = cursor();
+ cursor() = old_cursor; // that undo can restore the right cursor position
ParagraphList::iterator endpit = boost::next(old_pit);
- while (endpit != ownerParagraphs().end() && endpit->getDepth())
+ while (endpit != paragraphs().end() && endpit->getDepth())
++endpit;
recUndo(parOffset(old_pit), parOffset(endpit) - 1);
- cursor = tmpcursor;
+ cursor() = tmpcursor;
+ // cache cursor pit
+ ParagraphList::iterator tmppit = cursorPar();
// delete old par
- ownerParagraphs().erase(old_pit);
+ paragraphs().erase(old_pit);
+ // update cursor par offset
+ cursor().par(parOffset(tmppit));
redoParagraph();
- // correct cursor y
- setCursorIntern(cursor.par(), cursor.pos());
-
if (selection_position_was_oldcursor_position) {
// correct selection
- selection.cursor = cursor;
+ bv()->resetAnchor();
}
}
- if (!deleted) {
- if (old_pit->stripLeadingSpaces()) {
- redoParagraph(old_pit);
- // correct cursor y
- setCursorIntern(cursor.par(), cursor.pos());
- selection.cursor = cursor;
- }
+
+ if (deleted)
+ return true;
+
+ if (old_pit->stripLeadingSpaces()) {
+ redoParagraph(old_pit);
+ bv()->resetAnchor();
}
- return deleted;
+ return false;
+#endif
}
-ParagraphList & LyXText::ownerParagraphs() const
+ParagraphList & LyXText::paragraphs() const
{
- return *paragraphs_;
+ return const_cast<ParagraphList &>(paragraphs_);
}
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::isInInset() const
{
- // Sub-level has non-null bv owner and non-null inset owner.
- return inset_owner != 0;
+ return in_inset_;
+}
+
+
+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()
{
- LyXFont const font(LyXFont::ALL_SANE);
- return int(font_metrics::maxAscent(font)
- + font_metrics::maxDescent(font) * 1.5);
+ return int(font_metrics::maxHeight(LyXFont(LyXFont::ALL_SANE)) * 1.2);
}
projects / lyx.git / blobdiff