-/* This file is part of
- * ======================================================
+/**
+ * \file text2.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
*
- * LyX, The Document Processor
+ * \author Asger Alstrup
+ * \author Lars Gullik Bjønnes
+ * \author Alfredo Braunstein
+ * \author Jean-Marc Lasgouttes
+ * \author Angus Leeming
+ * \author John Levon
+ * \author André Pönitz
+ * \author Allan Rae
+ * \author Dekel Tsur
+ * \author Jürgen Vigna
*
- * Copyright 1995 Matthias Ettrich
- * Copyright 1995-2001 The LyX Team.
- *
- * ====================================================== */
+ * Full author contact details are available in file CREDITS.
+ */
#include <config.h>
#include "frontends/font_metrics.h"
#include "debug.h"
#include "lyxrc.h"
+#include "Floating.h"
#include "FloatList.h"
#include "language.h"
#include "ParagraphParameters.h"
using lyx::pos_type;
-LyXText::LyXText(BufferView * bv)
- : height(0), width(0), anchor_row_offset_(0),
- inset_owner(0), the_locking_inset(0), bv_owner(bv)
+LyXText::LyXText(BufferView * bv, InsetText * inset, bool ininset,
+ ParagraphList & paragraphs)
+ : height(0), width(0), anchor_y_(0),
+ inset_owner(inset), the_locking_inset(0), bv_owner(bv),
+ in_inset_(ininset), paragraphs_(paragraphs)
{
- anchor_row_ = rows().end();
-}
-
-
-LyXText::LyXText(BufferView * bv, InsetText * inset)
- : height(0), width(0), anchor_row_offset_(0),
- inset_owner(inset), the_locking_inset(0), bv_owner(bv)
-{
- anchor_row_ = rows().end();
}
{
bv_owner = bview;
- rowlist_.clear();
+ ParagraphList::iterator const beg = ownerParagraphs().begin();
+ ParagraphList::iterator const end = ownerParagraphs().end();
+ for (ParagraphList::iterator pit = beg; pit != end; ++pit)
+ pit->rows.clear();
+
width = 0;
height = 0;
- anchor_row_ = rows().end();
- anchor_row_offset_ = 0;
+ anchor_y_ = 0;
- current_font = getFont(ownerParagraphs().begin(), 0);
+ current_font = getFont(beg, 0);
- redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end());
-
- setCursorIntern(rowlist_.begin()->par(), 0);
+ redoParagraphs(beg, end);
+ setCursorIntern(beg, 0);
selection.cursor = cursor;
updateCounters();
}
-// removes the row and reset the touched counters
-void LyXText::removeRow(RowList::iterator rit)
-{
- if (anchor_row_ == rit) {
- if (rit != rows().begin()) {
- anchor_row_ = boost::prior(rit);
- anchor_row_offset_ += anchor_row_->height();
- } else {
- anchor_row_ = boost::next(rit);
- anchor_row_offset_ -= rit->height();
- }
- }
-
- // the text becomes smaller
- height -= rit->height();
-
- rowlist_.erase(rit);
-}
-
-
-// remove all following rows of the paragraph of the specified row.
-void LyXText::removeParagraph(RowList::iterator rit)
-{
- ParagraphList::iterator tmppit = rit->par();
- ++rit;
-
- while (rit != rows().end() && rit->par() == tmppit) {
- RowList::iterator tmprit = boost::next(rit);
- removeRow(rit);
- rit = tmprit;
- }
-}
-
-
-void LyXText::insertParagraph(ParagraphList::iterator pit,
- RowList::iterator rit)
-{
- // insert a new row, starting at position 0
- rit = rowlist_.insert(rit, Row(pit, 0));
-
- // and now append the whole paragraph before the new row
- Assert(rit != rowlist_.end());
-
- pos_type const last = rit->par()->size();
- bool done = false;
-
- do {
- pos_type z = rowBreakPoint(*rit);
-
- RowList::iterator tmprow = rit;
-
- if (z < last) {
- ++z;
- Row newrow(rit->par(), z);
- rit = rowlist_.insert(boost::next(rit), newrow);
- } else {
- done = true;
- }
-
- // Set the dimensions of the row
- // fixed fill setting now by calling inset->update() in
- // SingleWidth when needed!
- tmprow->fill(fill(tmprow, workWidth()));
- setHeightOfRow(tmprow);
-
- } while (!done);
-}
-
-
InsetOld * LyXText::getInset() const
{
ParagraphList::iterator pit = cursor.par();
else
inset->open(bv());
- bv()->updateInset();
+ bv()->updateInset(inset);
}
}
-RowList::iterator LyXText::firstRow(ParagraphList::iterator pit)
+int LyXText::redoParagraphInternal(ParagraphList::iterator pit)
{
- RowList::iterator rit;
- for (rit = rows().begin(); rit != rows().end(); ++rit)
- if (rit->par() == pit)
- break;
- return rit;
+ RowList::iterator rit = pit->rows.begin();
+ RowList::iterator end = pit->rows.end();
+
+ // remove rows of paragraph, keep track of height changes
+ for (int i = 0; rit != end; ++rit, ++i)
+ height -= rit->height();
+ pit->rows.clear();
+
+ // redo insets
+ InsetList::iterator ii = pit->insetlist.begin();
+ InsetList::iterator iend = pit->insetlist.end();
+ for (; ii != iend; ++ii) {
+ Dimension dim;
+ MetricsInfo mi(bv(), getFont(pit, ii->pos), workWidth());
+ ii->inset->metrics(mi, dim);
+ }
+
+ // rebreak the paragraph
+ for (pos_type z = 0; z < pit->size() + 1; ) {
+ Row row(z);
+ z = rowBreakPoint(pit, row) + 1;
+ row.end(z);
+ pit->rows.push_back(row);
+ }
+
+ int par_width = 0;
+ // set height and fill and width of rows
+ int const ww = workWidth();
+ for (rit = pit->rows.begin(); rit != end; ++rit) {
+ int const f = fill(pit, rit, ww);
+ int const w = ww - f;
+ par_width = std::max(par_width, w);
+ rit->fill(f);
+ rit->width(w);
+ prepareToPrint(pit, rit);
+ setHeightOfRow(pit, rit);
+ height += rit->height();
+ }
+
+ //lyxerr << "redoParagraph: " << pit->rows.size() << " rows\n";
+ return par_width;
}
-// rebreaks all paragraphs between the specified pars
-// This function is needed after SetLayout and SetFont etc.
-void LyXText::redoParagraphs(ParagraphList::iterator start,
+int LyXText::redoParagraphs(ParagraphList::iterator start,
ParagraphList::iterator end)
{
- for ( ; start != end; ++start)
- redoParagraph(start);
+ int pars_width = 0;
+ for ( ; start != end; ++start) {
+ int par_width = redoParagraphInternal(start);
+ pars_width = std::max(par_width, pars_width);
+ }
+ updateRowPositions();
+ return pars_width;
}
void LyXText::redoParagraph(ParagraphList::iterator pit)
{
- RowList::iterator rit = firstRow(pit);
-
- // remove paragraph from rowlist
- while (rit != rows().end() && rit->par() == pit) {
- RowList::iterator rit2 = rit++;
- removeRow(rit2);
- }
-
- // reinsert the paragraph
- insertParagraph(pit, rit);
-
- // why?
- setHeightOfRow(rows().begin());
+ redoParagraphInternal(pit);
+ updateRowPositions();
}
void LyXText::metrics(MetricsInfo & mi, Dimension & dim)
{
- //lyxerr << "LyXText::metrics: width: " << mi.base.textwidth << endl;
+ //lyxerr << "LyXText::metrics: width: " << mi.base.textwidth
+ // << " workWidth: " << workWidth() << endl;
//Assert(mi.base.textwidth);
// rebuild row cache
- rowlist_.clear();
- width = 0;
- height = 0;
+ width = 0;
+ ///height = 0;
- anchor_row_ = rows().end();
- anchor_row_offset_ = 0;
-
- ParagraphList::iterator pit = ownerParagraphs().begin();
- ParagraphList::iterator end = ownerParagraphs().end();
-
- for (; pit != end; ++pit) {
- InsetList::iterator ii = pit->insetlist.begin();
- InsetList::iterator iend = pit->insetlist.end();
- for (; ii != iend; ++ii) {
- Dimension dim;
- MetricsInfo m = mi;
-#warning FIXME: pos != 0
- m.base.font = getFont(pit, 0);
- ii->inset->metrics(m, dim);
- }
-
- redoParagraph(pit);
- }
+ //anchor_y_ = 0;
+ width = redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end());
// final dimension
- dim.asc = rows().begin()->ascent_of_text();
+ dim.asc = firstRow()->ascent_of_text();
dim.des = height - dim.asc;
dim.wid = std::max(mi.base.textwidth, int(width));
}
return;
RowList::iterator rit = cursorRow();
- RowList::iterator next_rit = boost::next(rit);
- ParagraphList::iterator pit = rit->par();
- pos_type last_pos = lastPos(*this, rit);
-
- if (next_rit == rows().end() || next_rit->par() != pit) {
- ++last_pos;
- } else {
- if (pit->empty() ||
- (pit->getChar(last_pos) != ' ' && !pit->isNewline(last_pos))) {
- ++last_pos;
- }
- }
-
- setCursor(pit, last_pos);
+ ParagraphList::iterator pit = cursor.par();
+ pos_type pos = lastPos(*pit, rit);
+ /* cursor should be before a hard newline only */
+ if (!pit->isNewline(pos))
+ ++pos;
+ setCursor(pit, pos);
}
else if (selection.start.par() != selection.end.par())
bv()->owner()->message(_("Cannot index more than one paragraph!"));
else
- idxstring = selectionAsString(bv()->buffer(), false);
+ idxstring = selectionAsString(*bv()->buffer(), false);
// Reset cursors to their original position.
cursor = reset_cursor;
setSelection();
setCursor(tmpcursor.par(), tmpcursor.pos());
if (inset_owner)
- bv()->updateInset();
+ bv()->updateInset(inset_owner);
}
// 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, ParagraphList::iterator pit)
{
- LyXTextClass const & textclass = buf->params.getLyXTextClass();
+ LyXTextClass const & textclass = buf.params.getLyXTextClass();
LyXLayout_ptr const & layout = pit->layout();
if (pit != ownerParagraphs().begin()) {
ostringstream s;
- if (i >= 0 && i <= buf->params.secnumdepth) {
+ if (i >= 0 && i <= buf.params.secnumdepth) {
string numbertype;
string langtype;
// Is there a label? Useful for Chapter layout
if (!pit->params().appendix()) {
- s << buf->B_(layout->labelstring());
+ s << buf.B_(layout->labelstring());
} else {
- s << buf->B_(layout->labelstring_appendix());
+ s << buf.B_(layout->labelstring_appendix());
}
// Use of an integer is here less than elegant. For now.
numbertype = "sectioning";
} else {
numbertype = "appendix";
- if (pit->isRightToLeftPar(buf->params))
+ if (pit->isRightToLeftPar(buf.params))
langtype = "hebrew";
else
langtype = "latin";
}
// In biblio should't be following counters but...
} else {
- string s = buf->B_(layout->labelstring());
+ string s = buf.B_(layout->labelstring());
// the caption hack:
if (layout->labeltype == LABEL_SENSITIVE) {
isOK = true;
break;
} else {
+ Paragraph const * owner = &ownerPar(buf, in);
tmppit = ownerParagraphs().begin();
for ( ; tmppit != end; ++tmppit)
- if (&*tmppit == in->parOwner())
+ if (&*tmppit == owner)
break;
}
}
textclass.counters().step(fl.type());
// Doesn't work... yet.
- s = bformat(_("%1$s #:"), buf->B_(fl.name()));
+ s = bformat(_("%1$s #:"), buf.B_(fl.name()));
} else {
// par->SetLayout(0);
// s = layout->labelstring;
pit->params().depth(maxdepth);
// setCounter can potentially change the labelString.
- setCounter(bv()->buffer(), pit);
+ setCounter(*bv()->buffer(), pit);
string const & newLabel = pit->params().labelString();
// 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))
// 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));
+ bv()->stuffClipboard(selectionAsString(*bv()->buffer(), true));
// This doesn't make sense, if there is no selection
if (!selection.set())
void LyXText::copySelection()
{
// stuff the selection onto the X clipboard, from an explicit copy request
- bv()->stuffClipboard(selectionAsString(bv()->buffer(), true));
+ bv()->stuffClipboard(selectionAsString(*bv()->buffer(), true));
// this doesnt make sense, if there is no selection
if (!selection.set())
cur.par(pit);
cur.pos(pos);
cur.boundary(boundary);
- if (rows().empty())
+ if (noRows())
return;
// get the cursor y position in text
- int y = 0;
- RowList::iterator row = getRow(pit, pos, y);
- RowList::iterator beg = rows().begin();
-
- RowList::iterator old_row = row;
- // if we are before the first char of this row and are still in the
- // same paragraph and there is a previous row then put the cursor on
- // the end of the previous row
- cur.iy(y + row->baseline());
- if (row != beg &&
- pos &&
- boost::prior(row)->par() == row->par() &&
- pos < pit->size() &&
- pit->getChar(pos) == Paragraph::META_INSET) {
- InsetOld * ins = pit->getInset(pos);
- if (ins && (ins->needFullRow() || ins->display())) {
- --row;
- y -= row->height();
- }
- }
+
+ RowList::iterator row = getRow(pit, pos);
+ int y = row->y();
// y is now the beginning of the cursor row
y += row->baseline();
// y is now the cursor baseline
cur.y(y);
- pos_type last = lastPrintablePos(*this, old_row);
+ pos_type last = lastPrintablePos(*pit, row);
// None of these should happen, but we're scaredy-cats
if (pos > pit->size()) {
- lyxerr << "dont like 1 please report" << endl;
+ lyxerr << "dont like 1, pos: " << pos << " size: " << pit->size() << endl;
pos = 0;
cur.pos(0);
} else if (pos > last + 1) {
}
// now get the cursors x position
- float x = getCursorX(row, pos, last, boundary);
+ float x = getCursorX(pit, row, pos, last, boundary);
cur.x(int(x));
cur.x_fix(cur.x());
- if (old_row != row) {
- x = getCursorX(old_row, pos, last, boundary);
- cur.ix(int(x));
- } else
- cur.ix(cur.x());
-/* We take out this for the time being because 1) the redraw code is not
- prepared to this yet and 2) because some good policy has yet to be decided
- while editting: for instance how to act on rows being created/deleted
- because of DEPM.
-*/
-#if 0
- //if the cursor is in a visible row, anchor to it
- int topy = top_y();
- if (topy < y && y < topy + bv()->workHeight())
- anchor_row(row);
-#endif
}
-float LyXText::getCursorX(RowList::iterator rit,
+float LyXText::getCursorX(ParagraphList::iterator pit, RowList::iterator rit,
pos_type pos, pos_type last, bool boundary) const
{
- pos_type cursor_vpos = 0;
- double x;
- double fill_separator;
- double fill_hfill;
- double fill_label_hfill;
- // This call HAS to be here because of the BidiTables!!!
- prepareToPrint(rit, x, fill_separator, fill_hfill,
- fill_label_hfill);
-
- ParagraphList::iterator rit_par = rit->par();
- pos_type const rit_pos = rit->pos();
+ pos_type cursor_vpos = 0;
+ double x = rit->x();
+ double fill_separator = rit->fill_separator();
+ double fill_hfill = rit->fill_hfill();
+ double fill_label_hfill = rit->fill_label_hfill();
+ pos_type const rit_pos = rit->pos();
if (last < rit_pos)
cursor_vpos = rit_pos;
else if (pos > last && !boundary)
- cursor_vpos = (rit_par->isRightToLeftPar(bv()->buffer()->params))
+ cursor_vpos = (pit->isRightToLeftPar(bv()->buffer()->params))
? rit_pos : last + 1;
else if (pos > rit_pos && (pos > last || boundary))
// Place cursor after char at (logical) position pos - 1
cursor_vpos = (bidi_level(pos) % 2 == 0)
? log2vis(pos) : log2vis(pos) + 1;
- pos_type body_pos = rit_par->beginningOfBody();
+ pos_type body_pos = pit->beginningOfBody();
if (body_pos > 0 &&
- (body_pos - 1 > last || !rit_par->isLineSeparator(body_pos - 1)))
+ (body_pos - 1 > last || !pit->isLineSeparator(body_pos - 1)))
body_pos = 0;
for (pos_type vpos = rit_pos; vpos < cursor_vpos; ++vpos) {
if (body_pos > 0 && pos == body_pos - 1) {
x += fill_label_hfill +
font_metrics::width(
- rit_par->layout()->labelsep, getLabelFont(rit_par));
- if (rit_par->isLineSeparator(body_pos - 1))
- x -= singleWidth(rit_par, body_pos - 1);
+ pit->layout()->labelsep, getLabelFont(pit));
+ if (pit->isLineSeparator(body_pos - 1))
+ x -= singleWidth(pit, body_pos - 1);
}
- if (hfillExpansion(*this, rit, pos)) {
- x += singleWidth(rit_par, pos);
+ if (hfillExpansion(*pit, rit, pos)) {
+ x += singleWidth(pit, pos);
if (pos >= body_pos)
x += fill_hfill;
else
x += fill_label_hfill;
- } else if (rit_par->isSeparator(pos)) {
- x += singleWidth(rit_par, pos);
+ } else if (pit->isSeparator(pos)) {
+ x += singleWidth(pit, pos);
if (pos >= body_pos)
x += fill_separator;
} else
- x += singleWidth(rit_par, pos);
+ x += singleWidth(pit, pos);
}
return x;
}
real_current_font = getFont(pit, pos);
if (cursor.pos() == pit->size() &&
- isBoundary(bv()->buffer(), *pit, cursor.pos()) &&
+ isBoundary(*bv()->buffer(), *pit, cursor.pos()) &&
!cursor.boundary()) {
Language const * lang =
pit->getParLanguage(bv()->buffer()->params);
// 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(RowList::iterator rit, int & x, bool & boundary) const
+pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
+ RowList::iterator rit, int & x, bool & boundary) const
{
- double tmpx = 0;
- double fill_separator;
- double fill_hfill;
- double fill_label_hfill;
-
- prepareToPrint(rit, tmpx, fill_separator, fill_hfill, fill_label_hfill);
+ double tmpx = rit->x();
+ double fill_separator = rit->fill_separator();
+ double fill_hfill = rit->fill_hfill();
+ double fill_label_hfill = rit->fill_label_hfill();
pos_type vc = rit->pos();
- pos_type last = lastPrintablePos(*this, rit);
+ pos_type last = lastPrintablePos(*pit, rit);
pos_type c = 0;
-
- ParagraphList::iterator rit_par = rit->par();
- LyXLayout_ptr const & layout = rit->par()->layout();
+ LyXLayout_ptr const & layout = pit->layout();
bool left_side = false;
- pos_type body_pos = rit_par->beginningOfBody();
+ pos_type body_pos = pit->beginningOfBody();
double last_tmpx = tmpx;
if (body_pos > 0 &&
(body_pos - 1 > last ||
- !rit_par->isLineSeparator(body_pos - 1)))
+ !pit->isLineSeparator(body_pos - 1)))
body_pos = 0;
// check for empty row
- if (!rit_par->size()) {
+ if (!pit->size()) {
x = int(tmpx);
return 0;
}
last_tmpx = tmpx;
if (body_pos > 0 && c == body_pos - 1) {
tmpx += fill_label_hfill +
- font_metrics::width(layout->labelsep, getLabelFont(rit_par));
- if (rit_par->isLineSeparator(body_pos - 1))
- tmpx -= singleWidth(rit_par, body_pos - 1);
+ font_metrics::width(layout->labelsep, getLabelFont(pit));
+ if (pit->isLineSeparator(body_pos - 1))
+ tmpx -= singleWidth(pit, body_pos - 1);
}
- if (hfillExpansion(*this, rit, c)) {
- tmpx += singleWidth(rit_par, c);
+ if (hfillExpansion(*pit, rit, c)) {
+ tmpx += singleWidth(pit, c);
if (c >= body_pos)
tmpx += fill_hfill;
else
tmpx += fill_label_hfill;
- } else if (rit_par->isSeparator(c)) {
- tmpx += singleWidth(rit_par, c);
+ } else if (pit->isSeparator(c)) {
+ tmpx += singleWidth(pit, c);
if (c >= body_pos)
tmpx += fill_separator;
} else {
- tmpx += singleWidth(rit_par, c);
+ tmpx += singleWidth(pit, c);
}
++vc;
}
boundary = false;
// This (rtl_support test) is not needed, but gives
- // some speedup if rtl_support=false
- RowList::iterator next_rit = boost::next(rit);
-
- bool const lastrow = lyxrc.rtl_support &&
- (next_rit == rowlist_.end() ||
- next_rit->par() != rit_par);
+ // some speedup if rtl_support == false
+ bool const lastrow = lyxrc.rtl_support
+ && boost::next(rit) == pit->rows.end();
// If lastrow is false, we don't need to compute
// the value of rtl.
bool const rtl = (lastrow)
- ? rit_par->isRightToLeftPar(bv()->buffer()->params)
+ ? pit->isRightToLeftPar(bv()->buffer()->params)
: false;
if (lastrow &&
- ((rtl && left_side && vc == rit->pos() && x < tmpx - 5) ||
- (!rtl && !left_side && vc == last + 1 && x > tmpx + 5)))
+ ((rtl && left_side && vc == rit->pos() && x < tmpx - 5) ||
+ (!rtl && !left_side && vc == last + 1 && x > tmpx + 5)))
c = last + 1;
else if (vc == rit->pos()) {
c = vis2log(vc);
bool const rtl = (bidi_level(c) % 2 == 1);
if (left_side == rtl) {
++c;
- boundary = isBoundary(bv()->buffer(), *rit_par, c);
+ boundary = isBoundary(*bv()->buffer(), *pit, c);
}
}
- if (rit->pos() <= last && c > last
- && rit_par->isNewline(last)) {
+ if (rit->pos() <= last && c > last && pit->isNewline(last)) {
if (bidi_level(last) % 2 == 0)
- tmpx -= singleWidth(rit_par, last);
+ tmpx -= singleWidth(pit, last);
else
- tmpx += singleWidth(rit_par, last);
+ tmpx += singleWidth(pit, last);
c = last;
}
void LyXText::setCursorFromCoordinates(int x, int y)
{
- //LyXCursor old_cursor = cursor;
+ LyXCursor old_cursor = cursor;
setCursorFromCoordinates(cursor, x, y);
setCurrentFont();
-#warning DEPM disabled, otherwise crash when entering new table
- //deleteEmptyParagraphMechanism(old_cursor);
-}
-
-
-namespace {
-
- /**
- * return true if the cursor given is at the end of a row,
- * and the next row is filled by an inset that spans an entire
- * row.
- */
- bool beforeFullRowInset(LyXText & lt, LyXCursor const & cur)
- {
- RowList::iterator row = lt.getRow(cur);
- if (boost::next(row) == lt.rows().end())
- return false;
-
- Row const & next = *boost::next(row);
-
- if (next.pos() != cur.pos() || next.par() != cur.par())
- return false;
-
- if (cur.pos() == cur.par()->size()
- || !cur.par()->isInset(cur.pos()))
- return false;
-
- InsetOld const * inset = cur.par()->getInset(cur.pos());
- if (inset->needFullRow() || inset->display())
- return true;
-
- return false;
- }
+ deleteEmptyParagraphMechanism(old_cursor);
}
void LyXText::setCursorFromCoordinates(LyXCursor & cur, int x, int y)
{
// Get the row first.
+ ParagraphList::iterator pit;
+ RowList::iterator rit = getRowNearY(y, pit);
+ y = rit->y();
- RowList::iterator row = getRowNearY(y);
bool bound = false;
- pos_type const column = getColumnNearX(row, x, bound);
- cur.par(row->par());
- cur.pos(row->pos() + column);
+ pos_type const column = getColumnNearX(pit, rit, x, bound);
+ cur.par(pit);
+ cur.pos(rit->pos() + column);
cur.x(x);
- cur.y(y + row->baseline());
+ cur.y(y + rit->baseline());
- if (beforeFullRowInset(*this, cur)) {
- pos_type const last = lastPrintablePos(*this, row);
- RowList::iterator next_row = boost::next(row);
-
- float x = getCursorX(next_row, cur.pos(), last, bound);
- cur.ix(int(x));
- cur.iy(y + row->height() + next_row->baseline());
- } else {
- cur.iy(cur.y());
- cur.ix(cur.x());
- }
cur.boundary(bound);
}
bool boundary = cursor.boundary();
setCursor(cursor.par(), cursor.pos() - 1, true, false);
if (!internal && !boundary &&
- isBoundary(bv()->buffer(), *cursor.par(), cursor.pos() + 1))
+ isBoundary(*bv()->buffer(), *cursor.par(), cursor.pos() + 1))
setCursor(cursor.par(), cursor.pos() + 1, true, true);
} else if (cursor.par() != ownerParagraphs().begin()) {
// steps into the paragraph above
else if (!at_end) {
setCursor(cursor.par(), cursor.pos() + 1, true, false);
if (!internal &&
- isBoundary(bv()->buffer(), *cursor.par(), cursor.pos()))
+ isBoundary(*bv()->buffer(), *cursor.par(), cursor.pos()))
setCursor(cursor.par(), cursor.pos(), true, true);
} else if (boost::next(cursor.par()) != ownerParagraphs().end())
setCursor(boost::next(cursor.par()), 0);
int y = cursor.y() - cursorRow()->baseline() - 1;
setCursorFromCoordinates(x, y);
if (!selecting) {
- int topy = top_y();
- int y1 = cursor.iy() - topy;
+ int topy = bv_owner->top_y();
+ int y1 = cursor.y() - topy;
int y2 = y1;
y -= topy;
InsetOld * inset_hit = checkInsetHit(x, y1);
}
}
#else
- setCursorFromCoordinates(bv(), cursor.x_fix(),
- cursor.y() - cursorRow()->baseline() - 1);
+ lyxerr << "cursorUp: y " << cursor.y() << " bl: " <<
+ cursorRow()->baseline() << endl;
+ setCursorFromCoordinates(cursor.x_fix(),
+ cursor.y() - cursorRow()->baseline() - 1);
#endif
}
int y = cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1;
setCursorFromCoordinates(x, y);
if (!selecting && cursorRow() == cursorIRow()) {
- int topy = top_y();
- int y1 = cursor.iy() - topy;
+ int topy = bv_owner->top_y();
+ int y1 = cursor.y() - topy;
int y2 = y1;
y -= topy;
InsetOld * inset_hit = checkInsetHit(x, y1);
}
}
#else
- setCursorFromCoordinates(bv(), cursor.x_fix(),
- cursor.y() - cursorRow()->baseline()
- + cursorRow()->height() + 1);
+ setCursorFromCoordinates(cursor.x_fix(),
+ cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1);
#endif
}
There are still some small problems that can lead to
double spaces stored in the document file or space at
the beginning of paragraphs. This happens if you have
- the cursor betwenn to spaces and then save. Or if you
+ the cursor between to spaces and then save. Or if you
cut and paste and the selection have a space at the
beginning and then save right after the paste. I am
sure none of these are very hard to fix, but I will
if (old_cursor.par()->empty() ||
(old_cursor.par()->size() == 1 &&
old_cursor.par()->isLineSeparator(0))) {
- // ok, we will delete anything
+ // ok, we will delete something
LyXCursor tmpcursor;
deleted = true;
selection.cursor.par() == old_cursor.par()
&& selection.cursor.pos() == old_cursor.pos());
- if (getRow(old_cursor) != rows().begin()) {
- RowList::iterator prevrow = boost::prior(getRow(old_cursor));
- tmpcursor = cursor;
- cursor = old_cursor; // that undo can restore the right cursor position
- #warning FIXME. --end() iterator is usable here
- ParagraphList::iterator endpit = boost::next(old_cursor.par());
- while (endpit != ownerParagraphs().end() &&
- endpit->getDepth()) {
- ++endpit;
- }
+ tmpcursor = cursor;
+ cursor = old_cursor; // that undo can restore the right cursor position
- recordUndo(bv(), Undo::DELETE, old_cursor.par(),
- boost::prior(endpit));
- cursor = tmpcursor;
-
- // delete old row
- removeRow(getRow(old_cursor));
- // delete old par
- ownerParagraphs().erase(old_cursor.par());
-
- /* Breakagain the next par. Needed because of
- * the parindent that can occur or dissappear.
- * The next row can change its height, if
- * there is another layout before */
- RowList::iterator tmprit = boost::next(prevrow);
- if (tmprit != rows().end()) {
- redoParagraph(tmprit->par());
- updateCounters();
- }
- setHeightOfRow(prevrow);
- } else {
- RowList::iterator nextrow = boost::next(getRow(old_cursor));
-
- tmpcursor = cursor;
- cursor = old_cursor; // that undo can restore the right cursor position
-#warning FIXME. --end() iterator is usable here
- ParagraphList::iterator endpit = boost::next(old_cursor.par());
- while (endpit != ownerParagraphs().end() &&
- endpit->getDepth()) {
- ++endpit;
- }
+ ParagraphList::iterator endpit = boost::next(old_cursor.par());
+ while (endpit != ownerParagraphs().end() && endpit->getDepth())
+ ++endpit;
- recordUndo(bv(), Undo::DELETE, old_cursor.par(), boost::prior(endpit));
- cursor = tmpcursor;
-
- // delete old row
- removeRow(getRow(old_cursor));
- // delete old par
- ownerParagraphs().erase(old_cursor.par());
-
- /* Breakagain the next par. Needed because of
- the parindent that can occur or dissappear.
- The next row can change its height, if
- there is another layout before */
- if (nextrow != rows().end()) {
- redoParagraph(nextrow->par());
- updateCounters();
- }
- }
+ recordUndo(bv(), Undo::DELETE, old_cursor.par(), boost::prior(endpit));
+ cursor = tmpcursor;
+
+ // delete old par
+ ownerParagraphs().erase(old_cursor.par());
+ redoParagraph();
// correct cursor y
setCursorIntern(cursor.par(), cursor.pos());
ParagraphList & LyXText::ownerParagraphs() const
{
- if (inset_owner) {
- return inset_owner->paragraphs;
- }
- return bv_owner->buffer()->paragraphs;
+ return paragraphs_;
}
bool LyXText::isInInset() const
{
// Sub-level has non-null bv owner and non-null inset owner.
- return inset_owner != 0 && bv_owner != 0;
+ return inset_owner != 0;
}