#include <config.h>
#include "lyxtext.h"
-#include "support/std_sstream.h"
-#include "funcrequest.h"
-#include "frontends/LyXView.h"
-#include "undo_funcs.h"
+
#include "buffer.h"
#include "buffer_funcs.h"
-#include "gettext.h"
+#include "bufferparams.h"
#include "BufferView.h"
+#include "Bullet.h"
+#include "counters.h"
+#include "cursor.h"
#include "CutAndPaste.h"
-#include "frontends/font_metrics.h"
#include "debug.h"
-#include "lyxrc.h"
+#include "dispatchresult.h"
+#include "errorlist.h"
#include "Floating.h"
#include "FloatList.h"
+#include "funcrequest.h"
+#include "gettext.h"
#include "language.h"
-#include "ParagraphParameters.h"
-#include "counters.h"
+#include "LColor.h"
+#include "lyxrc.h"
#include "lyxrow.h"
#include "lyxrow_funcs.h"
-#include "metricsinfo.h"
+#include "paragraph.h"
#include "paragraph_funcs.h"
+#include "ParagraphParameters.h"
+#include "PosIterator.h"
+#include "undo.h"
+#include "vspace.h"
+
+#include "frontends/font_metrics.h"
+#include "frontends/LyXView.h"
#include "insets/insetbibitem.h"
#include "insets/insetenv.h"
#include "insets/insetfloat.h"
#include "insets/insetwrap.h"
-#include "support/LAssert.h"
-#include "support/textutils.h"
#include "support/lstrings.h"
+#include "support/textutils.h"
+#include "support/tostr.h"
+#include "support/std_sstream.h"
#include <boost/tuple/tuple.hpp>
+using lyx::pos_type;
+using lyx::paroffset_type;
+using lyx::support::bformat;
-using namespace lyx::support;
-
-using std::ostringstream;
-using std::vector;
-using std::copy;
using std::endl;
-using std::find;
-using std::pair;
-using lyx::pos_type;
+using std::ostringstream;
+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_(paragraphs)
-{
-}
+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(beg, 0);
- selection.cursor = cursor;
+ bv->cursor().resetAnchor();
updateCounters();
}
// smaller. (Asger)
LyXFont LyXText::getFont(ParagraphList::iterator pit, pos_type pos) const
{
- Assert(pos >= 0);
+ BOOST_ASSERT(pos >= 0);
LyXLayout_ptr const & layout = pit->layout();
#warning broken?
- BufferParams const & params = bv()->buffer()->params;
+ BufferParams const & params = bv()->buffer()->params();
+ pos_type const body_pos = pit->beginOfBody();
// We specialize the 95% common case:
if (!pit->getDepth()) {
- if (layout->labeltype == LABEL_MANUAL
- && pos < pit->beginningOfBody()) {
- // 1% goes here
- LyXFont f = pit->getFontSettings(params, pos);
- if (pit->inInset())
- pit->inInset()->getDrawFont(f);
+ LyXFont f = pit->getFontSettings(params, pos);
+ if (in_inset_)
+ f.realize(font_);
+ if (layout->labeltype == LABEL_MANUAL && pos < body_pos)
return f.realize(layout->reslabelfont);
- } else {
- LyXFont f = pit->getFontSettings(params, pos);
- if (pit->inInset())
- pit->inInset()->getDrawFont(f);
+ else
return f.realize(layout->resfont);
- }
}
// The uncommon case need not be optimized as much
-
LyXFont layoutfont;
-
- if (pos < pit->beginningOfBody()) {
- // 1% goes here
+ if (pos < body_pos)
layoutfont = layout->labelfont;
- } else {
- // 99% goes here
+ else
layoutfont = layout->font;
- }
- LyXFont tmpfont = pit->getFontSettings(params, pos);
- tmpfont.realize(layoutfont);
+ LyXFont font = pit->getFontSettings(params, pos);
+ font.realize(layoutfont);
- if (pit->inInset())
- pit->inInset()->getDrawFont(tmpfont);
+ if (in_inset_)
+ font.realize(font_);
// Realize with the fonts of lesser depth.
- tmpfont.realize(outerFont(pit, ownerParagraphs()));
- tmpfont.realize(defaultfont_);
+ //font.realize(outerFont(pit, paragraphs()));
+ font.realize(defaultfont_);
- return tmpfont;
+ 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 = cursor.par();
- 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))
- recordUndo(bv(), Undo::ATOMIC);
-
- 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(send_cur.par());
- 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;
+}
- recordUndo(bv(), Undo::ATOMIC, sstart_cur.par(), boost::prior(undoendpit));
- // ok we have a selection. This is always between sstart_cur
- // and sel_end cursor
- cur = sstart_cur;
- ParagraphList::iterator pit = sstart_cur.par();
- ParagraphList::iterator epit = boost::next(send_cur.par());
+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 =
- bv()->buffer()->params.getLyXTextClass()[layout];
+ bufparams.getLyXTextClass()[layout];
- do {
+ for (ParagraphList::iterator pit = start; pit != end; ++pit) {
pit->applyLayout(lyxlayout);
- makeFontEntriesLayoutSpecific(bv()->buffer()->params, *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));
+ makeFontEntriesLayoutSpecific(bufparams, *pit);
if (lyxlayout->margintype == MARGIN_MANUAL)
pit->setLabelWidthString(lyxlayout->labelstring());
- cur.par(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;
+ BufferParams const & params = bv()->buffer()->params();
LyXLayout_ptr const & lyxlayout = params.getLyXTextClass()[layout];
if (lyxlayout->is_environment) {
// move everything in a new environment inset
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(selection.start.par(), 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 = cursor.par();
- ParagraphList::iterator end = cursor.par();
- ParagraphList::iterator start = pit;
+namespace {
- if (selection.set()) {
- pit = selection.start.par();
- end = selection.end.par();
- 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)
- recordUndo(bv(), Undo::ATOMIC, start, 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() < cursor.par()->beginningOfBody()) {
- layoutfont = getLabelFont(cursor.par());
- } else {
- layoutfont = getLayoutFont(cursor.par());
- }
+ if (cursor().pos() < cursorPar()->beginOfBody())
+ layoutfont = getLabelFont(cursorPar());
+ else
+ layoutfont = getLayoutFont(cursorPar());
+
// Update current font
real_current_font.update(font,
- bv()->buffer()->params.language,
+ bv()->buffer()->params().language,
toggleall);
// Reduce to implicit settings
return;
}
- LyXCursor tmpcursor = cursor; // store the current cursor
-
- // ok we have a selection. This is always between sel_start_cursor
- // and sel_end cursor
-
- recordUndo(bv(), Undo::ATOMIC, selection.start.par(), selection.end.par());
+ // ok we have a selection.
+ recUndo(cur.selBegin().par(), cur.selEnd().par());
freezeUndo();
- cursor = selection.start;
- while (cursor.par() != selection.end.par() ||
- cursor.pos() < selection.end.pos())
- {
- if (cursor.pos() < cursor.par()->size()) {
- // an open footnote should behave like a closed one
- setCharFont(cursor.par(), cursor.pos(),
- font, toggleall);
- cursor.pos(cursor.pos() + 1);
- } else {
- cursor.pos(0);
- cursor.par(boost::next(cursor.par()));
- }
- }
- unFreezeUndo();
-
- redoParagraph(selection.start.par());
-
- // 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());
-}
-
-
-int LyXText::redoParagraphInternal(ParagraphList::iterator pit)
-{
- RowList::iterator rit = pit->rows.begin();
- RowList::iterator end = pit->rows.end();
-
- // remove rows of paragraph, keep track of height changes
- for (int i = 0; rit != end; ++rit, ++i)
- height -= rit->height();
- pit->rows.clear();
-
- // redo insets
- InsetList::iterator ii = pit->insetlist.begin();
- InsetList::iterator iend = pit->insetlist.end();
- for (; ii != iend; ++ii) {
- Dimension dim;
- MetricsInfo mi(bv(), getFont(pit, ii->pos), workWidth());
- ii->inset->metrics(mi, dim);
- }
-
- // rebreak the paragraph
- for (pos_type z = 0; z < pit->size() + 1; ) {
- Row row(z);
- z = rowBreakPoint(pit, row) + 1;
- row.end(z);
- pit->rows.push_back(row);
- }
- int par_width = 0;
- // set height and fill and width of rows
- int const ww = workWidth();
- for (rit = pit->rows.begin(); rit != end; ++rit) {
- int const f = fill(pit, rit, ww);
- int const w = ww - f;
- par_width = std::max(par_width, w);
- rit->fill(f);
- rit->width(w);
- prepareToPrint(pit, rit);
- setHeightOfRow(pit, rit);
- height += rit->height();
- }
-
- //lyxerr << "redoParagraph: " << pit->rows.size() << " rows\n";
- return par_width;
-}
+ 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());
+ BufferParams const & params = bv()->buffer()->params();
-int LyXText::redoParagraphs(ParagraphList::iterator start,
- ParagraphList::iterator end)
-{
- int pars_width = 0;
- for ( ; start != end; ++start) {
- int par_width = redoParagraphInternal(start);
- pars_width = std::max(par_width, pars_width);
+ for (; pos != posend; ++pos) {
+ LyXFont f = getFont(pos.pit(), pos.pos());
+ f.update(font, params.language, toggleall);
+ setCharFont(pos.pit(), pos.pos(), f);
}
- updateRowPositions();
- return pars_width;
-}
-
-
-void LyXText::redoParagraph(ParagraphList::iterator pit)
-{
- redoParagraphInternal(pit);
- updateRowPositions();
-}
-
-
-void LyXText::fullRebreak()
-{
- redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end());
- redoCursor();
- selection.cursor = cursor;
-}
-
-
-void LyXText::metrics(MetricsInfo & mi, Dimension & dim)
-{
- //lyxerr << "LyXText::metrics: width: " << mi.base.textwidth
- // << " workWidth: " << workWidth() << endl;
- //Assert(mi.base.textwidth);
-
- // rebuild row cache
- width = 0;
- ///height = 0;
-
- //anchor_y_ = 0;
- width = redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end());
+
+ unFreezeUndo();
- // final dimension
- dim.asc = firstRow()->ascent_of_text();
- dim.des = height - dim.asc;
- dim.wid = std::max(mi.base.textwidth, int(width));
+ 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.
-// They also delete the corresponding row
-
-// 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(cursor.par(), cursorRow()->pos());
+ ParagraphList::iterator cpit = cursorPar();
+ setCursor(cpit, cpit->getRow(cursor().pos())->pos());
}
void LyXText::cursorEnd()
{
- setCursor(cursor.par(), 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(cursor.par(), 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(cursor.par(), 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(selection.end.par());
- ParagraphList::iterator undoendpit = endpit;
- ParagraphList::iterator pars_end = ownerParagraphs().end();
+ ParagraphList::iterator undopit = undoSpan(getPar(cur.selEnd()));
+ 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;
- }
+ ParagraphList::reverse_iterator pit(getPar(cur.selEnd().par()));
+ ParagraphList::reverse_iterator beg(getPar(cur.selBegin().par()));
- recordUndo(bv(), Undo::ATOMIC, selection.start.par(),
- boost::prior(undoendpit));
-
-
- ParagraphList::iterator tmppit = selection.end.par();
-
- while (tmppit != boost::prior(selection.start.par())) {
- setCursor(tmppit, 0);
-
- ParagraphList::iterator pit = cursor.par();
+ 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 = boost::prior(pit);
}
- redoParagraphs(selection.start.par(), endpit);
+ redoParagraphs(getPar(cur.selBegin()), undopit);
+}
+
+
+string expandLabel(LyXTextClass const & textclass,
+ LyXLayout_ptr const & layout, bool appendix)
+{
+ string fmt = appendix ?
+ layout->labelstring_appendix() : layout->labelstring();
+
+ // handle 'inherited level parts' in 'fmt',
+ // i.e. the stuff between '@' in '@Section@.\arabic{subsection}'
+ size_t const i = fmt.find('@', 0);
+ if (i != string::npos) {
+ size_t const j = fmt.find('@', i + 1);
+ if (j != string::npos) {
+ string parent(fmt, i + 1, j - i - 1);
+ string label = expandLabel(textclass, textclass[parent], appendix);
+ fmt = string(fmt, 0, i) + label + string(fmt, j + 1, string::npos);
+ }
+ }
- 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);
+ return textclass.counters().counterLabel(fmt);
}
+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)
+ return;
+
+ int const cur_depth = pit->getDepth();
+
+ ParagraphList::iterator prev_pit = boost::prior(pit);
+ while (true) {
+ int const prev_depth = prev_pit->getDepth();
+ int const prev_labeltype = prev_pit->layout()->labeltype;
+ if (prev_depth == 0 && cur_depth > 0) {
+ if (prev_labeltype == cur_labeltype) {
+ pit->itemdepth = prev_pit->itemdepth + 1;
+ }
+ break;
+ } else if (prev_depth < cur_depth) {
+ if (prev_labeltype == cur_labeltype) {
+ pit->itemdepth = prev_pit->itemdepth + 1;
+ break;
+ }
+ } else if (prev_depth == cur_depth) {
+ if (prev_labeltype == cur_labeltype) {
+ pit->itemdepth = prev_pit->itemdepth;
+ break;
+ }
+ }
+ if (prev_pit == first_pit)
+ break;
+
+ --prev_pit;
+ }
+}
+
+
+void resetEnumCounterIfNeeded(ParagraphList::iterator pit,
+ ParagraphList::iterator firstpit,
+ Counters & counters)
+{
+ if (pit == firstpit)
+ return;
+
+ int const cur_depth = pit->getDepth();
+ ParagraphList::iterator prev_pit = boost::prior(pit);
+ while (true) {
+ int const prev_depth = prev_pit->getDepth();
+ int const prev_labeltype = prev_pit->layout()->labeltype;
+ if (prev_depth <= cur_depth) {
+ if (prev_labeltype != LABEL_ENUMERATE) {
+ switch (pit->itemdepth) {
+ case 0:
+ counters.reset("enumi");
+ case 1:
+ counters.reset("enumii");
+ case 2:
+ counters.reset("enumiii");
+ case 3:
+ counters.reset("enumiv");
+ }
+ }
+ break;
+ }
+
+ if (prev_pit == firstpit)
+ break;
+
+ --prev_pit;
+ }
+}
+
+} // anon namespace
+
+
// set the counter of a paragraph. This includes the labels
void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
{
- LyXTextClass const & textclass = buf.params.getLyXTextClass();
+ BufferParams const & bufparams = buf.params();
+ LyXTextClass const & textclass = bufparams.getLyXTextClass();
LyXLayout_ptr const & layout = pit->layout();
+ ParagraphList::iterator first_pit = paragraphs().begin();
+ Counters & counters = textclass.counters();
- if (pit != ownerParagraphs().begin()) {
+ // Always reset
+ pit->itemdepth = 0;
+ if (pit == first_pit) {
+ pit->params().appendix(pit->params().startOfAppendix());
+ } else {
pit->params().appendix(boost::prior(pit)->params().appendix());
if (!pit->params().appendix() &&
pit->params().startOfAppendix()) {
pit->params().appendix(true);
textclass.counters().reset();
}
- pit->enumdepth = boost::prior(pit)->enumdepth;
- pit->itemdepth = boost::prior(pit)->itemdepth;
- } else {
- pit->params().appendix(pit->params().startOfAppendix());
- pit->enumdepth = 0;
- pit->itemdepth = 0;
- }
-
- // Maybe we have to increment the enumeration depth.
- // BUT, enumeration in a footnote is considered in isolation from its
- // surrounding paragraph so don't increment if this is the
- // first line of the footnote
- // AND, bibliographies can't have their depth changed ie. they
- // are always of depth 0
- if (pit != ownerParagraphs().begin()
- && boost::prior(pit)->getDepth() < pit->getDepth()
- && boost::prior(pit)->layout()->labeltype == LABEL_COUNTER_ENUMI
- && pit->enumdepth < 3
- && layout->labeltype != LABEL_BIBLIO) {
- pit->enumdepth++;
- }
- // Maybe we have to decrement the enumeration depth, see note above
- if (pit != ownerParagraphs().begin()
- && boost::prior(pit)->getDepth() > pit->getDepth()
- && layout->labeltype != LABEL_BIBLIO) {
- pit->enumdepth = depthHook(pit, ownerParagraphs(),
- pit->getDepth())->enumdepth;
+ // Maybe we have to increment the item depth.
+ incrementItemDepth(pit, first_pit);
}
- if (!pit->params().labelString().empty()) {
- pit->params().labelString(string());
- }
+ // erase what was there before
+ pit->params().labelString(string());
if (layout->margintype == MARGIN_MANUAL) {
if (pit->params().labelWidthString().empty())
}
// is it a layout that has an automatic label?
- if (layout->labeltype >= LABEL_COUNTER_CHAPTER) {
- int const i = layout->labeltype - LABEL_COUNTER_CHAPTER;
-
- ostringstream s;
-
- if (i >= 0 && i <= buf.params.secnumdepth) {
- string numbertype;
- string langtype;
-
- textclass.counters().step(layout->latexname());
+ if (layout->labeltype == LABEL_COUNTER) {
+ BufferParams const & bufparams = buf.params();
+ LyXTextClass const & textclass = bufparams.getLyXTextClass();
+ counters.step(layout->counter);
+ string label = expandLabel(textclass, layout, pit->params().appendix());
+ pit->params().labelString(label);
+ } else if (layout->labeltype == LABEL_ITEMIZE) {
+ // At some point of time we should do something more
+ // clever here, like:
+ // pit->params().labelString(
+ // bufparams.user_defined_bullet(pit->itemdepth).getText());
+ // for now, use a simple hardcoded label
+ string itemlabel;
+ switch (pit->itemdepth) {
+ case 0:
+ itemlabel = "*";
+ break;
+ case 1:
+ itemlabel = "-";
+ break;
+ case 2:
+ itemlabel = "@";
+ break;
+ case 3:
+ itemlabel = "·";
+ break;
+ }
- // Is there a label? Useful for Chapter layout
- if (!pit->params().appendix()) {
- s << buf.B_(layout->labelstring());
- } else {
- s << buf.B_(layout->labelstring_appendix());
- }
+ pit->params().labelString(itemlabel);
+ } else if (layout->labeltype == LABEL_ENUMERATE) {
+ // Maybe we have to reset the enumeration counter.
+ resetEnumCounterIfNeeded(pit, first_pit, counters);
- // Use of an integer is here less than elegant. For now.
- int head = textclass.maxcounter() - LABEL_COUNTER_CHAPTER;
- if (!pit->params().appendix()) {
- numbertype = "sectioning";
- } else {
- numbertype = "appendix";
- if (pit->isRightToLeftPar(buf.params))
- langtype = "hebrew";
- else
- langtype = "latin";
- }
+ // FIXME
+ // Yes I know this is a really, really! bad solution
+ // (Lgb)
+ string enumcounter = "enum";
- s << " "
- << textclass.counters()
- .numberLabel(layout->latexname(),
- numbertype, langtype, head);
-
- pit->params().labelString(STRCONV(s.str()));
-
- // reset enum counters
- textclass.counters().reset("enum");
- } else if (layout->labeltype < LABEL_COUNTER_ENUMI) {
- textclass.counters().reset("enum");
- } else if (layout->labeltype == LABEL_COUNTER_ENUMI) {
- // FIXME
- // Yes I know this is a really, really! bad solution
- // (Lgb)
- string enumcounter("enum");
-
- switch (pit->enumdepth) {
- case 2:
- enumcounter += 'i';
- case 1:
- enumcounter += 'i';
- case 0:
- enumcounter += 'i';
- break;
- case 3:
- enumcounter += "iv";
- break;
- default:
- // not a valid enumdepth...
- break;
- }
+ switch (pit->itemdepth) {
+ case 2:
+ enumcounter += 'i';
+ case 1:
+ enumcounter += 'i';
+ case 0:
+ enumcounter += 'i';
+ break;
+ case 3:
+ enumcounter += "iv";
+ break;
+ default:
+ // not a valid enumdepth...
+ break;
+ }
- textclass.counters().step(enumcounter);
+ counters.step(enumcounter);
- s << textclass.counters()
- .numberLabel(enumcounter, "enumeration");
- pit->params().labelString(STRCONV(s.str()));
- }
+ pit->params().labelString(counters.enumLabel(enumcounter));
} else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
- textclass.counters().step("bibitem");
- int number = textclass.counters().value("bibitem");
+ counters.step("bibitem");
+ int number = counters.value("bibitem");
if (pit->bibitem()) {
pit->bibitem()->setCounter(number);
pit->params().labelString(layout->labelstring());
// 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 {
Paragraph const * owner = &ownerPar(buf, in);
- tmppit = ownerParagraphs().begin();
+ tmppit = first_pit;
for ( ; tmppit != end; ++tmppit)
if (&*tmppit == owner)
break;
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
- Assert(0);
+ BOOST_ASSERT(false);
Floating const & fl = textclass.floats().getType(type);
- textclass.counters().step(fl.type());
+ counters.step(fl.type());
// Doesn't work... yet.
s = bformat(_("%1$s #:"), buf.B_(fl.name()));
}
pit->params().labelString(s);
- // reset the enumeration counter. They are always reset
- // when there is any other layout between
- // Just fall-through between the cases so that all
- // enum counters deeper than enumdepth is also reset.
- switch (pit->enumdepth) {
- case 0:
- textclass.counters().reset("enumi");
- case 1:
- textclass.counters().reset("enumii");
- case 2:
- textclass.counters().reset("enumiii");
- case 3:
- textclass.counters().reset("enumiv");
- }
}
}
-// 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();
+ 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 (!cursor.par()->insetAllowed(inset->lyxCode()))
+ if (!cursorPar()->insetAllowed(inset->lyxCode()))
return;
- recordUndo(bv(), Undo::ATOMIC, cursor.par());
+
+ recUndo(cursor().par());
freezeUndo();
- cursor.par()->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(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;
- }
-
- recordUndo(bv(), Undo::DELETE, selection.start.par(),
- boost::prior(undoendpit));
-
- endpit = 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(bv()->buffer()->params,
- ownerParagraphs(),
- selection.start.par(), endpit,
- selection.start.pos(), endpos,
- bv()->buffer()->params.textclass,
+ CutAndPaste::cutSelection(bufparams,
+ paragraphs(),
+ begpit , endpit,
+ cur.selBegin().pos(), endpos,
+ bufparams.textclass,
doclear)
- : CutAndPaste::eraseSelection(bv()->buffer()->params,
- ownerParagraphs(),
- selection.start.par(), endpit,
- selection.start.pos(), endpos,
+ : CutAndPaste::eraseSelection(bufparams,
+ paragraphs(),
+ begpit, endpit,
+ cur.selBegin().pos(), endpos,
doclear);
// sometimes necessary
if (doclear)
- selection.start.par()->stripLeadingSpaces();
+ begpit->stripLeadingSpaces();
- redoParagraphs(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(endpit);
+ cursor().pos(endpos);
+ cursor().par(parOffset(endpit));
// need a valid cursor. (Lgb)
- clearSelection();
-
- setCursor(cursor.par(), 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 (selection.start.par()->size() > selection.start.pos()
- && selection.start.par()->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(selection.start.par(),
- selection.end.par(),
- selection.start.pos(), selection.end.pos(),
- bv()->buffer()->params.textclass);
+ 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;
- recordUndo(bv(), Undo::INSERT, cursor.par());
+ recUndo(cursor().par());
ParagraphList::iterator endpit;
PitPosPair ppp;
boost::tie(ppp, endpit) =
CutAndPaste::pasteSelection(*bv()->buffer(),
- ownerParagraphs(),
- cursor.par(), cursor.pos(),
- bv()->buffer()->params.textclass,
+ paragraphs(),
+ cursorPar(), cursor().pos(),
+ bv()->buffer()->params().textclass,
sel_index, el);
bufferErrors(*bv()->buffer(), el);
bv()->showErrorList(_("Paste"));
- redoParagraphs(cursor.par(), endpit);
+ 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)
{
- recordUndo(bv(), Undo::ATOMIC);
+ 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 = selection.start.par()
- ->getFontSettings(bv()->buffer()->params,
- selection.start.pos());
+ pos_type pos = cur.selEnd().pos();
+ LyXFont const font = getPar(cur.selBegin())
+ ->getFontSettings(bv()->buffer()->params(),
+ cur.selBegin().pos());
// Insert the new string
string::const_iterator cit = str.begin();
string::const_iterator end = str.end();
for (; cit != end; ++cit) {
- selection.end.par()->insertChar(pos, (*cit), font);
+ getPar(cur.selEnd())->insertChar(pos, (*cit), font);
++pos;
}
// needed to insert the selection
void LyXText::insertStringAsLines(string const & str)
{
- ParagraphList::iterator pit = cursor.par();
- pos_type pos = cursor.pos();
- ParagraphList::iterator endpit = boost::next(cursor.par());
-
- recordUndo(bv(), Undo::ATOMIC);
+ LCursor & cur = bv()->cursor();
+ ParagraphList::iterator pit = cursorPar();
+ pos_type pos = cursor().pos();
+ ParagraphList::iterator endpit = boost::next(cursorPar());
+ recordUndo(cur, Undo::ATOMIC);
// only to be sure, should not be neccessary
- clearSelection();
-
+ cur.clearSelection();
bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
- redoParagraphs(cursor.par(), endpit);
- setCursor(cursor.par(), cursor.pos());
- selection.cursor = cursor;
+ redoParagraphs(cursorPar(), endpit);
+ 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(ParagraphList::iterator pit,
- pos_type pos,
- bool setfont, bool boundary)
+void LyXText::setCursor(ParagraphList::iterator pit, pos_type pos)
{
- LyXCursor old_cursor = cursor;
- setCursorIntern(pit, pos, setfont, boundary);
- return deleteEmptyParagraphMechanism(old_cursor);
+ setCursor(parOffset(pit), pos);
}
-void LyXText::redoCursor()
+bool LyXText::setCursor(paroffset_type par, pos_type pos, bool setfont,
+ bool boundary)
{
-#warning maybe the same for selections?
- setCursor(cursor, cursor.par(), cursor.pos(), cursor.boundary());
+ CursorSlice old_cursor = cursor();
+ setCursorIntern(par, pos, setfont, boundary);
+ return deleteEmptyParagraphMechanism(old_cursor);
}
-void LyXText::setCursor(LyXCursor & cur, ParagraphList::iterator pit,
- pos_type pos, bool boundary)
+void LyXText::setCursor(CursorSlice & cur, paroffset_type par,
+ pos_type pos, bool boundary)
{
- Assert(pit != ownerParagraphs().end());
+ BOOST_ASSERT(par != int(paragraphs().size()));
- cur.par(pit);
+ cur.par(par);
cur.pos(pos);
cur.boundary(boundary);
- if (noRows())
- return;
-
- // get the cursor y position in text
- RowList::iterator row = getRow(pit, pos);
- int y = row->y();
-
- // y is now the beginning of the cursor row
- y += row->baseline();
- // y is now the cursor baseline
- cur.y(y);
+ // no rows, no fun...
+ if (paragraphs().begin()->rows.empty())
+ return;
- 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);
- } else if (pos < row->pos()) {
- lyxerr << "dont like 3 please report" << endl;
- pos = row->pos();
+ BOOST_ASSERT(false);
+ } else if (pos < row.pos()) {
+ 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, RowList::iterator rit,
- pos_type pos, pos_type last, bool boundary) const
-{
- pos_type cursor_vpos = 0;
- double x = rit->x();
- double fill_separator = rit->fill_separator();
- double fill_hfill = rit->fill_hfill();
- double fill_label_hfill = rit->fill_label_hfill();
- pos_type const rit_pos = rit->pos();
-
- if (last < rit_pos)
- cursor_vpos = rit_pos;
- else if (pos > last && !boundary)
- cursor_vpos = (pit->isRightToLeftPar(bv()->buffer()->params))
- ? rit_pos : last + 1;
- else if (pos > rit_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 = rit_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, rit, 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(ParagraphList::iterator pit,
+void LyXText::setCursorIntern(paroffset_type par,
pos_type pos, bool setfont, bool boundary)
{
- setCursor(cursor, pit, pos, boundary);
+ setCursor(cursor(), par, pos, boundary);
+ bv()->cursor().x_target() = cursorX(cursor());
if (setfont)
setCurrentFont();
}
void LyXText::setCurrentFont()
{
- pos_type pos = cursor.pos();
- ParagraphList::iterator pit = cursor.par();
+ 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(bv()->buffer()->params, pos);
+ BufferParams const & bufparams = bv()->buffer()->params();
+ 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(bv()->buffer()->params);
+ pit->getParLanguage(bufparams);
current_font.setLanguage(lang);
current_font.setNumber(LyXFont::OFF);
real_current_font.setLanguage(lang);
// returns the column near the specified x-coordinate of the row
// x is set to the real beginning of this column
pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
- RowList::iterator rit, int & x, bool & boundary) const
+ Row const & row, int & x, bool & boundary) const
{
- double tmpx = rit->x();
- double fill_separator = rit->fill_separator();
- double fill_hfill = rit->fill_hfill();
- double fill_label_hfill = rit->fill_label_hfill();
-
- pos_type vc = rit->pos();
- pos_type last = lastPos(*pit, rit);
+ 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 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 +
tmpx -= singleWidth(pit, body_pos - 1);
}
- if (hfillExpansion(*pit, rit, c)) {
+ if (hfillExpansion(*pit, row, c)) {
tmpx += singleWidth(pit, c);
if (c >= body_pos)
tmpx += fill_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
- && boost::next(rit) == pit->rows.end();
+ 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)
- ? pit->isRightToLeftPar(bv()->buffer()->params)
+ bool const rtl = lastrow
+ ? pit->isRightToLeftPar(bv()->buffer()->params())
: false;
if (lastrow &&
- ((rtl && left_side && vc == rit->pos() && x < tmpx - 5) ||
- (!rtl && !left_side && vc == last + 1 && x > tmpx + 5)))
- c = last + 1;
- else if (vc == rit->pos()) {
- c = vis2log(vc);
- if (bidi_level(c) % 2 == 1)
+ ((rtl && left_side && vc == row.pos() && x < tmpx - 5) ||
+ (!rtl && !left_side && vc == end && x > tmpx + 5)))
+ c = end;
+ else if (vc == row.pos()) {
+ 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 (rit->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 -= rit->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;
- RowList::iterator rit = getRowNearY(y, pit);
- y = rit->y();
+ Row const & row = *getRowNearY(y, pit);
+ 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, rit, x, bound);
- cur.par(pit);
- cur.pos(rit->pos() + column);
- cur.x(x);
- cur.y(y + rit->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);
+}
+
+
+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);
+}
+
+
+DispatchResult LyXText::moveLeftIntern(bool front,
+ bool activate_inset, bool selecting)
+{
+ 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);
+}
- cur.boundary(bound);
+
+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);
}
-void LyXText::cursorLeft(bool internal)
+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 &&
- isBoundary(*bv()->buffer(), *cursor.par(), cursor.pos() + 1))
- setCursor(cursor.par(), cursor.pos() + 1, true, true);
- } else if (cursor.par() != ownerParagraphs().begin()) {
+ 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
- ParagraphList::iterator pit = boost::prior(cursor.par());
- setCursor(pit, pit->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() == cursor.par()->size());
- bool const at_newline = !at_end &&
- cursor.par()->isNewline(cursor.pos());
+ LCursor & cur = bv()->cursor();
+ if (!internal && cur.boundary()) {
+ setCursor(cur.par(), cur.pos(), true, false);
+ 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(), *cursor.par(), cursor.pos()))
- setCursor(cursor.par(), cursor.pos(), true, true);
- } else if (boost::next(cursor.par()) != ownerParagraphs().end())
- setCursor(boost::next(cursor.par()), 0);
+ 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 (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->localDispatch(
- 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 && cursorRow() == cursorIRow()) {
- 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->localDispatch(cmd);
- }
+
+ if (!selecting) {
+ 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(cursor.par(), 0);
- else if (cursor.par() != ownerParagraphs().begin())
- setCursor(boost::prior(cursor.par()), 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 = cursor.par();
- 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() > cur.par()->size())
- cur.pos(cur.par()->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.
- if (old_cursor.par()->isFreeSpacing())
+ ParagraphList::iterator const old_pit = getPar(old_cursor);
+ if (old_pit->isFreeSpacing())
return false;
/* Ok I'll put some comments here about what is missing.
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
- && old_cursor.pos() < old_cursor.par()->size()
- && old_cursor.par()->isLineSeparator(old_cursor.pos())
- && old_cursor.par()->isLineSeparator(old_cursor.pos() - 1)) {
- bool erased = old_cursor.par()->erase(old_cursor.pos() - 1);
- redoParagraph(old_cursor.par());
+ && old_cursor.pos() < old_pit->size()
+ && old_pit->isLineSeparator(old_cursor.pos())
+ && old_pit->isLineSeparator(old_cursor.pos() - 1)) {
+ bool erased = old_pit->erase(old_cursor.pos() - 1);
+ redoParagraph(old_pit);
if (!erased)
return false;
#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.
- if (old_cursor.par()->allowEmpty())
+ if (old_pit->allowEmpty())
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_cursor.par()->empty() ||
- (old_cursor.par()->size() == 1 &&
- old_cursor.par()->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());
+ bool selection_position_was_oldcursor_position =
+ 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_cursor.par());
- while (endpit != ownerParagraphs().end() && endpit->getDepth())
+ ParagraphList::iterator endpit = boost::next(old_pit);
+ while (endpit != paragraphs().end() && endpit->getDepth())
++endpit;
- recordUndo(bv(), Undo::DELETE, old_cursor.par(), boost::prior(endpit));
- cursor = tmpcursor;
+ recUndo(parOffset(old_pit), parOffset(endpit) - 1);
+ cursor() = tmpcursor;
+ // cache cursor pit
+ ParagraphList::iterator tmppit = cursorPar();
// delete old par
- ownerParagraphs().erase(old_cursor.par());
+ 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_cursor.par()->stripLeadingSpaces()) {
- redoParagraph(old_cursor.par());
- // 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::paragraphs() const
+{
+ return const_cast<ParagraphList &>(paragraphs_);
+}
+
+
+void LyXText::recUndo(paroffset_type first, paroffset_type last) const
+{
+ recordUndo(bv()->cursor(), Undo::ATOMIC, first, last);
}
-ParagraphList & LyXText::ownerParagraphs() const
+void LyXText::recUndo(lyx::paroffset_type par) const
{
- return paragraphs_;
+ 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);
}