#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::max;
+using std::min;
LyXText::LyXText(BufferView * bv)
- : width_(0), maxwidth_(bv ? bv->workWidth() : 100), height_(0),
+ : maxwidth_(bv ? bv->workWidth() : 100),
+ current_font(LyXFont::ALL_INHERIT),
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 screen x,y coordinates
+InsetBase * LyXText::checkInsetHit(int x, int y) const
+{
+ 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[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[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": Hit inset: " << inset << endl;
+ return inset;
+ }
+ }
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": No inset hit. " << endl;
+ return 0;
+}
+
+
+
// Gets the fully instantiated font at a given position in a paragraph
// Basically the same routine as Paragraph::getFont() in paragraph.C.
// 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);
+
+ // Find the pit value belonging to paragraph. This will not break
+ // even if pars_ would not be a vector anymore.
+ // Performance appears acceptable.
+
+ pit_type pit = pars_.size();
+ for (pit_type it = 0; it < pit; ++it)
+ if (&pars_[it] == &par) {
+ pit = it;
+ break;
+ }
+ // Realize against environment font information
+ if (pit < pars_.size())
+ font.realize(outerFont(pit, pars_));
// Realize with the fonts of lesser depth.
- //font.realize(outerFont(pit, paragraphs()));
- font.realize(defaultfont_);
+ font.realize(params.getFont());
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(bv()->buffer()->params().getFont());
+ 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 font = layout->font;
// Realize with the fonts of lesser depth.
//font.realize(outerFont(pit, paragraphs()));
- font.realize(defaultfont_);
+ font.realize(bv()->buffer()->params().getFont());
return font;
}
-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_);
+ font.realize(bv()->buffer()->params().getFont());
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);
}
}
- layoutfont.realize(defaultfont_);
+ // Inside inset, apply the inset's font attributes if any
+ // (charstyle!)
+ if (!isMainText())
+ layoutfont.realize(font_);
+
+ layoutfont.realize(bv()->buffer()->params().getFont());
// Now, reduce font against full layout font
font.reduce(layoutfont);
}
-// used in setLayout
-// Asger is not sure we want to do this...
-void LyXText::makeFontEntriesLayoutSpecific(BufferParams const & params,
- Paragraph & par)
-{
- LyXLayout_ptr const & layout = par.layout();
- pos_type const psize = par.size();
-
- LyXFont layoutfont;
- for (pos_type pos = 0; pos < psize; ++pos) {
- if (pos < par.beginOfBody())
- layoutfont = layout->labelfont;
- else
- layoutfont = layout->font;
-
- LyXFont tmpfont = par.getFontSettings(params, pos);
- tmpfont.reduce(layoutfont);
- par.setFont(pos, tmpfont);
- }
-}
-
-
// 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)
+void LyXText::setLayout(pit_type start, pit_type end, string const & layout)
{
BOOST_ASSERT(start != end);
- par_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)
pars_[pit].setLabelWidthString(lyxlayout->labelstring());
}
-
- return undopit;
}
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;
+ pit_type undopit = undoSpan(end - 1);
+ recUndo(start, undopit - 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);
}
// the cursor set functions have a special mechanism. When they
// realize you left an empty paragraph, they will delete it.
-void LyXText::cursorHome(LCursor & cur)
+bool 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());
+
+ return setCursor(cur, cur.pit(), row.pos());
}
-void LyXText::cursorEnd(LCursor & cur)
+bool LyXText::cursorEnd(LCursor & cur)
{
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 false;
+ bool boundary = false;
+ if (end != cur.lastpos()) {
+ if (!cur.paragraph().isLineSeparator(end-1)
+ && !cur.paragraph().isNewline(end-1))
+ boundary = true;
+ else
+ --end;
+ }
+ return setCursor(cur, cur.pit(), end, true, boundary);
}
-void LyXText::cursorTop(LCursor & cur)
+bool LyXText::cursorTop(LCursor & cur)
{
BOOST_ASSERT(this == cur.text());
- setCursor(cur, 0, 0);
+ return setCursor(cur, 0, 0);
}
-void LyXText::cursorBottom(LCursor & cur)
+bool LyXText::cursorBottom(LCursor & cur)
{
BOOST_ASSERT(this == cur.text());
- setCursor(cur, cur.lastpar(), boost::prior(paragraphs().end())->size());
+ return 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_);
}
linestr[i] = ' ';
newline_inserted = true;
}
- } else if (IsPrintable(linestr[i])) {
+ } else if (isPrintable(linestr[i])) {
newline_inserted = false;
}
}
}
-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;
}
- x = int(tmpx) + xo_;
- return c - row.pos();
+ // 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;
+ 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());
}
-// x,y are absolute coordinates
-void LyXText::setCursorFromCoordinates(LCursor & cur, int x, int y)
+// y is screen coordinate
+pit_type LyXText::getPitNearY(int y) 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);
+ BOOST_ASSERT(!paragraphs().empty());
+ 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_;
+ }
+ }
+
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": found best y: " << yy << " for pit: " << pit
+ << endl;
+
+ return pit;
+}
+
+
+Row const & LyXText::getRowNearY(int y, pit_type pit) const
+{
+ 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)
{
- 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[Debug::DEBUG] << "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.
BOOST_ASSERT((pos != 0 && inset == pars_[pit].getInset(pos - 1))
- || inset == pars_[pit].getInset(pos));
+ || inset == pars_[pit].getInset(pos));
// Make sure the cursor points to the position before
// 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);
+ cur.clearSelection();
+
+ // 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);
+ cur.clearSelection();
+
+ // 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)
+bool LyXText::deleteEmptyParagraphMechanism(LCursor & cur, LCursor & 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()];
+ // old should point to us
+ BOOST_ASSERT(old.text() == this);
+
+ Paragraph & oldpar = old.paragraph();
// We allow all kinds of "mumbo-jumbo" when freespacing.
if (oldpar.isFreeSpacing())
return false;
/* Ok I'll put some comments here about what is missing.
- I have fixed BackSpace (and thus Delete) to not delete
- double-spaces automagically. I have also changed Cut,
- 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 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
- sure none of these are very hard to fix, but I will
- put out 1.1.4pre2 with FIX_DOUBLE_SPACE defined so
- that I can get some feedback. (Lgb)
+ beginning and then save right after the paste. (Lgb)
*/
// If old.pos() == 0 and old.pos()(1) == LineSeparator
// delete the LineSeparator.
// MISSING
- // If the chars around the old cursor were spaces, delete one of them.
- if (old.par() != cur.par() || old.pos() != cur.pos()) {
+ bool const same_inset = &old.inset() == &cur.inset();
+ bool const same_par = same_inset && old.pit() == cur.pit();
+ bool const same_par_pos = same_par && old.pos() == cur.pos();
+ // If the chars around the old cursor were spaces, delete one of them.
+ if (!same_par_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
+ oldpar.setChange(old.pos() -1, Change::INSERTED);
+ oldpar.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
// automated way in CursorSlice code. (JMarc 26/09/2001)
#endif
// correct all cursor parts
- fixCursorAfterDelete(cur.top(), old.top());
-#ifdef WITH_WARNINGS
-#warning DEPM, look here
-#endif
- //fixCursorAfterDelete(cur.anchor(), old.top());
- return false;
+ if (same_par) {
+ fixCursorAfterDelete(cur.top(), old.top());
+ cur.resetAnchor();
+ }
+ return true;
}
}
// only do our magic if we changed paragraph
- if (old.par() == cur.par())
+ if (same_par)
return false;
// don't delete anything if this is the ONLY paragraph!
- if (pars_.size() == 1)
+ if (old.lastpit() == 0)
return false;
// Do not delete empty paragraphs with keepempty set.
if (oldpar.allowEmpty())
return false;
- // record if we have deleted a paragraph
- // we can't possibly have deleted a paragraph before this point
- bool deleted = false;
-
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();
-
- // 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());
-
// Delete old par.
- pars_.erase(pars_.begin() + old.par());
-
- // 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();
-#ifdef WITH_WARNINGS
-#warning DEPM, look here
-#endif
-// if (cur.anchor().par() > old.par())
-// --cur.anchor().par();
-
- if (selection_position_was_oldcursor_position) {
- // correct selection
- cur.resetAnchor();
+ recordUndo(old, Undo::ATOMIC,
+ max(old.pit() - 1, pit_type(0)),
+ min(old.pit() + 1, old.lastpit()));
+ ParagraphList & plist = old.text()->paragraphs();
+ plist.erase(boost::next(plist.begin(), old.pit()));
+
+ // see #warning above
+ if (cur.depth() >= old.depth()) {
+ CursorSlice & curslice = cur[old.depth() - 1];
+ if (&curslice.inset() == &old.inset()
+ && curslice.pit() > old.pit()) {
+ --curslice.pit();
+ // since a paragraph has been deleted, all the
+ // insets after `old' have been copied and
+ // their address has changed. Therefore we
+ // need to `regenerate' cur. (JMarc)
+ cur.updateInsets(&(cur.bottom().inset()));
+ cur.resetAnchor();
+ }
}
- }
-
- if (deleted)
+ ParIterator par_it(old);
+ if (needsUpdateCounters(old.buffer(), par_it))
+ updateCounters(old.buffer());
return true;
+ }
- if (pars_[old.par()].stripLeadingSpaces())
+ if (oldpar.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);
}