#include "buffer.h"
#include "buffer_funcs.h"
+#include "bufferlist.h"
#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 "LColor.h"
+#include "lyxfunc.h"
#include "lyxrc.h"
#include "lyxrow.h"
-#include "lyxrow_funcs.h"
#include "paragraph.h"
#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
+#include "pariterator.h"
+#include "lyxserver.h"
+#include "lyxsocket.h"
#include "undo.h"
#include "vspace.h"
-#include "frontends/font_metrics.h"
-#include "frontends/LyXView.h"
+#include "frontends/FontMetrics.h"
-#include "insets/insetbibitem.h"
#include "insets/insetenv.h"
-#include "insets/insetfloat.h"
-#include "insets/insetwrap.h"
-#include "support/lstrings.h"
+#include "mathed/InsetMathHull.h"
+
#include "support/textutils.h"
-#include "support/convert.h"
+
+#include <boost/current_function.hpp>
#include <sstream>
-using lyx::pit_type;
-using lyx::pos_type;
-using lyx::support::bformat;
+
+namespace lyx {
using std::endl;
using std::ostringstream;
using std::string;
+using std::max;
+using std::min;
LyXText::LyXText(BufferView * bv)
: maxwidth_(bv ? bv->workWidth() : 100),
+ current_font(LyXFont::ALL_INHERIT),
background_color_(LColor::background),
- bv_owner(bv),
autoBreakRows_(false)
{}
void LyXText::init(BufferView * bv)
{
BOOST_ASSERT(bv);
- bv_owner = bv;
maxwidth_ = bv->workWidth();
dim_.wid = maxwidth_;
dim_.asc = 10;
for (pit_type pit = 0; pit != end; ++pit)
pars_[pit].rows().clear();
- current_font = getFont(pars_[0], 0);
- updateCounters();
+ updateLabels(*bv->buffer());
}
-bool LyXText::isMainText() const
+bool LyXText::isMainText(Buffer const & buffer) const
{
- return &bv()->buffer()->text() == this;
+ return &buffer.text() == this;
}
//takes screen x,y coordinates
-InsetBase * LyXText::checkInsetHit(int x, int y) const
+InsetBase * LyXText::checkInsetHit(BufferView const & bv, int x, int y) const
{
- pit_type pit = getPitNearY(y);
+ pit_type pit = getPitNearY(bv, y);
BOOST_ASSERT(pit != -1);
Paragraph const & par = pars_[pit];
- lyxerr << "checkInsetHit: x: " << x << " y: " << y << endl;
- lyxerr << " pit: " << pit << endl;
+ 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.getInsets().has(inset))
- lyxerr
- << " xo: " << inset->xo() << "..."
- << inset->xo() + inset->width()
- << " yo: " << inset->yo() - inset->ascent()
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": examining inset " << inset << endl;
+
+ if (bv.coordCache().getInsets().has(inset))
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": xo: " << inset->xo(bv) << "..."
+ << inset->xo(bv) + inset->width()
+ << " yo: " << inset->yo(bv) - inset->ascent()
<< "..."
- << inset->yo() + inset->descent() << endl;
+ << inset->yo(bv) + inset->descent()
+ << endl;
else
- lyxerr << " inset has no cached position" << endl;
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": inset has no cached position" << endl;
#endif
- if (inset->covers(x, y)) {
- lyxerr << "Hit inset: " << inset << endl;
+ if (inset->covers(bv, 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(Paragraph const & par, pos_type const pos) const
+LyXFont LyXText::getFont(Buffer const & buffer, Paragraph const & par,
+ pos_type const pos) const
{
BOOST_ASSERT(pos >= 0);
#ifdef WITH_WARNINGS
#warning broken?
#endif
- BufferParams const & params = bv()->buffer()->params();
+ BufferParams const & params = buffer.params();
pos_type const body_pos = par.beginOfBody();
// We specialize the 95% common case:
if (!par.getDepth()) {
LyXFont f = par.getFontSettings(params, pos);
- if (!isMainText())
- f.realize(font_);
- if (layout->labeltype == LABEL_MANUAL && pos < body_pos)
- return f.realize(layout->reslabelfont);
- else
- return f.realize(layout->resfont);
+ if (!isMainText(buffer))
+ applyOuterFont(buffer, f);
+ LyXFont lf;
+ LyXFont rlf;
+ if (layout->labeltype == LABEL_MANUAL && pos < body_pos) {
+ lf = layout->labelfont;
+ rlf = layout->reslabelfont;
+ } else {
+ lf = layout->font;
+ rlf = layout->resfont;
+ }
+ // In case the default family has been customized
+ if (lf.family() == LyXFont::INHERIT_FAMILY)
+ rlf.setFamily(params.getFont().family());
+ return f.realize(rlf);
}
// The uncommon case need not be optimized as much
LyXFont font = par.getFontSettings(params, pos);
font.realize(layoutfont);
- if (!isMainText())
- font.realize(font_);
+ if (!isMainText(buffer))
+ applyOuterFont(buffer, 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
+ // NOTE: the cast to pit_type should be removed when pit_type
+ // changes to a unsigned integer.
+ if (pit < pit_type(pars_.size()))
+ font.realize(outerFont(pit, pars_));
// Realize with the fonts of lesser depth.
- 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(Buffer const & buffer, LyXFont & font) const {
+ LyXFont lf(font_);
+ lf.reduce(buffer.params().getFont());
+ lf.realize(font);
+ lf.setLanguage(font.language());
+ font = lf;
+}
+
-LyXFont LyXText::getLayoutFont(pit_type const pit) const
+LyXFont LyXText::getLayoutFont(Buffer const & buffer, pit_type const pit) const
{
LyXLayout_ptr const & layout = pars_[pit].layout();
- if (!pars_[pit].getDepth())
- return layout->resfont;
+ if (!pars_[pit].getDepth()) {
+ LyXFont lf = layout->resfont;
+ // In case the default family has been customized
+ if (layout->font.family() == LyXFont::INHERIT_FAMILY)
+ lf.setFamily(buffer.params().getFont().family());
+ return lf;
+ }
LyXFont font = layout->font;
// Realize with the fonts of lesser depth.
//font.realize(outerFont(pit, paragraphs()));
- font.realize(defaultfont_);
+ font.realize(buffer.params().getFont());
return font;
}
-LyXFont LyXText::getLabelFont(Paragraph const & par) const
+LyXFont LyXText::getLabelFont(Buffer const & buffer, Paragraph const & par) const
{
LyXLayout_ptr const & layout = par.layout();
- if (!par.getDepth())
- return layout->reslabelfont;
+ if (!par.getDepth()) {
+ LyXFont lf = layout->reslabelfont;
+ // In case the default family has been customized
+ if (layout->labelfont.family() == LyXFont::INHERIT_FAMILY)
+ lf.setFamily(buffer.params().getFont().family());
+ return lf;
+ }
LyXFont font = layout->labelfont;
// Realize with the fonts of lesser depth.
- font.realize(defaultfont_);
+ font.realize(buffer.params().getFont());
return font;
}
-void LyXText::setCharFont(pit_type pit, pos_type pos, LyXFont const & fnt)
+void LyXText::setCharFont(Buffer const & buffer, pit_type pit,
+ pos_type pos, LyXFont const & fnt)
{
LyXFont font = fnt;
LyXLayout_ptr const & layout = pars_[pit].layout();
}
}
- layoutfont.realize(defaultfont_);
+ // Inside inset, apply the inset's font attributes if any
+ // (charstyle!)
+ if (!isMainText(buffer))
+ layoutfont.realize(font_);
+
+ layoutfont.realize(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
pit_type LyXText::undoSpan(pit_type pit)
{
}
-pit_type LyXText::setLayout(pit_type start, pit_type end, string const & layout)
+void LyXText::setLayout(Buffer const & buffer, pit_type start, pit_type end,
+ string const & layout)
{
BOOST_ASSERT(start != end);
- pit_type undopit = undoSpan(end - 1);
- recUndo(start, undopit - 1);
- BufferParams const & bufparams = bv()->buffer()->params();
+ BufferParams const & bufparams = buffer.params();
LyXLayout_ptr const & lyxlayout = bufparams.getLyXTextClass()[layout];
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());
+ pars_[pit].setLabelWidthString(buffer.translateLabel(lyxlayout->labelstring()));
}
-
- return undopit;
}
if (lyxlayout->is_environment) {
// move everything in a new environment inset
lyxerr[Debug::DEBUG] << "setting layout " << layout << endl;
- bv.owner()->dispatch(FuncRequest(LFUN_HOME));
- bv.owner()->dispatch(FuncRequest(LFUN_ENDSEL));
- bv.owner()->dispatch(FuncRequest(LFUN_CUT));
+ lyx::dispatch(FuncRequest(LFUN_LINE_BEGIN));
+ lyx::dispatch(FuncRequest(LFUN_LINE_END_SELECT));
+ lyx::dispatch(FuncRequest(LFUN_CUT));
InsetBase * inset = new InsetEnvironment(params, layout);
insertInset(cur, inset);
//inset->edit(cur, true);
- //bv.owner()->dispatch(FuncRequest(LFUN_PASTE));
+ //lyx::dispatch(FuncRequest(LFUN_PASTE));
return;
}
pit_type start = cur.selBegin().pit();
pit_type end = cur.selEnd().pit() + 1;
- setLayout(start, end, layout);
- updateCounters();
+ pit_type undopit = undoSpan(end - 1);
+ recUndo(cur, start, undopit - 1);
+ setLayout(cur.buffer(), start, end, layout);
+ updateLabels(cur.buffer());
}
-namespace {
-
-
-bool changeDepthAllowed(LyXText::DEPTH_CHANGE type,
- Paragraph const & par, int max_depth)
+static bool changeDepthAllowed(LyXText::DEPTH_CHANGE type,
+ 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());
+ // this happens when selecting several cells in tabular (bug 2630)
+ if (cur.selBegin().idx() != cur.selEnd().idx())
+ return false;
+
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 (pit_type pit = beg; pit != end; ++pit) {
- if (::changeDepthAllowed(type, pars_[pit], max_depth))
+ if (lyx::changeDepthAllowed(type, pars_[pit], max_depth))
return true;
max_depth = pars_[pit].getMaxDepthAfter();
}
for (pit_type pit = beg; pit != end; ++pit) {
Paragraph & par = pars_[pit];
- if (::changeDepthAllowed(type, par, max_depth)) {
+ if (lyx::changeDepthAllowed(type, par, max_depth)) {
int const depth = par.params().depth();
if (type == INC_DEPTH)
par.params().depth(depth + 1);
}
// this handles the counter labels, and also fixes up
// depth values for follow-on (child) paragraphs
- updateCounters();
+ updateLabels(cur.buffer());
}
LyXFont layoutfont;
pit_type pit = cur.pit();
if (cur.pos() < pars_[pit].beginOfBody())
- layoutfont = getLabelFont(pars_[pit]);
+ layoutfont = getLabelFont(cur.buffer(), pars_[pit]);
else
- layoutfont = getLayoutFont(pit);
+ layoutfont = getLayoutFont(cur.buffer(), pit);
// Update current font
real_current_font.update(font,
// Don't use forwardChar here as ditend might have
// pos() == lastpos() and forwardChar would miss it.
- for (; dit != ditend; dit.forwardPos()) {
+ // 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());
+ LyXFont f = getFont(cur.buffer(), dit.paragraph(), dit.pos());
f.update(font, params.language, toggleall);
- setCharFont(dit.pit(), dit.pos(), f);
+ setCharFont(cur.buffer(), dit.pit(), dit.pos(), f);
}
}
}
// 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.pit(), 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
-// FIXME: does this final space exist?
- pos_type const end = cur.textRow().endpos();
- setCursor(cur, cur.pit(), 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.lastpit(), 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;
}
bool implicitSelection =
font.language() == ignore_language
&& font.number() == LyXFont::IGNORE
- && selectWordWhenUnderCursor(cur, lyx::WHOLE_WORD_STRICT);
+ && selectWordWhenUnderCursor(cur, WHOLE_WORD_STRICT);
// Set font
setFont(cur, font, toggleall);
}
-string LyXText::getStringToIndex(LCursor & cur)
+docstring 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().pit() != cur.selEnd().pit())
- cur.message(_("Cannot index more than one paragraph!"));
- else
- idxstring = cur.selectionAsString(false);
- // Reset cursors to their original position.
- cur.top() = reset_cursor;
- cur.resetAnchor();
-
- // Clear the implicit selection.
- if (implicitSelection)
- cur.clearSelection();
+ docstring idxstring;
+ if (cur.selection())
+ idxstring = cur.selectionAsString(false);
+ else {
+ // Try implicit word selection. If there is a change
+ // in the language the implicit word selection is
+ // disabled.
+ LCursor tmpcur = cur;
+ selectWord(tmpcur, 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,
+ docstring const & labelwidthstring, bool noindent)
{
BOOST_ASSERT(cur.text());
// make sure that the depth behind the selection are restored, too
pit_type undopit = undoSpan(cur.selEnd().pit());
- recUndo(cur.selBegin().pit(), undopit - 1);
+ recUndo(cur, cur.selBegin().pit(), undopit - 1);
for (pit_type pit = cur.selBegin().pit(), end = cur.selEnd().pit();
- pit <= end; ++pit) {
+ pit <= end; ++pit) {
Paragraph & par = pars_[pit];
ParagraphParameters & params = par.params();
params.spacing(spacing);
}
-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, pit_type pit, pit_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();
-
- pit_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, pit_type pit,
- pit_type firstpit, Counters & counters)
-{
- if (pit == firstpit)
- return;
-
- int const cur_depth = pars[pit].getDepth();
- pit_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, pit_type pit)
-{
- Paragraph & par = pars_[pit];
- BufferParams const & bufparams = buf.params();
- LyXTextClass const & textclass = bufparams.getLyXTextClass();
- LyXLayout_ptr const & layout = par.layout();
- Counters & counters = textclass.counters();
-
- // Always reset
- par.itemdepth = 0;
-
- if (pit == 0) {
- par.params().appendix(par.params().startOfAppendix());
- } else {
- par.params().appendix(pars_[pit - 1].params().appendix());
- if (!par.params().appendix() &&
- par.params().startOfAppendix()) {
- par.params().appendix(true);
- textclass.counters().reset();
- }
-
- // Maybe we have to increment the item depth.
- incrementItemDepth(pars_, pit, 0);
- }
-
- // erase what was there before
- par.params().labelString(string());
-
- if (layout->margintype == MARGIN_MANUAL) {
- if (par.params().labelWidthString().empty())
- par.setLabelWidthString(layout->labelstring());
- } else {
- par.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, par.params().appendix());
- par.params().labelString(label);
- } else if (layout->labeltype == LABEL_ITEMIZE) {
- // At some point of time we should do something more
- // clever here, like:
- // par.params().labelString(
- // bufparams.user_defined_bullet(par.itemdepth).getText());
- // for now, use a simple hardcoded label
- string itemlabel;
- switch (par.itemdepth) {
- case 0:
- itemlabel = "*";
- break;
- case 1:
- itemlabel = "-";
- break;
- case 2:
- itemlabel = "@";
- break;
- case 3:
- itemlabel = "·";
- break;
- }
-
- par.params().labelString(itemlabel);
- } else if (layout->labeltype == LABEL_ENUMERATE) {
- // Maybe we have to reset the enumeration counter.
- resetEnumCounterIfNeeded(pars_, pit, 0, counters);
-
- // FIXME
- // Yes I know this is a really, really! bad solution
- // (Lgb)
- string enumcounter = "enum";
-
- switch (par.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);
-
- par.params().labelString(counters.enumLabel(enumcounter));
- } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
- counters.step("bibitem");
- int number = counters.value("bibitem");
- if (par.bibitem()) {
- par.bibitem()->setCounter(number);
- par.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) {
- pit_type end = paragraphs().size();
- pit_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;
- }
-#ifdef WITH_WARNINGS
-#warning replace this code by something that works
-// This code does not work because we have currently no way to move up
-// in the hierarchy of insets (JMarc 16/08/2004)
-#endif
-#if 0
-/* I think this code is supposed to be useful when one has a caption
- * in a minipage in a figure inset. We need to go up to be able to see
- * that the caption should use "Figure" as label
- */
- else {
- Paragraph const * owner = &ownerPar(buf, in);
- tmppit = 0;
- for ( ; tmppit != end; ++tmppit)
- if (&pars_[tmppit] == owner)
- break;
- }
-#else
- ++tmppit;
-#endif
- }
-
- 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: ");
- }
- }
- par.params().labelString(s);
-
- }
-}
-
-
-// Updates all counters.
-void LyXText::updateCounters()
-{
- // start over
- bv()->buffer()->params().getLyXTextClass().counters().reset();
-
- bool update_pos = false;
-
- pit_type end = paragraphs().size();
- for (pit_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;
- update_pos = true;
- }
- }
-}
-
-
// 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);
+ cur.paragraph().insertInset(cur.pos(), inset,
+ Change(cur.buffer().params().trackChanges ?
+ Change::INSERTED : Change::UNCHANGED));
}
// needed to insert the selection
-void LyXText::insertStringAsLines(LCursor & cur, string const & str)
+void LyXText::insertStringAsLines(LCursor & cur, docstring const & str)
{
- pit_type pit = cur.pit();
- 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,
- autoBreakRows_);
-
- cur.resetAnchor();
- setCursor(cur, cur.pit(), pos);
- cur.setSelection();
+ cur.buffer().insertStringAsLines(pars_, cur.pit(), cur.pos(),
+ current_font, str, autoBreakRows_);
}
// turn double CR to single CR, others are converted into one
// blank. Then insertStringAsLines is called
-void LyXText::insertStringAsParagraphs(LCursor & cur, string const & str)
+void LyXText::insertStringAsParagraphs(LCursor & cur, docstring const & str)
{
- string linestr = str;
+ docstring linestr = str;
bool newline_inserted = false;
for (string::size_type i = 0, siz = linestr.size(); i < siz; ++i) {
linestr[i] = ' ';
newline_inserted = true;
}
- } else if (IsPrintable(linestr[i])) {
+ } else if (isPrintable(linestr[i])) {
newline_inserted = false;
}
}
bool LyXText::setCursor(LCursor & cur, pit_type par, pos_type pos,
- bool setfont, bool boundary)
+ bool setfont, bool boundary)
{
LCursor old = cur;
setCursorIntern(cur, par, pos, setfont, boundary);
}
-void LyXText::setCursor(CursorSlice & cur, pit_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.pit() = par;
cur.pos() = pos;
- cur.boundary() = boundary;
// now some strict checking
Paragraph & para = getPar(par);
void LyXText::setCursorIntern(LCursor & cur,
- pit_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);
+ BOOST_ASSERT(this == cur.text());
+ cur.boundary(boundary);
+ setCursor(cur.top(), par, pos);
cur.setTargetX();
if (setfont)
setCurrentFont(cur);
BufferParams const & bufparams = cur.buffer().params();
current_font = par.getFontSettings(bufparams, pos);
- real_current_font = getFont(par, pos);
+ real_current_font = getFont(cur.buffer(), par, pos);
if (cur.pos() == cur.lastpos()
&& bidi.isBoundary(cur.buffer(), par, cur.pos())
// 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(pit_type const pit,
- Row const & row, int & x, bool & boundary) const
+pos_type LyXText::getColumnNearX(BufferView const & bv, pit_type const pit,
+ Row const & row, int & x, bool & boundary) const
{
- int const xo = theCoords.get(this, pit).x_;
+ Buffer const & buffer = *bv.buffer();
+ int const xo = bv.coordCache().get(this, pit).x_;
x -= xo;
- RowMetrics const r = computeRowMetrics(pit, row);
+ RowMetrics const r = computeRowMetrics(buffer, pit, row);
Paragraph const & par = pars_[pit];
pos_type vc = row.pos();
return 0;
}
+ frontend::FontMetrics const & fm
+ = theFontMetrics(getLabelFont(buffer, par));
+
while (vc < end && tmpx <= x) {
c = bidi.vis2log(vc);
last_tmpx = tmpx;
if (body_pos > 0 && c == body_pos - 1) {
- tmpx += r.label_hfill +
- font_metrics::width(layout->labelsep, getLabelFont(par));
+ // FIXME UNICODE
+ docstring const lsep = from_utf8(layout->labelsep);
+ tmpx += r.label_hfill + fm.width(lsep);
if (par.isLineSeparator(body_pos - 1))
- tmpx -= singleWidth(par, body_pos - 1);
+ tmpx -= singleWidth(buffer, par, body_pos - 1);
}
- if (hfillExpansion(par, row, c)) {
- tmpx += singleWidth(par, c);
+ if (par.hfillExpansion(row, c)) {
+ tmpx += singleWidth(buffer, par, c);
if (c >= body_pos)
tmpx += r.hfill;
else
tmpx += r.label_hfill;
} else if (par.isSeparator(c)) {
- tmpx += singleWidth(par, c);
+ tmpx += singleWidth(buffer, par, c);
if (c >= body_pos)
tmpx += r.separator;
} else {
- tmpx += singleWidth(par, c);
+ tmpx += singleWidth(buffer, par, c);
}
++vc;
}
// If lastrow is false, we don't need to compute
// the value of rtl.
- bool const rtl = lastrow ? isRTL(par) : false;
+ bool const rtl = lastrow ? isRTL(buffer, 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(), par, c);
+ boundary = bidi.isBoundary(buffer, par, c);
}
}
+// 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(par, end - 1);
+ tmpx -= singleWidth(buffer, par, end - 1);
else
- tmpx += singleWidth(par, end - 1);
+ tmpx += singleWidth(buffer, 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();
+ 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 screen coordinate
-pit_type LyXText::getPitNearY(int y) const
+pit_type LyXText::getPitNearY(BufferView const & bv, int y) const
{
BOOST_ASSERT(!paragraphs().empty());
- BOOST_ASSERT(theCoords.getParPos().find(this) != theCoords.getParPos().end());
- CoordCache::InnerParPosCache const & cc = theCoords.getParPos().find(this)->second;
- lyxerr << "LyXText::getPitNearY: y: " << y << " cache size: "
- << cc.size() << endl;
+ BOOST_ASSERT(bv.coordCache().getParPos().find(this) != bv.coordCache().getParPos().end());
+ CoordCache::InnerParPosCache const & cc = bv.coordCache().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;
CoordCache::InnerParPosCache::const_iterator it = cc.begin();
CoordCache::InnerParPosCache::const_iterator et = cc.end();
for (; it != et; ++it) {
- lyxerr << " examining: pit: " << it->first << " y: "
- << it->second.y_ << endl;
+ 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 << " found best y: " << yy << " for pit: " << pit << endl;
+ 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
+Row const & LyXText::getRowNearY(BufferView const & bv, int y, pit_type pit) const
{
Paragraph const & par = pars_[pit];
- int yy = theCoords.get(this, pit).y_ - par.ascent();
+ int yy = bv.coordCache().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());
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)
{
- pit_type pit = getPitNearY(y);
+ if (lyxerr.debugging(Debug::WORKAREA)) {
+ lyxerr << "LyXText::editXY(cur, " << x << ", " << y << ")" << std::endl;
+ cur.bv().coordCache().dump();
+ }
+ pit_type pit = getPitNearY(cur.bv(), y);
BOOST_ASSERT(pit != -1);
- Row const & row = getRowNearY(y, pit);
+ Row const & row = getRowNearY(cur.bv(), y, pit);
bool bound = false;
int xx = x; // is modified by getColumnNearX
- pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound);
+ pos_type const pos = row.pos()
+ + getColumnNearX(cur.bv(), pit, row, xx, bound);
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;
+ InsetBase * inset = checkInsetHit(cur.bv(), x, y);
+ //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
- const_cast<LyXText *>(this)->setCurrentFont(cur);
+ // Either we deconst editXY or better we move current_font
+ // and real_current_font to LCursor
+ setCurrentFont(cur);
return 0;
}
+ InsetBase * insetBefore = pos? pars_[pit].getInset(pos - 1): 0;
+ //InsetBase * insetBehind = pars_[pit].getInset(pos);
+
// 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));
+ BOOST_ASSERT((pos != 0 && inset == insetBefore)
+ || inset == pars_[pit].getInset(pos));
+
// Make sure the cursor points to the position before
// this inset.
- if (inset == pars_[pit].getInset(pos - 1))
+ if (inset == insetBefore)
--cur.pos();
+
+ // Try to descend recursively inside the inset.
inset = inset->editXY(cur, x, y);
+
if (cur.top().text() == this)
- const_cast<LyXText *>(this)->setCurrentFont(cur);
+ 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.pit(), 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.pit(), 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.pit() != 0) {
- // steps into the paragraph above
- setCursor(cur, cur.pit() - 1, getPar(cur.pit() - 1).size());
+ // 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.pit(), 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.pit(), 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.pit(), cur.pos(), true, true);
+ cur.pos()))
+ updateNeeded |= setCursor(cur, cur.pit(), cur.pos(), true, true);
}
- return;
+ return updateNeeded;
}
if (cur.pit() != cur.lastpit())
- setCursor(cur, cur.pit() + 1, 0);
+ return setCursor(cur, cur.pit() + 1, 0);
+ return false;
}
-void LyXText::cursorUp(LCursor & cur)
+bool LyXText::cursorUp(LCursor & cur)
{
Paragraph const & par = cur.paragraph();
- int const row = par.pos2row(cur.pos());
+ 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()) {
- int const y = bv_funcs::getPos(cur).y_;
- editXY(cur, x, y - par.rows()[row].ascent() - 1);
- return;
+ int const y = bv_funcs::getPos(cur.bv(), cur, cur.boundary()).y_;
+ LCursor old = cur;
+ // Go to middle of previous row. 16 found to work OK;
+ // 12 = top/bottom margin of display math
+ int const margin = 3 * InsetMathHull::displayMargin() / 2;
+ editXY(cur, x, y - par.rows()[row].ascent() - margin);
+ 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) {
- setCursor(cur, cur.pit(), x2pos(cur.pit(), row - 1, x));
+ updateNeeded |= setCursor(cur, cur.pit(),
+ x2pos(cur.bv(), cur.pit(), row - 1, x));
} else if (cur.pit() > 0) {
--cur.pit();
- setCursor(cur, cur.pit(), x2pos(cur.pit(), cur.paragraph().rows().size() - 1, x));
-
+ //cannot use 'par' now
+ updateNeeded |= setCursor(cur, cur.pit(),
+ x2pos(cur.bv(), cur.pit(), cur.paragraph().rows().size() - 1, x));
}
cur.x_target() = x;
+
+ return updateNeeded;
}
-void LyXText::cursorDown(LCursor & cur)
+bool LyXText::cursorDown(LCursor & cur)
{
Paragraph const & par = cur.paragraph();
- int const row = par.pos2row(cur.pos());
+ 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()) {
- int const y = bv_funcs::getPos(cur).y_;
- editXY(cur, x, y + par.rows()[row].descent() + 1);
- return;
+ int const y = bv_funcs::getPos(cur.bv(), cur, cur.boundary()).y_;
+ LCursor old = cur;
+ // To middle of next row
+ int const margin = 3 * InsetMathHull::displayMargin() / 2;
+ editXY(cur, x, y + par.rows()[row].descent() + margin);
+ 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())) {
- setCursor(cur, cur.pit(), x2pos(cur.pit(), row + 1, x));
+ updateNeeded |= setCursor(cur, cur.pit(),
+ x2pos(cur.bv(), cur.pit(), row + 1, x));
} else if (cur.pit() + 1 < int(paragraphs().size())) {
++cur.pit();
- setCursor(cur, cur.pit(), x2pos(cur.pit(), 0, x));
+ updateNeeded |= setCursor(cur, cur.pit(),
+ x2pos(cur.bv(), 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.pit(), 0);
+ updated = setCursor(cur, cur.pit(), 0);
else if (cur.pit() != 0)
- setCursor(cur, cur.pit() - 1, 0);
+ updated = setCursor(cur, cur.pit() - 1, 0);
+ return updated;
}
-void LyXText::cursorDownParagraph(LCursor & cur)
+bool LyXText::cursorDownParagraph(LCursor & cur)
{
+ bool updated = false;
if (cur.pit() != cur.lastpit())
- setCursor(cur, cur.pit() + 1, 0);
+ updated = setCursor(cur, cur.pit() + 1, 0);
else
- setCursor(cur, cur.pit(), 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.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.pit()];
+ // 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.pit() != cur.pit() || 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.pit()].erase(old.pos() - 1);
+ && oldpar.isLineSeparator(old.pos() - 1)
+ && !oldpar.isDeleted(old.pos() - 1)) {
+ oldpar.eraseChar(old.pos() - 1, false); // do not track changes in DEPM
#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.pit() == cur.pit())
+ 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
- deleted = true;
-
- bool selection_position_was_oldcursor_position =
- 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.pit(), cur.pit());
-
// Delete 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.pit() > old.pit())
- --cur.pit();
-#ifdef WITH_WARNINGS
-#warning DEPM, look here
-#endif
-// if (cur.anchor().pit() > old.pit())
-// --cur.anchor().pit();
-
- 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)
+ // There is a crash reported by Edwin Leuven (16/04/2006) because of:
+ //ParIterator par_it(old);
+ //updateLabels(old.buffer(), par_it);
+ // So for now we do the full update:
+ updateLabels(old.buffer());
return true;
+ }
- if (pars_[old.pit()].stripLeadingSpaces())
+ if (oldpar.stripLeadingSpaces())
cur.resetAnchor();
return false;
}
-ParagraphList & LyXText::paragraphs() const
+void LyXText::recUndo(LCursor & cur, pit_type first, pit_type last) const
{
- return const_cast<ParagraphList &>(pars_);
+ recordUndo(cur, Undo::ATOMIC, first, last);
}
-void LyXText::recUndo(pit_type first, pit_type last) const
+void LyXText::recUndo(LCursor & cur, pit_type par) const
{
- recordUndo(bv()->cursor(), Undo::ATOMIC, first, last);
+ recordUndo(cur, Undo::ATOMIC, par, par);
}
-void LyXText::recUndo(pit_type par) const
+int defaultRowHeight()
{
- recordUndo(bv()->cursor(), Undo::ATOMIC, par, par);
+ return int(theFontMetrics(LyXFont(LyXFont::ALL_SANE)).maxHeight() * 1.2);
}
-int defaultRowHeight()
-{
- return int(font_metrics::maxHeight(LyXFont(LyXFont::ALL_SANE)) * 1.2);
-}
+} // namespace lyx
projects / lyx.git / blobdiff