#include "BufferView.h"
#include "Bullet.h"
#include "counters.h"
+#include "cursor.h"
#include "CutAndPaste.h"
#include "debug.h"
+#include "dispatchresult.h"
#include "errorlist.h"
#include "Floating.h"
#include "FloatList.h"
using std::string;
-LyXText::LyXText(BufferView * bv, InsetText * inset, bool ininset,
+LyXText::LyXText(BufferView * bv, InsetText * inset, bool in_inset,
ParagraphList & paragraphs)
- : height(0), width(0), anchor_y_(0),
- inset_owner(inset), the_locking_inset(0), bv_owner(bv),
- in_inset_(ininset), paragraphs_(¶graphs),
- cache_pos_(-1)
-{
-}
+ : height(0), width(0), textwidth_(bv ? bv->workWidth() : 100),
+ inset_owner(inset), bv_owner(bv),
+ in_inset_(in_inset), paragraphs_(¶graphs), xo_(0), yo_(0)
+{}
void LyXText::init(BufferView * bview)
width = 0;
height = 0;
- anchor_y_ = 0;
- cache_pos_ = -1;
-
current_font = getFont(beg, 0);
redoParagraphs(beg, end);
LyXLayout_ptr const & layout = pit->layout();
#warning broken?
BufferParams const & params = bv()->buffer()->params();
- pos_type const body_pos = pit->beginningOfBody();
+ pos_type const body_pos = pit->beginOfBody();
// We specialize the 95% common case:
if (!pit->getDepth()) {
// Get concrete layout font to reduce against
LyXFont layoutfont;
- if (pos < pit->beginningOfBody())
+ if (pos < pit->beginOfBody())
layoutfont = layout->labelfont;
else
layoutfont = layout->font;
// 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());
+ finishUndo();
+ inset_owner->owner()->close();
+ bv()->getLyXText()->cursorRight(true);
+ bv()->updateParagraphDialog();
}
return;
}
recUndo(cursor.par());
if (inset->isOpen())
- inset->close(bv());
+ inset->close();
else
- inset->open(bv());
-
- bv()->updateInset(inset);
+ inset->open();
}
-/* 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;
bool LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type, bool test_only)
{
ParagraphList::iterator pit = cursorPar();
- ParagraphList::iterator end = cursorPar();
+ ParagraphList::iterator end = pit;
ParagraphList::iterator start = pit;
if (selection.set()) {
start = pit;
}
- ParagraphList::iterator pastend = boost::next(end);
-
if (!test_only)
recUndo(parOffset(start), parOffset(end));
prev_after_depth = pit->getMaxDepthAfter();
+#warning SERIOUS: Uahh... does this mean we access end->getMaxDepthAfter?
if (pit == end) {
break;
}
if (test_only)
return changed;
- redoParagraphs(start, pastend);
+ redoParagraphs(start, boost::next(end));
// We need to actually move the text->cursor. I don't
// understand why ...
if (!selection.set()) {
// Determine basis font
LyXFont layoutfont;
- if (cursor.pos() < cursorPar()->beginningOfBody()) {
+ if (cursor.pos() < cursorPar()->beginOfBody()) {
layoutfont = getLabelFont(cursorPar());
} else {
layoutfont = getLayoutFont(cursorPar());
}
-
void LyXText::clearSelection()
{
TextCursor::clearSelection();
- // reset this in the bv_owner!
- if (bv_owner && bv_owner->text)
- bv_owner->text->xsel_cache.set(false);
+ // reset this in the bv()!
+ if (bv() && bv()->text)
+ bv()->text->xsel_cache.set(false);
}
{
ParagraphList::iterator cpit = cursorPar();
pos_type end = cpit->getRow(cursor.pos())->endpos();
- /* if not on the last row of the par, put the cursor before
- the final space */
+ // if not on the last row of the par, put the cursor before
+ // the final space
setCursor(cpit, end == cpit->size() ? end : end - 1);
}
// 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."));
+ bv()->owner()->message(_("No font change defined. "
+ "Use Character under the Layout menu to define font change."));
return;
}
// 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;
+ bool implicitSelection =
+ font.language() == ignore_language
+ && font.number() == LyXFont::IGNORE
+ && selectWordWhenUnderCursor(lyx::WHOLE_WORD_STRICT);
// Set font
setFont(font, toggleall);
// 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 cannnot make dirty things with
+// they do not duplicate themself and you cannot play dirty tricks with
// them!
void LyXText::setParagraph(
recUndo(selection.start.par(), parOffset(undoendpit) - 1);
-
int tmppit = selection.end.par();
while (tmppit != selection.start.par() - 1) {
setCursor(selection.end.par(), selection.end.pos());
setSelection();
setCursor(tmpcursor.par(), tmpcursor.pos());
- if (inset_owner)
- bv()->updateInset(inset_owner);
+ bv()->update();
}
-namespace {
-
string expandLabel(LyXTextClass const & textclass,
LyXLayout_ptr const & layout, bool appendix)
{
}
+namespace {
+
void incrementItemDepth(ParagraphList::iterator pit,
ParagraphList::iterator first_pit)
{
int const cur_labeltype = pit->layout()->labeltype;
- if (cur_labeltype != LABEL_ENUMERATE &&
- cur_labeltype != LABEL_ITEMIZE)
+ if (cur_labeltype != LABEL_ENUMERATE && cur_labeltype != LABEL_ITEMIZE)
return;
int const cur_depth = pit->getDepth();
}
-// Updates all counters. Paragraphs with changed label string will be rebroken
+// Updates all counters. Paragraphs with changed label string will be
+// not be rebroken as this is too expensive. The next round will get it
+// right anyway...
void LyXText::updateCounters()
{
// start over
ParagraphList::iterator beg = ownerParagraphs().begin();
ParagraphList::iterator end = ownerParagraphs().end();
for (ParagraphList::iterator pit = beg; pit != end; ++pit) {
- string const oldLabel = pit->params().labelString();
-
size_t maxdepth = 0;
if (pit != beg)
maxdepth = boost::prior(pit)->getMaxDepthAfter();
// setCounter can potentially change the labelString.
setCounter(*bv()->buffer(), pit);
-
- string const & newLabel = pit->params().labelString();
-
- if (oldLabel != newLabel)
- redoParagraph(pit);
}
}
{
if (!cursorPar()->insetAllowed(inset->lyxCode()))
return;
+
recUndo(cursor.par());
freezeUndo();
cursorPar()->insertInset(cursor.pos(), inset);
// 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(...)
+ // 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();
}
selection.cursor = cursor;
while (length--)
- cursorRight(bv());
+ cursorRight(true);
setSelection();
}
ParagraphList::iterator pit = getPar(par);
Row const & row = *pit->getRow(pos);
+
int y = pit->y + row.y_offset();
// y is now the beginning of the cursor row
BOOST_ASSERT(false);
}
// now get the cursors x position
- float x = getCursorX(pit, row, pos, boundary);
- cur.x(int(x));
- cur.x_fix(cur.x());
+ cur.x(int(getCursorX(pit, row, pos, boundary)));
}
double fill_label_hfill = row.fill_label_hfill();
pos_type const row_pos = row.pos();
pos_type const end = row.endpos();
-
+
if (end <= row_pos)
cursor_vpos = row_pos;
else if (pos >= end && !boundary)
cursor_vpos = (bidi.level(pos) % 2 == 0)
? bidi.log2vis(pos) : bidi.log2vis(pos) + 1;
- pos_type body_pos = pit->beginningOfBody();
+ pos_type body_pos = pit->beginOfBody();
if (body_pos > 0 &&
(body_pos > end || !pit->isLineSeparator(body_pos - 1)))
body_pos = 0;
pos_type pos, bool setfont, bool boundary)
{
setCursor(cursor, par, pos, boundary);
+ bv()->x_target(cursor.x() + xo_);
if (setfont)
setCurrentFont();
}
bool left_side = false;
- pos_type body_pos = pit->beginningOfBody();
+ pos_type body_pos = pit->beginOfBody();
double last_tmpx = tmpx;
if (body_pos > 0 &&
deleteEmptyParagraphMechanism(old_cursor);
}
-
+// x,y are coordinates relative to this LyXText
void LyXText::setCursorFromCoordinates(LyXCursor & cur, int x, int y)
{
// Get the row first.
}
-void LyXText::cursorLeft(bool internal)
+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);
+}
+
+
+DispatchResult LyXText::moveLeft()
+{
+ if (cursorPar()->isRightToLeftPar(bv()->buffer()->params()))
+ return moveRightIntern(true, true, false);
+ else
+ return moveLeftIntern(false, true, false);
+}
+
+
+DispatchResult LyXText::moveRightIntern(bool front, bool activate_inset, bool selecting)
+{
+ ParagraphList::iterator c_par = cursorPar();
+ if (boost::next(c_par) == ownerParagraphs().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);
+}
+
+
+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);
+}
+
+
+DispatchResult LyXText::moveUp()
+{
+ if (cursorPar() == firstPar() && cursorRow() == firstRow())
+ return DispatchResult(false, FINISHED_UP);
+ cursorUp(false);
+ clearSelection();
+ return DispatchResult(true);
+}
+
+
+DispatchResult LyXText::moveDown()
+{
+ if (cursorPar() == lastPar() && cursorRow() == lastRow())
+ return DispatchResult(false, FINISHED_DOWN);
+ cursorDown(false);
+ clearSelection();
+ return DispatchResult(true);
+}
+
+
+bool LyXText::cursorLeft(bool internal)
{
if (cursor.pos() > 0) {
bool boundary = cursor.boundary();
if (!internal && !boundary &&
bidi.isBoundary(*bv()->buffer(), *cursorPar(), cursor.pos() + 1))
setCursor(cursor.par(), cursor.pos() + 1, true, true);
- } else if (cursor.par() != 0) {
+ return true;
+ }
+
+ if (cursor.par() != 0) {
// steps into the paragraph above
setCursor(cursor.par() - 1, boost::prior(cursorPar())->size());
+ return true;
}
+
+ return false;
}
-void LyXText::cursorRight(bool internal)
+bool LyXText::cursorRight(bool internal)
{
- bool const at_end = (cursor.pos() == cursorPar()->size());
- bool const at_newline = !at_end &&
- cursorPar()->isNewline(cursor.pos());
-
- if (!internal && cursor.boundary() && !at_newline)
+ if (!internal && cursor.boundary()) {
setCursor(cursor.par(), cursor.pos(), true, false);
- else if (!at_end) {
+ 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);
- } else if (cursor.par() + 1 != int(ownerParagraphs().size()))
+ return true;
+ }
+
+ if (cursor.par() + 1 != int(ownerParagraphs().size())) {
setCursor(cursor.par() + 1, 0);
+ return true;
+ }
+
+ return false;
}
void LyXText::cursorUp(bool selecting)
{
- ParagraphList::iterator cpit = cursorPar();
- Row const & crow = *cpit->getRow(cursor.pos());
-#if 1
- int x = cursor.x_fix();
- int y = cursor.y() - crow.baseline() - 1;
+ Row const & row = *cursorRow();
+ int x = bv()->x_target() - xo_;
+ int y = cursor.y() - row.baseline() - 1;
setCursorFromCoordinates(x, y);
+
if (!selecting) {
- int topy = bv_owner->top_y();
- int y1 = cursor.y() - topy;
- int y2 = y1;
- y -= topy;
- InsetOld * inset_hit = checkInsetHit(x, y1);
- if (inset_hit && isHighlyEditableInset(inset_hit)) {
- inset_hit->dispatch(
- FuncRequest(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none));
- }
+ int y_abs = y + yo_ - bv()->top_y();
+ InsetOld * inset_hit = checkInsetHit(bv()->x_target(), y_abs);
+ if (inset_hit && isHighlyEditableInset(inset_hit))
+ inset_hit->edit(bv(), bv()->x_target(), y_abs);
}
-#else
- lyxerr << "cursorUp: y " << cursor.y() << " bl: " <<
- crow.baseline() << endl;
- setCursorFromCoordinates(cursor.x_fix(),
- cursor.y() - crow.baseline() - 1);
-#endif
}
void LyXText::cursorDown(bool selecting)
{
- ParagraphList::iterator cpit = cursorPar();
- Row const & crow = *cpit->getRow(cursor.pos());
-#if 1
- int x = cursor.x_fix();
- int y = cursor.y() - crow.baseline() + crow.height() + 1;
+ Row const & row = *cursorRow();
+ int x = bv()->x_target() - xo_;
+ int y = cursor.y() - row.baseline() + row.height() + 1;
setCursorFromCoordinates(x, y);
+
if (!selecting) {
- int topy = bv_owner->top_y();
- int y1 = cursor.y() - 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->dispatch(cmd);
- }
+ int y_abs = y + yo_ - bv()->top_y();
+ InsetOld * inset_hit = checkInsetHit(bv()->x_target(), y_abs);
+ if (inset_hit && isHighlyEditableInset(inset_hit))
+ inset_hit->edit(bv(), bv()->x_target(), y_abs);
}
-#else
- setCursorFromCoordinates(cursor.x_fix(),
- cursor.y() - crow.baseline() + crow.height() + 1);
-#endif
}
// 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 (old_pit->empty()
+ || (old_pit->size() == 1 && old_pit->isLineSeparator(0))) {
// ok, we will delete something
LyXCursor tmpcursor;
recUndo(parOffset(old_pit), parOffset(endpit) - 1);
cursor = tmpcursor;
+ // cache cursor pit
+ ParagraphList::iterator tmppit = cursorPar();
// delete old par
ownerParagraphs().erase(old_pit);
+ // update cursor par offset
+ cursor.par(parOffset(tmppit));
redoParagraph();
// correct cursor y
selection.cursor = cursor;
}
}
- if (!deleted) {
- if (old_pit->stripLeadingSpaces()) {
- redoParagraph(old_pit);
- // correct cursor y
- setCursorIntern(cursor.par(), cursor.pos());
- selection.cursor = cursor;
- }
+
+ if (deleted)
+ return true;
+
+ if (old_pit->stripLeadingSpaces()) {
+ redoParagraph(old_pit);
+ // correct cursor y
+ setCursorIntern(cursor.par(), cursor.pos());
+ selection.cursor = cursor;
}
- return deleted;
+ return false;
}
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(font) * 1.2);
}