#include "dispatchresult.h"
#include "encoding.h"
#include "funcrequest.h"
-#include "iterators.h"
#include "language.h"
#include "lfuns.h"
#include "lyxfont.h"
#include "lyxtext.h"
#include "paragraph.h"
#include "paragraph_funcs.h"
+#include "pariterator.h"
#include "insets/updatableinset.h"
#include "insets/insettabular.h"
LCursor::LCursor(BufferView & bv)
- : DocumentIterator(), bv_(&bv), anchor_(),
- cached_y_(0), x_target_(-1), selection_(false), mark_(false)
+ : DocIterator(), bv_(&bv), anchor_(), x_target_(-1),
+ selection_(false), mark_(false)
{}
{
clear();
push_back(CursorSlice(inset));
- anchor_.clear();
- cached_y_ = 0;
+ anchor_ = DocIterator(inset);
clearTargetX();
selection_ = false;
mark_ = false;
}
-void LCursor::setCursor(DocumentIterator const & cur, bool sel)
+void LCursor::setCursor(DocIterator const & cur, bool sel)
{
// this (intentionally) does not touch the anchor
- DocumentIterator::operator=(cur);
+ DocIterator::operator=(cur);
selection() = sel;
}
BOOST_ASSERT(idx() <= lastidx());
BOOST_ASSERT(par() <= lastpar());
- // The common case is 'LFUN handled, need update', so make the
+ // The common case is 'LFUN handled, need update', so make the
// LFUN handler's life easier by assuming this as default value.
// The handler can reset the update and val flags if necessary.
disp_.update(true);
if (!disp_.dispatched()) {
lyxerr << "RESTORING OLD CURSOR!" << endl;
operator=(safe);
+ disp_.dispatched(false);
}
return disp_;
}
{
BOOST_ASSERT(!empty());
//lyxerr << "Leaving inset to the left" << endl;
- inset().notifyCursorLeaves(idx());
+ inset().notifyCursorLeaves(*this);
if (depth() == 1)
return false;
pop();
{
BOOST_ASSERT(!empty());
//lyxerr << "Leaving inset to the right" << endl;
- inset().notifyCursorLeaves(idx());
+ inset().notifyCursorLeaves(*this);
if (depth() == 1)
return false;
pop();
}
-void LCursor::updatePos()
-{
- BOOST_ASSERT(!empty());
- if (size() > 1)
- cached_y_ = bv().top_y() + back().inset().yo();
- //cached_y_ = back().inset().yo();
-}
-
-
void LCursor::getDim(int & asc, int & des) const
{
if (inMathed()) {
y = 0;
if (!empty())
inset().getCursorPos(back(), x, y);
- // getCursorPos gives _screen_ coordinates. We need to add
- // top_y to get document coordinates. This is hidden in cached_y_.
- //y += cached_y_ - inset().yo();
- // The rest is non-obvious. The reason we have to have these
- // extra computation is that the getCursorPos() calls rely
- // on the inset's own knowledge of its screen position.
- // If we scroll up or down in a big enough increment,
- // inset->draw() is not called: this doesn't update
- // inset.yo_, so getCursor() returns an old value.
- // Ugly as you like.
}
}
-CursorSlice & LCursor::anchor()
-{
- BOOST_ASSERT(!anchor_.empty());
- return anchor_.back();
-}
-
-
-CursorSlice const & LCursor::anchor() const
+CursorSlice LCursor::anchor() const
{
- BOOST_ASSERT(!anchor_.empty());
- return anchor_.back();
+ BOOST_ASSERT(anchor_.size() >= size());
+ CursorSlice normal = anchor_[size() - 1];
+ if (size() < anchor_.size() && back() <= normal) {
+ // anchor is behind cursor -> move anchor behind the inset
+ ++normal.pos();
+ }
+ return normal;
}
-CursorSlice const & LCursor::selBegin() const
+CursorSlice LCursor::selBegin() const
{
if (!selection())
return back();
}
-CursorSlice const & LCursor::selEnd() const
+CursorSlice LCursor::selEnd() const
{
if (!selection())
return back();
}
-DocumentIterator LCursor::selectionBegin() const
+DocIterator LCursor::selectionBegin() const
{
if (!selection())
return *this;
}
-DocumentIterator LCursor::selectionEnd() const
+DocIterator LCursor::selectionEnd() const
{
if (!selection())
return *this;
{
selection() = true;
// a selection with no contents is not a selection
+#warning doesnt look ok
if (par() == anchor().par() && pos() == anchor().pos())
selection() = false;
}
-void LCursor::setSelection(DocumentIterator const & where, size_t n)
+void LCursor::setSelection(DocIterator const & where, size_t n)
{
- selection() = true;
- setCursor(where, false);
+ setCursor(where, true);
anchor_ = where;
pos() += n;
}
//lyxerr << "LCursor::eraseSelection" << endl;
CursorSlice const & i1 = selBegin();
CursorSlice const & i2 = selEnd();
+#ifdef WITH_WARNINGS
#warning FIXME
+#endif
if (i1.inset().asMathInset()) {
if (i1.idx() == i2.idx()) {
i1.cell().erase(i1.pos(), i2.pos());
}
-void LCursor::selClear()
-{
- resetAnchor();
- clearSelection();
-}
-
-
void LCursor::selCopy()
{
if (selection()) {
void LCursor::selHandle(bool sel)
{
//lyxerr << "LCursor::selHandle" << endl;
- if (sel == selection())
+ if (sel == selection()) {
+ if (!sel)
+ noUpdate();
return;
+ }
+
resetAnchor();
selection() = sel;
}
#include "mathed/math_factory.h"
#include "mathed/math_gridinset.h"
#include "mathed/math_macroarg.h"
-#include "mathed/math_macrotemplate.h"
#include "mathed/math_mathmlstream.h"
#include "mathed/math_scriptinset.h"
#include "mathed/math_support.h"
}
-bool positionable(DocumentIterator const & cursor,
- DocumentIterator const & anchor)
+bool positionable(DocIterator const & cursor,
+ DocIterator const & anchor)
{
// avoid deeper nested insets when selecting
if (cursor.size() > anchor.size())
void LCursor::markInsert()
{
- cell().insert(pos(), MathAtom(new MathCharInset(0)));
+ insert(char(0));
}
void LCursor::insert(string const & str)
{
- lyxerr << "LCursor::insert str '" << str << "'" << endl;
+ //lyxerr << "LCursor::insert str '" << str << "'" << endl;
for (string::const_iterator it = str.begin(); it != str.end(); ++it)
insert(*it);
}
BOOST_ASSERT(!empty());
if (inMathed()) {
selClearOrDel();
- plainInsert(MathAtom(new MathCharInset(c)));
+ insert(new MathCharInset(c));
} else {
text()->insertChar(*this, c);
}
macroModeClose();
selClearOrDel();
plainInsert(t);
+ lyxerr << "LCursor::insert MathAtom: cur:\n" << *this << endl;
}
if (pos() != 0 && prevAtom()->nargs() > 0) {
// let's require two backspaces for 'big stuff' and
// highlight on the first
+ resetAnchor();
selection() = true;
--pos();
} else {
return true;
}
+ // 'clever' UI hack: only erase large items if previously slected
if (pos() != lastpos() && inset().nargs() > 0) {
+ resetAnchor();
selection() = true;
++pos();
} else {
bool LCursor::up()
{
macroModeClose();
- DocumentIterator save = *this;
+ DocIterator save = *this;
if (goUpDown(true))
return true;
setCursor(save, false);
bool LCursor::down()
{
macroModeClose();
- DocumentIterator save = *this;
+ DocIterator save = *this;
if (goUpDown(false))
return true;
setCursor(save, false);
}
-void LCursor::adjust(pos_type from, int diff)
-{
- if (pos() > from)
- pos() += diff;
- if (anchor().pos() > from)
- anchor().pos() += diff;
- // just to be on the safe side
- // theoretically unecessary
- normalize();
-}
-
-
bool LCursor::inMacroMode() const
{
if (!pos() != 0)
}
-bool LCursor::inMacroArgMode() const
-{
- return pos() > 0 && prevAtom()->getChar() == '#';
-}
-
-
-MathGridInset * LCursor::enclosingGrid(idx_type & idx) const
-{
- for (MathInset::difference_type i = depth() - 1; i >= 0; --i) {
- MathInset * m = operator[](i).inset().asMathInset();
- if (!m)
- return 0;
- MathGridInset * p = m->asGridInset();
- if (p) {
- idx = operator[](i).idx();
- return p;
- }
- }
- return 0;
-}
-
-
void LCursor::pullArg()
{
+#ifdef WITH_WARNINGS
#warning Look here
+#endif
MathArray ar = cell();
if (popLeft() && inMathed()) {
plainErase();
void LCursor::touch()
{
+#ifdef WITH_WARNINGS
#warning look here
+#endif
#if 0
- DocumentIterator::const_iterator it = begin();
- DocumentIterator::const_iterator et = end();
+ DocIterator::const_iterator it = begin();
+ DocIterator::const_iterator et = end();
for ( ; it != et; ++it)
it->cell().touch();
#endif
}
-char LCursor::valign()
-{
- idx_type idx;
- MathGridInset * p = enclosingGrid(idx);
- return p ? p->valign() : '\0';
-}
-
-
-char LCursor::halign()
-{
- idx_type idx;
- MathGridInset * p = enclosingGrid(idx);
- return p ? p->halign(idx % p->ncols()) : '\0';
-}
-
-
bool LCursor::goUpDown(bool up)
{
// Be warned: The 'logic' implemented in this function is highly
{
BOOST_ASSERT(!empty());
par_type beg, end;
- CursorSlice bottom = operator[](0);
+ CursorSlice bottom = operator[](0);
LyXText * text = bottom.text();
BOOST_ASSERT(text);
getParsInRange(text->paragraphs(), ylow, yhigh, beg, end);
- DocumentIterator it(bv().buffer()->inset());
- DocumentIterator et;
+ DocIterator it = doc_iterator_begin(bv().buffer()->inset());
+ DocIterator et = doc_iterator_end(bv().buffer()->inset());
//lyxerr << "x: " << x << " y: " << y << endl;
//lyxerr << "xlow: " << xlow << " ylow: " << ylow << endl;
//lyxerr << "xhigh: " << xhigh << " yhigh: " << yhigh << endl;
//et.par() = text->parOffset(end);
double best_dist = 10e10;
- DocumentIterator best_cursor = it;
+ DocIterator best_cursor = it;
for ( ; it != et; it.forwardPos()) {
// avoid invalid nesting when selecting
{
double best_dist = 1e10;
- DocumentIterator it = *this;
+ DocIterator it = *this;
it.back().pos() = 0;
- DocumentIterator et = *this;
+ DocIterator et = *this;
et.back().pos() = et.back().asMathInset()->cell(et.back().idx()).size();
for (int i = 0; ; ++i) {
int xo, yo;
}
-CursorSlice LCursor::normalAnchor()
-{
- if (anchor_.size() < depth()) {
- resetAnchor();
- lyxerr << "unusual Anchor size" << endl;
- }
- //lyx::BOOST_ASSERT(Anchor_.size() >= cursor.depth());
- // use Anchor on the same level as Cursor
- CursorSlice normal = anchor_[size() - 1];
-#if 0
- if (depth() < anchor_.size() && !(normal < xx())) {
- // anchor is behind cursor -> move anchor behind the inset
- ++normal.pos_;
- }
-#endif
- return normal;
-}
-
-
void LCursor::handleFont(string const & font)
{
lyxerr << "LCursor::handleFont: " << font << endl;
return result;
}
+#ifdef WITH_WARNINGS
#warning and mathed?
+#endif
return string();
}
CursorSlice const & sl = operator[](s);
LyXText & text = *sl.text();
LyXFont font = text.getPar(sl.par()).getFont(
- bv().buffer()->params(), sl.pos(), outerFont(sl.par(), text.paragraphs()));
+ bv().buffer()->params(), sl.pos(), outerFont(sl.par(), text.paragraphs()));
return font.language()->encoding();
}
}
+void LCursor::dispatched()
+{
+ disp_.dispatched(true);
+}
+
+
void LCursor::noUpdate()
{
disp_.update(false);