#include "lyxtext.h"
#include "LString.h"
+#include "Lsstream.h"
#include "paragraph.h"
+#include "funcrequest.h"
#include "frontends/LyXView.h"
#include "undo_funcs.h"
#include "buffer.h"
+#include "buffer_funcs.h"
#include "bufferparams.h"
+#include "errorlist.h"
#include "gettext.h"
#include "BufferView.h"
#include "CutAndPaste.h"
#include "frontends/font_metrics.h"
#include "debug.h"
#include "lyxrc.h"
-#include "lyxrow.h"
#include "FloatList.h"
#include "language.h"
#include "ParagraphParameters.h"
#include "counters.h"
#include "lyxrow_funcs.h"
+#include "metricsinfo.h"
#include "paragraph_funcs.h"
#include "insets/insetbibitem.h"
+#include "insets/insetenv.h"
#include "insets/insetfloat.h"
+#include "insets/insetwrap.h"
#include "support/LAssert.h"
#include "support/textutils.h"
#include "support/lstrings.h"
-#include "support/BoostFormat.h"
#include <boost/tuple/tuple.hpp>
+#include <algorithm>
+
+using namespace lyx::support;
+
using std::vector;
using std::copy;
using std::endl;
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();
- need_break_row = rows().end();
- refresh_row = rows().end();
-
- clearPaint();
}
-LyXText::LyXText(BufferView * bv, InsetText * inset)
- : height(0), width(0), anchor_row_offset_(0),
- inset_owner(inset), the_locking_inset(0), bv_owner(bv)
+void LyXText::init(BufferView * bview)
{
- anchor_row_ = rows().end();
- need_break_row = rows().end();
- refresh_row = rows().end();
+ bv_owner = bview;
- clearPaint();
-}
+ 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;
-void LyXText::init(BufferView * bview, bool reinit)
-{
- if (reinit) {
- rowlist_.clear();
- need_break_row = rows().end();
- width = height = 0;
- top_y(0);
- clearPaint();
- } else if (!rowlist_.empty())
- return;
-
- ParagraphList::iterator pit = ownerParagraphs().begin();
- ParagraphList::iterator end = ownerParagraphs().end();
+ anchor_y_ = 0;
- current_font = getFont(bview->buffer(), pit, 0);
+ current_font = getFont(beg, 0);
- for (; pit != end; ++pit) {
- insertParagraph(pit, rowlist_.end());
- }
- setCursorIntern(rowlist_.begin()->par(), 0);
+ redoParagraphs(beg, end);
+ setCursorIntern(beg, 0);
selection.cursor = cursor;
updateCounters();
// The difference is that this one is used for displaying, and thus we
// are allowed to make cosmetic improvements. For instance make footnotes
// smaller. (Asger)
-// If position is -1, we get the layout font of the paragraph.
-// If position is -2, we get the font of the manual label of the paragraph.
-LyXFont const LyXText::getFont(Buffer const * buf, ParagraphList::iterator pit,
- pos_type pos) const
+LyXFont LyXText::getFont(ParagraphList::iterator pit, pos_type pos) const
{
- lyx::Assert(pos >= 0);
+ Assert(pos >= 0);
LyXLayout_ptr const & layout = pit->layout();
+#warning broken?
+ BufferParams const & params = bv()->buffer()->params;
// We specialize the 95% common case:
if (!pit->getDepth()) {
if (layout->labeltype == LABEL_MANUAL
&& pos < pit->beginningOfBody()) {
// 1% goes here
- LyXFont f = pit->getFontSettings(buf->params, pos);
+ LyXFont f = pit->getFontSettings(params, pos);
if (pit->inInset())
pit->inInset()->getDrawFont(f);
return f.realize(layout->reslabelfont);
} else {
- LyXFont f = pit->getFontSettings(buf->params, pos);
+ LyXFont f = pit->getFontSettings(params, pos);
if (pit->inInset())
pit->inInset()->getDrawFont(f);
return f.realize(layout->resfont);
layoutfont = layout->font;
}
- LyXFont tmpfont = pit->getFontSettings(buf->params, pos);
+ LyXFont tmpfont = pit->getFontSettings(params, pos);
tmpfont.realize(layoutfont);
if (pit->inInset())
// Realize with the fonts of lesser depth.
tmpfont.realize(outerFont(pit, ownerParagraphs()));
+ tmpfont.realize(defaultfont_);
- return realizeFont(tmpfont, buf->params);
+ return tmpfont;
}
-LyXFont const LyXText::getLayoutFont(Buffer const * buf,
- ParagraphList::iterator pit) const
+LyXFont LyXText::getLayoutFont(ParagraphList::iterator pit) const
{
LyXLayout_ptr const & layout = pit->layout();
- if (!pit->getDepth()) {
+ if (!pit->getDepth())
return layout->resfont;
- }
- LyXFont font(layout->font);
+ LyXFont font = layout->font;
// Realize with the fonts of lesser depth.
font.realize(outerFont(pit, ownerParagraphs()));
+ font.realize(defaultfont_);
- return realizeFont(font, buf->params);
+ return font;
}
-LyXFont const LyXText::getLabelFont(Buffer const * buf,
- ParagraphList::iterator pit) const
+LyXFont LyXText::getLabelFont(ParagraphList::iterator pit) const
{
LyXLayout_ptr const & layout = pit->layout();
- if (!pit->getDepth()) {
+ if (!pit->getDepth())
return layout->reslabelfont;
- }
- LyXFont font(layout->labelfont);
+ LyXFont font = layout->labelfont;
// Realize with the fonts of lesser depth.
font.realize(outerFont(pit, ownerParagraphs()));
+ font.realize(defaultfont_);
- return realizeFont(layout->labelfont, buf->params);
+ return font;
}
pos_type pos, LyXFont const & fnt,
bool toggleall)
{
- Buffer const * buf = bv()->buffer();
- LyXFont font = getFont(buf, pit, pos);
- font.update(fnt, buf->params.language, toggleall);
+ BufferParams const & params = bv()->buffer()->params;
+ LyXFont font = getFont(pit, pos);
+ font.update(fnt, params.language, toggleall);
// Let the insets convert their font
if (pit->isInset(pos)) {
- Inset * inset = pit->getInset(pos);
+ InsetOld * inset = pit->getInset(pos);
if (isEditableInset(inset)) {
- UpdatableInset * uinset =
- static_cast<UpdatableInset *>(inset);
- uinset->setFont(bv(), fnt, toggleall, true);
+ static_cast<UpdatableInset *>(inset)
+ ->setFont(bv(), fnt, toggleall, true);
}
}
- // Plug thru to version below:
- setCharFont(buf, pit, pos, font);
+ // Plug through to version below:
+ setCharFont(pit, pos, font);
}
-void LyXText::setCharFont(Buffer const * buf, ParagraphList::iterator pit,
- pos_type pos, LyXFont const & fnt)
+void LyXText::setCharFont(
+ ParagraphList::iterator pit, pos_type pos, LyXFont const & fnt)
{
- LyXFont font(fnt);
-
- LyXTextClass const & tclass = buf->params.getLyXTextClass();
+ LyXFont font = fnt;
LyXLayout_ptr const & layout = pit->layout();
// Get concrete layout font to reduce against
}
}
- layoutfont.realize(tclass.defaultfont());
+ layoutfont.realize(defaultfont_);
// Now, reduce font against full layout font
font.reduce(layoutfont);
}
-// removes the row and reset the touched counters
-void LyXText::removeRow(RowList::iterator rit)
-{
- /* FIXME: when we cache the bview, this should just
- * become a postPaint(), I think */
- if (refresh_row == rit) {
- if (rit == rows().begin())
- refresh_row = boost::next(rit);
- else
- refresh_row = boost::prior(rit);
-
- // what about refresh_y
- }
-
- 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 rowit)
-{
- // insert a new row, starting at position 0
- Row newrow(pit, 0);
- RowList::iterator rit = rowlist_.insert(rowit, newrow);
-
- // and now append the whole paragraph before the new row
- appendParagraph(rit);
-}
-
-
-Inset * LyXText::getInset() const
+InsetOld * LyXText::getInset() const
{
ParagraphList::iterator pit = cursor.par();
pos_type const pos = cursor.pos();
void LyXText::toggleInset()
{
- Inset * inset = getInset();
+ InsetOld * inset = getInset();
// is there an editable inset at cursor position?
if (!isEditableInset(inset)) {
// No, try to see if we are inside a collapsable inset
if (inset_owner && inset_owner->owner()
&& inset_owner->owner()->isOpen()) {
- bv()->unlockInset(static_cast<UpdatableInset *>(inset_owner->owner()));
+ bv()->unlockInset(inset_owner->owner());
inset_owner->owner()->close(bv());
bv()->getLyXText()->cursorRight(bv());
}
// do we want to keep this?? (JMarc)
if (!isHighlyEditableInset(inset))
- setCursorParUndo(bv());
+ recordUndo(bv(), Undo::ATOMIC);
- if (inset->isOpen()) {
+ if (inset->isOpen())
inset->close(bv());
- } else {
+ else
inset->open(bv());
- }
- bv()->updateInset(inset);
+ bv()->updateInset();
}
/* used in setlayout */
// Asger is not sure we want to do this...
-void LyXText::makeFontEntriesLayoutSpecific(Buffer const & buf,
+void LyXText::makeFontEntriesLayoutSpecific(BufferParams const & params,
Paragraph & par)
{
LyXLayout_ptr const & layout = par.layout();
else
layoutfont = layout->font;
- LyXFont tmpfont = par.getFontSettings(buf.params, pos);
+ LyXFont tmpfont = par.getFontSettings(params, pos);
tmpfont.reduce(layoutfont);
par.setFont(pos, tmpfont);
}
++endpit;
}
- setUndo(bv(), Undo::EDIT, sstart_cur.par(), undoendpit);
+ recordUndo(bv(), Undo::ATOMIC, sstart_cur.par(), boost::prior(undoendpit));
// ok we have a selection. This is always between sstart_cur
// and sel_end cursor
do {
pit->applyLayout(lyxlayout);
- makeFontEntriesLayoutSpecific(*bv()->buffer(), *pit);
- ParagraphList::iterator fppit = pit;
- fppit->params().spaceTop(lyxlayout->fill_top ?
+ makeFontEntriesLayoutSpecific(bv()->buffer()->params, *pit);
+ pit->params().spaceTop(lyxlayout->fill_top ?
VSpace(VSpace::VFILL)
: VSpace(VSpace::NONE));
- fppit->params().spaceBottom(lyxlayout->fill_bottom ?
+ pit->params().spaceBottom(lyxlayout->fill_bottom ?
VSpace(VSpace::VFILL)
: VSpace(VSpace::NONE));
if (lyxlayout->margintype == MARGIN_MANUAL)
// set layout over selection and make a total rebreak of those paragraphs
void LyXText::setLayout(string const & layout)
{
- LyXCursor tmpcursor = cursor; /* store the current cursor */
+ LyXCursor tmpcursor = cursor; // store the current cursor
// if there is no selection just set the layout
- // of the current paragraph */
+ // of the current paragraph
if (!selection.set()) {
selection.start = cursor; // dummy selection
selection.end = cursor;
}
+
+ // special handling of new environment insets
+ BufferParams const & params = bv()->buffer()->params;
+ LyXLayout_ptr const & lyxlayout = params.getLyXTextClass()[layout];
+ if (lyxlayout->is_environment) {
+ // move everything in a new environment inset
+ lyxerr << "setting layout " << layout << endl;
+ bv()->owner()->dispatch(FuncRequest(LFUN_HOME));
+ bv()->owner()->dispatch(FuncRequest(LFUN_ENDSEL));
+ bv()->owner()->dispatch(FuncRequest(LFUN_CUT));
+ InsetOld * inset = new InsetEnvironment(params, layout);
+ if (bv()->insertInset(inset)) {
+ //inset->edit(bv());
+ //bv()->owner()->dispatch(FuncRequest(LFUN_PASTE));
+ }
+ else
+ delete inset;
+ return;
+ }
+
ParagraphList::iterator endpit = setLayout(cursor, selection.start,
selection.end, layout);
- redoParagraphs(selection.start, endpit);
+ redoParagraphs(selection.start.par(), endpit);
// we have to reset the selection, because the
// geometry could have changed
- setCursor(selection.start.par(),
- selection.start.pos(), false);
+ setCursor(selection.start.par(), selection.start.pos(), false);
selection.cursor = cursor;
setCursor(selection.end.par(), selection.end.pos(), false);
updateCounters();
bool LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type, bool test_only)
{
- ParagraphList::iterator pit(cursor.par());
- ParagraphList::iterator end(cursor.par());
+ ParagraphList::iterator pit = cursor.par();
+ ParagraphList::iterator end = cursor.par();
ParagraphList::iterator start = pit;
if (selection.set()) {
ParagraphList::iterator pastend = boost::next(end);
if (!test_only)
- setUndo(bv(), Undo::EDIT, start, pastend);
+ recordUndo(bv(), Undo::ATOMIC, start, end);
bool changed = false;
if (depth < prev_after_depth
&& pit->layout()->labeltype != LABEL_BIBLIO) {
changed = true;
- if (!test_only) {
+ if (!test_only)
pit->params().depth(depth + 1);
- }
-
}
} else if (depth) {
changed = true;
if (test_only)
return changed;
- // Wow, redoParagraphs is stupid.
- LyXCursor tmpcursor;
- setCursor(tmpcursor, &(*start), 0);
-
- //redoParagraphs(tmpcursor, &(*pastend));
- redoParagraphs(tmpcursor, &(*pastend));
+ redoParagraphs(start, pastend);
// We need to actually move the text->cursor. I don't
// understand why ...
- tmpcursor = cursor;
+ LyXCursor tmpcursor = cursor;
// we have to reset the visual selection because the
// geometry could have changed
// Determine basis font
LyXFont layoutfont;
if (cursor.pos() < cursor.par()->beginningOfBody()) {
- layoutfont = getLabelFont(bv()->buffer(),
- cursor.par());
+ layoutfont = getLabelFont(cursor.par());
} else {
- layoutfont = getLayoutFont(bv()->buffer(),
- cursor.par());
+ layoutfont = getLayoutFont(cursor.par());
}
// Update current font
real_current_font.update(font,
// ok we have a selection. This is always between sel_start_cursor
// and sel_end cursor
- setUndo(bv(), Undo::EDIT,
- selection.start.par(), boost::next(selection.end.par()));
+ recordUndo(bv(), Undo::ATOMIC, selection.start.par(), selection.end.par());
freezeUndo();
cursor = selection.start;
while (cursor.par() != selection.end.par() ||
}
unFreezeUndo();
- redoParagraphs(selection.start, boost::next(selection.end.par()));
+ redoParagraph(selection.start.par());
// we have to reset the selection, because the
// geometry could have changed, but we keep
}
-void LyXText::redoHeightOfParagraph()
+// rebreaks all paragraphs between the specified pars
+// This function is needed after SetLayout and SetFont etc.
+void LyXText::redoParagraphs(ParagraphList::iterator start,
+ ParagraphList::iterator end)
{
- RowList::iterator tmprow = cursor.row();
- int y = cursor.y() - tmprow->baseline();
-
- setHeightOfRow(tmprow);
-
- while (tmprow != rows().begin()
- && boost::prior(tmprow)->par() == tmprow->par()) {
- --tmprow;
- y -= tmprow->height();
- setHeightOfRow(tmprow);
- }
-
- postPaint(y);
-
- setCursor(cursor.par(), cursor.pos(), false, cursor.boundary());
+ for ( ; start != end; ++start)
+ redoParagraph(start);
}
-void LyXText::redoDrawingOfParagraph(LyXCursor const & cur)
+void LyXText::redoParagraph(ParagraphList::iterator pit)
{
- RowList::iterator tmprow = cur.row();
+ RowList::iterator rit = pit->rows.begin();
+ RowList::iterator end = pit->rows.end();
- int y = cur.y() - tmprow->baseline();
- setHeightOfRow(tmprow);
+ // remove rows of paragraph
+ for (int i = 0; rit != end; ++rit, ++i)
+ height -= rit->height();
- while (tmprow != rows().begin()
- && boost::prior(tmprow)->par() == tmprow->par()) {
- --tmprow;
- y -= tmprow->height();
- }
+ pit->rows.clear();
- postPaint(y);
- setCursor(cur.par(), cur.pos());
-}
+ // rebreak the paragraph
+ // insert a new row, starting at position 0
+ pos_type z = 0;
+ pit->rows.push_back(Row(z));
+ bool done = false;
+ while (!done) {
+ z = rowBreakPoint(pit, pit->rows.back());
-// deletes and inserts again all paragaphs between the cursor
-// and the specified par
-// This function is needed after SetLayout and SetFont etc.
-void LyXText::redoParagraphs(LyXCursor const & cur,
- ParagraphList::iterator endpit)
-{
- RowList::iterator tmprit = cur.row();
- int y = cur.y() - tmprit->baseline();
-
- ParagraphList::iterator first_phys_pit;
- RowList::iterator prevrit;
- if (tmprit == rows().begin()) {
- // A trick/hack for UNDO.
- // This is needed because in an UNDO/REDO we could have
- // changed the ownerParagrah() so the paragraph inside
- // the row is NOT my really first par anymore.
- // Got it Lars ;) (Jug 20011206)
- first_phys_pit = ownerParagraphs().begin();
- prevrit = rows().end();
- } else {
- first_phys_pit = tmprit->par();
- while (tmprit != rows().begin()
- && boost::prior(tmprit)->par() == first_phys_pit)
- {
- --tmprit;
- y -= tmprit->height();
+ RowList::iterator tmprow = boost::prior(pit->rows.end());
+
+ if (z >= pit->size())
+ done = true;
+ else {
+ ++z;
+ pit->rows.push_back(Row(z));
}
- prevrit = boost::prior(tmprit);
- }
- // remove it
- while (tmprit != rows().end() && tmprit->par() != endpit) {
- RowList::iterator tmprit2 = tmprit++;
- removeRow(tmprit2);
+ tmprow->fill(fill(pit, tmprow, workWidth()));
+ setHeightOfRow(pit, tmprow);
}
- // Reinsert the paragraphs.
- ParagraphList::iterator tmppit = first_phys_pit;
+ //lyxerr << "redoParagraph: " << pit->rows.size() << " rows\n";
+}
- while (tmppit != ownerParagraphs().end()) {
- insertParagraph(tmppit, tmprit);
- while (tmprit != rows().end()
- && tmprit->par() == tmppit) {
- ++tmprit;
- }
- ++tmppit;
- if (tmppit == endpit)
- break;
- }
- if (prevrit != rows().end()) {
- setHeightOfRow(prevrit);
- const_cast<LyXText *>(this)->postPaint(y - prevrit->height());
- } else {
- setHeightOfRow(rows().begin());
- const_cast<LyXText *>(this)->postPaint(0);
- }
- if (tmprit != rows().end())
- setHeightOfRow(tmprit);
- updateCounters();
+void LyXText::fullRebreak()
+{
+ redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end());
+ redoCursor();
+ selection.cursor = cursor;
}
-void LyXText::fullRebreak()
+void LyXText::metrics(MetricsInfo & mi, Dimension & dim)
{
- if (rows().empty()) {
- init(bv());
- return;
- }
+ //lyxerr << "LyXText::metrics: width: " << mi.base.textwidth
+ // << " workWidth: " << workWidth() << endl;
+ //Assert(mi.base.textwidth);
- RowList::iterator rows_end = rows().end();
+ // rebuild row cache
+ width = 0;
+ height = 0;
- if (need_break_row != rows_end) {
- breakAgain(need_break_row);
- need_break_row = rows_end;
- return;
+ //anchor_y_ = 0;
+
+ ParagraphList::iterator pit = ownerParagraphs().begin();
+ ParagraphList::iterator end = ownerParagraphs().end();
+
+ for (; pit != end; ++pit) {
+ pit->rows.clear();
+
+ 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);
}
+
+ // final dimension
+ dim.asc = firstRow()->ascent_of_text();
+ dim.des = height - dim.asc;
+ dim.wid = std::max(mi.base.textwidth, int(width));
}
// need the selection cursor:
void LyXText::setSelection()
{
- bool const lsel = selection.set();
-
- if (!selection.set()) {
- last_sel_cursor = selection.cursor;
- selection.start = selection.cursor;
- selection.end = selection.cursor;
- }
-
- selection.set(true);
-
- // first the toggling area
- if (cursor.y() < last_sel_cursor.y()
- || (cursor.y() == last_sel_cursor.y()
- && cursor.x() < last_sel_cursor.x())) {
- toggle_end_cursor = last_sel_cursor;
- toggle_cursor = cursor;
- } else {
- toggle_end_cursor = cursor;
- toggle_cursor = last_sel_cursor;
- }
-
- last_sel_cursor = cursor;
-
- // and now the whole selection
-
- if (selection.cursor.par() == cursor.par())
- if (selection.cursor.pos() < cursor.pos()) {
- selection.end = cursor;
- selection.start = selection.cursor;
- } else {
- selection.end = selection.cursor;
- selection.start = cursor;
- }
- else if (selection.cursor.y() < cursor.y() ||
- (selection.cursor.y() == cursor.y()
- && selection.cursor.x() < cursor.x())) {
- selection.end = cursor;
- selection.start = selection.cursor;
- }
- else {
- selection.end = selection.cursor;
- selection.start = cursor;
- }
-
- // a selection with no contents is not a selection
- if (selection.start.par() == selection.end.par() &&
- selection.start.pos() == selection.end.pos())
- selection.set(false);
-
- if (inset_owner && (selection.set() || lsel))
- inset_owner->setUpdateStatus(bv(), InsetText::SELECTION);
+ TextCursor::setSelection();
}
-string const LyXText::selectionAsString(Buffer const * buffer,
- bool label) const
-{
- if (!selection.set()) return string();
-
- // should be const ...
- ParagraphList::iterator startpit = selection.start.par();
- ParagraphList::iterator endpit = selection.end.par();
- pos_type const startpos(selection.start.pos());
- pos_type const endpos(selection.end.pos());
-
- if (startpit == endpit) {
- return startpit->asString(buffer, startpos, endpos, label);
- }
-
- string result;
-
- // First paragraph in selection
- result += startpit->asString(buffer, startpos, startpit->size(), label) + "\n\n";
-
- // The paragraphs in between (if any)
- ParagraphList::iterator pit = boost::next(startpit);
- for (; pit != endpit; ++pit) {
- result += pit->asString(buffer, 0, pit->size(), label) + "\n\n";
- }
-
- // Last paragraph in selection
- result += endpit->asString(buffer, 0, endpos, label);
-
- return result;
-}
-
void LyXText::clearSelection()
{
- selection.set(false);
- selection.mark(false);
- last_sel_cursor = selection.end = selection.start = selection.cursor = cursor;
+ TextCursor::clearSelection();
+
// reset this in the bv_owner!
if (bv_owner && bv_owner->text)
bv_owner->text->xsel_cache.set(false);
void LyXText::cursorHome()
{
- setCursor(cursor.par(), cursor.row()->pos());
+ setCursor(cursor.par(), cursorRow()->pos());
}
if (cursor.par()->empty())
return;
- RowList::iterator rit = cursor.row();
+ RowList::iterator rit = cursorRow();
RowList::iterator next_rit = boost::next(rit);
- ParagraphList::iterator pit = rit->par();
- pos_type last_pos = lastPos(*this, rit);
+ RowList::iterator end = boost::next(rit);
+ ParagraphList::iterator pit = cursor.par();
+ pos_type last_pos = lastPos(*pit, rit);
- if (next_rit == rows().end() || next_rit->par() != pit) {
+ if (next_rit == end) {
++last_pos;
} else {
if (pit->empty() ||
void LyXText::cursorBottom()
{
-#warning FIXME
- // This is how it should be:
- // ParagraphList::iterator lastpit = boost::prior(ownerParagraphs().end());
- ParagraphList::iterator lastpit = &ownerParagraphs().back();
- int pos = lastpit->size();
- setCursor(lastpit, pos);
+ ParagraphList::iterator lastpit =
+ boost::prior(ownerParagraphs().end());
+ setCursor(lastpit, lastpit->size());
}
LyXCursor resetCursor = cursor;
bool implicitSelection = (font.language() == ignore_language
&& font.number() == LyXFont::IGNORE)
- ? selectWordWhenUnderCursor(WHOLE_WORD_STRICT) : false;
+ ? selectWordWhenUnderCursor(lyx::WHOLE_WORD_STRICT) : false;
// Set font
setFont(font, toggleall);
setCursor(cursor.par(), cursor.pos());
selection.cursor = cursor;
}
- if (inset_owner)
- inset_owner->setUpdateStatus(bv(), InsetText::CURSOR_PAR);
}
// If there is a change in the language the implicit word selection
// is disabled.
LyXCursor const reset_cursor = cursor;
- bool const implicitSelection = selectWordWhenUnderCursor(PREVIOUS_WORD);
+ bool const implicitSelection =
+ selectWordWhenUnderCursor(lyx::PREVIOUS_WORD);
string idxstring;
if (!selection.set())
// the DTP switches for paragraphs. LyX will store them in the first
-// physicla paragraph. When a paragraph is broken, the top settings rest,
-// the bottom settings are given to the new one. So I can make shure,
+// 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
// them!
++endpit;
undoendpit = endpit;
}
- } else if (endpit!= pars_end) {
+ } else if (endpit != pars_end) {
// because of parindents etc.
++endpit;
}
- setUndo(bv(), Undo::EDIT, selection.start.par(), undoendpit);
+ recordUndo(bv(), Undo::ATOMIC, selection.start.par(),
+ boost::prior(undoendpit));
ParagraphList::iterator tmppit = selection.end.par();
while (tmppit != boost::prior(selection.start.par())) {
setCursor(tmppit, 0);
- postPaint(cursor.y() - cursor.row()->baseline());
ParagraphList::iterator pit = cursor.par();
ParagraphParameters & params = pit->params();
tmppit = boost::prior(pit);
}
- redoParagraphs(selection.start, endpit);
+ redoParagraphs(selection.start.par(), endpit);
clearSelection();
setCursor(selection.start.par(), selection.start.pos());
setSelection();
setCursor(tmpcursor.par(), tmpcursor.pos());
if (inset_owner)
- bv()->updateInset(inset_owner);
+ bv()->updateInset();
}
pit->itemdepth = 0;
}
- /* Maybe we have to increment the enumeration depth.
- * BUT, enumeration in a footnote is considered in isolation from its
- * surrounding paragraph so don't increment if this is the
- * first line of the footnote
- * AND, bibliographies can't have their depth changed ie. they
- * are always of depth 0
- */
+ // Maybe we have to increment the enumeration depth.
+ // BUT, enumeration in a footnote is considered in isolation from its
+ // surrounding paragraph so don't increment if this is the
+ // first line of the footnote
+ // AND, bibliographies can't have their depth changed ie. they
+ // are always of depth 0
if (pit != ownerParagraphs().begin()
&& boost::prior(pit)->getDepth() < pit->getDepth()
&& boost::prior(pit)->layout()->labeltype == LABEL_COUNTER_ENUMI
}
if (layout->margintype == MARGIN_MANUAL) {
- if (pit->params().labelWidthString().empty()) {
+ if (pit->params().labelWidthString().empty())
pit->setLabelWidthString(layout->labelstring());
- }
} else {
pit->setLabelWidthString(string());
}
// the caption hack:
if (layout->labeltype == LABEL_SENSITIVE) {
+ ParagraphList::iterator end = ownerParagraphs().end();
ParagraphList::iterator tmppit = pit;
- Inset * in = 0;
+ InsetOld * in = 0;
bool isOK = false;
- while (tmppit != ownerParagraphs().end() &&
- tmppit->inInset()
+ while (tmppit != end && tmppit->inInset()
// the single '=' is intended below
- && (in = tmppit->inInset()->owner())) {
- if (in->lyxCode() == Inset::FLOAT_CODE ||
- in->lyxCode() == Inset::WRAP_CODE) {
+ && (in = tmppit->inInset()->owner()))
+ {
+ if (in->lyxCode() == InsetOld::FLOAT_CODE ||
+ in->lyxCode() == InsetOld::WRAP_CODE) {
isOK = true;
break;
} else {
- tmppit = in->parOwner();
+ tmppit = ownerParagraphs().begin();
+ for ( ; tmppit != end; ++tmppit)
+ if (&*tmppit == in->parOwner())
+ break;
}
}
if (isOK) {
- Floating const & fl
- = textclass.floats().getType(static_cast<InsetFloat*>(in)->type());
+ string type;
+
+ if (in->lyxCode() == InsetOld::FLOAT_CODE)
+ type = static_cast<InsetFloat*>(in)->params().type;
+ else if (in->lyxCode() == InsetOld::WRAP_CODE)
+ type = static_cast<InsetWrap*>(in)->params().type;
+ else
+ Assert(0);
+
+ Floating const & fl = textclass.floats().getType(type);
textclass.counters().step(fl.type());
// Doesn't work... yet.
-#if USE_BOOST_FORMAT
- s = boost::io::str(boost::format(_("%1$s #:")) % buf->B_(fl.name()));
- // s << boost::format(_("%1$s %1$d:")
- // % fl.name()
- // % buf->counters().value(fl.name());
-#else
- ostringstream o;
- //o << fl.name() << ' ' << buf->counters().value(fl.name()) << ":";
- o << buf->B_(fl.name()) << " #:";
- s = STRCONV(o.str());
-#endif
+ s = bformat(_("%1$s #:"), buf->B_(fl.name()));
} else {
// par->SetLayout(0);
// s = layout->labelstring;
// Updates all counters. Paragraphs with changed label string will be rebroken
void LyXText::updateCounters()
{
- RowList::iterator rowit = rows().begin();
- ParagraphList::iterator pit = rowit->par();
-
- // CHECK if this is really needed. (Lgb)
+ // start over
bv()->buffer()->params.getLyXTextClass().counters().reset();
- for (; pit != ownerParagraphs().end(); ++pit) {
- while (rowit->par() != pit)
- ++rowit;
-
+ ParagraphList::iterator beg = ownerParagraphs().begin();
+ ParagraphList::iterator end = ownerParagraphs().end();
+ for (ParagraphList::iterator pit = beg; pit != end; ++pit) {
string const oldLabel = pit->params().labelString();
- int maxdepth = 0;
- if (pit != ownerParagraphs().begin())
+ size_t maxdepth = 0;
+ if (pit != beg)
maxdepth = boost::prior(pit)->getMaxDepthAfter();
if (pit->params().depth() > maxdepth)
string const & newLabel = pit->params().labelString();
- if (oldLabel.empty() && !newLabel.empty()) {
- removeParagraph(rowit);
- appendParagraph(rowit);
- }
+ if (oldLabel != newLabel)
+ redoParagraph(pit);
}
}
-void LyXText::insertInset(Inset * inset)
+void LyXText::insertInset(InsetOld * inset)
{
if (!cursor.par()->insetAllowed(inset->lyxCode()))
return;
- setUndo(bv(), Undo::FINISH, cursor.par(),
- boost::next(cursor.par()));
+ recordUndo(bv(), Undo::ATOMIC, cursor.par());
freezeUndo();
cursor.par()->insertInset(cursor.pos(), inset);
// Just to rebreak and refresh correctly.
// The character will not be inserted a second time
insertChar(Paragraph::META_INSET);
- // If we enter a highly editable inset the cursor should be to before
- // the inset. This couldn't happen before as Undo was not handled inside
- // inset now after the Undo LyX tries to call inset->Edit(...) again
- // and cannot do this as the cursor is behind the inset and GetInset
+ // If we enter a highly editable inset the cursor should be before
+ // 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)) {
+ if (isHighlyEditableInset(inset))
cursorLeft(true);
- }
unFreezeUndo();
}
++endpit;
}
- setUndo(bv(), Undo::DELETE, selection.start.par(), undoendpit);
-
+ recordUndo(bv(), Undo::DELETE, selection.start.par(),
+ boost::prior(undoendpit));
endpit = selection.end.par();
int endpos = selection.end.pos();
- boost::tie(endpit, endpos) = realcut ?
- CutAndPaste::cutSelection(ownerParagraphs(),
+ boost::tie(endpit, endpos) = realcut ?
+ CutAndPaste::cutSelection(bv()->buffer()->params,
+ ownerParagraphs(),
selection.start.par(), endpit,
selection.start.pos(), endpos,
bv()->buffer()->params.textclass,
doclear)
- : CutAndPaste::eraseSelection(ownerParagraphs(),
+ : CutAndPaste::eraseSelection(bv()->buffer()->params,
+ ownerParagraphs(),
selection.start.par(), endpit,
selection.start.pos(), endpos,
doclear);
if (doclear)
selection.start.par()->stripLeadingSpaces();
- redoParagraphs(selection.start, boost::next(endpit));
-#warning FIXME latent bug
- // endpit will be invalidated on redoParagraphs once ParagraphList
- // becomes a std::list? There are maybe other places on which this
- // can happend? (Ab)
+ redoParagraphs(selection.start.par(), boost::next(endpit));
// cutSelection can invalidate the cursor so we need to set
// it anew. (Lgb)
// we prefer the end for when tracking changes
|| selection.start.pos() < selection.end.pos()))
selection.start.pos(selection.start.pos() + 1);
- CutAndPaste::copySelection(&*selection.start.par(),
- &*selection.end.par(),
+ CutAndPaste::copySelection(selection.start.par(),
+ selection.end.par(),
selection.start.pos(), selection.end.pos(),
bv()->buffer()->params.textclass);
}
-void LyXText::pasteSelection()
+void LyXText::pasteSelection(size_t sel_index)
{
// this does not make sense, if there is nothing to paste
if (!CutAndPaste::checkPastePossible())
return;
- setUndo(bv(), Undo::INSERT,
- cursor.par(), boost::next(cursor.par()));
+ recordUndo(bv(), Undo::INSERT, cursor.par());
+
+ ParagraphList::iterator endpit;
+ PitPosPair ppp;
- Paragraph * endpar;
- ParagraphList::iterator actpit = cursor.par();
- int pos = cursor.pos();
+ ErrorList el;
- Paragraph * actpar = &*actpit;
- CutAndPaste::pasteSelection(&actpar, &endpar, pos,
- bv()->buffer()->params.textclass);
+ boost::tie(ppp, endpit) =
+ CutAndPaste::pasteSelection(*bv()->buffer(),
+ ownerParagraphs(),
+ cursor.par(), cursor.pos(),
+ bv()->buffer()->params.textclass,
+ sel_index, el);
+ bufferErrors(*bv()->buffer(), el);
+ bv()->showErrorList(_("Paste"));
- redoParagraphs(cursor, endpar);
+ redoParagraphs(cursor.par(), endpit);
setCursor(cursor.par(), cursor.pos());
clearSelection();
selection.cursor = cursor;
- setCursor(actpit, pos);
+ setCursor(ppp.first, ppp.second);
setSelection();
updateCounters();
}
// simple replacing. The font of the first selected character is used
void LyXText::replaceSelectionWithString(string const & str)
{
- setCursorParUndo(bv());
+ recordUndo(bv(), Undo::ATOMIC);
freezeUndo();
if (!selection.set()) { // create a dummy selection
selection.start.pos());
// Insert the new string
- for (string::const_iterator cit = str.begin(); cit != str.end(); ++cit) {
+ string::const_iterator cit = str.begin();
+ string::const_iterator end = str.end();
+ for (; cit != end; ++cit) {
selection.end.par()->insertChar(pos, (*cit), font);
++pos;
}
pos_type pos = cursor.pos();
ParagraphList::iterator endpit = boost::next(cursor.par());
- setCursorParUndo(bv());
+ recordUndo(bv(), Undo::ATOMIC);
// only to be sure, should not be neccessary
clearSelection();
bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
- redoParagraphs(cursor, endpit);
+ redoParagraphs(cursor.par(), endpit);
setCursor(cursor.par(), cursor.pos());
selection.cursor = cursor;
setCursor(pit, pos);
{
string linestr(str);
bool newline_inserted = false;
- for (string::size_type i = 0; i < linestr.length(); ++i) {
+ string::size_type const siz = linestr.length();
+
+ for (string::size_type i = 0; i < siz; ++i) {
if (linestr[i] == '\n') {
if (newline_inserted) {
// we know that \r will be ignored by
}
-void LyXText::checkParagraph(ParagraphList::iterator pit, pos_type pos)
-{
- LyXCursor tmpcursor;
-
- int y = 0;
- pos_type z;
- RowList::iterator row = getRow(pit, pos, y);
- RowList::iterator beg = rows().begin();
-
- // is there a break one row above
- if (row != beg
- && boost::prior(row)->par() == row->par()) {
- z = rowBreakPoint(*boost::prior(row));
- if (z >= row->pos()) {
- // set the dimensions of the row above
- y -= boost::prior(row)->height();
- postPaint(y);
-
- breakAgain(boost::prior(row));
-
- // set the cursor again. Otherwise
- // dangling pointers are possible
- setCursor(cursor.par(), cursor.pos(),
- false, cursor.boundary());
- selection.cursor = cursor;
- return;
- }
- }
-
- int const tmpheight = row->height();
- pos_type const tmplast = lastPos(*this, row);
-
- breakAgain(row);
- if (row->height() == tmpheight && lastPos(*this, row) == tmplast) {
- postRowPaint(row, y);
- } else {
- postPaint(y);
- }
-
- // check the special right address boxes
- if (pit->layout()->margintype == MARGIN_RIGHT_ADDRESS_BOX) {
- tmpcursor.par(pit);
- tmpcursor.row(row);
- tmpcursor.y(y);
- tmpcursor.x(0);
- tmpcursor.x_fix(0);
- tmpcursor.pos(pos);
- redoDrawingOfParagraph(tmpcursor);
- }
-
- // set the cursor again. Otherwise dangling pointers are possible
- // also set the selection
-
- if (selection.set()) {
- tmpcursor = cursor;
- setCursorIntern(selection.cursor.par(), selection.cursor.pos(),
- false, selection.cursor.boundary());
- selection.cursor = cursor;
- setCursorIntern(selection.start.par(),
- selection.start.pos(),
- false, selection.start.boundary());
- selection.start = cursor;
- setCursorIntern(selection.end.par(),
- selection.end.pos(),
- false, selection.end.boundary());
- selection.end = cursor;
- setCursorIntern(last_sel_cursor.par(),
- last_sel_cursor.pos(),
- false, last_sel_cursor.boundary());
- last_sel_cursor = cursor;
- cursor = tmpcursor;
- }
- setCursorIntern(cursor.par(), cursor.pos(),
- false, cursor.boundary());
-}
-
-
-// returns false if inset wasn't found
-bool LyXText::updateInset(Inset * inset)
-{
- // first check the current paragraph
- int pos = cursor.par()->getPositionOfInset(inset);
- if (pos != -1) {
- checkParagraph(cursor.par(), pos);
- return true;
- }
-
- // check every paragraph
-
- ParagraphList::iterator par = ownerParagraphs().begin();
- ParagraphList::iterator end = ownerParagraphs().end();
- for (; par != end; ++par) {
- pos = par->getPositionOfInset(inset);
- if (pos != -1) {
- checkParagraph(par, pos);
- return true;
- }
- };
-
- return false;
-}
-
-
bool LyXText::setCursor(ParagraphList::iterator pit,
pos_type pos,
bool setfont, bool boundary)
}
+void LyXText::redoCursor()
+{
+#warning maybe the same for selections?
+ setCursor(cursor, cursor.par(), cursor.pos(), cursor.boundary());
+}
+
+
void LyXText::setCursor(LyXCursor & cur, ParagraphList::iterator pit,
pos_type pos, bool boundary)
{
- lyx::Assert(pit != ownerParagraphs().end());
+ Assert(pit != ownerParagraphs().end());
cur.par(pit);
cur.pos(pos);
cur.boundary(boundary);
+ 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;
- cur.irow(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) {
- Inset * ins = pit->getInset(pos);
+ if (row != pit->rows.begin()
+ && pos
+ && pos < pit->size()
+ && pit->getChar(pos) == Paragraph::META_INSET) {
+ InsetOld * ins = pit->getInset(pos);
if (ins && (ins->needFullRow() || ins->display())) {
--row;
y -= row->height();
}
}
-
- cur.row(row);
+
// 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, old_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);
+ x = getCursorX(pit, old_row, pos, last, boundary);
cur.ix(int(x));
} else
cur.ix(cur.x());
}
-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;
- float x;
- float fill_separator;
- float fill_hfill;
- float fill_label_hfill;
+ 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,
+ prepareToPrint(pit, rit, x, fill_separator, fill_hfill,
fill_label_hfill);
- ParagraphList::iterator rit_par = rit->par();
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
+ // Place cursor after char at (logical) position pos - 1
cursor_vpos = (bidi_level(pos - 1) % 2 == 0)
? log2vis(pos - 1) + 1 : log2vis(pos - 1);
else
- /// Place cursor before char at (logical) position pos
+ // Place cursor before char at (logical) position pos
cursor_vpos = (bidi_level(pos) % 2 == 0)
? log2vis(pos) : log2vis(pos) + 1;
- pos_type body_pos = rit_par->beginningOfBody();
- if ((body_pos > 0) &&
- ((body_pos - 1 > last) || !rit_par->isLineSeparator(body_pos - 1)))
+ pos_type body_pos = pit->beginningOfBody();
+ if (body_pos > 0 &&
+ (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(bv()->buffer(), 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;
}
void LyXText::setCursorIntern(ParagraphList::iterator pit,
pos_type pos, bool setfont, bool boundary)
{
- InsetText * it = static_cast<InsetText *>(pit->inInset());
- if (it) {
- if (it != inset_owner) {
- lyxerr[Debug::INSETS] << "InsetText is " << it
- << endl
- << "inset_owner is "
- << inset_owner << endl;
-#ifdef WITH_WARNINGS
-#warning I believe this code is wrong. (Lgb)
-#warning Jürgen, have a look at this. (Lgb)
-#warning Hmmm, I guess you are right but we
-#warning should verify when this is needed
-#endif
- // Jürgen, would you like to have a look?
- // I guess we need to move the outer cursor
- // and open and lock the inset (bla bla bla)
- // stuff I don't know... so can you have a look?
- // (Lgb)
- // I moved the lyxerr stuff in here so we can see if
- // this is actually really needed and where!
- // (Jug)
- // it->getLyXText(bv())->setCursorIntern(bv(), par, pos, setfont, boundary);
- return;
- }
- }
-
setCursor(cursor, pit, pos, boundary);
if (setfont)
setCurrentFont();
--pos;
else // potentional bug... BUG (Lgb)
if (pit->isSeparator(pos)) {
- if (pos > cursor.row()->pos() &&
+ if (pos > cursorRow()->pos() &&
bidi_level(pos) % 2 ==
bidi_level(pos - 1) % 2)
--pos;
}
}
- current_font =
- pit->getFontSettings(bv()->buffer()->params, pos);
- real_current_font = getFont(bv()->buffer(), pit, pos);
+ current_font = pit->getFontSettings(bv()->buffer()->params, pos);
+ real_current_font = getFont(pit, pos);
if (cursor.pos() == pit->size() &&
isBoundary(bv()->buffer(), *pit, cursor.pos()) &&
// 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
{
- float tmpx = 0.0;
- float fill_separator;
- float fill_hfill;
- float fill_label_hfill;
+ double tmpx = 0;
+ double fill_separator;
+ double fill_hfill;
+ double fill_label_hfill;
- prepareToPrint(rit, tmpx, fill_separator,
- fill_hfill, fill_label_hfill);
+ prepareToPrint(pit, rit, tmpx, fill_separator, fill_hfill, 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();
- float last_tmpx = tmpx;
+ 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(bv()->buffer(), &*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;
+ 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
- bool const lastrow = lyxrc.rtl_support &&
- (boost::next(rit) == rowlist_.end() ||
- boost::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;
-
setCursorFromCoordinates(cursor, x, y);
setCurrentFont();
deleteEmptyParagraphMechanism(old_cursor);
* and the next row is filled by an inset that spans an entire
* row.
*/
- bool beforeFullRowInset(LyXText & lt, LyXCursor const & cur) {
- RowList::iterator row = cur.row();
- if (boost::next(row) == lt.rows().end())
- return false;
- Row const & next = *boost::next(row);
+ bool beforeFullRowInset(LyXText & lt, LyXCursor const & cur)
+ {
+ RowList::iterator row = lt.getRow(cur);
+ RowList::iterator next = boost::next(row);
- if (next.pos() != cur.pos() || next.par() != cur.par())
+ if (next == cur.par()->rows.end() || next->pos() != cur.pos())
return false;
- if (cur.pos() == cur.par()->size()
- || !cur.par()->isInset(cur.pos()))
+ if (cur.pos() == cur.par()->size() || !cur.par()->isInset(cur.pos()))
return false;
- Inset const * inset = cur.par()->getInset(cur.pos());
+
+ InsetOld const * inset = cur.par()->getInset(cur.pos());
if (inset->needFullRow() || inset->display())
return true;
+
return false;
}
}
void LyXText::setCursorFromCoordinates(LyXCursor & cur, int x, int y)
{
// Get the row first.
-
- RowList::iterator row = getRowNearY(y);
+ ParagraphList::iterator pit;
+ RowList::iterator row = getRowNearY(y, pit);
bool bound = false;
- pos_type const column = getColumnNearX(row, x, bound);
- cur.par(row->par());
+ pos_type const column = getColumnNearX(pit, row, x, bound);
+ cur.par(pit);
cur.pos(row->pos() + column);
cur.x(x);
cur.y(y + row->baseline());
- cur.row(row);
- if (beforeFullRowInset(*this, cur)) {
- pos_type last = lastPrintablePos(*this, row);
- float x = getCursorX(boost::next(row), cur.pos(), last, bound);
- cur.ix(int(x));
- cur.iy(y + row->height() + boost::next(row)->baseline());
- cur.irow(boost::next(row));
- } else {
+// if (beforeFullRowInset(*this, cur)) {
+// pos_type const last = lastPrintablePos(*this, pit, row);
+// RowList::iterator next_row = nextRow(row);
+// cur.ix(int(getCursorX(pit, next_row, cur.pos(), last, bound)));
+// cur.iy(y + row->height() + next_row->baseline());
+// } else {
cur.iy(cur.y());
cur.ix(cur.x());
- cur.irow(row);
- }
+// }
cur.boundary(bound);
}
if (!internal && !boundary &&
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 above paragraph.
+ } else if (cursor.par() != ownerParagraphs().begin()) {
+ // steps into the paragraph above
ParagraphList::iterator pit = boost::prior(cursor.par());
setCursor(pit, pit->size());
}
{
#if 1
int x = cursor.x_fix();
- int y = cursor.y() - cursor.row()->baseline() - 1;
+ int y = cursor.y() - cursorRow()->baseline() - 1;
setCursorFromCoordinates(x, y);
if (!selecting) {
int topy = top_y();
int y1 = cursor.iy() - topy;
int y2 = y1;
y -= topy;
- Inset * inset_hit = checkInsetHit(x, y1);
+ InsetOld * inset_hit = checkInsetHit(x, y1);
if (inset_hit && isHighlyEditableInset(inset_hit)) {
- inset_hit->edit(bv(), x, y - (y2 - y1), mouse_button::none);
+ inset_hit->localDispatch(
+ FuncRequest(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none));
}
}
#else
- setCursorFromCoordinates(bv(), cursor.x_fix(),
- cursor.y() - cursor.row()->baseline() - 1);
+ lyxerr << "cursorUp: y " << cursor.y() << " bl: " <<
+ cursorRow()->baseline() << endl;
+ setCursorFromCoordinates(cursor.x_fix(),
+ cursor.y() - cursorRow()->baseline() - 1);
#endif
}
{
#if 1
int x = cursor.x_fix();
- int y = cursor.y() - cursor.row()->baseline() +
- cursor.row()->height() + 1;
+ int y = cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1;
setCursorFromCoordinates(x, y);
- if (!selecting && cursor.row() == cursor.irow()) {
+ if (!selecting && cursorRow() == cursorIRow()) {
int topy = top_y();
int y1 = cursor.iy() - topy;
int y2 = y1;
y -= topy;
- Inset * inset_hit = checkInsetHit(x, y1);
+ InsetOld * inset_hit = checkInsetHit(x, y1);
if (inset_hit && isHighlyEditableInset(inset_hit)) {
- inset_hit->edit(bv(), x, y - (y2 - y1), mouse_button::none);
+ FuncRequest cmd(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none);
+ inset_hit->localDispatch(cmd);
}
}
#else
- setCursorFromCoordinates(bv(), cursor.x_fix(),
- cursor.y() - cursor.row()->baseline()
- + cursor.row()->height() + 1);
+ setCursorFromCoordinates(cursor.x_fix(),
+ cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1);
#endif
}
void LyXText::cursorUpParagraph()
{
- if (cursor.pos() > 0) {
+ if (cursor.pos() > 0)
setCursor(cursor.par(), 0);
- }
- else if (cursor.par() != ownerParagraphs().begin()) {
+ else if (cursor.par() != ownerParagraphs().begin())
setCursor(boost::prior(cursor.par()), 0);
- }
}
void LyXText::cursorDownParagraph()
{
- if (boost::next(cursor.par()) != ownerParagraphs().end()) {
- setCursor(boost::next(cursor.par()), 0);
- } else {
- setCursor(cursor.par(), cursor.par()->size());
- }
+ ParagraphList::iterator par = cursor.par();
+ ParagraphList::iterator next_par = boost::next(par);
+
+ if (next_par != ownerParagraphs().end())
+ setCursor(next_par, 0);
+ else
+ setCursor(par, par->size());
}
+
// fix the cursor `cur' after a characters has been deleted at `where'
// position. Called by deleteEmptyParagraphMechanism
-void LyXText::fixCursorAfterDelete(LyXCursor & cur,
- LyXCursor const & where)
+void LyXText::fixCursorAfterDelete(LyXCursor & cur, LyXCursor const & where)
{
// if cursor is not in the paragraph where the delete occured,
// do nothing
return false;
// We allow all kinds of "mumbo-jumbo" when freespacing.
- if (old_cursor.par()->layout()->free_spacing
- || old_cursor.par()->isFreeSpacing()) {
+ if (old_cursor.par()->isFreeSpacing())
return false;
- }
/* Ok I'll put some comments here about what is missing.
I have fixed BackSpace (and thus Delete) to not delete
// If the pos around the old_cursor were spaces, delete one of them.
if (old_cursor.par() != cursor.par()
|| old_cursor.pos() != cursor.pos()) {
- // Only if the cursor has really moved
+ // Only if the cursor has really moved
if (old_cursor.pos() > 0
&& old_cursor.pos() < old_cursor.par()->size()
&& old_cursor.par()->isLineSeparator(old_cursor.pos())
&& old_cursor.par()->isLineSeparator(old_cursor.pos() - 1)) {
- old_cursor.par()->erase(old_cursor.pos() - 1);
- redoParagraphs(old_cursor, boost::next(old_cursor.par()));
+ bool erased = old_cursor.par()->erase(old_cursor.pos() - 1);
+ redoParagraph(old_cursor.par());
+ if (!erased)
+ return false;
#ifdef WITH_WARNINGS
#warning This will not work anymore when we have multiple views of the same buffer
// In this case, we will have to correct also the cursors held by
#endif
// correct all cursors held by the LyXText
fixCursorAfterDelete(cursor, old_cursor);
- fixCursorAfterDelete(selection.cursor,
- old_cursor);
- fixCursorAfterDelete(selection.start,
- old_cursor);
+ fixCursorAfterDelete(selection.cursor, old_cursor);
+ fixCursorAfterDelete(selection.start, old_cursor);
fixCursorAfterDelete(selection.end, old_cursor);
- fixCursorAfterDelete(last_sel_cursor,
- old_cursor);
- fixCursorAfterDelete(toggle_cursor, old_cursor);
- fixCursorAfterDelete(toggle_end_cursor,
- old_cursor);
return false;
}
}
return false;
// Do not delete empty paragraphs with keepempty set.
- if (old_cursor.par()->layout()->keepempty)
+ if (old_cursor.par()->allowEmpty())
return false;
// only do our magic if we changed paragraph
selection.cursor.par() == old_cursor.par()
&& selection.cursor.pos() == old_cursor.pos());
- if (old_cursor.row() != rows().begin()) {
- RowList::iterator
- prevrow = boost::prior(old_cursor.row());
- const_cast<LyXText *>(this)->postPaint(old_cursor.y() - old_cursor.row()->baseline() - prevrow->height());
- 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
- setUndo(bv(), Undo::DELETE, old_cursor.par(), endpit);
- cursor = tmpcursor;
-
- // delete old row
- removeRow(old_cursor.row());
- // 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 (boost::next(prevrow) != rows().end()) {
- breakAgain(boost::next(prevrow));
- updateCounters();
- }
- setHeightOfRow(prevrow);
- } else {
- RowList::iterator nextrow = boost::next(old_cursor.row());
- const_cast<LyXText *>(this)->postPaint(
- old_cursor.y() - old_cursor.row()->baseline());
-
- 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;
- setUndo(bv(), Undo::DELETE, old_cursor.par(), endpit);
- cursor = tmpcursor;
-
- // delete old row
- removeRow(old_cursor.row());
- // 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()) {
- breakAgain(nextrow);
- updateCounters();
- }
- }
+ // delete old par
+ ownerParagraphs().erase(old_cursor.par());
+ redoParagraph();
// correct cursor y
setCursorIntern(cursor.par(), cursor.pos());
}
if (!deleted) {
if (old_cursor.par()->stripLeadingSpaces()) {
- redoParagraphs(old_cursor, boost::next(old_cursor.par()));
+ redoParagraph(old_cursor.par());
// correct cursor y
setCursorIntern(cursor.par(), cursor.pos());
selection.cursor = cursor;
ParagraphList & LyXText::ownerParagraphs() const
{
- if (inset_owner) {
- return inset_owner->paragraphs;
- }
- return bv_owner->buffer()->paragraphs;
-}
-
-
-LyXText::refresh_status LyXText::refreshStatus() const
-{
- return refresh_status_;
-}
-
-
-void LyXText::clearPaint()
-{
- refresh_status_ = REFRESH_NONE;
- refresh_row = rows().end();
- refresh_y = 0;
-}
-
-
-void LyXText::postPaint(int start_y)
-{
- refresh_status old = refresh_status_;
-
- refresh_status_ = REFRESH_AREA;
- refresh_row = rows().end();
-
- if (old != REFRESH_NONE && refresh_y < start_y)
- return;
-
- refresh_y = start_y;
-
- if (!inset_owner)
- return;
-
- // We are an inset's lyxtext. Tell the top-level lyxtext
- // it needs to update the row we're in.
- LyXText * t = bv()->text;
- t->postRowPaint(t->cursor.row(), t->cursor.y() - t->cursor.row()->baseline());
-}
-
-
-// FIXME: we should probably remove this y parameter,
-// make refresh_y be 0, and use row->y etc.
-void LyXText::postRowPaint(RowList::iterator rit, int start_y)
-{
- if (refresh_status_ != REFRESH_NONE && refresh_y < start_y) {
- refresh_status_ = REFRESH_AREA;
- return;
- } else {
- refresh_y = start_y;
- }
-
- if (refresh_status_ == REFRESH_AREA)
- return;
-
- refresh_status_ = REFRESH_ROW;
- refresh_row = rit;
-
- if (!inset_owner)
- return;
-
- // We are an inset's lyxtext. Tell the top-level lyxtext
- // it needs to update the row we're in.
- LyXText * t = bv()->text;
- t->postRowPaint(t->cursor.row(), t->cursor.y() - t->cursor.row()->baseline());
+ 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;
+ // Sub-level has non-null bv owner and non-null inset owner.
+ return inset_owner != 0;
}