-/* This file is part of
- * ======================================================
+/**
+ * \file text2.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
*
- * LyX, The Document Processor
+ * \author Asger Alstrup
+ * \author Lars Gullik Bjønnes
+ * \author Alfredo Braunstein
+ * \author Jean-Marc Lasgouttes
+ * \author Angus Leeming
+ * \author John Levon
+ * \author André Pönitz
+ * \author Allan Rae
+ * \author Dekel Tsur
+ * \author Jürgen Vigna
*
- * Copyright 1995 Matthias Ettrich
- * Copyright 1995-2001 The LyX Team.
- *
- * ====================================================== */
+ * Full author contact details are available in file CREDITS.
+ */
#include <config.h>
#include "lyxtext.h"
-#include "LString.h"
-#include "Lsstream.h"
-#include "paragraph.h"
-#include "funcrequest.h"
-#include "frontends/LyXView.h"
-#include "undo_funcs.h"
+
#include "buffer.h"
#include "buffer_funcs.h"
#include "bufferparams.h"
-#include "errorlist.h"
-#include "gettext.h"
#include "BufferView.h"
+#include "Bullet.h"
+#include "counters.h"
+#include "coordcache.h"
+#include "cursor.h"
#include "CutAndPaste.h"
-#include "frontends/Painter.h"
-#include "frontends/font_metrics.h"
#include "debug.h"
-#include "lyxrc.h"
-#include "lyxrow.h"
+#include "dispatchresult.h"
+#include "errorlist.h"
+#include "Floating.h"
#include "FloatList.h"
+#include "funcrequest.h"
+#include "gettext.h"
#include "language.h"
-#include "ParagraphParameters.h"
-#include "counters.h"
+#include "LColor.h"
+#include "lyxrc.h"
+#include "lyxrow.h"
#include "lyxrow_funcs.h"
-#include "metricsinfo.h"
+#include "paragraph.h"
#include "paragraph_funcs.h"
+#include "ParagraphParameters.h"
+#include "undo.h"
+#include "vspace.h"
+
+#include "frontends/font_metrics.h"
+#include "frontends/LyXView.h"
#include "insets/insetbibitem.h"
#include "insets/insetenv.h"
#include "insets/insetfloat.h"
#include "insets/insetwrap.h"
-#include "support/LAssert.h"
-#include "support/textutils.h"
#include "support/lstrings.h"
+#include "support/textutils.h"
+#include "support/convert.h"
-#include <boost/tuple/tuple.hpp>
-
-#include <algorithm>
+#include <sstream>
-using namespace lyx::support;
+using lyx::pit_type;
+using lyx::pos_type;
+using lyx::support::bformat;
-using std::vector;
-using std::copy;
using std::endl;
-using std::find;
-using std::pair;
-using lyx::pos_type;
+using std::ostringstream;
+using std::string;
LyXText::LyXText(BufferView * bv)
- : height(0), width(0), anchor_row_offset_(0),
- inset_owner(0), the_locking_inset(0), bv_owner(bv)
-{
- anchor_row_ = rows().end();
-}
+ : maxwidth_(bv ? bv->workWidth() : 100),
+ background_color_(LColor::background),
+ bv_owner(bv),
+ autoBreakRows_(false)
+{}
-LyXText::LyXText(BufferView * bv, InsetText * inset)
- : height(0), width(0), anchor_row_offset_(0),
- inset_owner(inset), the_locking_inset(0), bv_owner(bv)
+void LyXText::init(BufferView * bv)
{
- anchor_row_ = rows().end();
-}
+ BOOST_ASSERT(bv);
+ bv_owner = bv;
+ maxwidth_ = bv->workWidth();
+ dim_.wid = maxwidth_;
+ dim_.asc = 10;
+ dim_.des = 10;
+ pit_type const end = paragraphs().size();
+ for (pit_type pit = 0; pit != end; ++pit)
+ pars_[pit].rows().clear();
-void LyXText::init(BufferView * bview)
-{
- bv_owner = bview;
+ current_font = getFont(pars_[0], 0);
+ updateCounters();
+}
- rowlist_.clear();
- width = height = 0;
- anchor_row_ = rows().end();
- anchor_row_offset_ = 0;
+bool LyXText::isMainText() const
+{
+ return &bv()->buffer()->text() == this;
+}
- current_font = getFont(ownerParagraphs().begin(), 0);
- redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end());
+//takes screen x,y coordinates
+InsetBase * LyXText::checkInsetHit(int x, int y) const
+{
+ pit_type pit = getPitNearY(y);
+ BOOST_ASSERT(pit != -1);
- setCursorIntern(rowlist_.begin()->par(), 0);
- selection.cursor = cursor;
+ Paragraph const & par = pars_[pit];
- updateCounters();
+ lyxerr << "checkInsetHit: x: " << x << " y: " << y << endl;
+ lyxerr << " 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()
+ << "..."
+ << inset->yo() + inset->descent() << endl;
+ else
+ lyxerr << " inset has no cached position" << endl;
+#endif
+ if (inset->covers(x, y)) {
+ lyxerr << "Hit inset: " << inset << endl;
+ return inset;
+ }
+ }
+ lyxerr << "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)
-// If position is -1, we get the layout font of the paragraph.
-// If position is -2, we get the font of the manual label of the paragraph.
-LyXFont LyXText::getFont(ParagraphList::iterator pit, pos_type pos) const
+LyXFont LyXText::getFont(Paragraph const & par, pos_type const pos) const
{
- Assert(pos >= 0);
+ BOOST_ASSERT(pos >= 0);
- LyXLayout_ptr const & layout = pit->layout();
+ LyXLayout_ptr const & layout = par.layout();
+#ifdef WITH_WARNINGS
#warning broken?
- BufferParams const & params = bv()->buffer()->params;
+#endif
+ BufferParams const & params = bv()->buffer()->params();
+ pos_type const body_pos = par.beginOfBody();
// We specialize the 95% common case:
- if (!pit->getDepth()) {
- if (layout->labeltype == LABEL_MANUAL
- && pos < pit->beginningOfBody()) {
- // 1% goes here
- LyXFont f = pit->getFontSettings(params, pos);
- if (pit->inInset())
- pit->inInset()->getDrawFont(f);
+ 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 {
- LyXFont f = pit->getFontSettings(params, pos);
- if (pit->inInset())
- pit->inInset()->getDrawFont(f);
+ else
return f.realize(layout->resfont);
- }
}
// The uncommon case need not be optimized as much
-
LyXFont layoutfont;
-
- if (pos < pit->beginningOfBody()) {
- // 1% goes here
+ if (pos < body_pos)
layoutfont = layout->labelfont;
- } else {
- // 99% goes here
+ else
layoutfont = layout->font;
- }
- LyXFont tmpfont = pit->getFontSettings(params, pos);
- tmpfont.realize(layoutfont);
+ LyXFont font = par.getFontSettings(params, pos);
+ font.realize(layoutfont);
- if (pit->inInset())
- pit->inInset()->getDrawFont(tmpfont);
+ if (!isMainText())
+ font.realize(font_);
// Realize with the fonts of lesser depth.
- tmpfont.realize(outerFont(pit, ownerParagraphs()));
- tmpfont.realize(defaultfont_);
+ font.realize(defaultfont_);
- return tmpfont;
+ return font;
}
-LyXFont LyXText::getLayoutFont(ParagraphList::iterator pit) const
+LyXFont LyXText::getLayoutFont(pit_type const pit) const
{
- LyXLayout_ptr const & layout = pit->layout();
+ LyXLayout_ptr const & layout = pars_[pit].layout();
- if (!pit->getDepth())
+ if (!pars_[pit].getDepth())
return layout->resfont;
LyXFont font = layout->font;
// Realize with the fonts of lesser depth.
- font.realize(outerFont(pit, ownerParagraphs()));
+ //font.realize(outerFont(pit, paragraphs()));
font.realize(defaultfont_);
return font;
}
-LyXFont LyXText::getLabelFont(ParagraphList::iterator pit) const
+LyXFont LyXText::getLabelFont(Paragraph const & par) const
{
- LyXLayout_ptr const & layout = pit->layout();
+ LyXLayout_ptr const & layout = par.layout();
- if (!pit->getDepth())
+ if (!par.getDepth())
return layout->reslabelfont;
LyXFont font = layout->labelfont;
// Realize with the fonts of lesser depth.
- font.realize(outerFont(pit, ownerParagraphs()));
font.realize(defaultfont_);
return font;
}
-void LyXText::setCharFont(ParagraphList::iterator pit,
- pos_type pos, LyXFont const & fnt,
- bool toggleall)
-{
- BufferParams const & params = bv()->buffer()->params;
- LyXFont font = getFont(pit, pos);
- font.update(fnt, params.language, toggleall);
- // Let the insets convert their font
- if (pit->isInset(pos)) {
- InsetOld * inset = pit->getInset(pos);
- if (isEditableInset(inset)) {
- static_cast<UpdatableInset *>(inset)
- ->setFont(bv(), fnt, toggleall, true);
- }
- }
-
- // Plug through to version below:
- setCharFont(pit, pos, font);
-}
-
-
-void LyXText::setCharFont(
- ParagraphList::iterator pit, pos_type pos, LyXFont const & fnt)
+void LyXText::setCharFont(pit_type pit, pos_type pos, LyXFont const & fnt)
{
LyXFont font = fnt;
- LyXLayout_ptr const & layout = pit->layout();
+ LyXLayout_ptr const & layout = pars_[pit].layout();
// Get concrete layout font to reduce against
LyXFont layoutfont;
- if (pos < pit->beginningOfBody())
+ if (pos < pars_[pit].beginOfBody())
layoutfont = layout->labelfont;
else
layoutfont = layout->font;
// Realize against environment font information
- if (pit->getDepth()) {
- ParagraphList::iterator tp = pit;
+ if (pars_[pit].getDepth()) {
+ pit_type tp = pit;
while (!layoutfont.resolved() &&
- tp != ownerParagraphs().end() &&
- tp->getDepth()) {
- tp = outerHook(tp, ownerParagraphs());
- if (tp != ownerParagraphs().end())
- layoutfont.realize(tp->layout()->font);
+ tp != pit_type(paragraphs().size()) &&
+ pars_[tp].getDepth()) {
+ tp = outerHook(tp, paragraphs());
+ if (tp != pit_type(paragraphs().size()))
+ layoutfont.realize(pars_[tp].layout()->font);
}
}
// Now, reduce font against full layout font
font.reduce(layoutfont);
- pit->setFont(pos, font);
+ pars_[pit].setFont(pos, font);
}
-// removes the row and reset the touched counters
-void LyXText::removeRow(RowList::iterator rit)
-{
- if (anchor_row_ == rit) {
- if (rit != rows().begin()) {
- anchor_row_ = boost::prior(rit);
- anchor_row_offset_ += anchor_row_->height();
- } else {
- anchor_row_ = boost::next(rit);
- anchor_row_offset_ -= rit->height();
- }
- }
-
- // the text becomes smaller
- height -= rit->height();
-
- rowlist_.erase(rit);
-}
-
-
-// remove all following rows of the paragraph of the specified row.
-void LyXText::removeParagraph(RowList::iterator rit)
-{
- ParagraphList::iterator tmppit = rit->par();
- ++rit;
-
- while (rit != rows().end() && rit->par() == tmppit) {
- RowList::iterator tmprit = boost::next(rit);
- removeRow(rit);
- rit = tmprit;
- }
-}
-
-
-void LyXText::insertParagraph(ParagraphList::iterator pit,
- RowList::iterator rit)
-{
- // insert a new row, starting at position 0
- Row newrow(pit, 0);
- rit = rowlist_.insert(rit, newrow);
-
- // and now append the whole paragraph before the new row
- appendParagraph(rit);
-}
-
-
-InsetOld * LyXText::getInset() const
-{
- ParagraphList::iterator pit = cursor.par();
- pos_type const pos = cursor.pos();
-
- if (pos < pit->size() && pit->isInset(pos)) {
- return pit->getInset(pos);
- }
- return 0;
-}
-
-
-void LyXText::toggleInset()
-{
- InsetOld * inset = getInset();
- // is there an editable inset at cursor position?
- if (!isEditableInset(inset)) {
- // No, try to see if we are inside a collapsable inset
- if (inset_owner && inset_owner->owner()
- && inset_owner->owner()->isOpen()) {
- bv()->unlockInset(inset_owner->owner());
- inset_owner->owner()->close(bv());
- bv()->getLyXText()->cursorRight(bv());
- }
- return;
- }
- //bv()->owner()->message(inset->editMessage());
-
- // do we want to keep this?? (JMarc)
- if (!isHighlyEditableInset(inset))
- recordUndo(bv(), Undo::ATOMIC);
-
- if (inset->isOpen()) {
- inset->close(bv());
- } else {
- inset->open(bv());
- }
-
- bv()->updateInset(inset);
-}
-
-
-/* used in setlayout */
+// used in setLayout
// Asger is not sure we want to do this...
void LyXText::makeFontEntriesLayoutSpecific(BufferParams const & params,
Paragraph & par)
LyXFont layoutfont;
for (pos_type pos = 0; pos < psize; ++pos) {
- if (pos < par.beginningOfBody())
+ if (pos < par.beginOfBody())
layoutfont = layout->labelfont;
else
layoutfont = layout->font;
}
-ParagraphList::iterator
-LyXText::setLayout(LyXCursor & cur, LyXCursor & sstart_cur,
- LyXCursor & send_cur,
- string const & layout)
+// return past-the-last paragraph influenced by a layout change on pit
+pit_type LyXText::undoSpan(pit_type pit)
{
- ParagraphList::iterator endpit = boost::next(send_cur.par());
- ParagraphList::iterator undoendpit = endpit;
- ParagraphList::iterator pars_end = ownerParagraphs().end();
-
- if (endpit != pars_end && endpit->getDepth()) {
- while (endpit != pars_end && endpit->getDepth()) {
- ++endpit;
- undoendpit = endpit;
- }
- } else if (endpit != pars_end) {
- // because of parindents etc.
- ++endpit;
+ pit_type end = paragraphs().size();
+ pit_type nextpit = pit + 1;
+ if (nextpit == end)
+ return nextpit;
+ //because of parindents
+ if (!pars_[pit].getDepth())
+ return boost::next(nextpit);
+ //because of depth constrains
+ for (; nextpit != end; ++pit, ++nextpit) {
+ if (!pars_[pit].getDepth())
+ break;
}
+ return nextpit;
+}
+
+
+pit_type LyXText::setLayout(pit_type start, pit_type end, string const & layout)
+{
+ BOOST_ASSERT(start != end);
+ pit_type undopit = undoSpan(end - 1);
+ recUndo(start, undopit - 1);
- recordUndo(bv(), Undo::ATOMIC, sstart_cur.par(), boost::prior(undoendpit));
-
- // ok we have a selection. This is always between sstart_cur
- // and sel_end cursor
- cur = sstart_cur;
- ParagraphList::iterator pit = sstart_cur.par();
- ParagraphList::iterator epit = boost::next(send_cur.par());
-
- LyXLayout_ptr const & lyxlayout =
- bv()->buffer()->params.getLyXTextClass()[layout];
-
- do {
- pit->applyLayout(lyxlayout);
- makeFontEntriesLayoutSpecific(bv()->buffer()->params, *pit);
- ParagraphList::iterator fppit = pit;
- fppit->params().spaceTop(lyxlayout->fill_top ?
- VSpace(VSpace::VFILL)
- : VSpace(VSpace::NONE));
- fppit->params().spaceBottom(lyxlayout->fill_bottom ?
- VSpace(VSpace::VFILL)
- : VSpace(VSpace::NONE));
+ BufferParams const & bufparams = bv()->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)
- pit->setLabelWidthString(lyxlayout->labelstring());
- cur.par(pit);
- ++pit;
- } while (pit != epit);
+ pars_[pit].setLabelWidthString(lyxlayout->labelstring());
+ }
- return endpit;
+ return undopit;
}
// set layout over selection and make a total rebreak of those paragraphs
-void LyXText::setLayout(string const & layout)
+void LyXText::setLayout(LCursor & cur, string const & layout)
{
- LyXCursor tmpcursor = cursor; // store the current cursor
-
- // if there is no selection just set the layout
- // of the current paragraph
- if (!selection.set()) {
- selection.start = cursor; // dummy selection
- selection.end = cursor;
- }
-
+ BOOST_ASSERT(this == cur.text());
// special handling of new environment insets
- BufferParams const & params = bv()->buffer()->params;
+ BufferView & bv = cur.bv();
+ BufferParams const & params = bv.buffer()->params();
LyXLayout_ptr const & lyxlayout = params.getLyXTextClass()[layout];
if (lyxlayout->is_environment) {
// move everything in a new environment inset
- lyxerr << "setting layout " << layout << endl;
- bv()->owner()->dispatch(FuncRequest(LFUN_HOME));
- bv()->owner()->dispatch(FuncRequest(LFUN_ENDSEL));
- bv()->owner()->dispatch(FuncRequest(LFUN_CUT));
- InsetOld * inset = new InsetEnvironment(params, layout);
- if (bv()->insertInset(inset)) {
- //inset->edit(bv());
- //bv()->owner()->dispatch(FuncRequest(LFUN_PASTE));
- }
- else
- delete 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));
+ InsetBase * inset = new InsetEnvironment(params, layout);
+ insertInset(cur, inset);
+ //inset->edit(cur, true);
+ //bv.owner()->dispatch(FuncRequest(LFUN_PASTE));
return;
}
- ParagraphList::iterator endpit = setLayout(cursor, selection.start,
- selection.end, layout);
- redoParagraphs(selection.start.par(), endpit);
-
- // we have to reset the selection, because the
- // geometry could have changed
- setCursor(selection.start.par(), selection.start.pos(), false);
- selection.cursor = cursor;
- setCursor(selection.end.par(), selection.end.pos(), false);
+ pit_type start = cur.selBegin().pit();
+ pit_type end = cur.selEnd().pit() + 1;
+ setLayout(start, end, layout);
updateCounters();
- clearSelection();
- setSelection();
- setCursor(tmpcursor.par(), tmpcursor.pos(), true);
}
-bool LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type, bool test_only)
-{
- ParagraphList::iterator pit(cursor.par());
- ParagraphList::iterator end(cursor.par());
- ParagraphList::iterator start = pit;
-
- if (selection.set()) {
- pit = selection.start.par();
- end = selection.end.par();
- start = pit;
- }
-
- ParagraphList::iterator pastend = boost::next(end);
-
- if (!test_only)
- recordUndo(bv(), Undo::ATOMIC, start, end);
+namespace {
- bool changed = false;
- int prev_after_depth = 0;
-#warning parlist ... could be nicer ?
- if (start != ownerParagraphs().begin()) {
- prev_after_depth = boost::prior(start)->getMaxDepthAfter();
- }
+bool changeDepthAllowed(LyXText::DEPTH_CHANGE type,
+ Paragraph const & par, int max_depth)
+{
+ if (par.layout()->labeltype == LABEL_BIBLIO)
+ return false;
+ int const depth = par.params().depth();
+ if (type == LyXText::INC_DEPTH && depth < max_depth)
+ return true;
+ if (type == LyXText::DEC_DEPTH && depth > 0)
+ return true;
+ return false;
+}
- while (true) {
- int const depth = pit->params().depth();
- if (type == bv_funcs::INC_DEPTH) {
- if (depth < prev_after_depth
- && pit->layout()->labeltype != LABEL_BIBLIO) {
- changed = true;
- if (!test_only) {
- pit->params().depth(depth + 1);
- }
- }
- } else if (depth) {
- changed = true;
- if (!test_only)
- pit->params().depth(depth - 1);
- }
+}
- prev_after_depth = pit->getMaxDepthAfter();
- if (pit == end) {
- break;
- }
+bool LyXText::changeDepthAllowed(LCursor & cur, DEPTH_CHANGE type) const
+{
+ BOOST_ASSERT(this == cur.text());
+ 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);
- ++pit;
+ for (pit_type pit = beg; pit != end; ++pit) {
+ if (::changeDepthAllowed(type, pars_[pit], max_depth))
+ return true;
+ max_depth = pars_[pit].getMaxDepthAfter();
}
+ return false;
+}
- if (test_only)
- return changed;
-
-
- redoParagraphs(start, pastend);
- // We need to actually move the text->cursor. I don't
- // understand why ...
- LyXCursor tmpcursor = cursor;
+void LyXText::changeDepth(LCursor & cur, DEPTH_CHANGE type)
+{
+ BOOST_ASSERT(this == cur.text());
+ 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);
- // we have to reset the visual selection because the
- // geometry could have changed
- if (selection.set()) {
- setCursor(selection.start.par(), selection.start.pos());
- selection.cursor = cursor;
- setCursor(selection.end.par(), selection.end.pos());
+ for (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)
+ par.params().depth(depth + 1);
+ else
+ par.params().depth(depth - 1);
+ }
+ max_depth = par.getMaxDepthAfter();
}
-
// this handles the counter labels, and also fixes up
// depth values for follow-on (child) paragraphs
updateCounters();
-
- setSelection();
- setCursor(tmpcursor.par(), tmpcursor.pos());
-
- return changed;
}
-// set font over selection and make a total rebreak of those paragraphs
-void LyXText::setFont(LyXFont const & font, bool toggleall)
+// set font over selection
+void LyXText::setFont(LCursor & cur, LyXFont const & font, bool toggleall)
{
+ BOOST_ASSERT(this == cur.text());
// if there is no selection just set the current_font
- if (!selection.set()) {
+ if (!cur.selection()) {
// Determine basis font
LyXFont layoutfont;
- if (cursor.pos() < cursor.par()->beginningOfBody()) {
- layoutfont = getLabelFont(cursor.par());
- } else {
- layoutfont = getLayoutFont(cursor.par());
- }
+ pit_type pit = cur.pit();
+ if (cur.pos() < pars_[pit].beginOfBody())
+ layoutfont = getLabelFont(pars_[pit]);
+ else
+ layoutfont = getLayoutFont(pit);
+
// Update current font
real_current_font.update(font,
- bv()->buffer()->params.language,
+ cur.buffer().params().language,
toggleall);
// Reduce to implicit settings
return;
}
- LyXCursor tmpcursor = cursor; // store the current cursor
-
- // ok we have a selection. This is always between sel_start_cursor
- // and sel_end cursor
-
- recordUndo(bv(), Undo::ATOMIC, selection.start.par(), selection.end.par());
- freezeUndo();
- cursor = selection.start;
- while (cursor.par() != selection.end.par() ||
- cursor.pos() < selection.end.pos())
- {
- if (cursor.pos() < cursor.par()->size()) {
- // an open footnote should behave like a closed one
- setCharFont(cursor.par(), cursor.pos(),
- font, toggleall);
- cursor.pos(cursor.pos() + 1);
- } else {
- cursor.pos(0);
- cursor.par(boost::next(cursor.par()));
- }
- }
- unFreezeUndo();
-
- redoParagraph(selection.start.par());
-
- // we have to reset the selection, because the
- // geometry could have changed, but we keep
- // it for user convenience
- setCursor(selection.start.par(), selection.start.pos());
- selection.cursor = cursor;
- setCursor(selection.end.par(), selection.end.pos());
- setSelection();
- setCursor(tmpcursor.par(), tmpcursor.pos(), true,
- tmpcursor.boundary());
-}
-
-
-void LyXText::redoHeightOfParagraph()
-{
- RowList::iterator tmprow = cursorRow();
-
- setHeightOfRow(tmprow);
-
- while (tmprow != rows().begin()
- && boost::prior(tmprow)->par() == tmprow->par()) {
- --tmprow;
- setHeightOfRow(tmprow);
- }
-
- setCursor(cursor.par(), cursor.pos(), false, cursor.boundary());
-}
-
-
-RowList::iterator LyXText::firstRow(ParagraphList::iterator pit)
-{
- RowList::iterator rit;
- for (rit = rows().begin(); rit != rows().end(); ++rit)
- if (rit->par() == pit)
- break;
- return rit;
-}
-
-
-// rebreaks all paragraphs between the specified pars
-// This function is needed after SetLayout and SetFont etc.
-void LyXText::redoParagraphs(ParagraphList::iterator start,
- ParagraphList::iterator end)
-{
- for ( ; start != end; ++start)
- redoParagraph(start);
-}
-
-
-void LyXText::redoParagraph(ParagraphList::iterator pit)
-{
- RowList::iterator rit = firstRow(pit);
-
- // remove paragraph from rowlist
- while (rit != rows().end() && rit->par() == pit) {
- RowList::iterator rit2 = rit++;
- removeRow(rit2);
- }
-
- // reinsert the paragraph
- // insert a new row, starting at position 0
- Row newrow(pit, 0);
- rit = rowlist_.insert(rit, newrow);
- //newrow.dump("newrow: ");
-
- // and now append the whole paragraph before the new row
- // was: appendParagraph(rit);
-
- pos_type const last = rit->par()->size();
- bool done = false;
-
- do {
- pos_type z = rowBreakPoint(*rit);
-
- RowList::iterator tmprow = rit;
- //tmprow->dump("tmprow: ");
-
- if (z < last) {
- ++z;
- Row newrow(rit->par(), z);
- //newrow.dump("newrow2: ");
- rit = rowlist_.insert(boost::next(rit), newrow);
- } else {
- done = true;
- }
-
- // Set the dimensions of the row
- // fixed fill setting now by calling inset->update() in
- // SingleWidth when needed!
- //tmprow->dump("tmprow 1: ");
- tmprow->fill(fill(tmprow, workWidth()));
- //tmprow->dump("tmprow 2: ");
- setHeightOfRow(tmprow);
- //tmprow->dump("tmprow 3: ");
- height += rit->height();
+ // Ok, we have a selection.
+ recordUndoSelection(cur);
- } while (!done);
-
- setHeightOfRow(rows().begin());
-}
-
-
-void LyXText::fullRebreak()
-{
- lyxerr << "fullRebreak" << endl;
- redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end());
- setCursorIntern(cursor.par(), cursor.pos());
- selection.cursor = cursor;
-}
+ DocIterator dit = cur.selectionBegin();
+ DocIterator ditend = cur.selectionEnd();
+ BufferParams const & params = cur.buffer().params();
-void LyXText::metrics(MetricsInfo & mi, Dimension & dim)
-{
- //lyxerr << "LyXText::metrics: width: " << mi.base.textwidth << endl;
- //Assert(mi.base.textwidth);
-
- // rebuild row cache
- rowlist_.clear();
- width = height = 0;
-
- anchor_row_ = rows().end();
- anchor_row_offset_ = 0;
-
- ParagraphList::iterator pit = ownerParagraphs().begin();
- ParagraphList::iterator end = ownerParagraphs().end();
-
- for (; pit != end; ++pit) {
- InsetList::iterator ii = pit->insetlist.begin();
- InsetList::iterator iend = pit->insetlist.end();
- for (; ii != iend; ++ii) {
- Dimension dim;
- MetricsInfo m = mi;
-#warning FIXME: pos != 0
- m.base.font = getFont(pit, 0);
- ii->inset->metrics(m, dim);
+ // Don't use forwardChar here as ditend might have
+ // pos() == lastpos() and forwardChar would miss it.
+ // 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(dit.pit(), dit.pos(), f);
}
-
- // insert a new row, starting at position 0
- Row newrow(pit, 0);
- RowList::iterator rit = rowlist_.insert(rowlist_.end(), newrow);
-
- // and now append the whole paragraph before the new row
- appendParagraph(rit);
- }
-
- // compute height
- //lyxerr << "height 0: " << height << endl;
- //for (RowList::iterator rit = rows().begin(); rit != rows().end(); ++rit) {
- // height += rit->height();
- //}
- //lyxerr << "height 1: " << height << endl;
-
- // final dimension
- dim.asc = rows().begin()->ascent_of_text();
- dim.des = height - dim.asc;
- dim.wid = std::max(mi.base.textwidth, int(width));
-}
-
-
-void LyXText::partialRebreak()
-{
- if (rows().empty()) {
- init(bv());
- return;
}
- breakAgain(rows().begin());
}
-// important for the screen
-
-
// the cursor set functions have a special mechanism. When they
-// realize, that you left an empty paragraph, they will delete it.
-// They also delete the corresponding row
+// realize you left an empty paragraph, they will delete it.
-// need the selection cursor:
-void LyXText::setSelection()
+void LyXText::cursorHome(LCursor & cur)
{
- bool const lsel = TextCursor::setSelection();
-
- if (inset_owner && (selection.set() || lsel))
- inset_owner->setUpdateStatus(InsetText::SELECTION);
+ BOOST_ASSERT(this == cur.text());
+ setCursor(cur, cur.pit(), cur.textRow().pos());
}
-
-void LyXText::clearSelection()
+void LyXText::cursorEnd(LCursor & cur)
{
- TextCursor::clearSelection();
-
- // reset this in the bv_owner!
- if (bv_owner && bv_owner->text)
- bv_owner->text->xsel_cache.set(false);
-}
-
-
-void LyXText::cursorHome()
-{
- setCursor(cursor.par(), cursorRow()->pos());
-}
-
-
-void LyXText::cursorEnd()
-{
- if (cursor.par()->empty())
- return;
-
- RowList::iterator rit = cursorRow();
- RowList::iterator next_rit = boost::next(rit);
- ParagraphList::iterator pit = rit->par();
- pos_type last_pos = lastPos(*this, rit);
-
- if (next_rit == rows().end() || next_rit->par() != pit) {
- ++last_pos;
- } else {
- if (pit->empty() ||
- (pit->getChar(last_pos) != ' ' && !pit->isNewline(last_pos))) {
- ++last_pos;
- }
- }
-
- setCursor(pit, last_pos);
+ 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);
}
-void LyXText::cursorTop()
+void LyXText::cursorTop(LCursor & cur)
{
- setCursor(ownerParagraphs().begin(), 0);
+ BOOST_ASSERT(this == cur.text());
+ setCursor(cur, 0, 0);
}
-void LyXText::cursorBottom()
+void LyXText::cursorBottom(LCursor & cur)
{
- ParagraphList::iterator lastpit =
- boost::prior(ownerParagraphs().end());
- setCursor(lastpit, lastpit->size());
+ BOOST_ASSERT(this == cur.text());
+ setCursor(cur, cur.lastpit(), boost::prior(paragraphs().end())->size());
}
-void LyXText::toggleFree(LyXFont const & font, bool toggleall)
+void LyXText::toggleFree(LCursor & cur, LyXFont const & font, bool toggleall)
{
+ BOOST_ASSERT(this == cur.text());
// If the mask is completely neutral, tell user
if (font == LyXFont(LyXFont::ALL_IGNORE)) {
// Could only happen with user style
- bv()->owner()->message(_("No font change defined. Use Character under the Layout menu to define font change."));
+ cur.message(_("No font change defined. "
+ "Use Character under the Layout menu to define font change."));
return;
}
// Try implicit word selection
// If there is a change in the language the implicit word selection
// is disabled.
- LyXCursor resetCursor = cursor;
- bool implicitSelection = (font.language() == ignore_language
- && font.number() == LyXFont::IGNORE)
- ? selectWordWhenUnderCursor(lyx::WHOLE_WORD_STRICT) : false;
+ CursorSlice resetCursor = cur.top();
+ bool implicitSelection =
+ font.language() == ignore_language
+ && font.number() == LyXFont::IGNORE
+ && selectWordWhenUnderCursor(cur, lyx::WHOLE_WORD_STRICT);
// Set font
- setFont(font, toggleall);
+ setFont(cur, font, toggleall);
// Implicit selections are cleared afterwards
- //and cursor is set to the original position.
+ // and cursor is set to the original position.
if (implicitSelection) {
- clearSelection();
- cursor = resetCursor;
- setCursor(cursor.par(), cursor.pos());
- selection.cursor = cursor;
+ cur.clearSelection();
+ cur.top() = resetCursor;
+ cur.resetAnchor();
}
- if (inset_owner)
- inset_owner->setUpdateStatus(InsetText::CURSOR_PAR);
}
-string LyXText::getStringToIndex()
+string LyXText::getStringToIndex(LCursor & cur)
{
+ BOOST_ASSERT(this == cur.text());
// Try implicit word selection
// If there is a change in the language the implicit word selection
// is disabled.
- LyXCursor const reset_cursor = cursor;
+ CursorSlice const reset_cursor = cur.top();
bool const implicitSelection =
- selectWordWhenUnderCursor(lyx::PREVIOUS_WORD);
+ selectWordWhenUnderCursor(cur, lyx::PREVIOUS_WORD);
string idxstring;
- if (!selection.set())
- bv()->owner()->message(_("Nothing to index!"));
- else if (selection.start.par() != selection.end.par())
- bv()->owner()->message(_("Cannot index more than one paragraph!"));
+ 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 = selectionAsString(bv()->buffer(), false);
+ idxstring = cur.selectionAsString(false);
// Reset cursors to their original position.
- cursor = reset_cursor;
- setCursor(cursor.par(), cursor.pos());
- selection.cursor = cursor;
+ cur.top() = reset_cursor;
+ cur.resetAnchor();
// Clear the implicit selection.
if (implicitSelection)
- clearSelection();
+ cur.clearSelection();
return idxstring;
}
-// the DTP switches for paragraphs. LyX will store them in the first
-// physicla paragraph. When a paragraph is broken, the top settings rest,
-// the bottom settings are given to the new one. So I can make shure,
-// they do not duplicate themself and you cannnot make dirty things with
-// them!
-
-void LyXText::setParagraph(bool line_top, bool line_bottom,
- bool pagebreak_top, bool pagebreak_bottom,
- VSpace const & space_top,
- VSpace const & space_bottom,
- Spacing const & spacing,
- LyXAlignment align,
- string const & labelwidthstring,
- bool noindent)
+void LyXText::setParagraph(LCursor & cur,
+ Spacing const & spacing, LyXAlignment align,
+ string const & labelwidthstring, bool noindent)
{
- LyXCursor tmpcursor = cursor;
- if (!selection.set()) {
- selection.start = cursor;
- selection.end = cursor;
- }
-
+ BOOST_ASSERT(cur.text());
// make sure that the depth behind the selection are restored, too
- ParagraphList::iterator endpit = boost::next(selection.end.par());
- ParagraphList::iterator undoendpit = endpit;
- ParagraphList::iterator pars_end = ownerParagraphs().end();
-
- if (endpit != pars_end && endpit->getDepth()) {
- while (endpit != pars_end && endpit->getDepth()) {
- ++endpit;
- undoendpit = endpit;
- }
- } else if (endpit != pars_end) {
- // because of parindents etc.
- ++endpit;
- }
+ pit_type undopit = undoSpan(cur.selEnd().pit());
+ recUndo(cur.selBegin().pit(), undopit - 1);
- recordUndo(bv(), Undo::ATOMIC, selection.start.par(),
- boost::prior(undoendpit));
-
-
- ParagraphList::iterator tmppit = selection.end.par();
-
- while (tmppit != boost::prior(selection.start.par())) {
- setCursor(tmppit, 0);
-
- ParagraphList::iterator pit = cursor.par();
- ParagraphParameters & params = pit->params();
-
- params.lineTop(line_top);
- params.lineBottom(line_bottom);
- params.pagebreakTop(pagebreak_top);
- params.pagebreakBottom(pagebreak_bottom);
- params.spaceTop(space_top);
- params.spaceBottom(space_bottom);
+ 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);
+
// does the layout allow the new alignment?
- LyXLayout_ptr const & layout = pit->layout();
+ LyXLayout_ptr const & layout = par.layout();
if (align == LYX_ALIGN_LAYOUT)
align = layout->align;
else
params.align(align);
}
- pit->setLabelWidthString(labelwidthstring);
- params.noindent(noindent);
- tmppit = boost::prior(pit);
- }
+ par.setLabelWidthString(labelwidthstring);
+ params.noindent(noindent);
+ }
+}
+
+
+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;
+ }
- redoParagraphs(selection.start.par(), endpit);
+ if (prev_pit == firstpit)
+ break;
- clearSelection();
- setCursor(selection.start.par(), selection.start.pos());
- selection.cursor = cursor;
- setCursor(selection.end.par(), selection.end.pos());
- setSelection();
- setCursor(tmpcursor.par(), tmpcursor.pos());
- if (inset_owner)
- bv()->updateInset(inset_owner);
+ --prev_pit;
+ }
}
+} // anon namespace
+
// set the counter of a paragraph. This includes the labels
-void LyXText::setCounter(Buffer const * buf, ParagraphList::iterator pit)
+void LyXText::setCounter(Buffer const & buf, pit_type pit)
{
- LyXTextClass const & textclass = buf->params.getLyXTextClass();
- LyXLayout_ptr const & layout = pit->layout();
+ Paragraph & par = pars_[pit];
+ BufferParams const & bufparams = buf.params();
+ LyXTextClass const & textclass = bufparams.getLyXTextClass();
+ LyXLayout_ptr const & layout = par.layout();
+ Counters & counters = textclass.counters();
- if (pit != ownerParagraphs().begin()) {
+ // Always reset
+ par.itemdepth = 0;
- pit->params().appendix(boost::prior(pit)->params().appendix());
- if (!pit->params().appendix() &&
- pit->params().startOfAppendix()) {
- pit->params().appendix(true);
+ 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();
}
- pit->enumdepth = boost::prior(pit)->enumdepth;
- pit->itemdepth = boost::prior(pit)->itemdepth;
- } else {
- pit->params().appendix(pit->params().startOfAppendix());
- pit->enumdepth = 0;
- pit->itemdepth = 0;
- }
-
- /* Maybe we have to increment the enumeration depth.
- * BUT, enumeration in a footnote is considered in isolation from its
- * surrounding paragraph so don't increment if this is the
- * first line of the footnote
- * AND, bibliographies can't have their depth changed ie. they
- * are always of depth 0
- */
- if (pit != ownerParagraphs().begin()
- && boost::prior(pit)->getDepth() < pit->getDepth()
- && boost::prior(pit)->layout()->labeltype == LABEL_COUNTER_ENUMI
- && pit->enumdepth < 3
- && layout->labeltype != LABEL_BIBLIO) {
- pit->enumdepth++;
- }
- // Maybe we have to decrement the enumeration depth, see note above
- if (pit != ownerParagraphs().begin()
- && boost::prior(pit)->getDepth() > pit->getDepth()
- && layout->labeltype != LABEL_BIBLIO) {
- pit->enumdepth = depthHook(pit, ownerParagraphs(),
- pit->getDepth())->enumdepth;
+ // Maybe we have to increment the item depth.
+ incrementItemDepth(pars_, pit, 0);
}
- if (!pit->params().labelString().empty()) {
- pit->params().labelString(string());
- }
+ // erase what was there before
+ par.params().labelString(string());
if (layout->margintype == MARGIN_MANUAL) {
- if (pit->params().labelWidthString().empty()) {
- pit->setLabelWidthString(layout->labelstring());
- }
+ if (par.params().labelWidthString().empty())
+ par.setLabelWidthString(layout->labelstring());
} else {
- pit->setLabelWidthString(string());
+ par.setLabelWidthString(string());
}
// is it a layout that has an automatic label?
- if (layout->labeltype >= LABEL_COUNTER_CHAPTER) {
- int const i = layout->labeltype - LABEL_COUNTER_CHAPTER;
-
- ostringstream s;
-
- if (i >= 0 && i <= buf->params.secnumdepth) {
- string numbertype;
- string langtype;
-
- textclass.counters().step(layout->latexname());
+ if (layout->labeltype == LABEL_COUNTER) {
+ BufferParams const & bufparams = buf.params();
+ LyXTextClass const & textclass = bufparams.getLyXTextClass();
+ counters.step(layout->counter);
+ string label = expandLabel(textclass, layout, 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;
+ }
- // Is there a label? Useful for Chapter layout
- if (!pit->params().appendix()) {
- s << buf->B_(layout->labelstring());
- } else {
- s << buf->B_(layout->labelstring_appendix());
- }
+ par.params().labelString(itemlabel);
+ } else if (layout->labeltype == LABEL_ENUMERATE) {
+ // Maybe we have to reset the enumeration counter.
+ resetEnumCounterIfNeeded(pars_, pit, 0, counters);
- // Use of an integer is here less than elegant. For now.
- int head = textclass.maxcounter() - LABEL_COUNTER_CHAPTER;
- if (!pit->params().appendix()) {
- numbertype = "sectioning";
- } else {
- numbertype = "appendix";
- if (pit->isRightToLeftPar(buf->params))
- langtype = "hebrew";
- else
- langtype = "latin";
- }
+ // FIXME
+ // Yes I know this is a really, really! bad solution
+ // (Lgb)
+ string enumcounter = "enum";
- s << " "
- << textclass.counters()
- .numberLabel(layout->latexname(),
- numbertype, langtype, head);
-
- pit->params().labelString(STRCONV(s.str()));
-
- // reset enum counters
- textclass.counters().reset("enum");
- } else if (layout->labeltype < LABEL_COUNTER_ENUMI) {
- textclass.counters().reset("enum");
- } else if (layout->labeltype == LABEL_COUNTER_ENUMI) {
- // FIXME
- // Yes I know this is a really, really! bad solution
- // (Lgb)
- string enumcounter("enum");
-
- switch (pit->enumdepth) {
- case 2:
- enumcounter += 'i';
- case 1:
- enumcounter += 'i';
- case 0:
- enumcounter += 'i';
- break;
- case 3:
- enumcounter += "iv";
- break;
- default:
- // not a valid enumdepth...
- break;
- }
+ switch (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;
+ }
- textclass.counters().step(enumcounter);
+ counters.step(enumcounter);
- s << textclass.counters()
- .numberLabel(enumcounter, "enumeration");
- pit->params().labelString(STRCONV(s.str()));
- }
+ par.params().labelString(counters.enumLabel(enumcounter));
} else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
- textclass.counters().step("bibitem");
- int number = textclass.counters().value("bibitem");
- if (pit->bibitem()) {
- pit->bibitem()->setCounter(number);
- pit->params().labelString(layout->labelstring());
+ 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());
+ string s = buf.B_(layout->labelstring());
// the caption hack:
if (layout->labeltype == LABEL_SENSITIVE) {
- ParagraphList::iterator end = ownerParagraphs().end();
- ParagraphList::iterator tmppit = pit;
- InsetOld * in = 0;
+ pit_type end = paragraphs().size();
+ pit_type tmppit = pit;
+ InsetBase * in = 0;
bool isOK = false;
- while (tmppit != end && tmppit->inInset()
- // the single '=' is intended below
- && (in = tmppit->inInset()->owner()))
- {
- if (in->lyxCode() == InsetOld::FLOAT_CODE ||
- in->lyxCode() == InsetOld::WRAP_CODE) {
+ while (tmppit != end) {
+ in = pars_[tmppit].inInset();
+ // FIXME: in should be always valid.
+ if (in &&
+ (in->lyxCode() == InsetBase::FLOAT_CODE ||
+ in->lyxCode() == InsetBase::WRAP_CODE)) {
isOK = true;
break;
- } else {
- tmppit = ownerParagraphs().begin();
+ }
+#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 (&*tmppit == in->parOwner())
+ if (&pars_[tmppit] == owner)
break;
}
+#else
+ ++tmppit;
+#endif
}
if (isOK) {
string type;
- if (in->lyxCode() == InsetOld::FLOAT_CODE)
+ if (in->lyxCode() == InsetBase::FLOAT_CODE)
type = static_cast<InsetFloat*>(in)->params().type;
- else if (in->lyxCode() == InsetOld::WRAP_CODE)
+ else if (in->lyxCode() == InsetBase::WRAP_CODE)
type = static_cast<InsetWrap*>(in)->params().type;
else
- Assert(0);
+ BOOST_ASSERT(false);
Floating const & fl = textclass.floats().getType(type);
- textclass.counters().step(fl.type());
+ counters.step(fl.type());
// Doesn't work... yet.
- s = bformat(_("%1$s #:"), buf->B_(fl.name()));
+ s = bformat(_("%1$s #:"), buf.B_(fl.name()));
} else {
// par->SetLayout(0);
// s = layout->labelstring;
s = _("Senseless: ");
}
}
- pit->params().labelString(s);
+ par.params().labelString(s);
- // reset the enumeration counter. They are always reset
- // when there is any other layout between
- // Just fall-through between the cases so that all
- // enum counters deeper than enumdepth is also reset.
- switch (pit->enumdepth) {
- case 0:
- textclass.counters().reset("enumi");
- case 1:
- textclass.counters().reset("enumii");
- case 2:
- textclass.counters().reset("enumiii");
- case 3:
- textclass.counters().reset("enumiv");
- }
}
}
-// Updates all counters. Paragraphs with changed label string will be rebroken
+// Updates all counters.
void LyXText::updateCounters()
{
- RowList::iterator rowit = rows().begin();
- ParagraphList::iterator pit = rowit->par();
+ // start over
+ bv()->buffer()->params().getLyXTextClass().counters().reset();
- // CHECK if this is really needed. (Lgb)
- bv()->buffer()->params.getLyXTextClass().counters().reset();
-
- ParagraphList::iterator beg = ownerParagraphs().begin();
- ParagraphList::iterator end = ownerParagraphs().end();
- for (; pit != end; ++pit) {
- while (rowit->par() != pit)
- ++rowit;
-
- string const oldLabel = pit->params().labelString();
+ 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 != beg)
- maxdepth = boost::prior(pit)->getMaxDepthAfter();
+ if (pit != 0)
+ maxdepth = pars_[pit - 1].getMaxDepthAfter();
- if (pit->params().depth() > maxdepth)
- pit->params().depth(maxdepth);
+ if (pars_[pit].params().depth() > maxdepth)
+ pars_[pit].params().depth(maxdepth);
// setCounter can potentially change the labelString.
- setCounter(bv()->buffer(), pit);
-
- string const & newLabel = pit->params().labelString();
-
- if (oldLabel.empty() && !newLabel.empty()) {
- removeParagraph(rowit);
- appendParagraph(rowit);
+ 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;
}
}
}
-void LyXText::insertInset(InsetOld * inset)
+// this really should just insert the inset and not move the cursor.
+void LyXText::insertInset(LCursor & cur, InsetBase * inset)
{
- if (!cursor.par()->insetAllowed(inset->lyxCode()))
- return;
- recordUndo(bv(), Undo::ATOMIC, cursor.par());
- freezeUndo();
- cursor.par()->insertInset(cursor.pos(), inset);
- // Just to rebreak and refresh correctly.
- // The character will not be inserted a second time
- insertChar(Paragraph::META_INSET);
- // If we enter a highly editable inset the cursor should be to before
- // the inset. This couldn't happen before as Undo was not handled inside
- // inset now after the Undo LyX tries to call inset->Edit(...) again
- // and cannot do this as the cursor is behind the inset and GetInset
- // does not return the inset!
- if (isHighlyEditableInset(inset)) {
- cursorLeft(true);
- }
- unFreezeUndo();
-}
-
-
-void LyXText::cutSelection(bool doclear, bool realcut)
-{
- // Stuff what we got on the clipboard. Even if there is no selection.
-
- // There is a problem with having the stuffing here in that the
- // larger the selection the slower LyX will get. This can be
- // solved by running the line below only when the selection has
- // finished. The solution used currently just works, to make it
- // faster we need to be more clever and probably also have more
- // calls to stuffClipboard. (Lgb)
- bv()->stuffClipboard(selectionAsString(bv()->buffer(), true));
-
- // This doesn't make sense, if there is no selection
- if (!selection.set())
- return;
-
- // OK, we have a selection. This is always between selection.start
- // and selection.end
-
- // make sure that the depth behind the selection are restored, too
- ParagraphList::iterator endpit = boost::next(selection.end.par());
- ParagraphList::iterator undoendpit = endpit;
- ParagraphList::iterator pars_end = ownerParagraphs().end();
-
- if (endpit != pars_end && endpit->getDepth()) {
- while (endpit != pars_end && endpit->getDepth()) {
- ++endpit;
- undoendpit = endpit;
- }
- } else if (endpit != pars_end) {
- // because of parindents etc.
- ++endpit;
- }
-
- recordUndo(bv(), Undo::DELETE, selection.start.par(),
- boost::prior(undoendpit));
-
-
- endpit = selection.end.par();
- int endpos = selection.end.pos();
-
- boost::tie(endpit, endpos) = realcut ?
- CutAndPaste::cutSelection(bv()->buffer()->params,
- ownerParagraphs(),
- selection.start.par(), endpit,
- selection.start.pos(), endpos,
- bv()->buffer()->params.textclass,
- doclear)
- : CutAndPaste::eraseSelection(bv()->buffer()->params,
- ownerParagraphs(),
- selection.start.par(), endpit,
- selection.start.pos(), endpos,
- doclear);
- // sometimes necessary
- if (doclear)
- selection.start.par()->stripLeadingSpaces();
-
- redoParagraphs(selection.start.par(), boost::next(endpit));
-#warning FIXME latent bug
- // endpit will be invalidated on redoParagraphs once ParagraphList
- // becomes a std::list? There are maybe other places on which this
- // can happend? (Ab)
- // cutSelection can invalidate the cursor so we need to set
- // it anew. (Lgb)
- // we prefer the end for when tracking changes
- cursor.pos(endpos);
- cursor.par(endpit);
-
- // need a valid cursor. (Lgb)
- clearSelection();
-
- setCursor(cursor.par(), cursor.pos());
- selection.cursor = cursor;
- updateCounters();
-}
-
-
-void LyXText::copySelection()
-{
- // stuff the selection onto the X clipboard, from an explicit copy request
- bv()->stuffClipboard(selectionAsString(bv()->buffer(), true));
-
- // this doesnt make sense, if there is no selection
- if (!selection.set())
- return;
-
- // ok we have a selection. This is always between selection.start
- // and sel_end cursor
-
- // copy behind a space if there is one
- while (selection.start.par()->size() > selection.start.pos()
- && selection.start.par()->isLineSeparator(selection.start.pos())
- && (selection.start.par() != selection.end.par()
- || selection.start.pos() < selection.end.pos()))
- selection.start.pos(selection.start.pos() + 1);
-
- CutAndPaste::copySelection(selection.start.par(),
- selection.end.par(),
- selection.start.pos(), selection.end.pos(),
- bv()->buffer()->params.textclass);
-}
-
-
-void LyXText::pasteSelection(size_t sel_index)
-{
- // this does not make sense, if there is nothing to paste
- if (!CutAndPaste::checkPastePossible())
- return;
-
- recordUndo(bv(), Undo::INSERT, cursor.par());
-
- ParagraphList::iterator endpit;
- PitPosPair ppp;
-
- ErrorList el;
-
- boost::tie(ppp, endpit) =
- CutAndPaste::pasteSelection(*bv()->buffer(),
- ownerParagraphs(),
- cursor.par(), cursor.pos(),
- bv()->buffer()->params.textclass,
- sel_index, el);
- bufferErrors(*bv()->buffer(), el);
- bv()->showErrorList(_("Paste"));
-
- redoParagraphs(cursor.par(), endpit);
-
- setCursor(cursor.par(), cursor.pos());
- clearSelection();
-
- selection.cursor = cursor;
- setCursor(ppp.first, ppp.second);
- setSelection();
- updateCounters();
-}
-
-
-void LyXText::setSelectionRange(lyx::pos_type length)
-{
- if (!length)
- return;
-
- selection.cursor = cursor;
- while (length--)
- cursorRight(bv());
- setSelection();
-}
-
-
-// simple replacing. The font of the first selected character is used
-void LyXText::replaceSelectionWithString(string const & str)
-{
- recordUndo(bv(), Undo::ATOMIC);
- freezeUndo();
-
- if (!selection.set()) { // create a dummy selection
- selection.end = cursor;
- selection.start = cursor;
- }
-
- // Get font setting before we cut
- pos_type pos = selection.end.pos();
- LyXFont const font = selection.start.par()
- ->getFontSettings(bv()->buffer()->params,
- selection.start.pos());
-
- // Insert the new string
- string::const_iterator cit = str.begin();
- string::const_iterator end = str.end();
- for (; cit != end; ++cit) {
- selection.end.par()->insertChar(pos, (*cit), font);
- ++pos;
- }
-
- // Cut the selection
- cutSelection(true, false);
-
- unFreezeUndo();
+ BOOST_ASSERT(this == cur.text());
+ BOOST_ASSERT(inset);
+ cur.paragraph().insertInset(cur.pos(), inset);
}
// needed to insert the selection
-void LyXText::insertStringAsLines(string const & str)
+void LyXText::insertStringAsLines(LCursor & cur, string const & str)
{
- ParagraphList::iterator pit = cursor.par();
- pos_type pos = cursor.pos();
- ParagraphList::iterator endpit = boost::next(cursor.par());
-
- recordUndo(bv(), Undo::ATOMIC);
+ pit_type pit = cur.pit();
+ pos_type pos = cur.pos();
+ recordUndo(cur);
// only to be sure, should not be neccessary
- clearSelection();
-
- bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
+ cur.clearSelection();
+ cur.buffer().insertStringAsLines(pars_, pit, pos, current_font, str,
+ autoBreakRows_);
- redoParagraphs(cursor.par(), endpit);
- setCursor(cursor.par(), cursor.pos());
- selection.cursor = cursor;
- setCursor(pit, pos);
- setSelection();
+ cur.resetAnchor();
+ setCursor(cur, cur.pit(), pos);
+ cur.setSelection();
}
-// turns double-CR to single CR, others where converted into one
-// blank. Then InsertStringAsLines is called
-void LyXText::insertStringAsParagraphs(string const & str)
+// turn double CR to single CR, others are converted into one
+// blank. Then insertStringAsLines is called
+void LyXText::insertStringAsParagraphs(LCursor & cur, string const & str)
{
- string linestr(str);
+ string linestr = str;
bool newline_inserted = false;
- string::size_type const siz = linestr.length();
- for (string::size_type i = 0; i < siz; ++i) {
+ for (string::size_type i = 0, siz = linestr.size(); i < siz; ++i) {
if (linestr[i] == '\n') {
if (newline_inserted) {
// we know that \r will be ignored by
- // InsertStringA. Of course, it is a dirty
+ // insertStringAsLines. Of course, it is a dirty
// trick, but it works...
linestr[i - 1] = '\r';
linestr[i] = '\n';
newline_inserted = false;
}
}
- insertStringAsLines(linestr);
-}
-
-
-void LyXText::checkParagraph(ParagraphList::iterator pit, pos_type pos)
-{
- breakAgain(getRow(pit, pos));
- setCursorIntern(cursor.par(), cursor.pos(), false, cursor.boundary());
-}
-
-
-// returns false if inset wasn't found
-bool LyXText::updateInset(InsetOld * inset)
-{
- // first check the current paragraph
- int pos = cursor.par()->getPositionOfInset(inset);
- if (pos != -1) {
- checkParagraph(cursor.par(), pos);
- return true;
- }
-
- // check every paragraph
- ParagraphList::iterator par = ownerParagraphs().begin();
- ParagraphList::iterator end = ownerParagraphs().end();
- for (; par != end; ++par) {
- pos = par->getPositionOfInset(inset);
- if (pos != -1) {
- checkParagraph(par, pos);
- return true;
- }
- }
-
- return false;
+ insertStringAsLines(cur, linestr);
}
-bool LyXText::setCursor(ParagraphList::iterator pit,
- pos_type pos,
- bool setfont, bool boundary)
+bool LyXText::setCursor(LCursor & cur, pit_type par, pos_type pos,
+ bool setfont, bool boundary)
{
- LyXCursor old_cursor = cursor;
- setCursorIntern(pit, pos, setfont, boundary);
- return deleteEmptyParagraphMechanism(old_cursor);
+ LCursor old = cur;
+ setCursorIntern(cur, par, pos, setfont, boundary);
+ return deleteEmptyParagraphMechanism(cur, old);
}
-void LyXText::setCursor(LyXCursor & cur, ParagraphList::iterator pit,
- pos_type pos, bool boundary)
+void LyXText::setCursor(CursorSlice & cur, pit_type par,
+ pos_type pos, bool boundary)
{
- Assert(pit != ownerParagraphs().end());
-
- cur.par(pit);
- cur.pos(pos);
- cur.boundary(boundary);
- if (rows().empty())
- return;
+ BOOST_ASSERT(par != int(paragraphs().size()));
+ cur.pit() = par;
+ cur.pos() = pos;
+ cur.boundary() = boundary;
- // get the cursor y position in text
- int y = 0;
- RowList::iterator row = getRow(pit, pos, y);
- RowList::iterator beg = rows().begin();
-
- RowList::iterator old_row = row;
- // if we are before the first char of this row and are still in the
- // same paragraph and there is a previous row then put the cursor on
- // the end of the previous row
- cur.iy(y + row->baseline());
- if (row != beg &&
- pos &&
- boost::prior(row)->par() == row->par() &&
- pos < pit->size() &&
- pit->getChar(pos) == Paragraph::META_INSET) {
- InsetOld * ins = pit->getInset(pos);
- if (ins && (ins->needFullRow() || ins->display())) {
- --row;
- y -= row->height();
- }
- }
-
- // y is now the beginning of the cursor row
- y += row->baseline();
- // y is now the cursor baseline
- cur.y(y);
-
- pos_type last = lastPrintablePos(*this, old_row);
+ // now some strict checking
+ Paragraph & para = getPar(par);
// None of these should happen, but we're scaredy-cats
- if (pos > pit->size()) {
- lyxerr << "dont like 1 please report" << endl;
- pos = 0;
- cur.pos(0);
- } else if (pos > last + 1) {
- lyxerr << "dont like 2 please report" << endl;
- // This shouldn't happen.
- pos = last + 1;
- cur.pos(pos);
- } else if (pos < row->pos()) {
- lyxerr << "dont like 3 please report" << endl;
- pos = row->pos();
- cur.pos(pos);
+ if (pos < 0) {
+ lyxerr << "dont like -1" << endl;
+ BOOST_ASSERT(false);
}
- // now get the cursors x position
- float x = getCursorX(row, pos, last, boundary);
- cur.x(int(x));
- cur.x_fix(cur.x());
- if (old_row != row) {
- x = getCursorX(old_row, pos, last, boundary);
- cur.ix(int(x));
- } else
- cur.ix(cur.x());
-/* We take out this for the time being because 1) the redraw code is not
- prepared to this yet and 2) because some good policy has yet to be decided
- while editting: for instance how to act on rows being created/deleted
- because of DEPM.
-*/
-#if 0
- //if the cursor is in a visible row, anchor to it
- int topy = top_y();
- if (topy < y && y < topy + bv()->workHeight())
- anchor_row(row);
-#endif
-}
-
-
-float LyXText::getCursorX(RowList::iterator rit,
- pos_type pos, pos_type last, bool boundary) const
-{
- pos_type cursor_vpos = 0;
- double x;
- double fill_separator;
- double fill_hfill;
- double fill_label_hfill;
- // This call HAS to be here because of the BidiTables!!!
- prepareToPrint(rit, x, fill_separator, fill_hfill,
- fill_label_hfill);
-
- ParagraphList::iterator rit_par = rit->par();
- pos_type const rit_pos = rit->pos();
-
- if (last < rit_pos)
- cursor_vpos = rit_pos;
- else if (pos > last && !boundary)
- cursor_vpos = (rit_par->isRightToLeftPar(bv()->buffer()->params))
- ? rit_pos : last + 1;
- else if (pos > rit_pos && (pos > last || boundary))
- /// Place cursor after char at (logical) position pos - 1
- cursor_vpos = (bidi_level(pos - 1) % 2 == 0)
- ? log2vis(pos - 1) + 1 : log2vis(pos - 1);
- else
- /// Place cursor before char at (logical) position pos
- cursor_vpos = (bidi_level(pos) % 2 == 0)
- ? log2vis(pos) : log2vis(pos) + 1;
-
- pos_type body_pos = rit_par->beginningOfBody();
- if (body_pos > 0 &&
- (body_pos - 1 > last || !rit_par->isLineSeparator(body_pos - 1)))
- body_pos = 0;
-
- for (pos_type vpos = rit_pos; vpos < cursor_vpos; ++vpos) {
- pos_type pos = vis2log(vpos);
- if (body_pos > 0 && pos == body_pos - 1) {
- x += fill_label_hfill +
- font_metrics::width(
- rit_par->layout()->labelsep, getLabelFont(rit_par));
- if (rit_par->isLineSeparator(body_pos - 1))
- x -= singleWidth(rit_par, body_pos - 1);
- }
-
- if (hfillExpansion(*this, rit, pos)) {
- x += singleWidth(rit_par, pos);
- if (pos >= body_pos)
- x += fill_hfill;
- else
- x += fill_label_hfill;
- } else if (rit_par->isSeparator(pos)) {
- x += singleWidth(rit_par, pos);
- if (pos >= body_pos)
- x += fill_separator;
- } else
- x += singleWidth(rit_par, pos);
+ if (pos > para.size()) {
+ lyxerr << "dont like 1, pos: " << pos
+ << " size: " << para.size()
+ << " par: " << par << endl;
+ BOOST_ASSERT(false);
}
- return x;
}
-void LyXText::setCursorIntern(ParagraphList::iterator pit,
- pos_type pos, bool setfont, bool boundary)
+void LyXText::setCursorIntern(LCursor & cur,
+ pit_type par, pos_type pos, bool setfont, bool boundary)
{
- UpdatableInset * it = pit->inInset();
- if (it) {
- if (it != inset_owner) {
- lyxerr[Debug::INSETS] << "InsetText is " << it
- << endl
- << "inset_owner is "
- << inset_owner << endl;
-#ifdef WITH_WARNINGS
-#warning I believe this code is wrong. (Lgb)
-#warning Jürgen, have a look at this. (Lgb)
-#warning Hmmm, I guess you are right but we
-#warning should verify when this is needed
-#endif
- // Jürgen, would you like to have a look?
- // I guess we need to move the outer cursor
- // and open and lock the inset (bla bla bla)
- // stuff I don't know... so can you have a look?
- // (Lgb)
- // I moved the lyxerr stuff in here so we can see if
- // this is actually really needed and where!
- // (Jug)
- // it->getLyXText(bv())->setCursorIntern(bv(), par, pos, setfont, boundary);
- return;
- }
- }
-
- setCursor(cursor, pit, pos, boundary);
+ setCursor(cur.top(), par, pos, boundary);
+ cur.setTargetX();
if (setfont)
- setCurrentFont();
+ setCurrentFont(cur);
}
-void LyXText::setCurrentFont()
+void LyXText::setCurrentFont(LCursor & cur)
{
- pos_type pos = cursor.pos();
- ParagraphList::iterator pit = cursor.par();
+ BOOST_ASSERT(this == cur.text());
+ pos_type pos = cur.pos();
+ Paragraph & par = cur.paragraph();
- if (cursor.boundary() && pos > 0)
+ if (cur.boundary() && pos > 0)
--pos;
if (pos > 0) {
- if (pos == pit->size())
+ if (pos == cur.lastpos())
--pos;
else // potentional bug... BUG (Lgb)
- if (pit->isSeparator(pos)) {
- if (pos > cursorRow()->pos() &&
- bidi_level(pos) % 2 ==
- bidi_level(pos - 1) % 2)
+ if (par.isSeparator(pos)) {
+ if (pos > cur.textRow().pos() &&
+ bidi.level(pos) % 2 ==
+ bidi.level(pos - 1) % 2)
--pos;
- else if (pos + 1 < pit->size())
+ else if (pos + 1 < cur.lastpos())
++pos;
}
}
- current_font = pit->getFontSettings(bv()->buffer()->params, pos);
- real_current_font = getFont(pit, pos);
+ BufferParams const & bufparams = cur.buffer().params();
+ current_font = par.getFontSettings(bufparams, pos);
+ real_current_font = getFont(par, pos);
- if (cursor.pos() == pit->size() &&
- isBoundary(bv()->buffer(), *pit, cursor.pos()) &&
- !cursor.boundary()) {
- Language const * lang =
- pit->getParLanguage(bv()->buffer()->params);
+ if (cur.pos() == cur.lastpos()
+ && bidi.isBoundary(cur.buffer(), par, cur.pos())
+ && !cur.boundary()) {
+ 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(RowList::iterator rit, int & x, bool & boundary) const
+pos_type LyXText::getColumnNearX(pit_type const pit,
+ Row const & row, int & x, bool & boundary) const
{
- double tmpx = 0;
- double fill_separator;
- double fill_hfill;
- double fill_label_hfill;
-
- prepareToPrint(rit, tmpx, fill_separator, fill_hfill, fill_label_hfill);
+ int const xo = theCoords.get(this, pit).x_;
+ x -= xo;
+ RowMetrics const r = computeRowMetrics(pit, row);
+ Paragraph const & par = pars_[pit];
- pos_type vc = rit->pos();
- pos_type last = lastPrintablePos(*this, rit);
+ pos_type vc = row.pos();
+ pos_type end = row.endpos();
pos_type c = 0;
-
- ParagraphList::iterator rit_par = rit->par();
- LyXLayout_ptr const & layout = rit->par()->layout();
+ LyXLayout_ptr const & layout = par.layout();
bool left_side = false;
- pos_type body_pos = rit_par->beginningOfBody();
+ pos_type body_pos = par.beginOfBody();
+
+ double tmpx = r.x;
double last_tmpx = tmpx;
if (body_pos > 0 &&
- (body_pos - 1 > last ||
- !rit_par->isLineSeparator(body_pos - 1)))
+ (body_pos > end || !par.isLineSeparator(body_pos - 1)))
body_pos = 0;
// check for empty row
- if (!rit_par->size()) {
- x = int(tmpx);
+ if (vc == end) {
+ x = int(tmpx) + xo;
return 0;
}
- while (vc <= last && tmpx <= x) {
- c = vis2log(vc);
+ while (vc < end && tmpx <= x) {
+ c = bidi.vis2log(vc);
last_tmpx = tmpx;
if (body_pos > 0 && c == body_pos - 1) {
- tmpx += fill_label_hfill +
- font_metrics::width(layout->labelsep, getLabelFont(rit_par));
- if (rit_par->isLineSeparator(body_pos - 1))
- tmpx -= singleWidth(rit_par, body_pos - 1);
+ tmpx += r.label_hfill +
+ font_metrics::width(layout->labelsep, getLabelFont(par));
+ if (par.isLineSeparator(body_pos - 1))
+ tmpx -= singleWidth(par, body_pos - 1);
}
- if (hfillExpansion(*this, rit, c)) {
- tmpx += singleWidth(rit_par, c);
+ if (hfillExpansion(par, row, c)) {
+ tmpx += singleWidth(par, c);
if (c >= body_pos)
- tmpx += fill_hfill;
+ tmpx += r.hfill;
else
- tmpx += fill_label_hfill;
- } else if (rit_par->isSeparator(c)) {
- tmpx += singleWidth(rit_par, c);
+ tmpx += r.label_hfill;
+ } else if (par.isSeparator(c)) {
+ tmpx += singleWidth(par, c);
if (c >= body_pos)
- tmpx += fill_separator;
+ tmpx += r.separator;
} else {
- tmpx += singleWidth(rit_par, c);
+ tmpx += singleWidth(par, c);
}
++vc;
}
left_side = true;
}
- if (vc > last + 1) // This shouldn't happen.
- vc = last + 1;
+ BOOST_ASSERT(vc <= end); // This shouldn't happen.
boundary = false;
// This (rtl_support test) is not needed, but gives
- // some speedup if rtl_support=false
- RowList::iterator next_rit = boost::next(rit);
-
- bool const lastrow = lyxrc.rtl_support &&
- (next_rit == rowlist_.end() ||
- next_rit->par() != rit_par);
+ // some speedup if rtl_support == false
+ 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)
- ? rit_par->isRightToLeftPar(bv()->buffer()->params)
- : false;
+ bool const rtl = lastrow ? isRTL(par) : false;
if (lastrow &&
- ((rtl && left_side && vc == rit->pos() && x < tmpx - 5) ||
- (!rtl && !left_side && vc == last + 1 && x > tmpx + 5)))
- c = last + 1;
- else if (vc == rit->pos()) {
- c = vis2log(vc);
- if (bidi_level(c) % 2 == 1)
+ ((rtl && left_side && vc == row.pos() && x < tmpx - 5) ||
+ (!rtl && !left_side && vc == end && x > tmpx + 5)))
+ c = end;
+ else if (vc == row.pos()) {
+ c = bidi.vis2log(vc);
+ if (bidi.level(c) % 2 == 1)
++c;
} else {
- c = vis2log(vc - 1);
- bool const rtl = (bidi_level(c) % 2 == 1);
+ c = bidi.vis2log(vc - 1);
+ bool const rtl = (bidi.level(c) % 2 == 1);
if (left_side == rtl) {
++c;
- boundary = isBoundary(bv()->buffer(), *rit_par, c);
+ boundary = bidi.isBoundary(*bv()->buffer(), par, c);
}
}
- if (rit->pos() <= last && c > last
- && rit_par->isNewline(last)) {
- if (bidi_level(last) % 2 == 0)
- tmpx -= singleWidth(rit_par, last);
+ if (row.pos() < end && c >= end && par.isNewline(end - 1)) {
+ if (bidi.level(end -1) % 2 == 0)
+ tmpx -= singleWidth(par, end - 1);
else
- tmpx += singleWidth(rit_par, last);
- c = last;
+ tmpx += singleWidth(par, end - 1);
+ c = end - 1;
}
- c -= rit->pos();
- x = int(tmpx);
- return c;
+ x = int(tmpx) + xo;
+ return c - row.pos();
}
-void LyXText::setCursorFromCoordinates(int x, int y)
+// y is screen coordinate
+pit_type LyXText::getPitNearY(int y) const
{
- //LyXCursor old_cursor = cursor;
- setCursorFromCoordinates(cursor, x, y);
- setCurrentFont();
-#warning DEPM disabled, otherwise crash when entering new table
- //deleteEmptyParagraphMechanism(old_cursor);
+ 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;
+
+ // 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 << " 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;
+ return pit;
}
-namespace {
+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;
+}
- /**
- * return true if the cursor given is at the end of a row,
- * and the next row is filled by an inset that spans an entire
- * row.
- */
- bool beforeFullRowInset(LyXText & lt, LyXCursor const & cur)
- {
- RowList::iterator row = lt.getRow(cur);
- if (boost::next(row) == lt.rows().end())
- return false;
- Row const & next = *boost::next(row);
+// x,y are absolute screen coordinates
+// sets cursor recursively descending into nested editable insets
+InsetBase * LyXText::editXY(LCursor & cur, int x, int y) const
+{
+ pit_type pit = getPitNearY(y);
+ BOOST_ASSERT(pit != -1);
+ Row const & row = getRowNearY(y, pit);
+ bool bound = false;
- if (next.pos() != cur.pos() || next.par() != cur.par())
- return false;
+ int xx = x; // is modified by getColumnNearX
+ pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound);
+ cur.pit() = pit;
+ cur.pos() = pos;
+ cur.boundary() = bound;
+ cur.x_target() = x;
+
+ // try to descend into nested insets
+ InsetBase * inset = checkInsetHit(x, y);
+ lyxerr << "inset " << inset << " hit at x: " << x << " y: " << y << endl;
+ if (!inset) {
+ // Either we deconst editXY or better we move current_font
+ // and real_current_font to LCursor
+ const_cast<LyXText *>(this)->setCurrentFont(cur);
+ return 0;
+ }
- if (cur.pos() == cur.par()->size()
- || !cur.par()->isInset(cur.pos()))
- return false;
+ // 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));
+ // Make sure the cursor points to the position before
+ // this inset.
+ if (inset == pars_[pit].getInset(pos - 1))
+ --cur.pos();
+ inset = inset->editXY(cur, x, y);
+ if (cur.top().text() == this)
+ const_cast<LyXText *>(this)->setCurrentFont(cur);
+ return inset;
+}
- InsetOld const * inset = cur.par()->getInset(cur.pos());
- if (inset->needFullRow() || inset->display())
- return true;
+bool LyXText::checkAndActivateInset(LCursor & cur, bool front)
+{
+ if (cur.selection())
return false;
- }
+ if (cur.pos() == cur.lastpos())
+ return false;
+ InsetBase * inset = cur.nextInset();
+ if (!isHighlyEditableInset(inset))
+ return false;
+ inset->edit(cur, front);
+ return true;
}
-void LyXText::setCursorFromCoordinates(LyXCursor & cur, int x, int y)
+bool LyXText::cursorLeft(LCursor & cur)
{
- // Get the row first.
+ if (cur.pos() != 0) {
+ bool boundary = cur.boundary();
+ 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))
+ updateNeeded |=
+ setCursor(cur, cur.pit(), cur.pos() + 1, true, true);
+ }
+ return updateNeeded;
+ }
- RowList::iterator row = getRowNearY(y);
- bool bound = false;
- pos_type const column = getColumnNearX(row, x, bound);
- cur.par(row->par());
- cur.pos(row->pos() + column);
- cur.x(x);
- cur.y(y + row->baseline());
-
- if (beforeFullRowInset(*this, cur)) {
- pos_type const last = lastPrintablePos(*this, row);
- RowList::iterator next_row = boost::next(row);
-
- float x = getCursorX(next_row, cur.pos(), last, bound);
- cur.ix(int(x));
- cur.iy(y + row->height() + next_row->baseline());
- } else {
- cur.iy(cur.y());
- cur.ix(cur.x());
+ if (cur.pit() != 0) {
+ // Steps into the paragraph above
+ return setCursor(cur, cur.pit() - 1, getPar(cur.pit() - 1).size());
}
- cur.boundary(bound);
+ return false;
}
-void LyXText::cursorLeft(bool internal)
+bool LyXText::cursorRight(LCursor & cur)
{
- if (cursor.pos() > 0) {
- bool boundary = cursor.boundary();
- setCursor(cursor.par(), cursor.pos() - 1, true, false);
- if (!internal && !boundary &&
- isBoundary(bv()->buffer(), *cursor.par(), cursor.pos() + 1))
- setCursor(cursor.par(), cursor.pos() + 1, true, true);
- } else if (cursor.par() != ownerParagraphs().begin()) {
- // steps into the paragraph above
- ParagraphList::iterator pit = boost::prior(cursor.par());
- setCursor(pit, pit->size());
+ if (false && cur.boundary()) {
+ return setCursor(cur, cur.pit(), cur.pos(), true, false);
}
-}
+ if (cur.pos() != cur.lastpos()) {
+ bool updateNeeded = false;
+ if (!checkAndActivateInset(cur, true)) {
+ updateNeeded |= setCursor(cur, cur.pit(), cur.pos() + 1, true, false);
+ if (false && bidi.isBoundary(cur.buffer(), cur.paragraph(),
+ cur.pos()))
+ updateNeeded |= setCursor(cur, cur.pit(), cur.pos(), true, true);
+ }
+ return updateNeeded;
+ }
-void LyXText::cursorRight(bool internal)
-{
- bool const at_end = (cursor.pos() == cursor.par()->size());
- bool const at_newline = !at_end &&
- cursor.par()->isNewline(cursor.pos());
-
- if (!internal && cursor.boundary() && !at_newline)
- setCursor(cursor.par(), cursor.pos(), true, false);
- else if (!at_end) {
- setCursor(cursor.par(), cursor.pos() + 1, true, false);
- if (!internal &&
- isBoundary(bv()->buffer(), *cursor.par(), cursor.pos()))
- setCursor(cursor.par(), cursor.pos(), true, true);
- } else if (boost::next(cursor.par()) != ownerParagraphs().end())
- setCursor(boost::next(cursor.par()), 0);
+ if (cur.pit() != cur.lastpit())
+ return setCursor(cur, cur.pit() + 1, 0);
+ return false;
}
-void LyXText::cursorUp(bool selecting)
+bool LyXText::cursorUp(LCursor & cur)
{
-#if 1
- int x = cursor.x_fix();
- int y = cursor.y() - cursorRow()->baseline() - 1;
- setCursorFromCoordinates(x, y);
- if (!selecting) {
- int topy = top_y();
- int y1 = cursor.iy() - topy;
- int y2 = y1;
- y -= topy;
- InsetOld * inset_hit = checkInsetHit(x, y1);
- if (inset_hit && isHighlyEditableInset(inset_hit)) {
- inset_hit->localDispatch(
- FuncRequest(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none));
- }
+ Paragraph const & par = cur.paragraph();
+ int const row = par.pos2row(cur.pos());
+ int const x = cur.targetX();
+
+ if (!cur.selection()) {
+ int const y = bv_funcs::getPos(cur).y_;
+ LCursor old = cur;
+ editXY(cur, x, y - par.rows()[row].ascent() - 1);
+
+ // This happens when you move out of an inset.
+ // And to give the DEPM the possibility of doing
+ // something we must provide it with two different
+ // cursors. (Lgb)
+ LCursor dummy = cur;
+ if (dummy == old)
+ ++dummy.pos();
+
+ return deleteEmptyParagraphMechanism(dummy, old);
}
-#else
- setCursorFromCoordinates(bv(), cursor.x_fix(),
- cursor.y() - cursorRow()->baseline() - 1);
-#endif
+
+ bool updateNeeded = false;
+
+ if (row > 0) {
+ updateNeeded |= setCursor(cur, cur.pit(),
+ x2pos(cur.pit(), row - 1, x));
+ } else if (cur.pit() > 0) {
+ --cur.pit();
+ updateNeeded |= setCursor(cur, cur.pit(),
+ x2pos(cur.pit(), par.rows().size() - 1, x));
+ }
+
+ cur.x_target() = x;
+
+ return updateNeeded;
}
-void LyXText::cursorDown(bool selecting)
+bool LyXText::cursorDown(LCursor & cur)
{
-#if 1
- int x = cursor.x_fix();
- int y = cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1;
- setCursorFromCoordinates(x, y);
- if (!selecting && cursorRow() == cursorIRow()) {
- int topy = top_y();
- int y1 = cursor.iy() - topy;
- int y2 = y1;
- y -= topy;
- InsetOld * inset_hit = checkInsetHit(x, y1);
- if (inset_hit && isHighlyEditableInset(inset_hit)) {
- FuncRequest cmd(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none);
- inset_hit->localDispatch(cmd);
- }
+ Paragraph const & par = cur.paragraph();
+ int const row = par.pos2row(cur.pos());
+ int const x = cur.targetX();
+
+ if (!cur.selection()) {
+ int const y = bv_funcs::getPos(cur).y_;
+ LCursor old = cur;
+ editXY(cur, x, y + par.rows()[row].descent() + 1);
+
+ // This happens when you move out of an inset.
+ // And to give the DEPM the possibility of doing
+ // something we must provide it with two different
+ // cursors. (Lgb)
+ LCursor dummy = cur;
+ if (dummy == old)
+ ++dummy.pos();
+
+ bool const changed = deleteEmptyParagraphMechanism(dummy, old);
+
+ // Make sure that cur gets back whatever happened to dummy(Lgb)
+ if (changed)
+ cur = dummy;
+
+ return changed;
+
}
-#else
- setCursorFromCoordinates(bv(), cursor.x_fix(),
- cursor.y() - cursorRow()->baseline()
- + cursorRow()->height() + 1);
-#endif
+
+ 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()
+bool LyXText::cursorUpParagraph(LCursor & cur)
{
- if (cursor.pos() > 0)
- setCursor(cursor.par(), 0);
- else if (cursor.par() != ownerParagraphs().begin())
- setCursor(boost::prior(cursor.par()), 0);
+ bool updated = false;
+ if (cur.pos() > 0)
+ updated = setCursor(cur, cur.pit(), 0);
+ else if (cur.pit() != 0)
+ updated = setCursor(cur, cur.pit() - 1, 0);
+ return updated;
}
-void LyXText::cursorDownParagraph()
+bool LyXText::cursorDownParagraph(LCursor & cur)
{
- ParagraphList::iterator par = cursor.par();
- ParagraphList::iterator next_par = boost::next(par);
-
- if (next_par != ownerParagraphs().end())
- setCursor(next_par, 0);
+ bool updated = false;
+ if (cur.pit() != cur.lastpit())
+ updated = setCursor(cur, cur.pit() + 1, 0);
else
- setCursor(par, par->size());
+ updated = setCursor(cur, cur.pit(), cur.lastpos());
+ return updated;
}
// fix the cursor `cur' after a characters has been deleted at `where'
// position. Called by deleteEmptyParagraphMechanism
-void LyXText::fixCursorAfterDelete(LyXCursor & cur,
- LyXCursor const & where)
+void LyXText::fixCursorAfterDelete(CursorSlice & cur, CursorSlice const & where)
{
- // if cursor is not in the paragraph where the delete occured,
- // do nothing
- if (cur.par() != where.par())
+ // 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 place where the delete occured,
- // update it
+ // If cursor position is after the deletion place update it
if (cur.pos() > where.pos())
- cur.pos(cur.pos()-1);
+ --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.par()->size())
- cur.pos(cur.par()->size());
-
- // recompute row et al. for this cursor
- setCursor(cur, cur.par(), cur.pos(), cur.boundary());
+ if (cur.pos() > cur.lastpos())
+ cur.pos() = cur.lastpos();
}
-bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
+bool LyXText::deleteEmptyParagraphMechanism(LCursor & cur, LCursor const & old)
{
// Would be wrong to delete anything if we have a selection.
- if (selection.set())
+ if (cur.selection())
return false;
+ //lyxerr[Debug::DEBUG] << "DEPM: cur:\n" << cur << "old:\n" << old << endl;
+ Paragraph const & oldpar = pars_[old.pit()];
+
// We allow all kinds of "mumbo-jumbo" when freespacing.
- if (old_cursor.par()->layout()->free_spacing
- || old_cursor.par()->isFreeSpacing()) {
+ 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
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 betwenn to spaces and then save. Or if you
+ 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
that I can get some feedback. (Lgb)
*/
- // If old_cursor.pos() == 0 and old_cursor.pos()(1) == LineSeparator
+ // If old.pos() == 0 and old.pos()(1) == LineSeparator
// delete the LineSeparator.
// MISSING
- // If old_cursor.pos() == 1 and old_cursor.pos()(0) == LineSeparator
+ // If old.pos() == 1 and old.pos()(0) == LineSeparator
// delete the LineSeparator.
// MISSING
- // If the pos around the old_cursor were spaces, delete one of them.
- if (old_cursor.par() != cursor.par()
- || old_cursor.pos() != cursor.pos()) {
- // Only if the cursor has really moved
-
- if (old_cursor.pos() > 0
- && old_cursor.pos() < old_cursor.par()->size()
- && old_cursor.par()->isLineSeparator(old_cursor.pos())
- && old_cursor.par()->isLineSeparator(old_cursor.pos() - 1)) {
- old_cursor.par()->erase(old_cursor.pos() - 1);
- redoParagraph(old_cursor.par());
+ // If the chars around the old cursor were spaces, delete one of them.
+ if (old.pit() != cur.pit() || old.pos() != cur.pos()) {
+ // Only if the cursor has really moved.
+ if (old.pos() > 0
+ && old.pos() < oldpar.size()
+ && oldpar.isLineSeparator(old.pos())
+ && oldpar.isLineSeparator(old.pos() - 1)) {
+ pars_[old.pit()].erase(old.pos() - 1);
#ifdef WITH_WARNINGS
#warning This will not work anymore when we have multiple views of the same buffer
// In this case, we will have to correct also the cursors held by
// other bufferviews. It will probably be easier to do that in a more
-// automated way in LyXCursor code. (JMarc 26/09/2001)
+// automated way in CursorSlice code. (JMarc 26/09/2001)
+#endif
+ // correct all cursor parts
+ fixCursorAfterDelete(cur.top(), old.top());
+#ifdef WITH_WARNINGS
+#warning DEPM, look here
#endif
- // correct all cursors held by the LyXText
- fixCursorAfterDelete(cursor, old_cursor);
- fixCursorAfterDelete(selection.cursor, old_cursor);
- fixCursorAfterDelete(selection.start, old_cursor);
- fixCursorAfterDelete(selection.end, old_cursor);
- fixCursorAfterDelete(last_sel_cursor, old_cursor);
- return false;
+ //fixCursorAfterDelete(cur.anchor(), old.top());
+ return true;
}
}
- // don't delete anything if this is the ONLY paragraph!
- if (ownerParagraphs().size() == 1)
+ // only do our magic if we changed paragraph
+ if (old.pit() == cur.pit())
return false;
- // Do not delete empty paragraphs with keepempty set.
- if (old_cursor.par()->allowEmpty())
+ // don't delete anything if this is the ONLY paragraph!
+ if (pars_.size() == 1)
return false;
- // only do our magic if we changed paragraph
- if (old_cursor.par() == cursor.par())
+ // 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 (old_cursor.par()->empty() ||
- (old_cursor.par()->size() == 1 &&
- old_cursor.par()->isLineSeparator(0))) {
- // ok, we will delete anything
- LyXCursor tmpcursor;
-
+ if (oldpar.empty() || (oldpar.size() == 1 && oldpar.isLineSeparator(0))) {
+ // ok, we will delete something
deleted = true;
- bool selection_position_was_oldcursor_position = (
- selection.cursor.par() == old_cursor.par()
- && selection.cursor.pos() == old_cursor.pos());
-
- if (getRow(old_cursor) != rows().begin()) {
- RowList::iterator prevrow = boost::prior(getRow(old_cursor));
- tmpcursor = cursor;
- cursor = old_cursor; // that undo can restore the right cursor position
- #warning FIXME. --end() iterator is usable here
- ParagraphList::iterator endpit = boost::next(old_cursor.par());
- while (endpit != ownerParagraphs().end() &&
- endpit->getDepth()) {
- ++endpit;
- }
+ bool selection_position_was_oldcursor_position =
+ cur.anchor().pit() == old.pit() && cur.anchor().pos() == old.pos();
- recordUndo(bv(), Undo::DELETE, old_cursor.par(),
- boost::prior(endpit));
- cursor = tmpcursor;
-
- // delete old row
- removeRow(getRow(old_cursor));
- // delete old par
- ownerParagraphs().erase(old_cursor.par());
-
- /* Breakagain the next par. Needed because of
- * the parindent that can occur or dissappear.
- * The next row can change its height, if
- * there is another layout before */
- RowList::iterator tmprit = boost::next(prevrow);
- if (tmprit != rows().end()) {
- breakAgain(tmprit);
- updateCounters();
- }
- setHeightOfRow(prevrow);
- } else {
- RowList::iterator nextrow = boost::next(getRow(old_cursor));
-
- tmpcursor = cursor;
- cursor = old_cursor; // that undo can restore the right cursor position
-#warning FIXME. --end() iterator is usable here
- ParagraphList::iterator endpit = boost::next(old_cursor.par());
- while (endpit != ownerParagraphs().end() &&
- endpit->getDepth()) {
- ++endpit;
- }
+ // 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());
- recordUndo(bv(), Undo::DELETE, old_cursor.par(), boost::prior(endpit));
- cursor = tmpcursor;
-
- // delete old row
- removeRow(getRow(old_cursor));
- // delete old par
- ownerParagraphs().erase(old_cursor.par());
-
- /* Breakagain the next par. Needed because of
- the parindent that can occur or dissappear.
- The next row can change its height, if
- there is another layout before */
- if (nextrow != rows().end()) {
- breakAgain(nextrow);
- updateCounters();
- }
- }
+ // Delete old par.
+ pars_.erase(pars_.begin() + old.pit());
- // correct cursor y
- setCursorIntern(cursor.par(), cursor.pos());
+ // 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
- selection.cursor = cursor;
+ cur.resetAnchor();
}
}
- if (!deleted) {
- if (old_cursor.par()->stripLeadingSpaces()) {
- redoParagraph(old_cursor.par());
- // correct cursor y
- setCursorIntern(cursor.par(), cursor.pos());
- selection.cursor = cursor;
- }
- }
- return deleted;
+
+ if (deleted)
+ return true;
+
+ if (pars_[old.pit()].stripLeadingSpaces())
+ cur.resetAnchor();
+
+ return false;
}
-ParagraphList & LyXText::ownerParagraphs() const
+ParagraphList & LyXText::paragraphs() const
{
- if (inset_owner) {
- return inset_owner->paragraphs;
- }
- return bv_owner->buffer()->paragraphs;
+ return const_cast<ParagraphList &>(pars_);
+}
+
+
+void LyXText::recUndo(pit_type first, pit_type last) const
+{
+ recordUndo(bv()->cursor(), Undo::ATOMIC, first, last);
}
-bool LyXText::isInInset() const
+void LyXText::recUndo(pit_type par) const
{
- // Sub-level has non-null bv owner and
- // non-null inset owner.
- return inset_owner != 0 && bv_owner != 0;
+ recordUndo(bv()->cursor(), Undo::ATOMIC, par, par);
}
int defaultRowHeight()
{
- LyXFont const font(LyXFont::ALL_SANE);
- return int(font_metrics::maxAscent(font)
- + font_metrics::maxDescent(font) * 1.5);
+ return int(font_metrics::maxHeight(LyXFont(LyXFont::ALL_SANE)) * 1.2);
}