#include "DispatchResult.h"
#include "Encoding.h"
#include "Font.h"
+#include "FuncCode.h"
#include "FuncRequest.h"
#include "Language.h"
-#include "lfuns.h"
#include "LyXFunc.h" // only for setMessage()
#include "LyXRC.h"
#include "paragraph_funcs.h"
#include "TextMetrics.h"
#include "TocBackend.h"
+#include "support/lassert.h"
#include "support/debug.h"
#include "support/docstream.h"
#include "mathed/MathData.h"
#include "mathed/MathMacro.h"
-#include <boost/assert.hpp>
#include <boost/bind.hpp>
#include <sstream>
bool bruteFind(Cursor & cursor,
int x, int y, int xlow, int xhigh, int ylow, int yhigh)
{
- BOOST_ASSERT(!cursor.empty());
+ LASSERT(!cursor.empty(), return false);
Inset & inset = cursor[0].inset();
BufferView & bv = cursor.bv();
for (; depth(); pop(), boundary(false)) {
LYXERR(Debug::DEBUG, "Cursor::dispatch: cmd: "
<< cmd0 << endl << *this);
- BOOST_ASSERT(pos() <= lastpos());
- BOOST_ASSERT(idx() <= lastidx());
- BOOST_ASSERT(pit() <= lastpit());
+ LASSERT(pos() <= lastpos(), /**/);
+ LASSERT(idx() <= lastidx(), /**/);
+ LASSERT(pit() <= lastpit(), /**/);
// The common case is 'LFUN handled, need update', so make the
// LFUN handler's life easier by assuming this as default value.
BufferView & Cursor::bv() const
{
- BOOST_ASSERT(bv_);
+ LASSERT(bv_, /**/);
return *bv_;
}
Buffer & Cursor::buffer() const
{
- BOOST_ASSERT(bv_);
+ LASSERT(bv_, /**/);
return bv_->buffer();
}
void Cursor::pop()
{
- BOOST_ASSERT(depth() >= 1);
+ LASSERT(depth() >= 1, /**/);
pop_back();
}
void Cursor::pushBackward(Inset & p)
{
- BOOST_ASSERT(!empty());
+ LASSERT(!empty(), /**/);
//lyxerr << "Entering inset " << t << " front" << endl;
push(p);
p.idxFirst(*this);
bool Cursor::popBackward()
{
- BOOST_ASSERT(!empty());
+ LASSERT(!empty(), /**/);
if (depth() == 1)
return false;
pop();
bool Cursor::popForward()
{
- BOOST_ASSERT(!empty());
+ LASSERT(!empty(), /**/);
//lyxerr << "Leaving inset from in back" << endl;
const pos_type lp = (depth() > 1) ? (*this)[depth() - 2].lastpos() : 0;
if (depth() == 1)
int Cursor::currentMode()
{
- BOOST_ASSERT(!empty());
+ LASSERT(!empty(), /**/);
for (int i = depth() - 1; i >= 0; --i) {
int res = operator[](i).inset().currentMode();
if (res != Inset::UNDECIDED_MODE)
{
CursorSlice const & cs = innerTextSlice();
ParagraphMetrics const & pm = bv().parMetrics(cs.text(), cs.pit());
- BOOST_ASSERT(!pm.rows().empty());
+ LASSERT(!pm.rows().empty(), /**/);
return pm.getRow(pos(), boundary());
}
}
+bool Cursor::posVisRight(bool skip_inset)
+{
+ Cursor new_cur = *this; // where we will move to
+ pos_type left_pos; // position visually left of current cursor
+ pos_type right_pos; // position visually right of current cursor
+ bool new_pos_is_RTL; // is new position we're moving to RTL?
+
+ getSurroundingPos(left_pos, right_pos);
+
+ LYXERR(Debug::RTL, left_pos <<"|"<< right_pos << " (pos: "<< pos() <<")");
+
+ // Are we at an inset?
+ new_cur.pos() = right_pos;
+ new_cur.boundary(false);
+ if (!skip_inset &&
+ text()->checkAndActivateInsetVisual(new_cur, right_pos>=pos(), false)) {
+ // we actually move the cursor at the end of this function, for now
+ // we just keep track of the new position in new_cur...
+ LYXERR(Debug::RTL, "entering inset at: " << new_cur.pos());
+ }
+
+ // Are we already at rightmost pos in row?
+ else if (text()->empty() || right_pos == -1) {
+
+ new_cur = *this;
+ if (!new_cur.posVisToNewRow(false)) {
+ LYXERR(Debug::RTL, "not moving!");
+ return false;
+ }
+
+ // we actually move the cursor at the end of this function, for now
+ // just keep track of the new position in new_cur...
+ LYXERR(Debug::RTL, "right edge, moving: " << int(new_cur.pit()) << ","
+ << int(new_cur.pos()) << "," << (new_cur.boundary() ? 1 : 0));
+
+ }
+ // normal movement to the right
+ else {
+ new_cur = *this;
+ // Recall, if the cursor is at position 'x', that means *before*
+ // the character at position 'x'. In RTL, "before" means "to the
+ // right of", in LTR, "to the left of". So currently our situation
+ // is this: the position to our right is 'right_pos' (i.e., we're
+ // currently to the left of 'right_pos'). In order to move to the
+ // right, it depends whether or not the character at 'right_pos' is RTL.
+ new_pos_is_RTL = paragraph().getFontSettings(
+ bv().buffer().params(), right_pos).isVisibleRightToLeft();
+ // If the character at 'right_pos' *is* LTR, then in order to move to
+ // the right of it, we need to be *after* 'right_pos', i.e., move to
+ // position 'right_pos' + 1.
+ if (!new_pos_is_RTL) {
+ new_cur.pos() = right_pos + 1;
+ // set the boundary to true in two situations:
+ if (
+ // 1. if new_pos is now lastpos (which means that we're moving
+ // right to the end of an LTR chunk which is at the end of an
+ // RTL paragraph);
+ new_cur.pos() == lastpos()
+ // 2. if the position *after* right_pos is RTL (we want to be
+ // *after* right_pos, not before right_pos + 1!)
+ || paragraph().getFontSettings(bv().buffer().params(),
+ new_cur.pos()).isVisibleRightToLeft()
+ )
+ new_cur.boundary(true);
+ else // set the boundary to false
+ new_cur.boundary(false);
+ }
+ // Otherwise (if the character at position 'right_pos' is RTL), then
+ // moving to the right of it is as easy as setting the new position
+ // to 'right_pos'.
+ else {
+ new_cur.pos() = right_pos;
+ new_cur.boundary(false);
+ }
+
+ }
+
+ bool moved = (new_cur.pos() != pos()
+ || new_cur.pit() != pit()
+ || new_cur.boundary() != boundary());
+
+ if (moved) {
+ LYXERR(Debug::RTL, "moving to: " << new_cur.pos()
+ << (new_cur.boundary() ? " (boundary)" : ""));
+ *this = new_cur;
+ }
+
+ return moved;
+}
+
+
+bool Cursor::posVisLeft(bool skip_inset)
+{
+ Cursor new_cur = *this; // where we will move to
+ pos_type left_pos; // position visually left of current cursor
+ pos_type right_pos; // position visually right of current cursor
+ bool new_pos_is_RTL; // is new position we're moving to RTL?
+
+ getSurroundingPos(left_pos, right_pos);
+
+ LYXERR(Debug::RTL, left_pos <<"|"<< right_pos << " (pos: "<< pos() <<")");
+
+ // Are we at an inset?
+ new_cur.pos() = left_pos;
+ new_cur.boundary(false);
+ if (!skip_inset &&
+ text()->checkAndActivateInsetVisual(new_cur, left_pos >= pos(), true)) {
+ // we actually move the cursor at the end of this function, for now
+ // we just keep track of the new position in new_cur...
+ LYXERR(Debug::RTL, "entering inset at: " << new_cur.pos());
+ }
+
+ // Are we already at leftmost pos in row?
+ else if (text()->empty() || left_pos == -1) {
+
+ new_cur = *this;
+ if (!new_cur.posVisToNewRow(true)) {
+ LYXERR(Debug::RTL, "not moving!");
+ return false;
+ }
+
+ // we actually move the cursor at the end of this function, for now
+ // just keep track of the new position in new_cur...
+ LYXERR(Debug::RTL, "left edge, moving: " << int(new_cur.pit()) << ","
+ << int(new_cur.pos()) << "," << (new_cur.boundary() ? 1 : 0));
+
+ }
+ // normal movement to the left
+ else {
+ new_cur = *this;
+ // Recall, if the cursor is at position 'x', that means *before*
+ // the character at position 'x'. In RTL, "before" means "to the
+ // right of", in LTR, "to the left of". So currently our situation
+ // is this: the position to our left is 'left_pos' (i.e., we're
+ // currently to the right of 'left_pos'). In order to move to the
+ // left, it depends whether or not the character at 'left_pos' is RTL.
+ new_pos_is_RTL = paragraph().getFontSettings(
+ bv().buffer().params(), left_pos).isVisibleRightToLeft();
+ // If the character at 'left_pos' *is* RTL, then in order to move to
+ // the left of it, we need to be *after* 'left_pos', i.e., move to
+ // position 'left_pos' + 1.
+ if (new_pos_is_RTL) {
+ new_cur.pos() = left_pos + 1;
+ // set the boundary to true in two situations:
+ if (
+ // 1. if new_pos is now lastpos (which means that we're moving left
+ // to the end of an RTL chunk which is at the end of an LTR
+ // paragraph);
+ new_cur.pos() == lastpos()
+ // 2. if the position *after* left_pos is not RTL (we want to be
+ // *after* left_pos, not before left_pos + 1!)
+ || !paragraph().getFontSettings(bv().buffer().params(),
+ new_cur.pos()).isVisibleRightToLeft()
+ )
+ new_cur.boundary(true);
+ else // set the boundary to false
+ new_cur.boundary(false);
+ }
+ // Otherwise (if the character at position 'left_pos' is LTR), then
+ // moving to the left of it is as easy as setting the new position
+ // to 'left_pos'.
+ else {
+ new_cur.pos() = left_pos;
+ new_cur.boundary(false);
+ }
+
+ }
+
+ bool moved = (new_cur.pos() != pos()
+ || new_cur.pit() != pit()
+ || new_cur.boundary() != boundary());
+
+ if (moved) {
+ LYXERR(Debug::RTL, "moving to: " << new_cur.pos()
+ << (new_cur.boundary() ? " (boundary)" : ""));
+ *this = new_cur;
+ }
+
+ return moved;
+}
+
+
void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos)
{
// preparing bidi tables
Buffer const & buf = buffer();
Row const & row = textRow();
bool par_is_LTR = !par.isRTL(buf.params());
+
+ // Inside a table, determining whether to move to the next or previous row
+ // should be done based on the table's direction.
+ int s = depth() - 1;
+ if (s >= 1 && (*this)[s].inset().asInsetTabular()) {
+ par_is_LTR = !(*this)[s].inset().asInsetTabular()->isRightToLeft(*this);
+ LYXERR(Debug::RTL, "Inside table! par_is_LTR=" << (par_is_LTR ? 1 : 0));
+ }
// if moving left in an LTR paragraph or moving right in an RTL one,
// move to previous row
CursorSlice Cursor::anchor() const
{
- BOOST_ASSERT(anchor_.depth() >= depth());
+ LASSERT(anchor_.depth() >= depth(), /**/);
CursorSlice normal = anchor_[depth() - 1];
if (depth() < anchor_.depth() && top() <= normal) {
// anchor is behind cursor -> move anchor behind the inset
void Cursor::insert(char_type c)
{
//lyxerr << "Cursor::insert char '" << c << "'" << endl;
- BOOST_ASSERT(!empty());
+ LASSERT(!empty(), /**/);
if (inMathed()) {
cap::selClearOrDel(*this);
insert(new InsetMathChar(c));
void Cursor::insert(Inset * inset0)
{
- BOOST_ASSERT(inset0);
+ LASSERT(inset0, /**/);
if (inMathed())
insert(MathAtom(inset0));
else {
bool Cursor::upDownInText(bool up, bool & updateNeeded)
{
- BOOST_ASSERT(text());
+ LASSERT(text(), /**/);
// where are we?
int xo = 0;