#include "bufferparams.h"
#include "BufferView.h"
#include "Bullet.h"
-#include "counters.h"
#include "coordcache.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 "paragraph.h"
#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
+#include "pariterator.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/lstrings.h"
#include "support/textutils.h"
-#include "support/tostr.h"
+
+#include <boost/current_function.hpp>
#include <sstream>
-using lyx::par_type;
+using lyx::pit_type;
using lyx::pos_type;
-using lyx::support::bformat;
using std::endl;
using std::ostringstream;
using std::string;
+using std::min;
LyXText::LyXText(BufferView * bv)
- : width_(0), maxwidth_(bv ? bv->workWidth() : 100), height_(0),
+ : maxwidth_(bv ? bv->workWidth() : 100),
background_color_(LColor::background),
- bv_owner(bv), xo_(0), yo_(0)
+ bv_owner(bv),
+ autoBreakRows_(false)
{}
BOOST_ASSERT(bv);
bv_owner = bv;
maxwidth_ = bv->workWidth();
- width_ = maxwidth_;
- height_ = 0;
+ dim_.wid = maxwidth_;
+ dim_.asc = 10;
+ dim_.des = 10;
- par_type const end = paragraphs().size();
- for (par_type pit = 0; pit != end; ++pit)
- pars_[pit].rows.clear();
+ pit_type const end = paragraphs().size();
+ for (pit_type pit = 0; pit != end; ++pit)
+ pars_[pit].rows().clear();
- current_font = getFont(0, 0);
- redoParagraphs(0, end);
- updateCounters();
+ current_font = getFont(pars_[0], 0);
+ updateCounters(*bv->buffer());
}
}
-// takes absolute x,y coordinates
-InsetBase * LyXText::checkInsetHit(int x, int y) const
+//takes screen x,y coordinates
+InsetBase * LyXText::checkInsetHit(int x, int y) const
{
- par_type pit;
- par_type end;
-
- getParsInRange(paragraphs(),
- bv()->top_y() - yo_,
- bv()->top_y() - yo_ + bv()->workHeight(),
- pit, end);
-
- // convert to screen-absolute y coordinate
- y -= bv()->top_y();
- lyxerr << "checkInsetHit: x: " << x << " y: " << y << endl;
- lyxerr << " pit: " << pit << " end: " << end << endl;
- for (; pit != end; ++pit) {
- InsetList::const_iterator iit = pars_[pit].insetlist.begin();
- InsetList::const_iterator iend = pars_[pit].insetlist.end();
- for (; iit != iend; ++iit) {
- InsetBase * inset = iit->inset;
+ pit_type pit = getPitNearY(y);
+ BOOST_ASSERT(pit != -1);
+
+ Paragraph const & par = pars_[pit];
+
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": x: " << x
+ << " y: " << y
+ << " pit: " << pit
+ << endl;
+ InsetList::const_iterator iit = par.insetlist.begin();
+ InsetList::const_iterator iend = par.insetlist.end();
+ for (; iit != iend; ++iit) {
+ InsetBase * inset = iit->inset;
#if 1
- lyxerr << "examining inset " << inset << endl;
- if (theCoords.insets_.has(inset))
- lyxerr
- << " xo: " << inset->xo() << "..." << inset->xo() + inset->width()
- << " yo: " << inset->yo() - inset->ascent() << "..."
- << inset->yo() + inset->descent() << endl;
- else
- lyxerr << " inset has no cached position";
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": examining inset " << inset << endl;
+
+ if (theCoords.getInsets().has(inset))
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": xo: " << inset->xo() << "..."
+ << inset->xo() + inset->width()
+ << " yo: " << inset->yo() - inset->ascent()
+ << "..."
+ << inset->yo() + inset->descent()
+ << endl;
+ else
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": inset has no cached position" << endl;
#endif
- if (inset->covers(x, y)) {
- lyxerr << "Hit inset: " << inset << endl;
- return inset;
- }
+ if (inset->covers(x, y)) {
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": Hit inset: " << inset << endl;
+ return inset;
}
}
- lyxerr << "No inset hit. " << endl;
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": No inset hit. " << endl;
return 0;
}
// The difference is that this one is used for displaying, and thus we
// are allowed to make cosmetic improvements. For instance make footnotes
// smaller. (Asger)
-LyXFont LyXText::getFont(par_type pit, pos_type pos) const
+LyXFont LyXText::getFont(Paragraph const & par, pos_type const pos) const
{
BOOST_ASSERT(pos >= 0);
- LyXLayout_ptr const & layout = pars_[pit].layout();
+ LyXLayout_ptr const & layout = par.layout();
#ifdef WITH_WARNINGS
#warning broken?
#endif
BufferParams const & params = bv()->buffer()->params();
- pos_type const body_pos = pars_[pit].beginOfBody();
+ pos_type const body_pos = par.beginOfBody();
// We specialize the 95% common case:
- if (!pars_[pit].getDepth()) {
- LyXFont f = pars_[pit].getFontSettings(params, pos);
+ if (!par.getDepth()) {
+ LyXFont f = par.getFontSettings(params, pos);
if (!isMainText())
- f.realize(font_);
+ applyOuterFont(f);
if (layout->labeltype == LABEL_MANUAL && pos < body_pos)
return f.realize(layout->reslabelfont);
else
else
layoutfont = layout->font;
- LyXFont font = pars_[pit].getFontSettings(params, pos);
+ LyXFont font = par.getFontSettings(params, pos);
font.realize(layoutfont);
if (!isMainText())
- font.realize(font_);
+ applyOuterFont(font);
// Realize with the fonts of lesser depth.
- //font.realize(outerFont(pit, paragraphs()));
font.realize(defaultfont_);
return font;
}
+// There are currently two font mechanisms in LyX:
+// 1. The font attributes in a lyxtext, and
+// 2. The inset-specific font properties, defined in an inset's
+// metrics() and draw() methods and handed down the inset chain through
+// the pi/mi parameters, and stored locally in a lyxtext in font_.
+// This is where the two are integrated in the final fully realized
+// font.
+void LyXText::applyOuterFont(LyXFont & font) const {
+ LyXFont lf(font_);
+ lf.reduce(defaultfont_);
+ lf.realize(font);
+ lf.setLanguage(font.language());
+ font = lf;
+}
+
-LyXFont LyXText::getLayoutFont(par_type pit) const
+LyXFont LyXText::getLayoutFont(pit_type const pit) const
{
LyXLayout_ptr const & layout = pars_[pit].layout();
}
-LyXFont LyXText::getLabelFont(par_type pit) const
+LyXFont LyXText::getLabelFont(Paragraph const & par) const
{
- LyXLayout_ptr const & layout = pars_[pit].layout();
+ LyXLayout_ptr const & layout = par.layout();
- if (!pars_[pit].getDepth())
+ if (!par.getDepth())
return layout->reslabelfont;
LyXFont font = layout->labelfont;
// Realize with the fonts of lesser depth.
- font.realize(outerFont(pit, paragraphs()));
font.realize(defaultfont_);
return font;
}
-void LyXText::setCharFont(par_type pit, pos_type pos, LyXFont const & fnt)
+void LyXText::setCharFont(pit_type pit, pos_type pos, LyXFont const & fnt)
{
LyXFont font = fnt;
LyXLayout_ptr const & layout = pars_[pit].layout();
// Realize against environment font information
if (pars_[pit].getDepth()) {
- par_type tp = pit;
+ pit_type tp = pit;
while (!layoutfont.resolved() &&
- tp != par_type(paragraphs().size()) &&
+ tp != pit_type(paragraphs().size()) &&
pars_[tp].getDepth()) {
tp = outerHook(tp, paragraphs());
- if (tp != par_type(paragraphs().size()))
+ if (tp != pit_type(paragraphs().size()))
layoutfont.realize(pars_[tp].layout()->font);
}
}
// return past-the-last paragraph influenced by a layout change on pit
-par_type LyXText::undoSpan(par_type pit)
+pit_type LyXText::undoSpan(pit_type pit)
{
- par_type end = paragraphs().size();
- par_type nextpit = pit + 1;
+ pit_type end = paragraphs().size();
+ pit_type nextpit = pit + 1;
if (nextpit == end)
return nextpit;
//because of parindents
}
-par_type LyXText::setLayout(par_type start, par_type end, string const & layout)
+pit_type LyXText::setLayout(pit_type start, pit_type end, string const & layout)
{
BOOST_ASSERT(start != end);
- par_type undopit = undoSpan(end - 1);
+ pit_type undopit = undoSpan(end - 1);
recUndo(start, undopit - 1);
BufferParams const & bufparams = bv()->buffer()->params();
LyXLayout_ptr const & lyxlayout = bufparams.getLyXTextClass()[layout];
- for (par_type pit = start; pit != end; ++pit) {
+ for (pit_type pit = start; pit != end; ++pit) {
pars_[pit].applyLayout(lyxlayout);
makeFontEntriesLayoutSpecific(bufparams, pars_[pit]);
if (lyxlayout->margintype == MARGIN_MANUAL)
return;
}
- par_type start = cur.selBegin().par();
- par_type end = cur.selEnd().par() + 1;
- par_type endpit = setLayout(start, end, layout);
- redoParagraphs(start, endpit);
- updateCounters();
+ pit_type start = cur.selBegin().pit();
+ pit_type end = cur.selEnd().pit() + 1;
+ setLayout(start, end, layout);
+ updateCounters(cur.buffer());
}
namespace {
-void getSelectionSpan(LCursor & cur, par_type & beg, par_type & end)
-{
- if (!cur.selection()) {
- beg = cur.par();
- end = cur.par() + 1;
- } else {
- beg = cur.selBegin().par();
- end = cur.selEnd().par() + 1;
- }
-}
-
-
bool changeDepthAllowed(LyXText::DEPTH_CHANGE type,
- Paragraph const & par, int max_depth)
+ Paragraph const & par, int max_depth)
{
if (par.layout()->labeltype == LABEL_BIBLIO)
return false;
bool LyXText::changeDepthAllowed(LCursor & cur, DEPTH_CHANGE type) const
{
BOOST_ASSERT(this == cur.text());
- par_type beg, end;
- getSelectionSpan(cur, beg, end);
- int max_depth = 0;
- if (beg != 0)
- max_depth = pars_[beg - 1].getMaxDepthAfter();
+ pit_type const beg = cur.selBegin().pit();
+ pit_type const end = cur.selEnd().pit() + 1;
+ int max_depth = (beg != 0 ? pars_[beg - 1].getMaxDepthAfter() : 0);
- for (par_type pit = beg; pit != end; ++pit) {
+ for (pit_type pit = beg; pit != end; ++pit) {
if (::changeDepthAllowed(type, pars_[pit], max_depth))
return true;
max_depth = pars_[pit].getMaxDepthAfter();
void LyXText::changeDepth(LCursor & cur, DEPTH_CHANGE type)
{
BOOST_ASSERT(this == cur.text());
- par_type beg, end;
- getSelectionSpan(cur, beg, end);
+ pit_type const beg = cur.selBegin().pit();
+ pit_type const end = cur.selEnd().pit() + 1;
recordUndoSelection(cur);
+ int max_depth = (beg != 0 ? pars_[beg - 1].getMaxDepthAfter() : 0);
- int max_depth = 0;
- if (beg != 0)
- max_depth = pars_[beg - 1].getMaxDepthAfter();
-
- for (par_type pit = beg; pit != end; ++pit) {
- if (::changeDepthAllowed(type, pars_[pit], max_depth)) {
- int const depth = pars_[pit].params().depth();
+ for (pit_type pit = beg; pit != end; ++pit) {
+ Paragraph & par = pars_[pit];
+ if (::changeDepthAllowed(type, par, max_depth)) {
+ int const depth = par.params().depth();
if (type == INC_DEPTH)
- pars_[pit].params().depth(depth + 1);
+ par.params().depth(depth + 1);
else
- pars_[pit].params().depth(depth - 1);
+ par.params().depth(depth - 1);
}
- max_depth = pars_[pit].getMaxDepthAfter();
+ max_depth = par.getMaxDepthAfter();
}
// this handles the counter labels, and also fixes up
// depth values for follow-on (child) paragraphs
- updateCounters();
+ updateCounters(cur.buffer());
}
if (!cur.selection()) {
// Determine basis font
LyXFont layoutfont;
- par_type pit = cur.par();
+ pit_type pit = cur.pit();
if (cur.pos() < pars_[pit].beginOfBody())
- layoutfont = getLabelFont(pit);
+ layoutfont = getLabelFont(pars_[pit]);
else
layoutfont = getLayoutFont(pit);
// Ok, we have a selection.
recordUndoSelection(cur);
- par_type const beg = cur.selBegin().par();
- par_type const end = cur.selEnd().par();
-
- DocIterator pos = cur.selectionBegin();
- DocIterator posend = cur.selectionEnd();
-
- lyxerr[Debug::DEBUG] << "pos: " << pos << " posend: " << posend
- << endl;
+ DocIterator dit = cur.selectionBegin();
+ DocIterator ditend = cur.selectionEnd();
BufferParams const & params = cur.buffer().params();
- // Don't use forwardChar here as posend might have
+ // Don't use forwardChar here as ditend might have
// pos() == lastpos() and forwardChar would miss it.
- for (; pos != posend; pos.forwardPos()) {
- if (pos.pos() != pos.lastpos()) {
- LyXFont f = getFont(pos.par(), pos.pos());
+ // Can't use forwardPos either as this descends into
+ // nested insets.
+ for (; dit != ditend; dit.forwardPosNoDescend()) {
+ if (dit.pos() != dit.lastpos()) {
+ LyXFont f = getFont(dit.paragraph(), dit.pos());
f.update(font, params.language, toggleall);
- setCharFont(pos.par(), pos.pos(), f);
+ setCharFont(dit.pit(), dit.pos(), f);
}
}
-
- redoParagraphs(beg, end + 1);
}
void LyXText::cursorHome(LCursor & cur)
{
BOOST_ASSERT(this == cur.text());
- setCursor(cur, cur.par(), cur.textRow().pos());
+ Row const & row = cur.paragraph().getRow(cur.pos(),cur.boundary());
+
+ setCursor(cur, cur.pit(), row.pos());
}
{
BOOST_ASSERT(this == cur.text());
// if not on the last row of the par, put the cursor before
- // the final space
- pos_type const end = cur.textRow().endpos();
- setCursor(cur, cur.par(), end == cur.lastpos() ? end : end - 1);
+ // the final space exept if I have a spanning inset or one string
+ // is so long that we force a break.
+ pos_type end = cur.textRow().endpos();
+ if (end == 0)
+ // empty text, end-1 is no valid position
+ return;
+ bool boundary = false;
+ if (end != cur.lastpos()) {
+ if (!cur.paragraph().isLineSeparator(end-1)
+ && !cur.paragraph().isNewline(end-1))
+ boundary = true;
+ else
+ --end;
+ }
+ setCursor(cur, cur.pit(), end, true, boundary);
}
void LyXText::cursorBottom(LCursor & cur)
{
BOOST_ASSERT(this == cur.text());
- setCursor(cur, cur.lastpar(), boost::prior(paragraphs().end())->size());
+ setCursor(cur, cur.lastpit(), boost::prior(paragraphs().end())->size());
}
if (font == LyXFont(LyXFont::ALL_IGNORE)) {
// Could only happen with user style
cur.message(_("No font change defined. "
- "Use Character under the Layout menu to define font change."));
+ "Use Character under the Layout menu to define font change."));
return;
}
}
-string LyXText::getStringToIndex(LCursor & cur)
+string LyXText::getStringToIndex(LCursor const & cur)
{
BOOST_ASSERT(this == cur.text());
- // Try implicit word selection
- // If there is a change in the language the implicit word selection
- // is disabled.
- CursorSlice const reset_cursor = cur.top();
- bool const implicitSelection =
- selectWordWhenUnderCursor(cur, lyx::PREVIOUS_WORD);
string idxstring;
- if (!cur.selection())
- cur.message(_("Nothing to index!"));
- else if (cur.selBegin().par() != cur.selEnd().par())
- cur.message(_("Cannot index more than one paragraph!"));
- else
+ if (cur.selection()) {
idxstring = cur.selectionAsString(false);
-
- // Reset cursors to their original position.
- cur.top() = reset_cursor;
- cur.resetAnchor();
-
- // Clear the implicit selection.
- if (implicitSelection)
- cur.clearSelection();
+ } else {
+ // Try implicit word selection. If there is a change
+ // in the language the implicit word selection is
+ // disabled.
+ LCursor tmpcur = cur;
+ selectWord(tmpcur, lyx::PREVIOUS_WORD);
+
+ if (!tmpcur.selection())
+ cur.message(_("Nothing to index!"));
+ else if (tmpcur.selBegin().pit() != tmpcur.selEnd().pit())
+ cur.message(_("Cannot index more than one paragraph!"));
+ else
+ idxstring = tmpcur.selectionAsString(false);
+ }
return idxstring;
}
void LyXText::setParagraph(LCursor & cur,
- Spacing const & spacing, LyXAlignment align,
- string const & labelwidthstring, bool noindent)
+ Spacing const & spacing, LyXAlignment align,
+ string const & labelwidthstring, bool noindent)
{
BOOST_ASSERT(cur.text());
// make sure that the depth behind the selection are restored, too
- par_type undopit = undoSpan(cur.selEnd().par());
- recUndo(cur.selBegin().par(), undopit - 1);
+ pit_type undopit = undoSpan(cur.selEnd().pit());
+ recUndo(cur.selBegin().pit(), undopit - 1);
- for (par_type pit = cur.selBegin().par(), end = cur.selEnd().par();
- pit <= end; ++pit) {
+ for (pit_type pit = cur.selBegin().pit(), end = cur.selEnd().pit();
+ pit <= end; ++pit) {
Paragraph & par = pars_[pit];
ParagraphParameters & params = par.params();
params.spacing(spacing);
par.setLabelWidthString(labelwidthstring);
params.noindent(noindent);
}
-
- redoParagraphs(cur.selBegin().par(), 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);
- }
- }
-
- return textclass.counters().counterLabel(fmt);
-}
-
-
-namespace {
-
-void incrementItemDepth(ParagraphList & pars, par_type pit, par_type first_pit)
-{
- int const cur_labeltype = pars[pit].layout()->labeltype;
-
- if (cur_labeltype != LABEL_ENUMERATE && cur_labeltype != LABEL_ITEMIZE)
- return;
-
- int const cur_depth = pars[pit].getDepth();
-
- par_type prev_pit = pit - 1;
- while (true) {
- int const prev_depth = pars[prev_pit].getDepth();
- int const prev_labeltype = pars[prev_pit].layout()->labeltype;
- if (prev_depth == 0 && cur_depth > 0) {
- if (prev_labeltype == cur_labeltype) {
- pars[pit].itemdepth = pars[prev_pit].itemdepth + 1;
- }
- break;
- } else if (prev_depth < cur_depth) {
- if (prev_labeltype == cur_labeltype) {
- pars[pit].itemdepth = pars[prev_pit].itemdepth + 1;
- break;
- }
- } else if (prev_depth == cur_depth) {
- if (prev_labeltype == cur_labeltype) {
- pars[pit].itemdepth = pars[prev_pit].itemdepth;
- break;
- }
- }
- if (prev_pit == first_pit)
- break;
-
- --prev_pit;
- }
}
-void resetEnumCounterIfNeeded(ParagraphList & pars, par_type pit,
- par_type firstpit, Counters & counters)
-{
- if (pit == firstpit)
- return;
-
- int const cur_depth = pars[pit].getDepth();
- par_type prev_pit = pit - 1;
- while (true) {
- int const prev_depth = pars[prev_pit].getDepth();
- int const prev_labeltype = pars[prev_pit].layout()->labeltype;
- if (prev_depth <= cur_depth) {
- if (prev_labeltype != LABEL_ENUMERATE) {
- switch (pars[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, par_type pit)
-{
- BufferParams const & bufparams = buf.params();
- LyXTextClass const & textclass = bufparams.getLyXTextClass();
- LyXLayout_ptr const & layout = pars_[pit].layout();
- par_type first_pit = 0;
- Counters & counters = textclass.counters();
-
- // Always reset
- pars_[pit].itemdepth = 0;
-
- if (pit == first_pit) {
- pars_[pit].params().appendix(pars_[pit].params().startOfAppendix());
- } else {
- pars_[pit].params().appendix(pars_[pit - 1].params().appendix());
- if (!pars_[pit].params().appendix() &&
- pars_[pit].params().startOfAppendix()) {
- pars_[pit].params().appendix(true);
- textclass.counters().reset();
- }
-
- // Maybe we have to increment the item depth.
- incrementItemDepth(pars_, pit, first_pit);
- }
-
- // erase what was there before
- pars_[pit].params().labelString(string());
-
- if (layout->margintype == MARGIN_MANUAL) {
- if (pars_[pit].params().labelWidthString().empty())
- pars_[pit].setLabelWidthString(layout->labelstring());
- } else {
- pars_[pit].setLabelWidthString(string());
- }
-
- // is it a layout that has an automatic label?
- if (layout->labeltype == LABEL_COUNTER) {
- BufferParams const & bufparams = buf.params();
- LyXTextClass const & textclass = bufparams.getLyXTextClass();
- counters.step(layout->counter);
- string label = expandLabel(textclass, layout, pars_[pit].params().appendix());
- pars_[pit].params().labelString(label);
- } else if (layout->labeltype == LABEL_ITEMIZE) {
- // At some point of time we should do something more
- // clever here, like:
- // pars_[pit].params().labelString(
- // bufparams.user_defined_bullet(pars_[pit].itemdepth).getText());
- // for now, use a simple hardcoded label
- string itemlabel;
- switch (pars_[pit].itemdepth) {
- case 0:
- itemlabel = "*";
- break;
- case 1:
- itemlabel = "-";
- break;
- case 2:
- itemlabel = "@";
- break;
- case 3:
- itemlabel = "·";
- break;
- }
-
- pars_[pit].params().labelString(itemlabel);
- } else if (layout->labeltype == LABEL_ENUMERATE) {
- // Maybe we have to reset the enumeration counter.
- resetEnumCounterIfNeeded(pars_, pit, first_pit, counters);
-
- // FIXME
- // Yes I know this is a really, really! bad solution
- // (Lgb)
- string enumcounter = "enum";
-
- switch (pars_[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;
- }
-
- counters.step(enumcounter);
-
- pars_[pit].params().labelString(counters.enumLabel(enumcounter));
- } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
- counters.step("bibitem");
- int number = counters.value("bibitem");
- if (pars_[pit].bibitem()) {
- pars_[pit].bibitem()->setCounter(number);
- pars_[pit].params().labelString(layout->labelstring());
- }
- // In biblio should't be following counters but...
- } else {
- string s = buf.B_(layout->labelstring());
-
- // the caption hack:
- if (layout->labeltype == LABEL_SENSITIVE) {
- par_type end = paragraphs().size();
- par_type tmppit = pit;
- InsetBase * in = 0;
- bool isOK = false;
- while (tmppit != end) {
- in = pars_[tmppit].inInset();
- if (in->lyxCode() == InsetBase::FLOAT_CODE ||
- in->lyxCode() == InsetBase::WRAP_CODE) {
- isOK = true;
- break;
- } else {
- Paragraph const * owner = &ownerPar(buf, in);
- tmppit = first_pit;
- for ( ; tmppit != end; ++tmppit)
- if (&pars_[tmppit] == owner)
- break;
- }
- }
-
- if (isOK) {
- string type;
-
- if (in->lyxCode() == InsetBase::FLOAT_CODE)
- type = static_cast<InsetFloat*>(in)->params().type;
- else if (in->lyxCode() == InsetBase::WRAP_CODE)
- type = static_cast<InsetWrap*>(in)->params().type;
- else
- BOOST_ASSERT(false);
-
- Floating const & fl = textclass.floats().getType(type);
-
- counters.step(fl.type());
-
- // Doesn't work... yet.
- s = bformat(_("%1$s #:"), buf.B_(fl.name()));
- } else {
- // par->SetLayout(0);
- // s = layout->labelstring;
- s = _("Senseless: ");
- }
- }
- pars_[pit].params().labelString(s);
-
- }
-}
-
-
-// Updates all counters.
-void LyXText::updateCounters()
-{
- // start over
- bv()->buffer()->params().getLyXTextClass().counters().reset();
-
- bool update_pos = false;
-
- par_type end = paragraphs().size();
- for (par_type pit = 0; pit != end; ++pit) {
- string const oldLabel = pars_[pit].params().labelString();
- size_t maxdepth = 0;
- if (pit != 0)
- maxdepth = pars_[pit - 1].getMaxDepthAfter();
-
- if (pars_[pit].params().depth() > maxdepth)
- pars_[pit].params().depth(maxdepth);
-
- // setCounter can potentially change the labelString.
- setCounter(*bv()->buffer(), pit);
- string const & newLabel = pars_[pit].params().labelString();
- if (oldLabel != newLabel) {
- //lyxerr[Debug::DEBUG] << "changing labels: old: " << oldLabel << " new: "
- // << newLabel << endl;
- redoParagraphInternal(pit);
- update_pos = true;
- }
- }
- if (update_pos)
- updateParPositions();
-}
-
-
-// this really should just inset the inset and not move the cursor.
+// this really should just insert the inset and not move the cursor.
void LyXText::insertInset(LCursor & cur, InsetBase * inset)
{
BOOST_ASSERT(this == cur.text());
BOOST_ASSERT(inset);
cur.paragraph().insertInset(cur.pos(), inset);
- redoParagraph(cur);
}
// needed to insert the selection
void LyXText::insertStringAsLines(LCursor & cur, string const & str)
{
- par_type pit = cur.par();
- par_type endpit = cur.par() + 1;
- pos_type pos = cur.pos();
- recordUndo(cur);
-
- // only to be sure, should not be neccessary
- cur.clearSelection();
- cur.buffer().insertStringAsLines(pars_, pit, pos, current_font, str);
-
- redoParagraphs(cur.par(), endpit);
- cur.resetAnchor();
- setCursor(cur, cur.par(), pos);
- cur.setSelection();
+ cur.buffer().insertStringAsLines(pars_, cur.pit(), cur.pos(),
+ current_font, str, autoBreakRows_);
}
}
-bool LyXText::setCursor(LCursor & cur, par_type par, pos_type pos,
- bool setfont, bool boundary)
+bool LyXText::setCursor(LCursor & cur, pit_type par, pos_type pos,
+ bool setfont, bool boundary)
{
LCursor old = cur;
setCursorIntern(cur, par, pos, setfont, boundary);
}
-void LyXText::setCursor(CursorSlice & cur, par_type par,
- pos_type pos, bool boundary)
+void LyXText::setCursor(CursorSlice & cur, pit_type par, pos_type pos)
{
BOOST_ASSERT(par != int(paragraphs().size()));
-
- cur.par() = par;
+ cur.pit() = par;
cur.pos() = pos;
- cur.boundary() = boundary;
-
- // no rows, no fun...
- if (paragraphs().begin()->rows.empty())
- return;
// 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 < 0) {
if (pos > para.size()) {
lyxerr << "dont like 1, pos: " << pos
<< " size: " << para.size()
- << " row.pos():" << row.pos()
- << " par: " << par << endl;
- BOOST_ASSERT(false);
- }
-
- if (pos > end) {
- lyxerr << "dont like 2, pos: " << pos
- << " size: " << para.size()
- << " row.pos():" << row.pos()
- << " par: " << par << endl;
- // This shouldn't happen.
- BOOST_ASSERT(false);
- }
-
- if (pos < row.pos()) {
- lyxerr << "dont like 3 please report pos:" << pos
- << " size: " << para.size()
- << " row.pos():" << row.pos()
<< " par: " << par << endl;
BOOST_ASSERT(false);
}
void LyXText::setCursorIntern(LCursor & cur,
- par_type par, pos_type pos, bool setfont, bool boundary)
+ pit_type par, pos_type pos, bool setfont, bool boundary)
{
- setCursor(cur.top(), par, pos, boundary);
- cur.x_target() = cursorX(cur.top());
+ cur.boundary(boundary);
+ setCursor(cur.top(), par, pos);
+ cur.setTargetX();
if (setfont)
setCurrentFont(cur);
}
{
BOOST_ASSERT(this == cur.text());
pos_type pos = cur.pos();
- par_type pit = cur.par();
+ Paragraph & par = cur.paragraph();
if (cur.boundary() && pos > 0)
--pos;
if (pos == cur.lastpos())
--pos;
else // potentional bug... BUG (Lgb)
- if (pars_[pit].isSeparator(pos)) {
+ if (par.isSeparator(pos)) {
if (pos > cur.textRow().pos() &&
bidi.level(pos) % 2 ==
bidi.level(pos - 1) % 2)
}
BufferParams const & bufparams = cur.buffer().params();
- current_font = pars_[pit].getFontSettings(bufparams, pos);
- real_current_font = getFont(pit, pos);
+ current_font = par.getFontSettings(bufparams, pos);
+ real_current_font = getFont(par, pos);
if (cur.pos() == cur.lastpos()
- && bidi.isBoundary(cur.buffer(), pars_[pit], cur.pos())
+ && bidi.isBoundary(cur.buffer(), par, cur.pos())
&& !cur.boundary()) {
- Language const * lang = pars_[pit].getParLanguage(bufparams);
+ Language const * lang = par.getParLanguage(bufparams);
current_font.setLanguage(lang);
current_font.setNumber(LyXFont::OFF);
real_current_font.setLanguage(lang);
// x is an absolute screen coord
// 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(par_type pit,
- Row const & row, int & x, bool & boundary) const
+pos_type LyXText::getColumnNearX(pit_type const pit,
+ Row const & row, int & x, bool & boundary) const
{
- x -= xo_;
+ int const xo = theCoords.get(this, pit).x_;
+ x -= xo;
RowMetrics const r = computeRowMetrics(pit, row);
+ Paragraph const & par = pars_[pit];
pos_type vc = row.pos();
pos_type end = row.endpos();
pos_type c = 0;
- LyXLayout_ptr const & layout = pars_[pit].layout();
+ LyXLayout_ptr const & layout = par.layout();
bool left_side = false;
- pos_type body_pos = pars_[pit].beginOfBody();
+ pos_type body_pos = par.beginOfBody();
double tmpx = r.x;
double last_tmpx = tmpx;
if (body_pos > 0 &&
- (body_pos > end || !pars_[pit].isLineSeparator(body_pos - 1)))
+ (body_pos > end || !par.isLineSeparator(body_pos - 1)))
body_pos = 0;
// check for empty row
if (vc == end) {
- x = int(tmpx) + xo_;
+ x = int(tmpx) + xo;
return 0;
}
last_tmpx = tmpx;
if (body_pos > 0 && c == body_pos - 1) {
tmpx += r.label_hfill +
- font_metrics::width(layout->labelsep, getLabelFont(pit));
- if (pars_[pit].isLineSeparator(body_pos - 1))
- tmpx -= singleWidth(pit, body_pos - 1);
+ font_metrics::width(layout->labelsep, getLabelFont(par));
+ if (par.isLineSeparator(body_pos - 1))
+ tmpx -= singleWidth(par, body_pos - 1);
}
- if (hfillExpansion(pars_[pit], row, c)) {
- tmpx += singleWidth(pit, c);
+ if (hfillExpansion(par, row, c)) {
+ tmpx += singleWidth(par, c);
if (c >= body_pos)
tmpx += r.hfill;
else
tmpx += r.label_hfill;
- } else if (pars_[pit].isSeparator(c)) {
- tmpx += singleWidth(pit, c);
+ } else if (par.isSeparator(c)) {
+ tmpx += singleWidth(par, c);
if (c >= body_pos)
tmpx += r.separator;
} else {
- tmpx += singleWidth(pit, c);
+ tmpx += singleWidth(par, c);
}
++vc;
}
boundary = false;
// This (rtl_support test) is not needed, but gives
// some speedup if rtl_support == false
- bool const lastrow = lyxrc.rtl_support && row.endpos() == pars_[pit].size();
+ bool const lastrow = lyxrc.rtl_support && row.endpos() == par.size();
// If lastrow is false, we don't need to compute
// the value of rtl.
- bool const rtl = lastrow ? isRTL(pars_[pit]) : false;
+ bool const rtl = lastrow ? isRTL(par) : false;
if (lastrow &&
- ((rtl && left_side && vc == row.pos() && x < tmpx - 5) ||
- (!rtl && !left_side && vc == end && x > tmpx + 5)))
+ ((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);
bool const rtl = (bidi.level(c) % 2 == 1);
if (left_side == rtl) {
++c;
- boundary = bidi.isBoundary(*bv()->buffer(), pars_[pit], c);
+ boundary = bidi.isBoundary(*bv()->buffer(), par, c);
}
}
- if (row.pos() < end && c >= end && pars_[pit].isNewline(end - 1)) {
+// I believe this code is not needed anymore (Jug 20050717)
+#if 0
+ // The following code is necessary because the cursor position past
+ // the last char in a row is logically equivalent to that before
+ // the first char in the next row. That's why insets causing row
+ // divisions -- Newline and display-style insets -- must be treated
+ // specially, so cursor up/down doesn't get stuck in an air gap -- MV
+ // Newline inset, air gap below:
+ if (row.pos() < end && c >= end && par.isNewline(end - 1)) {
if (bidi.level(end -1) % 2 == 0)
- tmpx -= singleWidth(pit, end - 1);
+ tmpx -= singleWidth(par, end - 1);
else
- tmpx += singleWidth(pit, end - 1);
+ tmpx += singleWidth(par, end - 1);
+ c = end - 1;
+ }
+
+ // Air gap above display inset:
+ if (row.pos() < end && c >= end && end < par.size()
+ && par.isInset(end) && par.getInset(end)->display()) {
c = end - 1;
}
+ // Air gap below display inset:
+ if (row.pos() < end && c >= end && par.isInset(end - 1)
+ && par.getInset(end - 1)->display()) {
+ c = end - 1;
+ }
+#endif
- x = int(tmpx) + xo_;
- return c - row.pos();
+ x = int(tmpx) + xo;
+ pos_type const col = c - row.pos();
+
+ if (!c || end == par.size())
+ return col;
+
+ if (c==end && !par.isLineSeparator(c-1) && !par.isNewline(c-1)) {
+ boundary = true;
+ return col;
+ }
+
+ return min(col, end - 1 - row.pos());
}
-// y is relative to this LyXText's top
-// this is only used in the two functions below
-Row const & LyXText::getRowNearY(int y, par_type & pit) const
+// y is screen coordinate
+pit_type LyXText::getPitNearY(int y) const
{
BOOST_ASSERT(!paragraphs().empty());
- BOOST_ASSERT(!paragraphs().begin()->rows.empty());
- par_type const pend = paragraphs().size() - 1;
- pit = 0;
- while (int(pars_[pit].y + pars_[pit].height) < y && pit != pend)
- ++pit;
-
- RowList::iterator rit = pars_[pit].rows.end();
- RowList::iterator const rbegin = pars_[pit].rows.begin();
- do {
- --rit;
- } while (rit != rbegin && int(pars_[pit].y + rit->y_offset()) > y);
+ BOOST_ASSERT(theCoords.getParPos().find(this) != theCoords.getParPos().end());
+ CoordCache::InnerParPosCache const & cc = theCoords.getParPos().find(this)->second;
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": y: " << y << " cache size: " << cc.size()
+ << endl;
+
+ // look for highest numbered paragraph with y coordinate less than given y
+ pit_type pit = 0;
+ int yy = -1;
+ CoordCache::InnerParPosCache::const_iterator it = cc.begin();
+ CoordCache::InnerParPosCache::const_iterator et = cc.end();
+ for (; it != et; ++it) {
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << " examining: pit: " << it->first
+ << " y: " << it->second.y_
+ << endl;
+
+ if (it->first >= pit && int(it->second.y_) - int(pars_[it->first].ascent()) <= y) {
+ pit = it->first;
+ yy = it->second.y_;
+ }
+ }
- return *rit;
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": found best y: " << yy << " for pit: " << pit
+ << endl;
+
+ return pit;
}
-// x,y are absolute coordinates
-// sets cursor only within this LyXText
-void LyXText::setCursorFromCoordinates(LCursor & cur, int x, int y)
+Row const & LyXText::getRowNearY(int y, pit_type pit) const
{
- x -= xo_;
- y -= yo_;
- par_type pit;
- Row const & row = getRowNearY(y, pit);
- lyxerr[Debug::DEBUG] << "setCursorFromCoordinates:: hit row at: "
- << row.pos() << endl;
- bool bound = false;
- int xx = x + xo_; // getRowNearX get absolute x coords
- pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound);
- setCursor(cur, pit, pos, true, bound);
+ Paragraph const & par = pars_[pit];
+ int yy = theCoords.get(this, pit).y_ - par.ascent();
+ BOOST_ASSERT(!par.rows().empty());
+ RowList::const_iterator rit = par.rows().begin();
+ RowList::const_iterator const rlast = boost::prior(par.rows().end());
+ for (; rit != rlast; yy += rit->height(), ++rit)
+ if (yy + rit->height() > y)
+ break;
+ return *rit;
}
// x,y are absolute screen coordinates
// sets cursor recursively descending into nested editable insets
-InsetBase * LyXText::editXY(LCursor & cur, int x, int y) const
+InsetBase * LyXText::editXY(LCursor & cur, int x, int y)
{
- par_type pit;
- Row const & row = getRowNearY(y - yo_, pit);
+ pit_type pit = getPitNearY(y);
+ BOOST_ASSERT(pit != -1);
+ Row const & row = getRowNearY(y, pit);
bool bound = false;
int xx = x; // is modified by getColumnNearX
pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound);
- cur.par() = pit;
+ cur.pit() = pit;
cur.pos() = pos;
- cur.boundary() = bound;
+ cur.boundary(bound);
+ cur.x_target() = x;
// try to descend into nested insets
InsetBase * inset = checkInsetHit(x, y);
- lyxerr << "inset " << inset << " hit at x: " << x << " y: " << y << endl;
- if (!inset)
+ //lyxerr << "inset " << inset << " hit at x: " << x << " y: " << y << endl;
+ if (!inset) {
+ // Either we deconst editXY or better we move current_font
+ // and real_current_font to LCursor
+ setCurrentFont(cur);
return 0;
+ }
// This should be just before or just behind the
// cursor position set above.
// this inset.
if (inset == pars_[pit].getInset(pos - 1))
--cur.pos();
- return inset->editXY(cur, x, y);
+ inset = inset->editXY(cur, x, y);
+ if (cur.top().text() == this)
+ setCurrentFont(cur);
+ return inset;
}
}
-void LyXText::cursorLeft(LCursor & cur)
+bool LyXText::cursorLeft(LCursor & cur)
{
+ if (!cur.boundary() && cur.pos() > 0 &&
+ cur.textRow().pos() == cur.pos() &&
+ !cur.paragraph().isLineSeparator(cur.pos()-1) &&
+ !cur.paragraph().isNewline(cur.pos()-1)) {
+ return setCursor(cur, cur.pit(), cur.pos(), true, true);
+ }
if (cur.pos() != 0) {
bool boundary = cur.boundary();
- setCursor(cur, cur.par(), cur.pos() - 1, true, false);
+ bool updateNeeded = setCursor(cur, cur.pit(), cur.pos() - 1, true, false);
if (!checkAndActivateInset(cur, false)) {
if (false && !boundary &&
- bidi.isBoundary(cur.buffer(), cur.paragraph(), cur.pos() + 1))
- setCursor(cur, cur.par(), cur.pos() + 1, true, true);
+ bidi.isBoundary(cur.buffer(), cur.paragraph(), cur.pos() + 1))
+ updateNeeded |=
+ setCursor(cur, cur.pit(), cur.pos() + 1, true, true);
}
- return;
+ return updateNeeded;
}
- if (cur.par() != 0) {
- // steps into the paragraph above
- setCursor(cur, cur.par() - 1, getPar(cur.par() - 1).size());
+ if (cur.pit() != 0) {
+ // Steps into the paragraph above
+ return setCursor(cur, cur.pit() - 1, getPar(cur.pit() - 1).size());
}
+ return false;
}
-void LyXText::cursorRight(LCursor & cur)
+bool LyXText::cursorRight(LCursor & cur)
{
- if (false && cur.boundary()) {
- setCursor(cur, cur.par(), cur.pos(), true, false);
- return;
- }
-
if (cur.pos() != cur.lastpos()) {
+ if (cur.boundary())
+ return setCursor(cur, cur.pit(), cur.pos(),
+ true, false);
+
+ bool updateNeeded = false;
if (!checkAndActivateInset(cur, true)) {
- setCursor(cur, cur.par(), cur.pos() + 1, true, false);
+ if (cur.textRow().endpos() == cur.pos() + 1 &&
+ cur.textRow().endpos() != cur.lastpos() &&
+ !cur.paragraph().isLineSeparator(cur.pos()) &&
+ !cur.paragraph().isNewline(cur.pos())) {
+ cur.boundary(true);
+ }
+ updateNeeded |= setCursor(cur, cur.pit(), cur.pos() + 1, true, cur.boundary());
if (false && bidi.isBoundary(cur.buffer(), cur.paragraph(),
- cur.pos()))
- setCursor(cur, cur.par(), cur.pos(), true, true);
+ cur.pos()))
+ updateNeeded |= setCursor(cur, cur.pit(), cur.pos(), true, true);
}
- return;
+ return updateNeeded;
}
- if (cur.par() != cur.lastpar())
- setCursor(cur, cur.par() + 1, 0);
+ if (cur.pit() != cur.lastpit())
+ return setCursor(cur, cur.pit() + 1, 0);
+ return false;
}
-void LyXText::cursorUp(LCursor & cur)
+bool LyXText::cursorUp(LCursor & cur)
{
- Row const & row = cur.textRow();
- int x = cur.x_target();
- int y = cursorY(cur.top()) - row.baseline() - 1;
- setCursorFromCoordinates(cur, x, y);
+ Paragraph const & par = cur.paragraph();
+ int row;
+ int const x = cur.targetX();
+
+ if (cur.pos() && cur.boundary())
+ row = par.pos2row(cur.pos()-1);
+ else
+ row = par.pos2row(cur.pos());
if (!cur.selection()) {
- InsetBase * inset_hit = checkInsetHit(cur.x_target(), y);
- if (inset_hit && isHighlyEditableInset(inset_hit))
- inset_hit->editXY(cur, cur.x_target(), y);
+ int const y = bv_funcs::getPos(cur, cur.boundary()).y_;
+ LCursor old = cur;
+ editXY(cur, x, y - par.rows()[row].ascent() - 1);
+
+ // This happens when you move out of an inset.
+ // And to give the DEPM the possibility of doing
+ // something we must provide it with two different
+ // cursors. (Lgb)
+ LCursor dummy = cur;
+ if (dummy == old)
+ ++dummy.pos();
+
+ return deleteEmptyParagraphMechanism(dummy, old);
+ }
+
+ bool updateNeeded = false;
+
+ if (row > 0) {
+ updateNeeded |= setCursor(cur, cur.pit(),
+ x2pos(cur.pit(), row - 1, x));
+ } else if (cur.pit() > 0) {
+ --cur.pit();
+ //cannot use 'par' now
+ updateNeeded |= setCursor(cur, cur.pit(),
+ x2pos(cur.pit(), cur.paragraph().rows().size() - 1, x));
}
+
+ cur.x_target() = x;
+
+ return updateNeeded;
}
-void LyXText::cursorDown(LCursor & cur)
+bool LyXText::cursorDown(LCursor & cur)
{
- Row const & row = cur.textRow();
- int x = cur.x_target();
- int y = cursorY(cur.top()) - row.baseline() + row.height() + 1;
- setCursorFromCoordinates(cur, x, y);
+ Paragraph const & par = cur.paragraph();
+ int row;
+ int const x = cur.targetX();
+
+ if (cur.pos() && cur.boundary())
+ row = par.pos2row(cur.pos()-1);
+ else
+ row = par.pos2row(cur.pos());
if (!cur.selection()) {
- InsetBase * inset_hit = checkInsetHit(cur.x_target(), y);
- if (inset_hit && isHighlyEditableInset(inset_hit))
- inset_hit->editXY(cur, cur.x_target(), y);
+ int const y = bv_funcs::getPos(cur, cur.boundary()).y_;
+ LCursor old = cur;
+ editXY(cur, x, y + par.rows()[row].descent() + 1);
+
+ // This happens when you move out of an inset.
+ // And to give the DEPM the possibility of doing
+ // something we must provide it with two different
+ // cursors. (Lgb)
+ LCursor dummy = cur;
+ if (dummy == old)
+ ++dummy.pos();
+
+ bool const changed = deleteEmptyParagraphMechanism(dummy, old);
+
+ // Make sure that cur gets back whatever happened to dummy(Lgb)
+ if (changed)
+ cur = dummy;
+
+ return changed;
+
}
+
+ bool updateNeeded = false;
+
+ if (row + 1 < int(par.rows().size())) {
+ updateNeeded |= setCursor(cur, cur.pit(),
+ x2pos(cur.pit(), row + 1, x));
+ } else if (cur.pit() + 1 < int(paragraphs().size())) {
+ ++cur.pit();
+ updateNeeded |= setCursor(cur, cur.pit(),
+ x2pos(cur.pit(), 0, x));
+ }
+
+ cur.x_target() = x;
+
+ return updateNeeded;
}
-void LyXText::cursorUpParagraph(LCursor & cur)
+bool LyXText::cursorUpParagraph(LCursor & cur)
{
+ bool updated = false;
if (cur.pos() > 0)
- setCursor(cur, cur.par(), 0);
- else if (cur.par() != 0)
- setCursor(cur, cur.par() - 1, 0);
+ updated = setCursor(cur, cur.pit(), 0);
+ else if (cur.pit() != 0)
+ updated = setCursor(cur, cur.pit() - 1, 0);
+ return updated;
}
-void LyXText::cursorDownParagraph(LCursor & cur)
+bool LyXText::cursorDownParagraph(LCursor & cur)
{
- if (cur.par() != cur.lastpar())
- setCursor(cur, cur.par() + 1, 0);
+ bool updated = false;
+ if (cur.pit() != cur.lastpit())
+ updated = setCursor(cur, cur.pit() + 1, 0);
else
- setCursor(cur, cur.par(), cur.lastpos());
+ updated = setCursor(cur, cur.pit(), cur.lastpos());
+ return updated;
}
// position. Called by deleteEmptyParagraphMechanism
void LyXText::fixCursorAfterDelete(CursorSlice & cur, CursorSlice const & where)
{
- // do notheing if cursor is not in the paragraph where the
+ // Do nothing if cursor is not in the paragraph where the
// deletion occured,
- if (cur.par() != where.par())
+ if (cur.pit() != where.pit())
return;
- // if cursor position is after the deletion place update it
+ // If cursor position is after the deletion place update it
if (cur.pos() > where.pos())
--cur.pos();
- // check also if we don't want to set the cursor on a spot behind the
+ // 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.lastpos())
cur.pos() = cur.lastpos();
bool LyXText::deleteEmptyParagraphMechanism(LCursor & cur, LCursor const & old)
{
- BOOST_ASSERT(cur.size() == old.size());
// Would be wrong to delete anything if we have a selection.
if (cur.selection())
return false;
//lyxerr[Debug::DEBUG] << "DEPM: cur:\n" << cur << "old:\n" << old << endl;
- Paragraph const & oldpar = pars_[old.par()];
+ Paragraph const & oldpar = pars_[old.pit()];
// We allow all kinds of "mumbo-jumbo" when freespacing.
if (oldpar.isFreeSpacing())
// MISSING
// If the chars around the old cursor were spaces, delete one of them.
- if (old.par() != cur.par() || old.pos() != cur.pos()) {
+ if (old.pit() != cur.pit() || old.pos() != cur.pos()) {
// Only if the cursor has really moved.
if (old.pos() > 0
&& old.pos() < oldpar.size()
&& oldpar.isLineSeparator(old.pos())
- && oldpar.isLineSeparator(old.pos() - 1)) {
- pars_[old.par()].erase(old.pos() - 1);
+ && oldpar.isLineSeparator(old.pos() - 1)
+ && oldpar.lookupChange(old.pos() - 1) != Change::DELETED) {
+ // We need to set the text to Change::INSERTED to
+ // get it erased properly
+ pars_[old.pit()].setChange(old.pos() -1,
+ Change::INSERTED);
+ pars_[old.pit()].erase(old.pos() - 1);
#ifdef WITH_WARNINGS
#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
#warning DEPM, look here
#endif
//fixCursorAfterDelete(cur.anchor(), old.top());
- return false;
+ return true;
}
}
// only do our magic if we changed paragraph
- if (old.par() == cur.par())
+ if (old.pit() == cur.pit())
return false;
// don't delete anything if this is the ONLY paragraph!
if (oldpar.empty() || (oldpar.size() == 1 && oldpar.isLineSeparator(0))) {
// ok, we will delete something
- CursorSlice tmpcursor;
-
deleted = true;
bool selection_position_was_oldcursor_position =
- cur.anchor().par() == old.par() && cur.anchor().pos() == old.pos();
+ cur.anchor().pit() == old.pit() && cur.anchor().pos() == old.pos();
// This is a bit of a overkill. We change the old and the cur par
// at max, certainly not everything in between...
- recUndo(old.par(), cur.par());
+ recUndo(old.pit(), cur.pit());
// Delete old par.
- pars_.erase(pars_.begin() + old.par());
+ pars_.erase(pars_.begin() + old.pit());
// Update cursor par offset if necessary.
// Some 'iterator registration' would be nice that takes care of
// such events. Maybe even signal/slot?
- if (cur.par() > old.par())
- --cur.par();
+ if (cur.pit() > old.pit())
+ --cur.pit();
#ifdef WITH_WARNINGS
#warning DEPM, look here
#endif
-// if (cur.anchor().par() > old.par())
-// --cur.anchor().par();
+// if (cur.anchor().pit() > old.pit())
+// --cur.anchor().pit();
if (selection_position_was_oldcursor_position) {
// correct selection
}
}
- if (deleted)
+ if (deleted) {
+ updateCounters(cur.buffer());
return true;
+ }
- if (pars_[old.par()].stripLeadingSpaces())
+ if (pars_[old.pit()].stripLeadingSpaces())
cur.resetAnchor();
return false;
}
-ParagraphList & LyXText::paragraphs() const
-{
- return const_cast<ParagraphList &>(pars_);
-}
-
-
-void LyXText::recUndo(par_type first, par_type last) const
+void LyXText::recUndo(pit_type first, pit_type last) const
{
recordUndo(bv()->cursor(), Undo::ATOMIC, first, last);
}
-void LyXText::recUndo(par_type par) const
+void LyXText::recUndo(pit_type par) const
{
recordUndo(bv()->cursor(), Undo::ATOMIC, par, par);
}