#include "BufferView.h"
#include "Bullet.h"
#include "counters.h"
+#include "coordcache.h"
#include "cursor.h"
#include "CutAndPaste.h"
#include "debug.h"
#include "paragraph.h"
#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
-#include "PosIterator.h"
#include "undo.h"
#include "vspace.h"
#include "support/lstrings.h"
#include "support/textutils.h"
#include "support/tostr.h"
-#include "support/std_sstream.h"
-#include <boost/tuple/tuple.hpp>
+#include <sstream>
+using lyx::par_type;
using lyx::pos_type;
-using lyx::paroffset_type;
using lyx::support::bformat;
using std::endl;
using std::string;
-LyXText::LyXText(BufferView * bv, bool in_inset)
- : height(0), width(0), textwidth_(bv ? bv->workWidth() : 100),
- background_color_(LColor::background),
- bv_owner(bv), in_inset_(in_inset), xo_(0), yo_(0)
+LyXText::LyXText(BufferView * bv)
+ : width_(0), maxwidth_(bv ? bv->workWidth() : 100), height_(0),
+ background_color_(LColor::background),
+ bv_owner(bv), xo_(0), yo_(0)
{}
-void LyXText::init(BufferView * bview)
+void LyXText::init(BufferView * bv)
{
- bv_owner = bview;
+ BOOST_ASSERT(bv);
+ bv_owner = bv;
+ maxwidth_ = bv->workWidth();
+ width_ = maxwidth_;
+ height_ = 0;
- ParagraphList::iterator const beg = paragraphs().begin();
- ParagraphList::iterator const end = paragraphs().end();
- for (ParagraphList::iterator pit = beg; pit != end; ++pit)
- pit->rows.clear();
+ par_type const end = paragraphs().size();
+ for (par_type pit = 0; pit != end; ++pit)
+ pars_[pit].rows.clear();
- width = 0;
- height = 0;
+ current_font = getFont(pars_[0], 0);
+ redoParagraphs(0, end);
+ updateCounters();
+}
- current_font = getFont(beg, 0);
- redoParagraphs(beg, end);
- setCursorIntern(0, 0);
- selection.cursor = cursor;
+bool LyXText::isMainText() const
+{
+ return &bv()->buffer()->text() == this;
+}
- updateCounters();
+
+// takes absolute x,y coordinates
+InsetBase * LyXText::checkInsetHit(int x, int y) const
+{
+ par_type pit;
+ par_type end;
+
+ getParsInRange(paragraphs(),
+ bv()->top_y() - yo_,
+ bv()->top_y() - yo_ + bv()->workHeight(),
+ pit, end);
+
+ // convert to screen-absolute y coordinate
+ y -= bv()->top_y();
+ lyxerr << "checkInsetHit: x: " << x << " y: " << y << endl;
+ lyxerr << " pit: " << pit << " end: " << end << endl;
+ for (; pit != end; ++pit) {
+ InsetList::const_iterator iit = pars_[pit].insetlist.begin();
+ InsetList::const_iterator iend = pars_[pit].insetlist.end();
+ for (; iit != iend; ++iit) {
+ InsetBase * inset = iit->inset;
+#if 1
+ lyxerr << "examining inset " << inset << endl;
+ if (theCoords.insets_.has(inset))
+ lyxerr
+ << " xo: " << inset->xo() << "..." << inset->xo() + inset->width()
+ << " yo: " << inset->yo() - inset->ascent() << "..."
+ << inset->yo() + inset->descent() << endl;
+ else
+ lyxerr << " inset has no cached position";
+#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)
-LyXFont LyXText::getFont(ParagraphList::iterator pit, pos_type pos) const
+LyXFont LyXText::getFont(Paragraph const & par, pos_type const pos) const
{
BOOST_ASSERT(pos >= 0);
- LyXLayout_ptr const & layout = pit->layout();
+ LyXLayout_ptr const & layout = par.layout();
+#ifdef WITH_WARNINGS
#warning broken?
+#endif
BufferParams const & params = bv()->buffer()->params();
- pos_type const body_pos = pit->beginOfBody();
+ pos_type const body_pos = par.beginOfBody();
// We specialize the 95% common case:
- if (!pit->getDepth()) {
- LyXFont f = pit->getFontSettings(params, pos);
- if (in_inset_)
+ 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
layoutfont = layout->font;
- LyXFont font = pit->getFontSettings(params, pos);
+ LyXFont font = par.getFontSettings(params, pos);
font.realize(layoutfont);
- if (in_inset_)
+ if (!isMainText())
font.realize(font_);
// Realize with the fonts of lesser depth.
- //font.realize(outerFont(pit, paragraphs()));
font.realize(defaultfont_);
return font;
}
-LyXFont LyXText::getLayoutFont(ParagraphList::iterator pit) const
+LyXFont LyXText::getLayoutFont(par_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;
}
-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, paragraphs()));
font.realize(defaultfont_);
return font;
}
-void LyXText::setCharFont(
- ParagraphList::iterator pit, pos_type pos, LyXFont const & fnt)
+void LyXText::setCharFont(par_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->beginOfBody())
+ 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()) {
+ par_type tp = pit;
while (!layoutfont.resolved() &&
- tp != paragraphs().end() &&
- tp->getDepth()) {
+ tp != par_type(paragraphs().size()) &&
+ pars_[tp].getDepth()) {
tp = outerHook(tp, paragraphs());
- if (tp != paragraphs().end())
- layoutfont.realize(tp->layout()->font);
+ if (tp != par_type(paragraphs().size()))
+ layoutfont.realize(pars_[tp].layout()->font);
}
}
// Now, reduce font against full layout font
font.reduce(layoutfont);
- pit->setFont(pos, font);
-}
-
-
-InsetOld * LyXText::getInset() const
-{
- ParagraphList::iterator pit = cursorPar();
- pos_type const pos = cursor.pos();
-
- if (pos < pit->size() && pit->isInset(pos)) {
- return pit->getInset(pos);
- }
- return 0;
-}
-
-
-bool LyXText::toggleInset()
-{
- InsetOld * inset = getInset();
- // is there an editable inset at cursor position?
- if (!isEditableInset(inset))
- return false;
- //bv()->owner()->message(inset->editMessage());
-
- // do we want to keep this?? (JMarc)
- if (!isHighlyEditableInset(inset))
- recUndo(cursor.par());
-
- if (inset->isOpen())
- inset->close();
- else
- inset->open();
- return true;
+ pars_[pit].setFont(pos, font);
}
}
-ParagraphList::iterator
-LyXText::setLayout(ParagraphList::iterator start,
- ParagraphList::iterator end,
- string const & layout)
+// return past-the-last paragraph influenced by a layout change on pit
+par_type LyXText::undoSpan(par_type pit)
{
- ParagraphList::iterator undopit = end;
- ParagraphList::iterator pars_end = paragraphs().end();
+ par_type end = paragraphs().size();
+ par_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;
+}
+
- while (undopit != pars_end && undopit->getDepth())
- ++undopit;
- //because of parindets etc
- if (undopit != pars_end)
- ++undopit;
- recUndo(parOffset(start), parOffset(undopit) - 1);
+par_type LyXText::setLayout(par_type start, par_type end, string const & layout)
+{
+ BOOST_ASSERT(start != end);
+ par_type undopit = undoSpan(end - 1);
+ recUndo(start, undopit - 1);
BufferParams const & bufparams = bv()->buffer()->params();
- LyXLayout_ptr const & lyxlayout =
- bufparams.getLyXTextClass()[layout];
+ LyXLayout_ptr const & lyxlayout = bufparams.getLyXTextClass()[layout];
- for (ParagraphList::iterator pit = start; pit != end; ++pit) {
- pit->applyLayout(lyxlayout);
- makeFontEntriesLayoutSpecific(bufparams, *pit);
+ for (par_type pit = start; pit != end; ++pit) {
+ pars_[pit].applyLayout(lyxlayout);
+ makeFontEntriesLayoutSpecific(bufparams, pars_[pit]);
if (lyxlayout->margintype == MARGIN_MANUAL)
- pit->setLabelWidthString(lyxlayout->labelstring());
+ pars_[pit].setLabelWidthString(lyxlayout->labelstring());
}
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)
{
+ 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 start = getPar(selStart().par());
- ParagraphList::iterator end = boost::next(getPar(selEnd().par()));
- ParagraphList::iterator endpit = setLayout(start, end, layout);
-
+ par_type start = cur.selBegin().par();
+ par_type end = cur.selEnd().par() + 1;
+ par_type endpit = setLayout(start, end, layout);
redoParagraphs(start, endpit);
updateCounters();
- redoCursor();
}
namespace {
-void getSelectionSpan(LyXText & text,
- ParagraphList::iterator & beg,
- ParagraphList::iterator & end)
+void getSelectionSpan(LCursor & cur, par_type & beg, par_type & end)
{
- if (!text.selection.set()) {
- beg = text.cursorPar();
- end = boost::next(beg);
+ if (!cur.selection()) {
+ beg = cur.par();
+ end = cur.par() + 1;
} else {
- beg = text.getPar(text.selStart());
- end = boost::next(text.getPar(text.selEnd()));
+ beg = cur.selBegin().par();
+ end = cur.selEnd().par() + 1;
}
}
-bool changeDepthAllowed(bv_funcs::DEPTH_CHANGE type,
- Paragraph const & par,
- int max_depth)
+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 == bv_funcs::INC_DEPTH && depth < max_depth)
+ if (type == LyXText::INC_DEPTH && depth < max_depth)
return true;
- if (type == bv_funcs::DEC_DEPTH && depth > 0)
+ if (type == LyXText::DEC_DEPTH && depth > 0)
return true;
return false;
}
}
-bool LyXText::changeDepthAllowed(bv_funcs::DEPTH_CHANGE type)
+bool LyXText::changeDepthAllowed(LCursor & cur, DEPTH_CHANGE type) const
{
- ParagraphList::iterator beg, end;
- getSelectionSpan(*this, beg, end);
+ BOOST_ASSERT(this == cur.text());
+ par_type beg, end;
+ getSelectionSpan(cur, beg, end);
int max_depth = 0;
- if (beg != paragraphs().begin())
- max_depth = boost::prior(beg)->getMaxDepthAfter();
+ if (beg != 0)
+ max_depth = pars_[beg - 1].getMaxDepthAfter();
- for (ParagraphList::iterator pit = beg; pit != end; ++pit) {
- if (::changeDepthAllowed(type, *pit, max_depth))
+ for (par_type pit = beg; pit != end; ++pit) {
+ if (::changeDepthAllowed(type, pars_[pit], max_depth))
return true;
- max_depth = pit->getMaxDepthAfter();
+ max_depth = pars_[pit].getMaxDepthAfter();
}
return false;
}
-void LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type)
+void LyXText::changeDepth(LCursor & cur, DEPTH_CHANGE type)
{
- ParagraphList::iterator beg, end;
- getSelectionSpan(*this, beg, end);
-
- recUndo(parOffset(beg), parOffset(end) - 1);
+ BOOST_ASSERT(this == cur.text());
+ par_type beg, end;
+ getSelectionSpan(cur, beg, end);
+ recordUndoSelection(cur);
int max_depth = 0;
- if (beg != paragraphs().begin())
- max_depth = boost::prior(beg)->getMaxDepthAfter();
-
- for (ParagraphList::iterator pit = beg; pit != end; ++pit) {
- if (::changeDepthAllowed(type, *pit, max_depth)) {
- int const depth = pit->params().depth();
- if (type == bv_funcs::INC_DEPTH)
- pit->params().depth(depth + 1);
+ if (beg != 0)
+ max_depth = pars_[beg - 1].getMaxDepthAfter();
+
+ for (par_type pit = beg; pit != end; ++pit) {
+ if (::changeDepthAllowed(type, pars_[pit], max_depth)) {
+ int const depth = pars_[pit].params().depth();
+ if (type == INC_DEPTH)
+ pars_[pit].params().depth(depth + 1);
else
- pit->params().depth(depth - 1);
+ pars_[pit].params().depth(depth - 1);
}
- max_depth = pit->getMaxDepthAfter();
+ max_depth = pars_[pit].getMaxDepthAfter();
}
// this handles the counter labels, and also fixes up
// depth values for follow-on (child) paragraphs
updateCounters();
- redoCursor();
}
-// 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() < cursorPar()->beginOfBody())
- layoutfont = getLabelFont(cursorPar());
+ par_type pit = cur.par();
+ if (cur.pos() < pars_[pit].beginOfBody())
+ layoutfont = getLabelFont(pars_[pit]);
else
- layoutfont = getLayoutFont(cursorPar());
+ 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;
}
- // ok we have a selection.
- recUndo(selStart().par(), selEnd().par());
- freezeUndo();
+ // Ok, we have a selection.
+ recordUndoSelection(cur);
- ParagraphList::iterator beg = getPar(selStart().par());
- ParagraphList::iterator end = getPar(selEnd().par());
-
- PosIterator pos(¶graphs(), beg, selStart().pos());
- PosIterator posend(¶graphs(), end, selEnd().pos());
+ par_type const beg = cur.selBegin().par();
+ par_type const end = cur.selEnd().par();
- BufferParams const & params = bv()->buffer()->params();
+ DocIterator dit = cur.selectionBegin();
+ DocIterator ditend = cur.selectionEnd();
+
+ BufferParams const & params = cur.buffer().params();
- for (; pos != posend; ++pos) {
- LyXFont f = getFont(pos.pit(), pos.pos());
- f.update(font, params.language, toggleall);
- setCharFont(pos.pit(), pos.pos(), f);
+ // Don't use forwardChar here as ditend might have
+ // pos() == lastpos() and forwardChar would miss it.
+ for (; dit != ditend; dit.forwardPos()) {
+ if (dit.pos() != dit.lastpos()) {
+ LyXFont f = getFont(dit.paragraph(), dit.pos());
+ f.update(font, params.language, toggleall);
+ setCharFont(dit.par(), dit.pos(), f);
+ }
}
-
- unFreezeUndo();
- redoParagraphs(beg, ++end);
- redoCursor();
+ redoParagraphs(beg, end + 1);
}
-// 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.
-
-// need the selection cursor:
-void LyXText::setSelection()
-{
- TextCursor::setSelection();
-}
+// realize you left an empty paragraph, they will delete it.
-
-void LyXText::clearSelection()
+void LyXText::cursorHome(LCursor & cur)
{
- TextCursor::clearSelection();
-
- // reset this in the bv()!
- if (bv() && bv()->text())
- bv()->unsetXSel();
+ BOOST_ASSERT(this == cur.text());
+ setCursor(cur, cur.par(), cur.textRow().pos());
}
-void LyXText::cursorHome()
+void LyXText::cursorEnd(LCursor & cur)
{
- ParagraphList::iterator cpit = cursorPar();
- setCursor(cpit, cpit->getRow(cursor.pos())->pos());
-}
-
-
-void LyXText::cursorEnd()
-{
- ParagraphList::iterator cpit = cursorPar();
- pos_type end = cpit->getRow(cursor.pos())->endpos();
+ BOOST_ASSERT(this == cur.text());
// if not on the last row of the par, put the cursor before
// the final space
- setCursor(cpit, end == cpit->size() ? end : end - 1);
+ pos_type const end = cur.textRow().endpos();
+ setCursor(cur, cur.par(), end == cur.lastpos() ? end : end - 1);
}
-void LyXText::cursorTop()
+void LyXText::cursorTop(LCursor & cur)
{
- setCursor(paragraphs().begin(), 0);
+ BOOST_ASSERT(this == cur.text());
+ setCursor(cur, 0, 0);
}
-void LyXText::cursorBottom()
+void LyXText::cursorBottom(LCursor & cur)
{
- ParagraphList::iterator lastpit =
- boost::prior(paragraphs().end());
- setCursor(lastpit, lastpit->size());
+ BOOST_ASSERT(this == cur.text());
+ setCursor(cur, cur.lastpar(), 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. "
+ 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;
+ CursorSlice resetCursor = cur.top();
bool implicitSelection =
font.language() == ignore_language
&& font.number() == LyXFont::IGNORE
- && selectWordWhenUnderCursor(lyx::WHOLE_WORD_STRICT);
+ && 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(cursorPar(), cursor.pos());
- selection.cursor = cursor;
+ cur.clearSelection();
+ cur.top() = resetCursor;
+ cur.resetAnchor();
}
}
-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 (selStart().par() != selEnd().par())
- bv()->owner()->message(_("Cannot index more than one paragraph!"));
+ if (!cur.selection())
+ cur.message(_("Nothing to index!"));
+ else if (cur.selBegin().par() != cur.selEnd().par())
+ cur.message(_("Cannot index more than one paragraph!"));
else
- idxstring = selectionAsString(*bv()->buffer(), false);
+ idxstring = cur.selectionAsString(false);
// Reset cursors to their original position.
- cursor = reset_cursor;
- setCursor(cursorPar(), 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
-// physical paragraph. When a paragraph is broken, the top settings rest,
-// the bottom settings are given to the new one. So I can make sure,
-// they do not duplicate themself and you cannot play dirty tricks with
-// them!
-
-void LyXText::setParagraph(Spacing const & spacing, LyXAlignment align,
+void LyXText::setParagraph(LCursor & cur,
+ Spacing const & spacing, LyXAlignment align,
string const & labelwidthstring, bool noindent)
{
+ BOOST_ASSERT(cur.text());
// make sure that the depth behind the selection are restored, too
- ParagraphList::iterator endpit = boost::next(getPar(selEnd()));
- ParagraphList::iterator pars_end = paragraphs().end();
+ par_type undopit = undoSpan(cur.selEnd().par());
+ recUndo(cur.selBegin().par(), undopit - 1);
- while (endpit != pars_end && endpit->getDepth())
- ++endpit;
- // because of parindents etc.
- if (endpit != pars_end)
- ++endpit;
-
- recUndo(selStart().par(), parOffset(endpit) - 1);
-
- ParagraphList::reverse_iterator pit(getPar(selEnd().par()));
- ParagraphList::reverse_iterator beg(getPar(selStart().par()));
-
- for (++beg; pit != beg; ++pit) {
- ParagraphParameters & params = pit->params();
+ for (par_type pit = cur.selBegin().par(), end = cur.selEnd().par();
+ 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);
+ par.setLabelWidthString(labelwidthstring);
params.noindent(noindent);
}
- redoParagraphs(getPar(selStart()), endpit);
- redoCursor();
+ redoParagraphs(cur.selBegin().par(), undopit);
}
namespace {
-void incrementItemDepth(ParagraphList::iterator pit,
- ParagraphList::iterator first_pit)
+void incrementItemDepth(ParagraphList & pars, par_type pit, par_type first_pit)
{
- int const cur_labeltype = pit->layout()->labeltype;
+ int const cur_labeltype = pars[pit].layout()->labeltype;
if (cur_labeltype != LABEL_ENUMERATE && cur_labeltype != LABEL_ITEMIZE)
return;
- int const cur_depth = pit->getDepth();
+ int const cur_depth = pars[pit].getDepth();
- ParagraphList::iterator prev_pit = boost::prior(pit);
+ par_type prev_pit = pit - 1;
while (true) {
- int const prev_depth = prev_pit->getDepth();
- int const prev_labeltype = prev_pit->layout()->labeltype;
+ 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) {
- pit->itemdepth = prev_pit->itemdepth + 1;
+ pars[pit].itemdepth = pars[prev_pit].itemdepth + 1;
}
break;
} else if (prev_depth < cur_depth) {
if (prev_labeltype == cur_labeltype) {
- pit->itemdepth = prev_pit->itemdepth + 1;
+ pars[pit].itemdepth = pars[prev_pit].itemdepth + 1;
break;
}
} else if (prev_depth == cur_depth) {
if (prev_labeltype == cur_labeltype) {
- pit->itemdepth = prev_pit->itemdepth;
+ pars[pit].itemdepth = pars[prev_pit].itemdepth;
break;
}
}
}
-void resetEnumCounterIfNeeded(ParagraphList::iterator pit,
- ParagraphList::iterator firstpit,
- Counters & counters)
+void resetEnumCounterIfNeeded(ParagraphList & pars, par_type pit,
+ par_type firstpit, Counters & counters)
{
if (pit == firstpit)
return;
- int const cur_depth = pit->getDepth();
- ParagraphList::iterator prev_pit = boost::prior(pit);
+ int const cur_depth = pars[pit].getDepth();
+ par_type prev_pit = pit - 1;
while (true) {
- int const prev_depth = prev_pit->getDepth();
- int const prev_labeltype = prev_pit->layout()->labeltype;
+ 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 (pit->itemdepth) {
+ switch (pars[pit].itemdepth) {
case 0:
counters.reset("enumi");
case 1:
// 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, par_type pit)
{
+ Paragraph & par = pars_[pit];
BufferParams const & bufparams = buf.params();
LyXTextClass const & textclass = bufparams.getLyXTextClass();
- LyXLayout_ptr const & layout = pit->layout();
- ParagraphList::iterator first_pit = paragraphs().begin();
+ LyXLayout_ptr const & layout = par.layout();
Counters & counters = textclass.counters();
// Always reset
- pit->itemdepth = 0;
+ par.itemdepth = 0;
- if (pit == first_pit) {
- pit->params().appendix(pit->params().startOfAppendix());
+ if (pit == 0) {
+ par.params().appendix(par.params().startOfAppendix());
} else {
- pit->params().appendix(boost::prior(pit)->params().appendix());
- if (!pit->params().appendix() &&
- pit->params().startOfAppendix()) {
- pit->params().appendix(true);
+ 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(pit, first_pit);
+ incrementItemDepth(pars_, pit, 0);
}
// erase what was there before
- pit->params().labelString(string());
+ 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?
BufferParams const & bufparams = buf.params();
LyXTextClass const & textclass = bufparams.getLyXTextClass();
counters.step(layout->counter);
- string label = expandLabel(textclass, layout, pit->params().appendix());
- pit->params().labelString(label);
+ 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:
- // pit->params().labelString(
- // bufparams.user_defined_bullet(pit->itemdepth).getText());
+ // par.params().labelString(
+ // bufparams.user_defined_bullet(par.itemdepth).getText());
// for now, use a simple hardcoded label
string itemlabel;
- switch (pit->itemdepth) {
+ switch (par.itemdepth) {
case 0:
itemlabel = "*";
break;
break;
}
- pit->params().labelString(itemlabel);
+ par.params().labelString(itemlabel);
} else if (layout->labeltype == LABEL_ENUMERATE) {
// Maybe we have to reset the enumeration counter.
- resetEnumCounterIfNeeded(pit, first_pit, counters);
+ resetEnumCounterIfNeeded(pars_, pit, 0, counters);
// FIXME
// Yes I know this is a really, really! bad solution
// (Lgb)
string enumcounter = "enum";
- switch (pit->itemdepth) {
+ switch (par.itemdepth) {
case 2:
enumcounter += 'i';
case 1:
counters.step(enumcounter);
- pit->params().labelString(counters.enumLabel(enumcounter));
+ par.params().labelString(counters.enumLabel(enumcounter));
} else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
counters.step("bibitem");
int number = counters.value("bibitem");
- if (pit->bibitem()) {
- pit->bibitem()->setCounter(number);
- pit->params().labelString(layout->labelstring());
+ if (par.bibitem()) {
+ par.bibitem()->setCounter(number);
+ par.params().labelString(layout->labelstring());
}
// In biblio should't be following counters but...
} else {
// the caption hack:
if (layout->labeltype == LABEL_SENSITIVE) {
- ParagraphList::iterator end = paragraphs().end();
- ParagraphList::iterator tmppit = pit;
- InsetOld * in = 0;
+ par_type end = paragraphs().size();
+ par_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();
+ if (in->lyxCode() == InsetBase::FLOAT_CODE ||
+ in->lyxCode() == InsetBase::WRAP_CODE) {
isOK = true;
break;
- } else {
+ }
+#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 = first_pit;
+ tmppit = 0;
for ( ; tmppit != end; ++tmppit)
- if (&*tmppit == owner)
+ 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
BOOST_ASSERT(false);
s = _("Senseless: ");
}
}
- pit->params().labelString(s);
+ par.params().labelString(s);
}
}
bv()->buffer()->params().getLyXTextClass().counters().reset();
bool update_pos = false;
-
- ParagraphList::iterator beg = paragraphs().begin();
- ParagraphList::iterator end = paragraphs().end();
- for (ParagraphList::iterator pit = beg; pit != end; ++pit) {
- string const oldLabel = pit->params().labelString();
+
+ par_type end = paragraphs().size();
+ for (par_type pit = 0; pit != end; ++pit) {
+ string const oldLabel = pars_[pit].params().labelString();
size_t maxdepth = 0;
- if (pit != 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();
+ string const & newLabel = pars_[pit].params().labelString();
if (oldLabel != newLabel) {
+ //lyxerr[Debug::DEBUG] << "changing labels: old: " << oldLabel << " new: "
+ // << newLabel << endl;
redoParagraphInternal(pit);
update_pos = true;
}
-
}
if (update_pos)
updateParPositions();
}
-void LyXText::insertInset(InsetOld * inset)
-{
- if (!cursorPar()->insetAllowed(inset->lyxCode()))
- return;
-
- recUndo(cursor.par());
- freezeUndo();
- cursorPar()->insertInset(cursor.pos(), inset);
- // Just to rebreak and refresh correctly.
- // The character will not be inserted a second time
- insertChar(Paragraph::META_INSET);
- // If we enter a highly editable inset the cursor should be before
- // the inset. After an undo LyX tries to call inset->edit(...)
- // and fails if the cursor is behind the inset and getInset
- // does not return the inset!
- if (isHighlyEditableInset(inset))
- cursorLeft(true);
-
- unFreezeUndo();
-}
-
-
-void LyXText::cutSelection(bool doclear, bool realcut)
-{
- // 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 selStart()
- // and selEnd()
-
- // make sure that the depth behind the selection are restored, too
- ParagraphList::iterator begpit = getPar(selStart().par());
- ParagraphList::iterator endpit = getPar(selEnd().par());
- ParagraphList::iterator undopit = boost::next(endpit);
- ParagraphList::iterator pars_end = paragraphs().end();
-
- while (undopit != pars_end && undopit->getDepth())
- ++undopit;
- //because of parindents etc.
- if (undopit != pars_end)
- ++undopit;
- recUndo(selStart().par(), parOffset(undopit) - 1);
-
- int endpos = selEnd().pos();
-
- BufferParams const & bufparams = bv()->buffer()->params();
- boost::tie(endpit, endpos) = realcut ?
- CutAndPaste::cutSelection(bufparams,
- paragraphs(),
- begpit , endpit,
- selStart().pos(), endpos,
- bufparams.textclass,
- doclear)
- : CutAndPaste::eraseSelection(bufparams,
- paragraphs(),
- begpit, endpit,
- selStart().pos(), endpos,
- doclear);
- // sometimes necessary
- if (doclear)
- begpit->stripLeadingSpaces();
-
- redoParagraphs(begpit, undopit);
- // cutSelection can invalidate the cursor so we need to set
- // it anew. (Lgb)
- // we prefer the end for when tracking changes
- cursor.pos(endpos);
- cursor.par(parOffset(endpit));
-
- // need a valid cursor. (Lgb)
- clearSelection();
- redoCursor();
- 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 selStart()
- // and sel_end cursor
-
- // copy behind a space if there is one
- while (getPar(selStart())->size() > selStart().pos()
- && getPar(selStart())->isLineSeparator(selStart().pos())
- && (selStart().par() != selEnd().par()
- || selStart().pos() < selEnd().pos()))
- selStart().pos(selStart().pos() + 1);
-
- CutAndPaste::copySelection(getPar(selStart().par()),
- getPar(selEnd().par()),
- selStart().pos(),
- selEnd().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;
-
- recUndo(cursor.par());
-
- ParagraphList::iterator endpit;
- PitPosPair ppp;
-
- ErrorList el;
-
- boost::tie(ppp, endpit) =
- CutAndPaste::pasteSelection(*bv()->buffer(),
- paragraphs(),
- cursorPar(), cursor.pos(),
- bv()->buffer()->params().textclass,
- sel_index, el);
- bufferErrors(*bv()->buffer(), el);
- bv()->showErrorList(_("Paste"));
-
- redoParagraphs(cursorPar(), 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(true);
- setSelection();
-}
-
-
-// simple replacing. The font of the first selected character is used
-void LyXText::replaceSelectionWithString(string const & str)
+// this really should just insert the inset and not move the cursor.
+void LyXText::insertInset(LCursor & cur, InsetBase * inset)
{
- recUndo(cursor.par());
- freezeUndo();
-
- // Get font setting before we cut
- pos_type pos = selEnd().pos();
- LyXFont const font = getPar(selStart())
- ->getFontSettings(bv()->buffer()->params(),
- selStart().pos());
-
- // Insert the new string
- string::const_iterator cit = str.begin();
- string::const_iterator end = str.end();
- for (; cit != end; ++cit) {
- getPar(selEnd())->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);
+ redoParagraph(cur);
}
// needed to insert the selection
-void LyXText::insertStringAsLines(string const & str)
+void LyXText::insertStringAsLines(LCursor & cur, string const & str)
{
- ParagraphList::iterator pit = cursorPar();
- pos_type pos = cursor.pos();
- ParagraphList::iterator endpit = boost::next(cursorPar());
-
- recUndo(cursor.par());
+ par_type pit = cur.par();
+ par_type endpit = cur.par() + 1;
+ pos_type pos = cur.pos();
+ recordUndo(cur);
// only to be sure, should not be neccessary
- clearSelection();
-
- bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
+ cur.clearSelection();
+ cur.buffer().insertStringAsLines(pars_, pit, pos, current_font, str);
- redoParagraphs(cursorPar(), endpit);
- setCursor(cursorPar(), cursor.pos());
- selection.cursor = cursor;
- setCursor(pit, pos);
- setSelection();
+ redoParagraphs(cur.par(), endpit);
+ cur.resetAnchor();
+ setCursor(cur, cur.par(), pos);
+ cur.setSelection();
}
// turn double CR to single CR, others are converted into one
// blank. Then insertStringAsLines is called
-void LyXText::insertStringAsParagraphs(string const & str)
+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
newline_inserted = false;
}
}
- insertStringAsLines(linestr);
+ insertStringAsLines(cur, linestr);
}
-void LyXText::setCursor(ParagraphList::iterator pit, pos_type pos)
+bool LyXText::setCursor(LCursor & cur, par_type par, pos_type pos,
+ bool setfont, bool boundary)
{
- setCursor(parOffset(pit), pos);
+ LCursor old = cur;
+ setCursorIntern(cur, par, pos, setfont, boundary);
+ return deleteEmptyParagraphMechanism(cur, old);
}
-bool LyXText::setCursor(paroffset_type par, pos_type pos, bool setfont,
- bool boundary)
-{
- LyXCursor old_cursor = cursor;
- setCursorIntern(par, pos, setfont, boundary);
- return deleteEmptyParagraphMechanism(old_cursor);
-}
-
-
-void LyXText::redoCursor()
-{
- setCursor(cursor, cursor.par(), cursor.pos(), cursor.boundary());
-
- if (!selection.set())
- return;
-
- LyXCursor tmpcursor = cursor;
- setCursor(selection.cursor.par(), selection.cursor.pos());
- selection.cursor = cursor;
- setCursor(tmpcursor.par(), tmpcursor.pos());
- setSelection();
-}
-
-
-void LyXText::setCursor(LyXCursor & cur, paroffset_type par,
+void LyXText::setCursor(CursorSlice & cur, par_type par,
pos_type pos, bool boundary)
{
BOOST_ASSERT(par != int(paragraphs().size()));
- cur.par(par);
- cur.pos(pos);
- cur.boundary(boundary);
+ cur.par() = par;
+ cur.pos() = pos;
+ cur.boundary() = boundary;
// no rows, no fun...
if (paragraphs().begin()->rows.empty())
return;
- // get the cursor y position in text
-
- ParagraphList::iterator pit = getPar(par);
- Row const & row = *pit->getRow(pos);
+ // now some strict checking
+ Paragraph & para = getPar(par);
+ Row const & row = *para.getRow(pos);
pos_type const end = row.endpos();
// None of these should happen, but we're scaredy-cats
if (pos < 0) {
lyxerr << "dont like -1" << endl;
- pos = 0;
- cur.pos(0);
BOOST_ASSERT(false);
- } else if (pos > pit->size()) {
+ }
+
+ if (pos > para.size()) {
lyxerr << "dont like 1, pos: " << pos
- << " size: " << pit->size()
+ << " size: " << para.size()
<< " row.pos():" << row.pos()
- << " paroffset: " << par << endl;
- pos = 0;
- cur.pos(0);
+ << " par: " << par << endl;
BOOST_ASSERT(false);
- } else if (pos > end) {
- lyxerr << "dont like 2 please report" << endl;
+ }
+
+ if (pos > end) {
+ lyxerr << "dont like 2, pos: " << pos
+ << " size: " << para.size()
+ << " row.pos():" << row.pos()
+ << " par: " << par << endl;
// This shouldn't happen.
- pos = end;
- cur.pos(pos);
BOOST_ASSERT(false);
- } else if (pos < row.pos()) {
+ }
+
+ if (pos < row.pos()) {
lyxerr << "dont like 3 please report pos:" << pos
- << " size: " << pit->size()
+ << " size: " << para.size()
<< " row.pos():" << row.pos()
- << " paroffset: " << par << endl;
- pos = row.pos();
- cur.pos(pos);
+ << " par: " << par << endl;
BOOST_ASSERT(false);
}
}
-void LyXText::setCursorIntern(paroffset_type par,
- pos_type pos, bool setfont, bool boundary)
+void LyXText::setCursorIntern(LCursor & cur,
+ par_type par, pos_type pos, bool setfont, bool boundary)
{
- setCursor(cursor, par, pos, boundary);
- bv()->x_target(cursorX() + xo_);
+ setCursor(cur.top(), par, pos, boundary);
+ cur.x_target() = cursorX(cur.top());
if (setfont)
- setCurrentFont();
+ setCurrentFont(cur);
}
-void LyXText::setCurrentFont()
+void LyXText::setCurrentFont(LCursor & cur)
{
- pos_type pos = cursor.pos();
- ParagraphList::iterator pit = cursorPar();
+ 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 > pit->getRow(pos)->pos() &&
+ 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;
}
}
- BufferParams const & bufparams = bv()->buffer()->params();
- current_font = pit->getFontSettings(bufparams, pos);
- real_current_font = getFont(pit, pos);
-
- if (cursor.pos() == pit->size() &&
- bidi.isBoundary(*bv()->buffer(), *pit, cursor.pos()) &&
- !cursor.boundary()) {
- Language const * lang =
- pit->getParLanguage(bufparams);
+ BufferParams const & bufparams = cur.buffer().params();
+ current_font = par.getFontSettings(bufparams, pos);
+ real_current_font = getFont(par, pos);
+
+ 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(ParagraphList::iterator pit,
+pos_type LyXText::getColumnNearX(par_type const pit,
Row const & row, int & x, bool & boundary) const
{
- double tmpx = row.x();
- double fill_separator = row.fill_separator();
- double fill_hfill = row.fill_hfill();
- double fill_label_hfill = row.fill_label_hfill();
+ x -= xo_;
+ RowMetrics const r = computeRowMetrics(pit, row);
+ Paragraph const & par = pars_[pit];
pos_type vc = row.pos();
pos_type end = row.endpos();
pos_type c = 0;
- LyXLayout_ptr const & layout = pit->layout();
+ LyXLayout_ptr const & layout = par.layout();
bool left_side = false;
- pos_type body_pos = pit->beginOfBody();
+ pos_type body_pos = par.beginOfBody();
+
+ double tmpx = r.x;
double last_tmpx = tmpx;
if (body_pos > 0 &&
- (body_pos > end || !pit->isLineSeparator(body_pos - 1)))
+ (body_pos > end || !par.isLineSeparator(body_pos - 1)))
body_pos = 0;
// check for empty row
if (vc == end) {
- x = int(tmpx);
+ x = int(tmpx) + xo_;
return 0;
}
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(pit));
- if (pit->isLineSeparator(body_pos - 1))
- tmpx -= singleWidth(pit, 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(*pit, row, c)) {
- tmpx += singleWidth(pit, 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 (pit->isSeparator(c)) {
- tmpx += singleWidth(pit, 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(pit, c);
+ tmpx += singleWidth(par, c);
}
++vc;
}
boundary = false;
// This (rtl_support test) is not needed, but gives
// some speedup if rtl_support == false
- bool const lastrow = lyxrc.rtl_support && row.endpos() == pit->size();
+ bool const lastrow = lyxrc.rtl_support && row.endpos() == par.size();
// If lastrow is false, we don't need to compute
// the value of rtl.
- bool const rtl = (lastrow)
- ? pit->isRightToLeftPar(bv()->buffer()->params())
- : false;
+ bool const rtl = lastrow ? isRTL(par) : false;
if (lastrow &&
((rtl && left_side && vc == row.pos() && x < tmpx - 5) ||
(!rtl && !left_side && vc == end && x > tmpx + 5)))
bool const rtl = (bidi.level(c) % 2 == 1);
if (left_side == rtl) {
++c;
- boundary = bidi.isBoundary(*bv()->buffer(), *pit, c);
+ boundary = bidi.isBoundary(*bv()->buffer(), par, c);
}
}
- if (row.pos() < end && c >= end && pit->isNewline(end - 1)) {
+ if (row.pos() < end && c >= end && par.isNewline(end - 1)) {
if (bidi.level(end -1) % 2 == 0)
- tmpx -= singleWidth(pit, end - 1);
+ tmpx -= singleWidth(par, end - 1);
else
- tmpx += singleWidth(pit, end - 1);
+ tmpx += singleWidth(par, end - 1);
c = end - 1;
}
- c -= row.pos();
- x = int(tmpx);
- return c;
-}
-
-
-void LyXText::setCursorFromCoordinates(int x, int y)
-{
- LyXCursor old_cursor = cursor;
- setCursorFromCoordinates(cursor, x, y);
- setCurrentFont();
- deleteEmptyParagraphMechanism(old_cursor);
+ x = int(tmpx) + xo_;
+ return c - row.pos();
}
-// x,y are coordinates relative to this LyXText
-void LyXText::setCursorFromCoordinates(LyXCursor & cur, int x, int y)
+// y is relative to this LyXText's top
+// this is only used in the two functions below
+Row const & LyXText::getRowNearY(int y, par_type & pit) const
{
- ParagraphList::iterator pit;
- Row const & row = *getRowNearY(y, pit);
- bool bound = false;
- pos_type const column = getColumnNearX(pit, row, x, bound);
- cur.par(parOffset(pit));
- cur.pos(row.pos() + column);
- cur.boundary(bound);
-}
+ BOOST_ASSERT(!paragraphs().empty());
+ BOOST_ASSERT(!paragraphs().begin()->rows.empty());
+ par_type const pend = paragraphs().size() - 1;
+ pit = 0;
+ while (int(pars_[pit].y + pars_[pit].height) < y && pit != pend)
+ ++pit;
+ RowList::iterator rit = pars_[pit].rows.end();
+ RowList::iterator const rbegin = pars_[pit].rows.begin();
+ do {
+ --rit;
+ } while (rit != rbegin && int(pars_[pit].y + rit->y_offset()) > y);
-bool LyXText::checkAndActivateInset(bool front)
-{
- if (cursor.pos() == cursorPar()->size())
- return false;
- InsetOld * inset = cursorPar()->getInset(cursor.pos());
- if (!isHighlyEditableInset(inset))
- return false;
- inset->edit(bv(), front);
- return true;
-}
-
-
-DispatchResult LyXText::moveRight()
-{
- if (cursorPar()->isRightToLeftPar(bv()->buffer()->params()))
- return moveLeftIntern(false, true, false);
- else
- return moveRightIntern(true, true, false);
+ return *rit;
}
-DispatchResult LyXText::moveLeft()
+// x,y are absolute coordinates
+// sets cursor only within this LyXText
+void LyXText::setCursorFromCoordinates(LCursor & cur, int x, int y)
{
- if (cursorPar()->isRightToLeftPar(bv()->buffer()->params()))
- return moveRightIntern(true, true, false);
- else
- return moveLeftIntern(false, true, false);
+ x -= xo_;
+ y -= yo_;
+ par_type pit;
+ Row const & row = getRowNearY(y, pit);
+ lyxerr[Debug::DEBUG] << "setCursorFromCoordinates:: hit row at: "
+ << row.pos() << endl;
+ bool bound = false;
+ int xx = x + xo_; // getRowNearX get absolute x coords
+ pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound);
+ setCursor(cur, pit, pos, true, bound);
}
-DispatchResult LyXText::moveRightIntern(bool front, bool activate_inset, bool selecting)
+// x,y are absolute screen coordinates
+// sets cursor recursively descending into nested editable insets
+InsetBase * LyXText::editXY(LCursor & cur, int x, int y) const
{
- ParagraphList::iterator c_par = cursorPar();
- if (boost::next(c_par) == paragraphs().end()
- && cursor.pos() >= c_par->size())
- return DispatchResult(false, FINISHED_RIGHT);
- if (activate_inset && checkAndActivateInset(front))
- return DispatchResult(true, true);
- cursorRight(true);
- if (!selecting)
- clearSelection();
- return DispatchResult(true);
-}
-
+ par_type pit;
+ Row const & row = getRowNearY(y - yo_, pit);
+ bool bound = false;
-DispatchResult LyXText::moveLeftIntern(bool front,
- bool activate_inset, bool selecting)
-{
- if (cursor.par() == 0 && cursor.pos() <= 0)
- return DispatchResult(false, FINISHED);
- cursorLeft(true);
- if (!selecting)
- clearSelection();
- if (activate_inset && checkAndActivateInset(front))
- return DispatchResult(true, true);
- return DispatchResult(true);
-}
+ int xx = x; // is modified by getColumnNearX
+ pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound);
+ cur.par() = pit;
+ cur.pos() = pos;
+ cur.boundary() = bound;
+ // try to descend into nested insets
+ InsetBase * inset = checkInsetHit(x, y);
+ lyxerr << "inset " << inset << " hit at x: " << x << " y: " << y << endl;
+ if (!inset)
+ return 0;
-DispatchResult LyXText::moveUp()
-{
- if (cursorPar() == firstPar() && cursorRow() == firstRow())
- return DispatchResult(false, FINISHED_UP);
- cursorUp(false);
- clearSelection();
- return DispatchResult(true);
+ // 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();
+ return inset->editXY(cur, x, y);
}
-DispatchResult LyXText::moveDown()
+bool LyXText::checkAndActivateInset(LCursor & cur, bool front)
{
- if (cursorPar() == lastPar() && cursorRow() == lastRow())
- return DispatchResult(false, FINISHED_DOWN);
- cursorDown(false);
- clearSelection();
- return DispatchResult(true);
+ 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;
}
-bool LyXText::cursorLeft(bool internal)
+void LyXText::cursorLeft(LCursor & cur)
{
- if (cursor.pos() > 0) {
- bool boundary = cursor.boundary();
- setCursor(cursor.par(), cursor.pos() - 1, true, false);
- if (!internal && !boundary &&
- bidi.isBoundary(*bv()->buffer(), *cursorPar(), cursor.pos() + 1))
- setCursor(cursor.par(), cursor.pos() + 1, true, true);
- return true;
+ if (cur.pos() != 0) {
+ bool boundary = cur.boundary();
+ setCursor(cur, cur.par(), cur.pos() - 1, true, false);
+ if (!checkAndActivateInset(cur, false)) {
+ if (false && !boundary &&
+ bidi.isBoundary(cur.buffer(), cur.paragraph(), cur.pos() + 1))
+ setCursor(cur, cur.par(), cur.pos() + 1, true, true);
+ }
+ return;
}
- if (cursor.par() != 0) {
+ if (cur.par() != 0) {
// steps into the paragraph above
- setCursor(cursor.par() - 1, boost::prior(cursorPar())->size());
- return true;
+ setCursor(cur, cur.par() - 1, getPar(cur.par() - 1).size());
}
-
- return false;
}
-bool LyXText::cursorRight(bool internal)
+void LyXText::cursorRight(LCursor & cur)
{
- if (!internal && cursor.boundary()) {
- setCursor(cursor.par(), cursor.pos(), true, false);
- return true;
- }
-
- if (cursor.pos() != cursorPar()->size()) {
- setCursor(cursor.par(), cursor.pos() + 1, true, false);
- if (!internal && bidi.isBoundary(*bv()->buffer(), *cursorPar(),
- cursor.pos()))
- setCursor(cursor.par(), cursor.pos(), true, true);
- return true;
+ if (false && cur.boundary()) {
+ setCursor(cur, cur.par(), cur.pos(), true, false);
+ return;
}
- if (cursor.par() + 1 != int(paragraphs().size())) {
- setCursor(cursor.par() + 1, 0);
- return true;
+ if (cur.pos() != cur.lastpos()) {
+ if (!checkAndActivateInset(cur, true)) {
+ setCursor(cur, cur.par(), cur.pos() + 1, true, false);
+ if (false && bidi.isBoundary(cur.buffer(), cur.paragraph(),
+ cur.pos()))
+ setCursor(cur, cur.par(), cur.pos(), true, true);
+ }
+ return;
}
- return false;
+ if (cur.par() != cur.lastpar())
+ setCursor(cur, cur.par() + 1, 0);
}
-void LyXText::cursorUp(bool selecting)
+void LyXText::cursorUp(LCursor & cur)
{
- Row const & row = *cursorRow();
- int x = bv()->x_target() - xo_;
- int y = cursorY() - row.baseline() - 1;
- setCursorFromCoordinates(x, y);
-
- if (!selecting) {
- int y_abs = y + yo_ - bv()->top_y();
- InsetOld * inset_hit = checkInsetHit(bv()->x_target(), y_abs);
+ Row const & row = cur.textRow();
+ int x = cur.x_target();
+ int y = cursorY(cur.top()) - row.baseline() - 1;
+ setCursorFromCoordinates(cur, x, y);
+
+ if (!cur.selection()) {
+ InsetBase * inset_hit = checkInsetHit(cur.x_target(), y);
if (inset_hit && isHighlyEditableInset(inset_hit))
- inset_hit->edit(bv(), bv()->x_target(), y_abs);
+ inset_hit->editXY(cur, cur.x_target(), y);
}
}
-void LyXText::cursorDown(bool selecting)
+void LyXText::cursorDown(LCursor & cur)
{
- Row const & row = *cursorRow();
- int x = bv()->x_target() - xo_;
- int y = cursorY() - row.baseline() + row.height() + 1;
- setCursorFromCoordinates(x, y);
-
- if (!selecting) {
- int y_abs = y + yo_ - bv()->top_y();
- InsetOld * inset_hit = checkInsetHit(bv()->x_target(), y_abs);
+ Row const & row = cur.textRow();
+ int x = cur.x_target();
+ int y = cursorY(cur.top()) - row.baseline() + row.height() + 1;
+ setCursorFromCoordinates(cur, x, y);
+
+ if (!cur.selection()) {
+ InsetBase * inset_hit = checkInsetHit(cur.x_target(), y);
if (inset_hit && isHighlyEditableInset(inset_hit))
- inset_hit->edit(bv(), bv()->x_target(), y_abs);
+ inset_hit->editXY(cur, cur.x_target(), y);
}
}
-void LyXText::cursorUpParagraph()
+void LyXText::cursorUpParagraph(LCursor & cur)
{
- ParagraphList::iterator cpit = cursorPar();
- if (cursor.pos() > 0)
- setCursor(cpit, 0);
- else if (cpit != paragraphs().begin())
- setCursor(boost::prior(cpit), 0);
+ if (cur.pos() > 0)
+ setCursor(cur, cur.par(), 0);
+ else if (cur.par() != 0)
+ setCursor(cur, cur.par() - 1, 0);
}
-void LyXText::cursorDownParagraph()
+void LyXText::cursorDownParagraph(LCursor & cur)
{
- ParagraphList::iterator pit = cursorPar();
- ParagraphList::iterator next_pit = boost::next(pit);
-
- if (next_pit != paragraphs().end())
- setCursor(next_pit, 0);
+ if (cur.par() != cur.lastpar())
+ setCursor(cur, cur.par() + 1, 0);
else
- setCursor(pit, pit->size());
+ setCursor(cur, cur.par(), cur.lastpos());
}
// 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
+ // do notheing if cursor is not in the paragraph where the
+ // deletion occured,
if (cur.par() != where.par())
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
// pagragraph because we erased the last character.
- if (cur.pos() > getPar(cur)->size())
- cur.pos(getPar(cur)->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)
{
+ BOOST_ASSERT(cur.size() == old.size());
// Would be wrong to delete anything if we have a selection.
- if (selection.set())
+ if (cur.selection())
return false;
- // Don't do anything if the cursor is invalid
- if (old_cursor.par() == -1)
- return false;
+ //lyxerr[Debug::DEBUG] << "DEPM: cur:\n" << cur << "old:\n" << old << endl;
+ Paragraph const & oldpar = pars_[old.par()];
// We allow all kinds of "mumbo-jumbo" when freespacing.
- ParagraphList::iterator const old_pit = getPar(old_cursor);
- if (old_pit->isFreeSpacing())
+ if (oldpar.isFreeSpacing())
return false;
/* Ok I'll put some comments here about what is missing.
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()) {
+ // If the chars around the old cursor were spaces, delete one of them.
+ if (old.par() != cur.par() || old.pos() != cur.pos()) {
- // Only if the cursor has really moved
- if (old_cursor.pos() > 0
- && old_cursor.pos() < old_pit->size()
- && old_pit->isLineSeparator(old_cursor.pos())
- && old_pit->isLineSeparator(old_cursor.pos() - 1)) {
- bool erased = old_pit->erase(old_cursor.pos() - 1);
- redoParagraph(old_pit);
-
- if (!erased)
- return false;
+ // Only if the cursor has really moved.
+ if (old.pos() > 0
+ && old.pos() < oldpar.size()
+ && oldpar.isLineSeparator(old.pos())
+ && oldpar.isLineSeparator(old.pos() - 1)) {
+ pars_[old.par()].erase(old.pos() - 1);
#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(cur.anchor(), old.top());
return false;
}
}
- // don't delete anything if this is the ONLY paragraph!
- if (paragraphs().size() == 1)
+ // only do our magic if we changed paragraph
+ if (old.par() == cur.par())
return false;
- // Do not delete empty paragraphs with keepempty set.
- if (old_pit->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_pit->empty()
- || (old_pit->size() == 1 && old_pit->isLineSeparator(0))) {
+ if (oldpar.empty() || (oldpar.size() == 1 && oldpar.isLineSeparator(0))) {
// ok, we will delete something
- LyXCursor tmpcursor;
+ CursorSlice tmpcursor;
deleted = true;
bool selection_position_was_oldcursor_position =
- selection.cursor.par() == old_cursor.par()
- && selection.cursor.pos() == old_cursor.pos();
-
- tmpcursor = cursor;
- cursor = old_cursor; // that undo can restore the right cursor position
+ cur.anchor().par() == old.par() && cur.anchor().pos() == old.pos();
- ParagraphList::iterator endpit = boost::next(old_pit);
- while (endpit != paragraphs().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.par(), cur.par());
- recUndo(parOffset(old_pit), parOffset(endpit) - 1);
- cursor = tmpcursor;
+ // Delete old par.
+ pars_.erase(pars_.begin() + old.par());
- // cache cursor pit
- ParagraphList::iterator tmppit = cursorPar();
- // delete old par
- paragraphs().erase(old_pit);
- // update cursor par offset
- cursor.par(parOffset(tmppit));
- redoParagraph();
-
- // 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.par() > old.par())
+ --cur.par();
+#ifdef WITH_WARNINGS
+#warning DEPM, look here
+#endif
+// if (cur.anchor().par() > old.par())
+// --cur.anchor().par();
if (selection_position_was_oldcursor_position) {
// correct selection
- selection.cursor = cursor;
+ cur.resetAnchor();
}
}
if (deleted)
return true;
- if (old_pit->stripLeadingSpaces()) {
- redoParagraph(old_pit);
- // correct cursor y
- setCursorIntern(cursor.par(), cursor.pos());
- selection.cursor = cursor;
- }
+ if (pars_[old.par()].stripLeadingSpaces())
+ cur.resetAnchor();
+
return false;
}
ParagraphList & LyXText::paragraphs() const
{
- return const_cast<ParagraphList &>(paragraphs_);
-}
-
-
-void LyXText::recUndo(paroffset_type first, paroffset_type last) const
-{
- recordUndo(Undo::ATOMIC, this, first, last);
+ return const_cast<ParagraphList &>(pars_);
}
-void LyXText::recUndo(lyx::paroffset_type par) const
+void LyXText::recUndo(par_type first, par_type last) const
{
- recordUndo(Undo::ATOMIC, this, par, par);
+ recordUndo(bv()->cursor(), Undo::ATOMIC, first, last);
}
-bool LyXText::isInInset() const
+void LyXText::recUndo(par_type par) const
{
- return in_inset_;
+ recordUndo(bv()->cursor(), Undo::ATOMIC, par, par);
}