#include "mathed/math_data.h"
#include "mathed/math_support.h"
#include "mathed/math_inset.h"
+#include "mathed/math_braceinset.h"
+#include "mathed/math_macrotable.h"
#include "support/limited_stack.h"
#include "support/std_sstream.h"
LCursor::LCursor(BufferView & bv)
- : DocIterator(), bv_(&bv),
- anchor_(), cached_y_(0), x_target_(-1),
+ : DocIterator(), bv_(&bv), anchor_(), x_target_(-1),
selection_(false), mark_(false)
{}
clear();
push_back(CursorSlice(inset));
anchor_ = DocIterator(inset);
- cached_y_ = 0;
clearTargetX();
selection_ = false;
mark_ = false;
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_;
}
BufferView & LCursor::bv() const
{
+ BOOST_ASSERT(bv_);
return *bv_;
}
+Buffer & LCursor::buffer() const
+{
+ BOOST_ASSERT(bv_);
+ BOOST_ASSERT(bv_->buffer());
+ return *bv_->buffer();
+}
+
+
void LCursor::pop()
{
BOOST_ASSERT(size() >= 1);
{
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()) {
x = 0;
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.
+ inset().getCursorPos(*this, x, y);
}
}
-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();
{
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(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()) {
+#warning Alfredo: This is too strong (Andre)
+ //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"
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 {
if (macro && macro->getInsetName() == name)
lyxerr << "can't enter recursive macro" << endl;
- niceInsert(createMathInset(name));
+ niceInsert(createMathInset(name));
}
}
-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
DocIterator::const_iterator it = begin();
DocIterator::const_iterator et = end();
}
-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);
// avoid invalid nesting when selecting
if (!selection() || positionable(it, anchor_)) {
int xo = 0, yo = 0;
- CursorSlice & cur = it.back();
+ LCursor cur = *this;
+ cur.setCursor(it, false);
cur.inset().getCursorPos(cur, xo, yo);
if (xlow <= xo && xo <= xhigh && ylow <= yo && yo <= yhigh) {
double d = (x - xo) * (x - xo) + (y - yo) * (y - yo);
et.back().pos() = et.back().asMathInset()->cell(et.back().idx()).size();
for (int i = 0; ; ++i) {
int xo, yo;
- CursorSlice & cur = it.back();
+ LCursor cur = *this;
+ cur.setCursor(it, false);
cur.inset().getCursorPos(cur, xo, yo);
double d = (x - xo) * (x - xo) + (y - yo) * (y - yo);
// '<=' in order to take the last possible position
}
-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();
}
projects / lyx.git / blobdiff