-/* 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>
-#ifdef __GNUG__
-#pragma implementation "lyxtext.h"
-#endif
-
#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/inseterror.h"
-#include "insets/insetbib.h"
-#include "insets/insetspecialchar.h"
-#include "insets/insettext.h"
+#include "insets/insetbibitem.h"
+#include "insets/insetenv.h"
#include "insets/insetfloat.h"
#include "insets/insetwrap.h"
#include "support/textutils.h"
#include "support/lstrings.h"
-#include <boost/format.hpp>
+#include <boost/tuple/tuple.hpp>
+
+#include <algorithm>
+
+using namespace lyx::support;
using std::vector;
using std::copy;
using lyx::pos_type;
-LyXText::LyXText(BufferView * bv)
- : height(0), width(0), first_y(0),
- bv_owner(bv), inset_owner(0), the_locking_inset(0),
- need_break_row(0), refresh_y(0), refresh_row(0),
- status_(LyXText::UNCHANGED), firstrow(0), lastrow(0)
-{}
-
-
-LyXText::LyXText(InsetText * inset)
- : height(0), width(0), first_y(0),
- bv_owner(0), inset_owner(inset), the_locking_inset(0),
- need_break_row(0), refresh_y(0), refresh_row(0),
- status_(LyXText::UNCHANGED), firstrow(0), lastrow(0)
-{}
-
-
-void LyXText::init(BufferView * bview, bool reinit)
+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)
{
- if (reinit) {
- // Delete all rows, this does not touch the paragraphs!
- Row * tmprow = firstrow;
- while (firstrow) {
- tmprow = firstrow->next();
- delete firstrow;
- firstrow = tmprow;
- }
-
- lastrow = 0;
- refresh_row = 0;
- need_break_row = 0;
- width = height = 0;
- copylayouttype.erase();
- first_y = refresh_y = 0;
- status_ = LyXText::UNCHANGED;
- } else if (firstrow)
- return;
-
- Paragraph * par = ownerParagraph();
- current_font = getFont(bview->buffer(), par, 0);
-
- while (par) {
- insertParagraph(bview, par, lastrow);
- par = par->next();
- }
- setCursorIntern(bview, firstrow->par(), 0);
- selection.cursor = cursor;
-
- updateCounters(bview);
}
-LyXText::~LyXText()
+void LyXText::init(BufferView * bview)
{
- // Delete all rows, this does not touch the paragraphs!
- Row * tmprow = firstrow;
- while (firstrow) {
- tmprow = firstrow->next();
- delete firstrow;
- firstrow = tmprow;
- }
-}
+ bv_owner = bview;
+ ParagraphList::iterator const beg = ownerParagraphs().begin();
+ ParagraphList::iterator const end = ownerParagraphs().end();
+ for (ParagraphList::iterator pit = beg; pit != end; ++pit)
+ pit->rows.clear();
-namespace {
+ width = 0;
+ height = 0;
-LyXFont const realizeFont(LyXFont const & font,
- Buffer const * buf,
- Paragraph * par)
-{
- LyXTextClass const & tclass = buf->params.getLyXTextClass();
- LyXFont tmpfont(font);
- Paragraph::depth_type par_depth = par->getDepth();
-
- // Resolve against environment font information
- while (par && par_depth && !tmpfont.resolved()) {
- par = par->outerHook();
- if (par) {
- tmpfont.realize(par->layout()->font);
- par_depth = par->getDepth();
- }
- }
+ anchor_y_ = 0;
- tmpfont.realize(tclass.defaultfont());
+ current_font = getFont(beg, 0);
- return tmpfont;
-}
+ 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, Paragraph * par,
- 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 = par->layout();
+ LyXLayout_ptr const & layout = pit->layout();
+#warning broken?
+ BufferParams const & params = bv()->buffer()->params;
// We specialize the 95% common case:
- if (!par->getDepth()) {
+ if (!pit->getDepth()) {
if (layout->labeltype == LABEL_MANUAL
- && pos < beginningOfMainBody(buf, par)) {
+ && pos < pit->beginningOfBody()) {
// 1% goes here
- LyXFont f = par->getFontSettings(buf->params, pos);
- if (par->inInset())
- par->inInset()->getDrawFont(f);
+ LyXFont f = pit->getFontSettings(params, pos);
+ if (pit->inInset())
+ pit->inInset()->getDrawFont(f);
return f.realize(layout->reslabelfont);
} else {
- LyXFont f = par->getFontSettings(buf->params, pos);
- if (par->inInset())
- par->inInset()->getDrawFont(f);
+ LyXFont f = pit->getFontSettings(params, pos);
+ if (pit->inInset())
+ pit->inInset()->getDrawFont(f);
return f.realize(layout->resfont);
}
}
LyXFont layoutfont;
- if (pos < beginningOfMainBody(buf, par)) {
+ if (pos < pit->beginningOfBody()) {
// 1% goes here
layoutfont = layout->labelfont;
} else {
layoutfont = layout->font;
}
- LyXFont tmpfont = par->getFontSettings(buf->params, pos);
+ LyXFont tmpfont = pit->getFontSettings(params, pos);
tmpfont.realize(layoutfont);
- if (par->inInset())
- par->inInset()->getDrawFont(tmpfont);
+ if (pit->inInset())
+ pit->inInset()->getDrawFont(tmpfont);
+
+ // Realize with the fonts of lesser depth.
+ tmpfont.realize(outerFont(pit, ownerParagraphs()));
+ tmpfont.realize(defaultfont_);
- return realizeFont(tmpfont, buf, par);
+ return tmpfont;
}
-LyXFont const LyXText::getLayoutFont(Buffer const * buf, Paragraph * par) const
+LyXFont LyXText::getLayoutFont(ParagraphList::iterator pit) const
{
- LyXLayout_ptr const & layout = par->layout();
+ LyXLayout_ptr const & layout = pit->layout();
- if (!par->getDepth()) {
+ if (!pit->getDepth())
return layout->resfont;
- }
- return realizeFont(layout->font, buf, par);
+ LyXFont font = layout->font;
+ // Realize with the fonts of lesser depth.
+ font.realize(outerFont(pit, ownerParagraphs()));
+ font.realize(defaultfont_);
+
+ return font;
}
-LyXFont const LyXText::getLabelFont(Buffer const * buf, Paragraph * par) const
+LyXFont LyXText::getLabelFont(ParagraphList::iterator pit) const
{
- LyXLayout_ptr const & layout = par->layout();
+ LyXLayout_ptr const & layout = pit->layout();
- if (!par->getDepth()) {
+ if (!pit->getDepth())
return layout->reslabelfont;
- }
- return realizeFont(layout->labelfont, buf, par);
+ LyXFont font = layout->labelfont;
+ // Realize with the fonts of lesser depth.
+ font.realize(outerFont(pit, ownerParagraphs()));
+ font.realize(defaultfont_);
+
+ return font;
}
-void LyXText::setCharFont(BufferView * bv, Paragraph * par,
+void LyXText::setCharFont(ParagraphList::iterator pit,
pos_type pos, LyXFont const & fnt,
bool toggleall)
{
- Buffer const * buf = bv->buffer();
- LyXFont font = getFont(buf, par, 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 (par->isInset(pos)) {
- Inset * inset = par->getInset(pos);
+ if (pit->isInset(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, par, pos, font);
+ // Plug through to version below:
+ setCharFont(pit, pos, font);
}
-void LyXText::setCharFont(Buffer const * buf, Paragraph * par,
- 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();
- LyXLayout_ptr const & layout = par->layout();
+ LyXFont font = fnt;
+ LyXLayout_ptr const & layout = pit->layout();
// Get concrete layout font to reduce against
LyXFont layoutfont;
- if (pos < beginningOfMainBody(buf, par))
+ if (pos < pit->beginningOfBody())
layoutfont = layout->labelfont;
else
layoutfont = layout->font;
// Realize against environment font information
- if (par->getDepth()) {
- Paragraph * tp = par;
- while (!layoutfont.resolved() && tp && tp->getDepth()) {
- tp = tp->outerHook();
- if (tp)
+ if (pit->getDepth()) {
+ ParagraphList::iterator tp = pit;
+ while (!layoutfont.resolved() &&
+ tp != ownerParagraphs().end() &&
+ tp->getDepth()) {
+ tp = outerHook(tp, ownerParagraphs());
+ if (tp != ownerParagraphs().end())
layoutfont.realize(tp->layout()->font);
}
}
- layoutfont.realize(tclass.defaultfont());
+ layoutfont.realize(defaultfont_);
// Now, reduce font against full layout font
font.reduce(layoutfont);
- par->setFont(pos, font);
-}
-
-
-// inserts a new row behind the specified row, increments
-// the touched counters
-void LyXText::insertRow(Row * row, Paragraph * par,
- pos_type pos) const
-{
- Row * tmprow = new Row;
- if (!row) {
- tmprow->previous(0);
- tmprow->next(firstrow);
- firstrow = tmprow;
- } else {
- tmprow->previous(row);
- tmprow->next(row->next());
- row->next(tmprow);
- }
-
- if (tmprow->next())
- tmprow->next()->previous(tmprow);
-
- if (tmprow->previous())
- tmprow->previous()->next(tmprow);
-
-
- tmprow->par(par);
- tmprow->pos(pos);
-
- if (row == lastrow)
- lastrow = tmprow;
-}
-
-
-// removes the row and reset the touched counters
-void LyXText::removeRow(Row * row) const
-{
- Row * row_prev = row->previous();
- if (row->next())
- row->next()->previous(row_prev);
- if (!row_prev) {
- firstrow = row->next();
-// lyx::Assert(firstrow);
- } else {
- row_prev->next(row->next());
- }
- if (row == lastrow) {
- lyx::Assert(!row->next());
- lastrow = row_prev;
- }
- if (refresh_row == row) {
- refresh_row = row_prev ? row_prev : row->next();
- // what about refresh_y, refresh_height
- }
-
- height -= row->height(); // the text becomes smaller
-
- delete row;
-}
-
-
-// remove all following rows of the paragraph of the specified row.
-void LyXText::removeParagraph(Row * row) const
-{
- Paragraph * tmppar = row->par();
- row = row->next();
-
- Row * tmprow;
- while (row && row->par() == tmppar) {
- tmprow = row->next();
- removeRow(row);
- row = tmprow;
- }
+ pit->setFont(pos, font);
}
-// insert the specified paragraph behind the specified row
-void LyXText::insertParagraph(BufferView * bview, Paragraph * par,
- Row * row) const
+InsetOld * LyXText::getInset() const
{
- // insert a new row, starting at position 0
- insertRow(row, par, 0);
-
- // and now append the whole paragraph behind the new row
- if (!row) {
- firstrow->height(0);
- appendParagraph(bview, firstrow);
- } else {
- row->next()->height(0);
- appendParagraph(bview, row->next());
- }
-}
-
+ ParagraphList::iterator pit = cursor.par();
+ pos_type const pos = cursor.pos();
-Inset * LyXText::getInset() const
-{
- Inset * inset = 0;
- if (cursor.pos() == 0 && cursor.par()->bibkey) {
- inset = cursor.par()->bibkey;
- } else if (cursor.pos() < cursor.par()->size()
- && cursor.par()->isInset(cursor.pos())) {
- inset = cursor.par()->getInset(cursor.pos());
+ if (pos < pit->size() && pit->isInset(pos)) {
+ return pit->getInset(pos);
}
- return inset;
+ return 0;
}
-void LyXText::toggleInset(BufferView * bview)
+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()) {
- bview->unlockInset(static_cast<UpdatableInset *>(inset_owner->owner()));
- inset_owner->owner()->close(bview);
- bview->getLyXText()->cursorRight(bview);
+ bv()->unlockInset(inset_owner->owner());
+ inset_owner->owner()->close(bv());
+ bv()->getLyXText()->cursorRight(bv());
}
return;
}
- //bview->owner()->message(inset->editMessage());
+ //bv()->owner()->message(inset->editMessage());
// do we want to keep this?? (JMarc)
if (!isHighlyEditableInset(inset))
- setCursorParUndo(bview);
+ recordUndo(bv(), Undo::ATOMIC);
- if (inset->isOpen()) {
- inset->close(bview);
- } else {
- inset->open(bview);
- }
-#if 0
- inset->open(bview, !inset->isOpen());
-#endif
+ if (inset->isOpen())
+ inset->close(bv());
+ else
+ inset->open(bv());
+
+ bv()->updateInset(inset);
}
/* used in setlayout */
// Asger is not sure we want to do this...
-void LyXText::makeFontEntriesLayoutSpecific(Buffer const * buf,
- Paragraph * par)
+void LyXText::makeFontEntriesLayoutSpecific(BufferParams const & params,
+ Paragraph & par)
{
- LyXLayout_ptr const & layout = par->layout();
+ LyXLayout_ptr const & layout = par.layout();
+ pos_type const psize = par.size();
LyXFont layoutfont;
- for (pos_type pos = 0; pos < par->size(); ++pos) {
- if (pos < beginningOfMainBody(buf, par))
+ for (pos_type pos = 0; pos < psize; ++pos) {
+ if (pos < par.beginningOfBody())
layoutfont = layout->labelfont;
else
layoutfont = layout->font;
- LyXFont tmpfont = par->getFontSettings(buf->params, pos);
+ LyXFont tmpfont = par.getFontSettings(params, pos);
tmpfont.reduce(layoutfont);
- par->setFont(pos, tmpfont);
+ par.setFont(pos, tmpfont);
}
}
-Paragraph * LyXText::setLayout(BufferView * bview,
- LyXCursor & cur, LyXCursor & sstart_cur,
- LyXCursor & send_cur,
- string const & layout)
+ParagraphList::iterator
+LyXText::setLayout(LyXCursor & cur, LyXCursor & sstart_cur,
+ LyXCursor & send_cur,
+ string const & layout)
{
- Paragraph * endpar = send_cur.par()->next();
- Paragraph * undoendpar = endpar;
+ ParagraphList::iterator endpit = boost::next(send_cur.par());
+ ParagraphList::iterator undoendpit = endpit;
+ ParagraphList::iterator pars_end = ownerParagraphs().end();
- if (endpar && endpar->getDepth()) {
- while (endpar && endpar->getDepth()) {
- endpar = endpar->next();
- undoendpar = endpar;
+ if (endpit != pars_end && endpit->getDepth()) {
+ while (endpit != pars_end && endpit->getDepth()) {
+ ++endpit;
+ undoendpit = endpit;
}
- } else if (endpar) {
- endpar = endpar->next(); // because of parindents etc.
+ } else if (endpit != pars_end) {
+ // because of parindents etc.
+ ++endpit;
}
- setUndo(bview, Undo::EDIT, sstart_cur.par(), undoendpar);
+ 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
cur = sstart_cur;
- Paragraph * par = sstart_cur.par();
- Paragraph * epar = send_cur.par()->next();
+ ParagraphList::iterator pit = sstart_cur.par();
+ ParagraphList::iterator epit = boost::next(send_cur.par());
LyXLayout_ptr const & lyxlayout =
- bview->buffer()->params.getLyXTextClass()[layout];
+ bv()->buffer()->params.getLyXTextClass()[layout];
do {
- par->applyLayout(lyxlayout);
- makeFontEntriesLayoutSpecific(bview->buffer(), par);
- Paragraph * fppar = par;
- fppar->params().spaceTop(lyxlayout->fill_top ?
+ pit->applyLayout(lyxlayout);
+ makeFontEntriesLayoutSpecific(bv()->buffer()->params, *pit);
+ pit->params().spaceTop(lyxlayout->fill_top ?
VSpace(VSpace::VFILL)
: VSpace(VSpace::NONE));
- fppar->params().spaceBottom(lyxlayout->fill_bottom ?
+ pit->params().spaceBottom(lyxlayout->fill_bottom ?
VSpace(VSpace::VFILL)
: VSpace(VSpace::NONE));
if (lyxlayout->margintype == MARGIN_MANUAL)
- par->setLabelWidthString(lyxlayout->labelstring());
- if (lyxlayout->labeltype != LABEL_BIBLIO
- && fppar->bibkey) {
- delete fppar->bibkey;
- fppar->bibkey = 0;
- }
- cur.par(par);
- par = par->next();
- } while (par != epar);
+ pit->setLabelWidthString(lyxlayout->labelstring());
+ cur.par(pit);
+ ++pit;
+ } while (pit != epit);
- return endpar;
+ return endpit;
}
// set layout over selection and make a total rebreak of those paragraphs
-void LyXText::setLayout(BufferView * bview, string const & layout)
+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;
}
- Paragraph * endpar = setLayout(bview, cursor, selection.start,
- selection.end, layout);
- redoParagraphs(bview, selection.start, endpar);
+
+ // 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.par(), endpit);
// we have to reset the selection, because the
// geometry could have changed
- setCursor(bview, selection.start.par(),
- selection.start.pos(), false);
+ setCursor(selection.start.par(), selection.start.pos(), false);
selection.cursor = cursor;
- setCursor(bview, selection.end.par(), selection.end.pos(), false);
- updateCounters(bview);
+ setCursor(selection.end.par(), selection.end.pos(), false);
+ updateCounters();
clearSelection();
- setSelection(bview);
- setCursor(bview, tmpcursor.par(), tmpcursor.pos(), true);
+ setSelection();
+ setCursor(tmpcursor.par(), tmpcursor.pos(), true);
}
-// increment depth over selection and
-// make a total rebreak of those paragraphs
-void LyXText::incDepth(BufferView * bview)
+bool LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type, bool test_only)
{
- // If there is no selection, just use the current paragraph
- if (!selection.set()) {
- selection.start = cursor; // dummy selection
- selection.end = cursor;
- }
+ ParagraphList::iterator pit = cursor.par();
+ ParagraphList::iterator end = cursor.par();
+ ParagraphList::iterator start = pit;
- // We end at the next paragraph with depth 0
- Paragraph * endpar = selection.end.par()->next();
-
- Paragraph * undoendpar = endpar;
-
- if (endpar && endpar->getDepth()) {
- while (endpar && endpar->getDepth()) {
- endpar = endpar->next();
- undoendpar = endpar;
- }
- } else if (endpar) {
- endpar = endpar->next(); // because of parindents etc.
+ if (selection.set()) {
+ pit = selection.start.par();
+ end = selection.end.par();
+ start = pit;
}
- setUndo(bview, Undo::EDIT,
- selection.start.par(), undoendpar);
+ ParagraphList::iterator pastend = boost::next(end);
- LyXCursor tmpcursor = cursor; // store the current cursor
+ if (!test_only)
+ recordUndo(bv(), Undo::ATOMIC, start, end);
- // ok we have a selection. This is always between sel_start_cursor
- // and sel_end cursor
- cursor = selection.start;
+ bool changed = false;
+
+ int prev_after_depth = 0;
+#warning parlist ... could be nicer ?
+ if (start != ownerParagraphs().begin()) {
+ prev_after_depth = boost::prior(start)->getMaxDepthAfter();
+ }
while (true) {
- // NOTE: you can't change the depth of a bibliography entry
- if (cursor.par()->layout()->labeltype != LABEL_BIBLIO) {
- Paragraph * prev = cursor.par()->previous();
-
- if (prev) {
- if (cursor.par()->getDepth()
- < prev->getMaxDepthAfter()) {
- cursor.par()->params().depth(cursor.par()->getDepth() + 1);
- }
+ int const depth = pit->params().depth();
+ if (type == bv_funcs::INC_DEPTH) {
+ if (depth < prev_after_depth
+ && pit->layout()->labeltype != LABEL_BIBLIO) {
+ changed = true;
+ if (!test_only)
+ pit->params().depth(depth + 1);
}
+ } else if (depth) {
+ changed = true;
+ if (!test_only)
+ pit->params().depth(depth - 1);
}
- if (cursor.par() == selection.end.par())
- break;
- cursor.par(cursor.par()->next());
- }
- redoParagraphs(bview, selection.start, endpar);
+ prev_after_depth = pit->getMaxDepthAfter();
- // we have to reset the selection, because the
- // geometry could have changed
- setCursor(bview, selection.start.par(), selection.start.pos());
- selection.cursor = cursor;
- setCursor(bview, selection.end.par(), selection.end.pos());
- updateCounters(bview);
- clearSelection();
- setSelection(bview);
- setCursor(bview, tmpcursor.par(), tmpcursor.pos());
-}
-
-
-// decrement depth over selection and
-// make a total rebreak of those paragraphs
-void LyXText::decDepth(BufferView * bview)
-{
- // if there is no selection just set the layout
- // of the current paragraph
- if (!selection.set()) {
- selection.start = cursor; // dummy selection
- selection.end = cursor;
- }
- Paragraph * endpar = selection.end.par()->next();
- Paragraph * undoendpar = endpar;
-
- if (endpar && endpar->getDepth()) {
- while (endpar && endpar->getDepth()) {
- endpar = endpar->next();
- undoendpar = endpar;
+ if (pit == end) {
+ break;
}
- } else if (endpar) {
- endpar = endpar->next(); // because of parindents etc.
+
+ ++pit;
}
- setUndo(bview, Undo::EDIT,
- selection.start.par(), undoendpar);
+ if (test_only)
+ return changed;
- LyXCursor tmpcursor = cursor; // store the current cursor
+ redoParagraphs(start, pastend);
- // ok we have a selection. This is always between sel_start_cursor
- // and sel_end cursor
- cursor = selection.start;
+ // We need to actually move the text->cursor. I don't
+ // understand why ...
+ LyXCursor tmpcursor = cursor;
- while (true) {
- if (cursor.par()->params().depth()) {
- cursor.par()->params()
- .depth(cursor.par()->params().depth() - 1);
- }
- if (cursor.par() == selection.end.par()) {
- break;
- }
- cursor.par(cursor.par()->next());
+ // we have to reset the visual selection because the
+ // geometry could have changed
+ if (selection.set()) {
+ setCursor(selection.start.par(), selection.start.pos());
+ selection.cursor = cursor;
+ setCursor(selection.end.par(), selection.end.pos());
}
- redoParagraphs(bview, selection.start, endpar);
+ // this handles the counter labels, and also fixes up
+ // depth values for follow-on (child) paragraphs
+ updateCounters();
- // we have to reset the selection, because the
- // geometry could have changed
- setCursor(bview, selection.start.par(),
- selection.start.pos());
- selection.cursor = cursor;
- setCursor(bview, selection.end.par(), selection.end.pos());
- updateCounters(bview);
- clearSelection();
- setSelection(bview);
- setCursor(bview, tmpcursor.par(), tmpcursor.pos());
+ setSelection();
+ setCursor(tmpcursor.par(), tmpcursor.pos());
+
+ return changed;
}
// set font over selection and make a total rebreak of those paragraphs
-void LyXText::setFont(BufferView * bview, LyXFont const & font, bool toggleall)
+void LyXText::setFont(LyXFont const & font, bool toggleall)
{
// if there is no selection just set the current_font
if (!selection.set()) {
// Determine basis font
LyXFont layoutfont;
- if (cursor.pos() < beginningOfMainBody(bview->buffer(),
- cursor.par())) {
- layoutfont = getLabelFont(bview->buffer(),
- cursor.par());
+ if (cursor.pos() < cursor.par()->beginningOfBody()) {
+ layoutfont = getLabelFont(cursor.par());
} else {
- layoutfont = getLayoutFont(bview->buffer(),
- cursor.par());
+ layoutfont = getLayoutFont(cursor.par());
}
// Update current font
real_current_font.update(font,
- bview->buffer()->params.language,
+ bv()->buffer()->params.language,
toggleall);
// Reduce to implicit settings
// ok we have a selection. This is always between sel_start_cursor
// and sel_end cursor
- setUndo(bview, Undo::EDIT,
- selection.start.par(), selection.end.par()->next());
+ recordUndo(bv(), Undo::ATOMIC, selection.start.par(), selection.end.par());
freezeUndo();
cursor = selection.start;
while (cursor.par() != selection.end.par() ||
{
if (cursor.pos() < cursor.par()->size()) {
// an open footnote should behave like a closed one
- setCharFont(bview, cursor.par(), cursor.pos(),
+ setCharFont(cursor.par(), cursor.pos(),
font, toggleall);
cursor.pos(cursor.pos() + 1);
} else {
cursor.pos(0);
- cursor.par(cursor.par()->next());
+ cursor.par(boost::next(cursor.par()));
}
}
unFreezeUndo();
- redoParagraphs(bview, selection.start, selection.end.par()->next());
+ redoParagraph(selection.start.par());
// we have to reset the selection, because the
// geometry could have changed, but we keep
// it for user convenience
- setCursor(bview, selection.start.par(), selection.start.pos());
+ setCursor(selection.start.par(), selection.start.pos());
selection.cursor = cursor;
- setCursor(bview, selection.end.par(), selection.end.pos());
- setSelection(bview);
- setCursor(bview, tmpcursor.par(), tmpcursor.pos(), true,
+ setCursor(selection.end.par(), selection.end.pos());
+ setSelection();
+ setCursor(tmpcursor.par(), tmpcursor.pos(), true,
tmpcursor.boundary());
}
-void LyXText::redoHeightOfParagraph(BufferView * bview, LyXCursor const & cur)
+int LyXText::redoParagraphInternal(ParagraphList::iterator pit)
{
- Row * tmprow = cur.row();
- int y = cur.y() - tmprow->baseline();
+ RowList::iterator rit = pit->rows.begin();
+ RowList::iterator end = pit->rows.end();
- setHeightOfRow(bview, tmprow);
+ // remove rows of paragraph, keep track of height changes
+ for (int i = 0; rit != end; ++rit, ++i)
+ height -= rit->height();
+ pit->rows.clear();
- while (tmprow->previous()
- && tmprow->previous()->par() == tmprow->par()) {
- tmprow = tmprow->previous();
- y -= tmprow->height();
- setHeightOfRow(bview, tmprow);
+ // 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);
}
- // we can set the refreshing parameters now
- status(bview, LyXText::NEED_MORE_REFRESH);
- refresh_y = y;
- refresh_row = tmprow;
- setCursor(bview, cur.par(), cur.pos(), false, cursor.boundary());
-}
-
-
-void LyXText::redoDrawingOfParagraph(BufferView * bview, LyXCursor const & cur)
-{
- Row * tmprow = cur.row();
-
- int y = cur.y() - tmprow->baseline();
- setHeightOfRow(bview, tmprow);
-
- while (tmprow->previous()
- && tmprow->previous()->par() == tmprow->par()) {
- tmprow = tmprow->previous();
- y -= tmprow->height();
+ // 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);
}
- // we can set the refreshing parameters now
- if (status_ == LyXText::UNCHANGED || y < refresh_y) {
- refresh_y = y;
- refresh_row = tmprow;
+ 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();
}
- status(bview, LyXText::NEED_MORE_REFRESH);
- setCursor(bview, cur.par(), cur.pos());
+
+ //lyxerr << "redoParagraph: " << pit->rows.size() << " rows\n";
+ return par_width;
}
-// 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(BufferView * bview, LyXCursor const & cur,
- Paragraph const * endpar) const
+int LyXText::redoParagraphs(ParagraphList::iterator start,
+ ParagraphList::iterator end)
{
- Row * tmprow2;
- Paragraph * tmppar = 0;
- Paragraph * first_phys_par = 0;
-
- Row * tmprow = cur.row();
-
- int y = cur.y() - tmprow->baseline();
-
- if (!tmprow->previous()) {
- // 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_par = ownerParagraph();
- } else {
- first_phys_par = tmprow->par();
- while (tmprow->previous()
- && tmprow->previous()->par() == first_phys_par)
- {
- tmprow = tmprow->previous();
- y -= tmprow->height();
- }
+ 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;
+}
- // we can set the refreshing parameters now
- status(bview, LyXText::NEED_MORE_REFRESH);
- refresh_y = y;
- refresh_row = tmprow->previous(); /* the real refresh row will
- be deleted, so I store
- the previous here */
- // remove it
- if (tmprow->next())
- tmppar = tmprow->next()->par();
- else
- tmppar = 0;
- while (tmprow->next() && tmppar != endpar) {
- removeRow(tmprow->next());
- if (tmprow->next()) {
- tmppar = tmprow->next()->par();
- } else {
- tmppar = 0;
- }
- }
-
- // remove the first one
- tmprow2 = tmprow; /* this is because tmprow->previous()
- can be 0 */
- tmprow = tmprow->previous();
- removeRow(tmprow2);
-
- tmppar = first_phys_par;
- do {
- if (tmppar) {
- insertParagraph(bview, tmppar, tmprow);
- if (!tmprow) {
- tmprow = firstrow;
- }
- while (tmprow->next()
- && tmprow->next()->par() == tmppar) {
- tmprow = tmprow->next();
- }
- tmppar = tmppar->next();
- }
- } while (tmppar && tmppar != endpar);
+void LyXText::redoParagraph(ParagraphList::iterator pit)
+{
+ redoParagraphInternal(pit);
+ updateRowPositions();
+}
- // this is because of layout changes
- if (refresh_row) {
- refresh_y -= refresh_row->height();
- setHeightOfRow(bview, refresh_row);
- } else {
- refresh_row = firstrow;
- refresh_y = 0;
- setHeightOfRow(bview, refresh_row);
- }
- if (tmprow && tmprow->next())
- setHeightOfRow(bview, tmprow->next());
- updateCounters(bview);
+void LyXText::fullRebreak()
+{
+ redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end());
+ redoCursor();
+ selection.cursor = cursor;
}
-void LyXText::fullRebreak(BufferView * bview)
+void LyXText::metrics(MetricsInfo & mi, Dimension & dim)
{
- if (!firstrow) {
- init(bview);
- return;
- }
- if (need_break_row) {
- breakAgain(bview, need_break_row);
- need_break_row = 0;
- return;
- }
+ //lyxerr << "LyXText::metrics: width: " << mi.base.textwidth
+ // << " workWidth: " << workWidth() << endl;
+ //Assert(mi.base.textwidth);
+
+ // rebuild row cache
+ width = 0;
+ ///height = 0;
+
+ //anchor_y_ = 0;
+ width = redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end());
+
+ // final dimension
+ dim.asc = firstRow()->ascent_of_text();
+ dim.des = height - dim.asc;
+ dim.wid = std::max(mi.base.textwidth, int(width));
}
// They also delete the corresponding row
// need the selection cursor:
-void LyXText::setSelection(BufferView * bview)
+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(bview, InsetText::SELECTION);
+ TextCursor::setSelection();
}
-string const LyXText::selectionAsString(Buffer const * buffer,
- bool label) const
-{
- if (!selection.set()) return string();
-
- // should be const ...
- Paragraph * startpar(selection.start.par());
- Paragraph * endpar(selection.end.par());
- pos_type const startpos(selection.start.pos());
- pos_type const endpos(selection.end.pos());
- if (startpar == endpar) {
- return startpar->asString(buffer, startpos, endpos, label);
- }
-
- string result;
-
- // First paragraph in selection
- result += startpar->asString(buffer, startpos, startpar->size(), label) + "\n\n";
-
- // The paragraphs in between (if any)
- LyXCursor tmpcur(selection.start);
- tmpcur.par(tmpcur.par()->next());
- while (tmpcur.par() != endpar) {
- result += tmpcur.par()->asString(buffer, 0,
- tmpcur.par()->size(),
- label) + "\n\n";
- tmpcur.par(tmpcur.par()->next());
- }
-
- // Last paragraph in selection
- result += endpar->asString(buffer, 0, endpos, label);
-
- return result;
-}
-
-
-void LyXText::clearSelection() const
+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(BufferView * bview) const
+void LyXText::cursorHome()
{
- setCursor(bview, cursor.par(), cursor.row()->pos());
+ setCursor(cursor.par(), cursorRow()->pos());
}
-void LyXText::cursorEnd(BufferView * bview) const
+void LyXText::cursorEnd()
{
- if (!cursor.row()->next()
- || cursor.row()->next()->par() != cursor.row()->par()) {
- setCursor(bview, cursor.par(), rowLast(cursor.row()) + 1);
- } else {
- if (!cursor.par()->empty() &&
- (cursor.par()->getChar(rowLast(cursor.row())) == ' '
- || cursor.par()->isNewline(rowLast(cursor.row())))) {
- setCursor(bview, cursor.par(), rowLast(cursor.row()));
- } else {
- setCursor(bview,cursor.par(),
- rowLast(cursor.row()) + 1);
- }
- }
+ if (cursor.par()->empty())
+ return;
+
+ RowList::iterator rit = cursorRow();
+ 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);
}
-void LyXText::cursorTop(BufferView * bview) const
+void LyXText::cursorTop()
{
- while (cursor.par()->previous())
- cursor.par(cursor.par()->previous());
- setCursor(bview, cursor.par(), 0);
+ setCursor(ownerParagraphs().begin(), 0);
}
-void LyXText::cursorBottom(BufferView * bview) const
+void LyXText::cursorBottom()
{
- while (cursor.par()->next())
- cursor.par(cursor.par()->next());
- setCursor(bview, cursor.par(), cursor.par()->size());
+ ParagraphList::iterator lastpit =
+ boost::prior(ownerParagraphs().end());
+ setCursor(lastpit, lastpit->size());
}
-void LyXText::toggleFree(BufferView * bview,
- LyXFont const & font, bool toggleall)
+void LyXText::toggleFree(LyXFont const & font, bool toggleall)
{
// If the mask is completely neutral, tell user
if (font == LyXFont(LyXFont::ALL_IGNORE)) {
// Could only happen with user style
- bview->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;
}
LyXCursor resetCursor = cursor;
bool implicitSelection = (font.language() == ignore_language
&& font.number() == LyXFont::IGNORE)
- ? selectWordWhenUnderCursor(bview, WHOLE_WORD_STRICT) : false;
+ ? selectWordWhenUnderCursor(lyx::WHOLE_WORD_STRICT) : false;
// Set font
- setFont(bview, font, toggleall);
+ setFont(font, toggleall);
// Implicit selections are cleared afterwards
//and cursor is set to the original position.
if (implicitSelection) {
clearSelection();
cursor = resetCursor;
- setCursor(bview, cursor.par(), cursor.pos());
+ setCursor(cursor.par(), cursor.pos());
selection.cursor = cursor;
}
- if (inset_owner)
- inset_owner->setUpdateStatus(bview, InsetText::CURSOR_PAR);
}
-string LyXText::getStringToIndex(BufferView * bview)
+string LyXText::getStringToIndex()
{
- string idxstring;
-
// Try implicit word selection
// If there is a change in the language the implicit word selection
// is disabled.
LyXCursor const reset_cursor = cursor;
- bool const implicitSelection = selectWordWhenUnderCursor(bview, PREVIOUS_WORD);
+ bool const implicitSelection =
+ selectWordWhenUnderCursor(lyx::PREVIOUS_WORD);
- if (!selection.set()) {
- bview->owner()->message(_("Nothing to index!"));
- return string();
- }
- if (selection.start.par() != selection.end.par()) {
- bview->owner()->message(_("Cannot index more than one paragraph!"));
- return string();
- }
+ string idxstring;
+ if (!selection.set())
+ bv()->owner()->message(_("Nothing to index!"));
+ 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(bview->buffer(), false);
+ // Reset cursors to their original position.
+ cursor = reset_cursor;
+ setCursor(cursor.par(), cursor.pos());
+ selection.cursor = cursor;
- // Implicit selections are cleared afterwards
- //and cursor is set to the original position.
- if (implicitSelection) {
+ // Clear the implicit selection.
+ if (implicitSelection)
clearSelection();
- cursor = reset_cursor;
- setCursor(bview, cursor.par(), cursor.pos());
- selection.cursor = cursor;
- }
- return idxstring;
-}
-
-pos_type LyXText::beginningOfMainBody(Buffer const * /*buf*/,
- Paragraph const * par) const
-{
- if (par->layout()->labeltype != LABEL_MANUAL)
- return 0;
- else
- return par->beginningOfMainBody();
+ return idxstring;
}
// 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!
-void LyXText::setParagraph(BufferView * bview,
- bool line_top, bool line_bottom,
+void LyXText::setParagraph(bool line_top, bool line_bottom,
bool pagebreak_top, bool pagebreak_bottom,
VSpace const & space_top,
VSpace const & space_bottom,
Spacing const & spacing,
LyXAlignment align,
- string labelwidthstring,
+ string const & labelwidthstring,
bool noindent)
{
LyXCursor tmpcursor = cursor;
}
// make sure that the depth behind the selection are restored, too
- Paragraph * endpar = selection.end.par()->next();
- Paragraph * undoendpar = endpar;
-
- if (endpar && endpar->getDepth()) {
- while (endpar && endpar->getDepth()) {
- endpar = endpar->next();
- undoendpar = endpar;
+ ParagraphList::iterator endpit = boost::next(selection.end.par());
+ ParagraphList::iterator undoendpit = endpit;
+ ParagraphList::iterator pars_end = ownerParagraphs().end();
+
+ if (endpit != pars_end && endpit->getDepth()) {
+ while (endpit != pars_end && endpit->getDepth()) {
+ ++endpit;
+ undoendpit = endpit;
}
- }
- else if (endpar) {
+ } else if (endpit != pars_end) {
// because of parindents etc.
- endpar = endpar->next();
+ ++endpit;
}
- setUndo(bview, Undo::EDIT, selection.start.par(), undoendpar);
+ 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);
- Paragraph * tmppar = selection.end.par();
+ ParagraphList::iterator pit = cursor.par();
+ ParagraphParameters & params = pit->params();
- while (tmppar != selection.start.par()->previous()) {
- setCursor(bview, tmppar, 0);
- status(bview, LyXText::NEED_MORE_REFRESH);
- refresh_row = cursor.row();
- refresh_y = cursor.y() - cursor.row()->baseline();
- cursor.par()->params().lineTop(line_top);
- cursor.par()->params().lineBottom(line_bottom);
- cursor.par()->params().pagebreakTop(pagebreak_top);
- cursor.par()->params().pagebreakBottom(pagebreak_bottom);
- cursor.par()->params().spaceTop(space_top);
- cursor.par()->params().spaceBottom(space_bottom);
- cursor.par()->params().spacing(spacing);
+ params.lineTop(line_top);
+ params.lineBottom(line_bottom);
+ params.pagebreakTop(pagebreak_top);
+ params.pagebreakBottom(pagebreak_bottom);
+ params.spaceTop(space_top);
+ params.spaceBottom(space_bottom);
+ params.spacing(spacing);
// does the layout allow the new alignment?
- LyXLayout_ptr const & layout = cursor.par()->layout();
+ LyXLayout_ptr const & layout = pit->layout();
if (align == LYX_ALIGN_LAYOUT)
align = layout->align;
if (align & layout->alignpossible) {
if (align == layout->align)
- cursor.par()->params().align(LYX_ALIGN_LAYOUT);
+ params.align(LYX_ALIGN_LAYOUT);
else
- cursor.par()->params().align(align);
+ params.align(align);
}
- cursor.par()->setLabelWidthString(labelwidthstring);
- cursor.par()->params().noindent(noindent);
- tmppar = cursor.par()->previous();
+ pit->setLabelWidthString(labelwidthstring);
+ params.noindent(noindent);
+ tmppit = boost::prior(pit);
}
- redoParagraphs(bview, selection.start, endpar);
+ redoParagraphs(selection.start.par(), endpit);
clearSelection();
- setCursor(bview, selection.start.par(), selection.start.pos());
+ setCursor(selection.start.par(), selection.start.pos());
selection.cursor = cursor;
- setCursor(bview, selection.end.par(), selection.end.pos());
- setSelection(bview);
- setCursor(bview, tmpcursor.par(), tmpcursor.pos());
+ setCursor(selection.end.par(), selection.end.pos());
+ setSelection();
+ setCursor(tmpcursor.par(), tmpcursor.pos());
if (inset_owner)
- bview->updateInset(inset_owner, true);
+ bv()->updateInset(inset_owner);
}
// set the counter of a paragraph. This includes the labels
-void LyXText::setCounter(Buffer const * buf, Paragraph * par) const
+void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
{
- LyXTextClass const & textclass = buf->params.getLyXTextClass();
- LyXLayout_ptr const & layout = par->layout();
+ LyXTextClass const & textclass = buf.params.getLyXTextClass();
+ LyXLayout_ptr const & layout = pit->layout();
- if (par->previous()) {
+ if (pit != ownerParagraphs().begin()) {
- par->params().appendix(par->previous()->params().appendix());
- if (!par->params().appendix() && par->params().startOfAppendix()) {
- par->params().appendix(true);
+ pit->params().appendix(boost::prior(pit)->params().appendix());
+ if (!pit->params().appendix() &&
+ pit->params().startOfAppendix()) {
+ pit->params().appendix(true);
textclass.counters().reset();
}
- par->enumdepth = par->previous()->enumdepth;
- par->itemdepth = par->previous()->itemdepth;
+ pit->enumdepth = boost::prior(pit)->enumdepth;
+ pit->itemdepth = boost::prior(pit)->itemdepth;
} else {
- par->params().appendix(par->params().startOfAppendix());
- par->enumdepth = 0;
- par->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
- */
- if (par->previous()
- && par->previous()->getDepth() < par->getDepth()
- && par->previous()->layout()->labeltype == LABEL_COUNTER_ENUMI
- && par->enumdepth < 3
+ pit->params().appendix(pit->params().startOfAppendix());
+ pit->enumdepth = 0;
+ 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
+ if (pit != ownerParagraphs().begin()
+ && boost::prior(pit)->getDepth() < pit->getDepth()
+ && boost::prior(pit)->layout()->labeltype == LABEL_COUNTER_ENUMI
+ && pit->enumdepth < 3
&& layout->labeltype != LABEL_BIBLIO) {
- par->enumdepth++;
+ pit->enumdepth++;
}
// Maybe we have to decrement the enumeration depth, see note above
- if (par->previous()
- && par->previous()->getDepth() > par->getDepth()
+ if (pit != ownerParagraphs().begin()
+ && boost::prior(pit)->getDepth() > pit->getDepth()
&& layout->labeltype != LABEL_BIBLIO) {
- par->enumdepth = par->depthHook(par->getDepth())->enumdepth;
+ pit->enumdepth = depthHook(pit, ownerParagraphs(),
+ pit->getDepth())->enumdepth;
}
- if (!par->params().labelString().empty()) {
- par->params().labelString(string());
+ if (!pit->params().labelString().empty()) {
+ pit->params().labelString(string());
}
if (layout->margintype == MARGIN_MANUAL) {
- if (par->params().labelWidthString().empty()) {
- par->setLabelWidthString(layout->labelstring());
- }
+ if (pit->params().labelWidthString().empty())
+ pit->setLabelWidthString(layout->labelstring());
} else {
- par->setLabelWidthString(string());
+ pit->setLabelWidthString(string());
}
// is it a layout that has an automatic label?
ostringstream s;
- if (i >= 0 && i <= buf->params.secnumdepth) {
+ if (i >= 0 && i <= buf.params.secnumdepth) {
string numbertype;
string langtype;
textclass.counters().step(layout->latexname());
// Is there a label? Useful for Chapter layout
- if (!par->params().appendix()) {
- s << layout->labelstring();
+ if (!pit->params().appendix()) {
+ s << buf.B_(layout->labelstring());
} else {
- s << layout->labelstring_appendix();
+ s << buf.B_(layout->labelstring_appendix());
}
// Use of an integer is here less than elegant. For now.
int head = textclass.maxcounter() - LABEL_COUNTER_CHAPTER;
- if (!par->params().appendix()) {
+ if (!pit->params().appendix()) {
numbertype = "sectioning";
} else {
numbertype = "appendix";
- if (par->isRightToLeftPar(buf->params))
+ if (pit->isRightToLeftPar(buf.params))
langtype = "hebrew";
else
langtype = "latin";
}
- s << textclass.counters()
+ s << " "
+ << textclass.counters()
.numberLabel(layout->latexname(),
numbertype, langtype, head);
- par->params().labelString(STRCONV(s.str()));
+ pit->params().labelString(STRCONV(s.str()));
// reset enum counters
textclass.counters().reset("enum");
// (Lgb)
string enumcounter("enum");
- switch (par->enumdepth) {
+ switch (pit->enumdepth) {
case 2:
enumcounter += 'i';
case 1:
s << textclass.counters()
.numberLabel(enumcounter, "enumeration");
- par->params().labelString(STRCONV(s.str()));
+ pit->params().labelString(STRCONV(s.str()));
}
} else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
textclass.counters().step("bibitem");
int number = textclass.counters().value("bibitem");
- if (!par->bibkey) {
- InsetCommandParams p("bibitem");
- par->bibkey = new InsetBibKey(p);
+ if (pit->bibitem()) {
+ pit->bibitem()->setCounter(number);
+ pit->params().labelString(layout->labelstring());
}
- par->bibkey->setCounter(number);
- par->params().labelString(layout->labelstring());
-
// In biblio should't be following counters but...
} else {
- string s = layout->labelstring();
+ string s = buf.B_(layout->labelstring());
// the caption hack:
if (layout->labeltype == LABEL_SENSITIVE) {
- Paragraph * tmppar = par;
- Inset * in = 0;
+ ParagraphList::iterator end = ownerParagraphs().end();
+ ParagraphList::iterator tmppit = pit;
+ InsetOld * in = 0;
bool isOK = false;
- while (tmppar && tmppar->inInset()
+ while (tmppit != end && tmppit->inInset()
// the single '=' is intended below
- && (in = tmppar->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 {
- tmppar = in->parOwner();
+ Paragraph const * owner = &ownerPar(buf, in);
+ tmppit = ownerParagraphs().begin();
+ for ( ; tmppit != end; ++tmppit)
+ if (&*tmppit == owner)
+ 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.
-#warning use boost.format
-#if USE_BOOST_FORMAT
- s = boost::io::str(boost::format(_("%1$s #:")) % 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 << fl.name() << " #:";
- s = STRCONV(o.str());
-#endif
+ s = bformat(_("%1$s #:"), buf.B_(fl.name()));
} else {
// par->SetLayout(0);
// s = layout->labelstring;
s = _("Senseless: ");
}
}
- par->params().labelString(s);
+ pit->params().labelString(s);
// reset the enumeration counter. They are always reset
// when there is any other layout between
// Just fall-through between the cases so that all
// enum counters deeper than enumdepth is also reset.
- switch (par->enumdepth) {
+ switch (pit->enumdepth) {
case 0:
textclass.counters().reset("enumi");
case 1:
// Updates all counters. Paragraphs with changed label string will be rebroken
-void LyXText::updateCounters(BufferView * bview) const
+void LyXText::updateCounters()
{
- Row * row = firstrow;
- Paragraph * par = row->par();
+ // start over
+ bv()->buffer()->params.getLyXTextClass().counters().reset();
- // CHECK if this is really needed. (Lgb)
- bview->buffer()->params.getLyXTextClass().counters().reset();
+ ParagraphList::iterator beg = ownerParagraphs().begin();
+ ParagraphList::iterator end = ownerParagraphs().end();
+ for (ParagraphList::iterator pit = beg; pit != end; ++pit) {
+ string const oldLabel = pit->params().labelString();
- while (par) {
- while (row->par() != par)
- row = row->next();
+ size_t maxdepth = 0;
+ if (pit != beg)
+ maxdepth = boost::prior(pit)->getMaxDepthAfter();
- string const oldLabel = par->params().labelString();
+ if (pit->params().depth() > maxdepth)
+ pit->params().depth(maxdepth);
// setCounter can potentially change the labelString.
- setCounter(bview->buffer(), par);
-
- string const & newLabel = par->params().labelString();
+ setCounter(*bv()->buffer(), pit);
- if (oldLabel.empty() && !newLabel.empty()) {
- removeParagraph(row);
- appendParagraph(bview, row);
- }
+ string const & newLabel = pit->params().labelString();
- par = par->next();
+ if (oldLabel != newLabel)
+ redoParagraph(pit);
}
}
-void LyXText::insertInset(BufferView * bview, Inset * inset)
+void LyXText::insertInset(InsetOld * inset)
{
if (!cursor.par()->insetAllowed(inset->lyxCode()))
return;
- setUndo(bview, Undo::FINISH, cursor.par(), cursor.par()->next());
+ 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(bview, 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
+ 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(...)
+ // and fails if the cursor is behind the inset and getInset
// does not return the inset!
- if (isHighlyEditableInset(inset)) {
- cursorLeft(bview, true);
- }
+ if (isHighlyEditableInset(inset))
+ cursorLeft(true);
unFreezeUndo();
}
-void LyXText::copyEnvironmentType()
-{
- copylayouttype = cursor.par()->layout()->name();
-}
-
-
-void LyXText::pasteEnvironmentType(BufferView * bview)
-{
- setLayout(bview, copylayouttype);
-}
-
-
-void LyXText::cutSelection(BufferView * bview, bool doclear, bool realcut)
+void LyXText::cutSelection(bool doclear, bool realcut)
{
// Stuff what we got on the clipboard. Even if there is no selection.
// 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)
- bview->stuffClipboard(selectionAsString(bview->buffer(), true));
+ bv()->stuffClipboard(selectionAsString(*bv()->buffer(), true));
// This doesn't make sense, if there is no selection
if (!selection.set())
// and selection.end
// make sure that the depth behind the selection are restored, too
- Paragraph * endpar = selection.end.par()->next();
- Paragraph * undoendpar = endpar;
-
- if (endpar && endpar->getDepth()) {
- while (endpar && endpar->getDepth()) {
- endpar = endpar->next();
- undoendpar = endpar;
+ ParagraphList::iterator endpit = boost::next(selection.end.par());
+ ParagraphList::iterator undoendpit = endpit;
+ ParagraphList::iterator pars_end = ownerParagraphs().end();
+
+ if (endpit != pars_end && endpit->getDepth()) {
+ while (endpit != pars_end && endpit->getDepth()) {
+ ++endpit;
+ undoendpit = endpit;
}
- } else if (endpar) {
- endpar = endpar->next(); // because of parindents etc.
- }
-
- setUndo(bview, Undo::DELETE,
- selection.start.par(), undoendpar);
-
- // there are two cases: cut only within one paragraph or
- // more than one paragraph
- if (selection.start.par() == selection.end.par()) {
- // only within one paragraph
- endpar = selection.end.par();
- int pos = selection.end.pos();
- CutAndPaste::cutSelection(selection.start.par(), &endpar,
- selection.start.pos(), pos,
- bview->buffer()->params.textclass,
- doclear, realcut);
- selection.end.pos(pos);
- } else {
- endpar = selection.end.par();
- int pos = selection.end.pos();
- CutAndPaste::cutSelection(selection.start.par(), &endpar,
- selection.start.pos(), pos,
- bview->buffer()->params.textclass,
- doclear, realcut);
- cursor.par(endpar);
- selection.end.par(endpar);
- selection.end.pos(pos);
- cursor.pos(selection.end.pos());
- }
- endpar = endpar->next();
-
+ } else if (endpit != pars_end) {
+ // because of parindents etc.
+ ++endpit;
+ }
+
+ 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(bv()->buffer()->params,
+ ownerParagraphs(),
+ selection.start.par(), endpit,
+ selection.start.pos(), endpos,
+ bv()->buffer()->params.textclass,
+ doclear)
+ : CutAndPaste::eraseSelection(bv()->buffer()->params,
+ ownerParagraphs(),
+ selection.start.par(), endpit,
+ selection.start.pos(), endpos,
+ doclear);
// sometimes necessary
if (doclear)
selection.start.par()->stripLeadingSpaces();
- redoParagraphs(bview, selection.start, endpar);
-
+ redoParagraphs(selection.start.par(), boost::next(endpit));
// cutSelection can invalidate the cursor so we need to set
// it anew. (Lgb)
- cursor = selection.start;
+ // we prefer the end for when tracking changes
+ cursor.pos(endpos);
+ cursor.par(endpit);
// need a valid cursor. (Lgb)
clearSelection();
- setCursor(bview, cursor.par(), cursor.pos());
+ setCursor(cursor.par(), cursor.pos());
selection.cursor = cursor;
- updateCounters(bview);
+ updateCounters();
}
-void LyXText::copySelection(BufferView * bview)
+void LyXText::copySelection()
{
// stuff the selection onto the X clipboard, from an explicit copy request
- bview->stuffClipboard(selectionAsString(bview->buffer(), true));
+ bv()->stuffClipboard(selectionAsString(*bv()->buffer(), true));
// this doesnt make sense, if there is no selection
if (!selection.set())
|| 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(),
- bview->buffer()->params.textclass);
+ bv()->buffer()->params.textclass);
}
-void LyXText::pasteSelection(BufferView * bview)
+void LyXText::pasteSelection(size_t sel_index)
{
// this does not make sense, if there is nothing to paste
- if (!CutAndPaste::checkPastePossible(cursor.par()))
+ if (!CutAndPaste::checkPastePossible())
return;
- setUndo(bview, Undo::INSERT,
- cursor.par(), cursor.par()->next());
+ recordUndo(bv(), Undo::INSERT, cursor.par());
+
+ ParagraphList::iterator endpit;
+ PitPosPair ppp;
- Paragraph * endpar;
- Paragraph * actpar = cursor.par();
- int pos = cursor.pos();
+ ErrorList el;
- CutAndPaste::pasteSelection(&actpar, &endpar, pos,
- bview->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(bview, cursor, endpar);
+ redoParagraphs(cursor.par(), endpit);
- setCursor(bview, cursor.par(), cursor.pos());
+ setCursor(cursor.par(), cursor.pos());
clearSelection();
selection.cursor = cursor;
- setCursor(bview, actpar, pos);
- setSelection(bview);
- updateCounters(bview);
+ setCursor(ppp.first, ppp.second);
+ setSelection();
+ updateCounters();
}
-// sets the selection over the number of characters of string, no check!!
-void LyXText::setSelectionOverString(BufferView * bview, string const & str)
+void LyXText::setSelectionRange(lyx::pos_type length)
{
- if (str.empty())
+ if (!length)
return;
selection.cursor = cursor;
- for (string::size_type i = 0; i < str.length(); ++i)
- cursorRight(bview);
- setSelection(bview);
+ while (length--)
+ cursorRight(bv());
+ setSelection();
}
// simple replacing. The font of the first selected character is used
-void LyXText::replaceSelectionWithString(BufferView * bview,
- string const & str)
+void LyXText::replaceSelectionWithString(string const & str)
{
- setCursorParUndo(bview);
+ recordUndo(bv(), Undo::ATOMIC);
freezeUndo();
if (!selection.set()) { // create a dummy selection
// Get font setting before we cut
pos_type pos = selection.end.pos();
LyXFont const font = selection.start.par()
- ->getFontSettings(bview->buffer()->params,
+ ->getFontSettings(bv()->buffer()->params,
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;
}
// Cut the selection
- cutSelection(bview, true, false);
+ cutSelection(true, false);
unFreezeUndo();
}
// needed to insert the selection
-void LyXText::insertStringAsLines(BufferView * bview, string const & str)
+void LyXText::insertStringAsLines(string const & str)
{
- Paragraph * par = cursor.par();
+ ParagraphList::iterator pit = cursor.par();
pos_type pos = cursor.pos();
- Paragraph * endpar = cursor.par()->next();
+ ParagraphList::iterator endpit = boost::next(cursor.par());
- setCursorParUndo(bview);
+ recordUndo(bv(), Undo::ATOMIC);
// only to be sure, should not be neccessary
clearSelection();
- bview->buffer()->insertStringAsLines(par, pos, current_font, str);
+ bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
- redoParagraphs(bview, cursor, endpar);
- setCursor(bview, cursor.par(), cursor.pos());
+ redoParagraphs(cursor.par(), endpit);
+ setCursor(cursor.par(), cursor.pos());
selection.cursor = cursor;
- setCursor(bview, par, pos);
- setSelection(bview);
+ setCursor(pit, pos);
+ setSelection();
}
// turns double-CR to single CR, others where converted into one
// blank. Then InsertStringAsLines is called
-void LyXText::insertStringAsParagraphs(BufferView * bview, string const & str)
+void LyXText::insertStringAsParagraphs(string const & str)
{
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
newline_inserted = false;
}
}
- insertStringAsLines(bview, linestr);
+ insertStringAsLines(linestr);
}
-void LyXText::checkParagraph(BufferView * bview, Paragraph * par,
- pos_type pos)
-{
- LyXCursor tmpcursor;
-
- int y = 0;
- pos_type z;
- Row * row = getRow(par, pos, y);
-
- // is there a break one row above
- if (row->previous() && row->previous()->par() == row->par()) {
- z = nextBreakPoint(bview, row->previous(), workWidth(bview));
- if (z >= row->pos()) {
- // set the dimensions of the row above
- y -= row->previous()->height();
- refresh_y = y;
- refresh_row = row->previous();
- status(bview, LyXText::NEED_MORE_REFRESH);
-
- breakAgain(bview, row->previous());
-
- // set the cursor again. Otherwise
- // dangling pointers are possible
- setCursor(bview, cursor.par(), cursor.pos(),
- false, cursor.boundary());
- selection.cursor = cursor;
- return;
- }
- }
-
- int const tmpheight = row->height();
- pos_type const tmplast = rowLast(row);
- refresh_y = y;
- refresh_row = row;
-
- breakAgain(bview, row);
- if (row->height() == tmpheight && rowLast(row) == tmplast)
- status(bview, LyXText::NEED_VERY_LITTLE_REFRESH);
- else
- status(bview, LyXText::NEED_MORE_REFRESH);
-
- // check the special right address boxes
- if (par->layout()->margintype == MARGIN_RIGHT_ADDRESS_BOX) {
- tmpcursor.par(par);
- tmpcursor.row(row);
- tmpcursor.y(y);
- tmpcursor.x(0);
- tmpcursor.x_fix(0);
- tmpcursor.pos(pos);
- redoDrawingOfParagraph(bview, tmpcursor);
- }
-
- // set the cursor again. Otherwise dangling pointers are possible
- // also set the selection
-
- if (selection.set()) {
- tmpcursor = cursor;
- setCursorIntern(bview, selection.cursor.par(), selection.cursor.pos(),
- false, selection.cursor.boundary());
- selection.cursor = cursor;
- setCursorIntern(bview, selection.start.par(),
- selection.start.pos(),
- false, selection.start.boundary());
- selection.start = cursor;
- setCursorIntern(bview, selection.end.par(),
- selection.end.pos(),
- false, selection.end.boundary());
- selection.end = cursor;
- setCursorIntern(bview, last_sel_cursor.par(),
- last_sel_cursor.pos(),
- false, last_sel_cursor.boundary());
- last_sel_cursor = cursor;
- cursor = tmpcursor;
- }
- setCursorIntern(bview, cursor.par(), cursor.pos(),
- false, cursor.boundary());
-}
-
-
-// returns false if inset wasn't found
-bool LyXText::updateInset(BufferView * bview, Inset * inset)
+bool LyXText::setCursor(ParagraphList::iterator pit,
+ pos_type pos,
+ bool setfont, bool boundary)
{
- // first check the current paragraph
- int pos = cursor.par()->getPositionOfInset(inset);
- if (pos != -1) {
- checkParagraph(bview, cursor.par(), pos);
- return true;
- }
-
- // check every paragraph
-
- Paragraph * par = ownerParagraph();
- do {
- pos = par->getPositionOfInset(inset);
- if (pos != -1) {
- checkParagraph(bview, par, pos);
- return true;
- }
- par = par->next();
- } while (par);
-
- return false;
+ LyXCursor old_cursor = cursor;
+ setCursorIntern(pit, pos, setfont, boundary);
+ return deleteEmptyParagraphMechanism(old_cursor);
}
-bool LyXText::setCursor(BufferView * bview, Paragraph * par,
- pos_type pos,
- bool setfont, bool boundary) const
+void LyXText::redoCursor()
{
- LyXCursor old_cursor = cursor;
- setCursorIntern(bview, par, pos, setfont, boundary);
- return deleteEmptyParagraphMechanism(bview, old_cursor);
+#warning maybe the same for selections?
+ setCursor(cursor, cursor.par(), cursor.pos(), cursor.boundary());
}
-void LyXText::setCursor(BufferView * bview, LyXCursor & cur, Paragraph * par,
- pos_type pos, bool boundary) const
+void LyXText::setCursor(LyXCursor & cur, ParagraphList::iterator pit,
+ pos_type pos, bool boundary)
{
- lyx::Assert(par);
- lyx::Assert(bview);
+ Assert(pit != ownerParagraphs().end());
- cur.par(par);
+ cur.par(pit);
cur.pos(pos);
cur.boundary(boundary);
+ if (noRows())
+ return;
// get the cursor y position in text
- int y = 0;
- Row * row = getRow(par, pos, y);
- Row * old_row = row;
- cur.irow(row);
+
+ RowList::iterator row = getRow(pit, pos);
+ int y = row->y();
+
+ 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());
- Inset * ins;
- if (row->previous() && pos &&
- row->previous()->par() == row->par() &&
- par->getChar(pos) == Paragraph::META_INSET &&
- (ins=par->getInset(pos)) && (ins->needFullRow() || ins->display()))
- {
- row = row->previous();
- 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 = rowLastPrintable(old_row);
+ pos_type last = lastPrintablePos(*pit, old_row);
- if (pos > last + 1) {
+ // None of these should happen, but we're scaredy-cats
+ if (pos > pit->size()) {
+ lyxerr << "dont like 1, pos: " << pos << " size: " << pit->size() << endl;
+ pos = 0;
+ cur.pos(0);
+ } else if (pos > last + 1) {
+ lyxerr << "dont like 2 please report" << endl;
// This shouldn't happen.
pos = last + 1;
cur.pos(pos);
} else if (pos < row->pos()) {
+ lyxerr << "dont like 3 please report" << endl;
pos = row->pos();
cur.pos(pos);
}
// now get the cursors x position
- float x = getCursorX(bview, 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(bview, 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(BufferView * bview, Row * row,
- pos_type pos, pos_type last, bool boundary) const
+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;
- // This call HAS to be here because of the BidiTables!!!
- prepareToPrint(bview, row, x, fill_separator, fill_hfill,
- fill_label_hfill);
-
- if (last < row->pos())
- cursor_vpos = row->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 = (row->par()->isRightToLeftPar(bview->buffer()->params))
- ? row->pos() : last + 1;
- else if (pos > row->pos() &&
- (pos > last || boundary))
- /// Place cursor after char at (logical) position pos - 1
+ 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 - 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 main_body =
- beginningOfMainBody(bview->buffer(), row->par());
- if ((main_body > 0) &&
- ((main_body-1 > last) ||
- !row->par()->isLineSeparator(main_body-1)))
- main_body = 0;
+ 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 = row->pos(); vpos < cursor_vpos; ++vpos) {
+ for (pos_type vpos = rit_pos; vpos < cursor_vpos; ++vpos) {
pos_type pos = vis2log(vpos);
- if (main_body > 0 && pos == main_body - 1) {
+ if (body_pos > 0 && pos == body_pos - 1) {
x += fill_label_hfill +
font_metrics::width(
- row->par()->layout()->labelsep,
- getLabelFont(bview->buffer(),
- row->par()));
- if (row->par()->isLineSeparator(main_body - 1))
- x -= singleWidth(bview,
- row->par(), main_body - 1);
+ pit->layout()->labelsep, getLabelFont(pit));
+ if (pit->isLineSeparator(body_pos - 1))
+ x -= singleWidth(pit, body_pos - 1);
}
- if (hfillExpansion(bview->buffer(), row, pos)) {
- x += singleWidth(bview, row->par(), pos);
- if (pos >= main_body)
+
+ if (hfillExpansion(*pit, rit, pos)) {
+ x += singleWidth(pit, pos);
+ if (pos >= body_pos)
x += fill_hfill;
else
x += fill_label_hfill;
- } else if (row->par()->isSeparator(pos)) {
- x += singleWidth(bview, row->par(), pos);
- if (pos >= main_body)
+ } else if (pit->isSeparator(pos)) {
+ x += singleWidth(pit, pos);
+ if (pos >= body_pos)
x += fill_separator;
} else
- x += singleWidth(bview, row->par(), pos);
+ x += singleWidth(pit, pos);
}
return x;
}
-void LyXText::setCursorIntern(BufferView * bview, Paragraph * par,
- pos_type pos, bool setfont, bool boundary) const
+void LyXText::setCursorIntern(ParagraphList::iterator pit,
+ pos_type pos, bool setfont, bool boundary)
{
- InsetText * it = static_cast<InsetText *>(par->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(bview)->setCursorIntern(bview, par, pos, setfont, boundary);
- return;
- }
- }
-
- setCursor(bview, cursor, par, pos, boundary);
+ setCursor(cursor, pit, pos, boundary);
if (setfont)
- setCurrentFont(bview);
+ setCurrentFont();
}
-void LyXText::setCurrentFont(BufferView * bview) const
+void LyXText::setCurrentFont()
{
pos_type pos = cursor.pos();
+ ParagraphList::iterator pit = cursor.par();
+
if (cursor.boundary() && pos > 0)
--pos;
if (pos > 0) {
- if (pos == cursor.par()->size())
+ if (pos == pit->size())
--pos;
else // potentional bug... BUG (Lgb)
- if (cursor.par()->isSeparator(pos)) {
- if (pos > cursor.row()->pos() &&
+ if (pit->isSeparator(pos)) {
+ if (pos > cursorRow()->pos() &&
bidi_level(pos) % 2 ==
bidi_level(pos - 1) % 2)
--pos;
- else if (pos + 1 < cursor.par()->size())
+ else if (pos + 1 < pit->size())
++pos;
}
}
- current_font =
- cursor.par()->getFontSettings(bview->buffer()->params, pos);
- real_current_font = getFont(bview->buffer(), cursor.par(), pos);
+ current_font = pit->getFontSettings(bv()->buffer()->params, pos);
+ real_current_font = getFont(pit, pos);
- if (cursor.pos() == cursor.par()->size() &&
- isBoundary(bview->buffer(), cursor.par(), cursor.pos()) &&
+ if (cursor.pos() == pit->size() &&
+ isBoundary(*bv()->buffer(), *pit, cursor.pos()) &&
!cursor.boundary()) {
Language const * lang =
- cursor.par()->getParLanguage(bview->buffer()->params);
+ pit->getParLanguage(bv()->buffer()->params);
current_font.setLanguage(lang);
current_font.setNumber(LyXFont::OFF);
real_current_font.setLanguage(lang);
}
-void LyXText::setCursorFromCoordinates(BufferView * bview, int x, int y) const
+// 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(ParagraphList::iterator pit,
+ RowList::iterator rit, int & x, bool & boundary) const
{
- LyXCursor old_cursor = cursor;
+ double tmpx = rit->x();
+ double fill_separator = rit->fill_separator();
+ double fill_hfill = rit->fill_hfill();
+ double fill_label_hfill = rit->fill_label_hfill();
- setCursorFromCoordinates(bview, cursor, x, y);
- setCurrentFont(bview);
- deleteEmptyParagraphMechanism(bview, old_cursor);
-}
+ pos_type vc = rit->pos();
+ pos_type last = lastPrintablePos(*pit, rit);
+ pos_type c = 0;
+ LyXLayout_ptr const & layout = pit->layout();
+ bool left_side = false;
-namespace {
+ pos_type body_pos = pit->beginningOfBody();
+ double last_tmpx = tmpx;
- /**
- * 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(Row & row, LyXCursor & cur) {
- if (!row.next())
- return false;
- Row const & next = *row.next();
+ if (body_pos > 0 &&
+ (body_pos - 1 > last ||
+ !pit->isLineSeparator(body_pos - 1)))
+ body_pos = 0;
- if (next.pos() != cur.pos() || next.par() != cur.par())
- return false;
- if (!cur.par()->isInset(cur.pos()))
- return false;
- Inset const * inset = cur.par()->getInset(cur.pos());
- if (inset->needFullRow() || inset->display())
- return true;
- return false;
+ // check for empty row
+ if (!pit->size()) {
+ x = int(tmpx);
+ return 0;
}
+
+ while (vc <= last && tmpx <= x) {
+ c = vis2log(vc);
+ last_tmpx = tmpx;
+ if (body_pos > 0 && c == body_pos - 1) {
+ tmpx += fill_label_hfill +
+ font_metrics::width(layout->labelsep, getLabelFont(pit));
+ if (pit->isLineSeparator(body_pos - 1))
+ tmpx -= singleWidth(pit, body_pos - 1);
+ }
+
+ if (hfillExpansion(*pit, rit, c)) {
+ tmpx += singleWidth(pit, c);
+ if (c >= body_pos)
+ tmpx += fill_hfill;
+ else
+ tmpx += fill_label_hfill;
+ } else if (pit->isSeparator(c)) {
+ tmpx += singleWidth(pit, c);
+ if (c >= body_pos)
+ tmpx += fill_separator;
+ } else {
+ tmpx += singleWidth(pit, c);
+ }
+ ++vc;
+ }
+
+ if ((tmpx + last_tmpx) / 2 > x) {
+ tmpx = last_tmpx;
+ left_side = true;
+ }
+
+ if (vc > last + 1) // This shouldn't happen.
+ vc = last + 1;
+
+ 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) == pit->rows.end();
+
+ // If lastrow is false, we don't need to compute
+ // the value of rtl.
+ bool const rtl = (lastrow)
+ ? 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)))
+ c = last + 1;
+ else if (vc == rit->pos()) {
+ c = vis2log(vc);
+ if (bidi_level(c) % 2 == 1)
+ ++c;
+ } else {
+ c = vis2log(vc - 1);
+ bool const rtl = (bidi_level(c) % 2 == 1);
+ if (left_side == rtl) {
+ ++c;
+ boundary = isBoundary(*bv()->buffer(), *pit, c);
+ }
+ }
+
+ if (rit->pos() <= last && c > last && pit->isNewline(last)) {
+ if (bidi_level(last) % 2 == 0)
+ tmpx -= singleWidth(pit, last);
+ else
+ tmpx += singleWidth(pit, last);
+ c = last;
+ }
+
+ c -= rit->pos();
+ x = int(tmpx);
+ return c;
+}
+
+
+void LyXText::setCursorFromCoordinates(int x, int y)
+{
+ LyXCursor old_cursor = cursor;
+ setCursorFromCoordinates(cursor, x, y);
+ setCurrentFont();
+ deleteEmptyParagraphMechanism(old_cursor);
}
-void LyXText::setCursorFromCoordinates(BufferView * bview, LyXCursor & cur,
- int x, int y) const
+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();
- Row * row = getRowNearY(y);
bool bound = false;
- pos_type const column = getColumnNearX(bview, 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.row(row);
+ cur.y(y + rit->baseline());
+
+ cur.iy(cur.y());
+ cur.ix(cur.x());
- if (beforeFullRowInset(*row, cur)) {
- pos_type last = rowLastPrintable(row);
- float x = getCursorX(bview, row->next(), cur.pos(), last, bound);
- cur.ix(int(x));
- cur.iy(y + row->height() + row->next()->baseline());
- cur.irow(row->next());
- } else {
- cur.iy(cur.y());
- cur.ix(cur.x());
- cur.irow(row);
- }
cur.boundary(bound);
}
-void LyXText::cursorLeft(BufferView * bview, bool internal) const
+void LyXText::cursorLeft(bool internal)
{
if (cursor.pos() > 0) {
bool boundary = cursor.boundary();
- setCursor(bview, cursor.par(), cursor.pos() - 1, true, false);
+ setCursor(cursor.par(), cursor.pos() - 1, true, false);
if (!internal && !boundary &&
- isBoundary(bview->buffer(), cursor.par(), cursor.pos() + 1))
- setCursor(bview, cursor.par(), cursor.pos() + 1, true, true);
- } else if (cursor.par()->previous()) { // steps into the above paragraph.
- Paragraph * par = cursor.par()->previous();
- setCursor(bview, par, par->size());
+ 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
+ ParagraphList::iterator pit = boost::prior(cursor.par());
+ setCursor(pit, pit->size());
}
}
-void LyXText::cursorRight(BufferView * bview, bool internal) const
+void LyXText::cursorRight(bool internal)
{
- if (!internal && cursor.boundary() &&
- !cursor.par()->isNewline(cursor.pos()))
- setCursor(bview, cursor.par(), cursor.pos(), true, false);
- else if (cursor.pos() < cursor.par()->size()) {
- setCursor(bview, cursor.par(), cursor.pos() + 1, true, false);
+ bool const at_end = (cursor.pos() == cursor.par()->size());
+ bool const at_newline = !at_end &&
+ cursor.par()->isNewline(cursor.pos());
+
+ if (!internal && cursor.boundary() && !at_newline)
+ setCursor(cursor.par(), cursor.pos(), true, false);
+ else if (!at_end) {
+ setCursor(cursor.par(), cursor.pos() + 1, true, false);
if (!internal &&
- isBoundary(bview->buffer(), cursor.par(), cursor.pos()))
- setCursor(bview, cursor.par(), cursor.pos(), true, true);
- } else if (cursor.par()->next())
- setCursor(bview, cursor.par()->next(), 0);
+ 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);
}
-void LyXText::cursorUp(BufferView * bview, bool selecting) const
+void LyXText::cursorUp(bool selecting)
{
#if 1
int x = cursor.x_fix();
- int y = cursor.y() - cursor.row()->baseline() - 1;
- setCursorFromCoordinates(bview, x, y);
+ int y = cursor.y() - cursorRow()->baseline() - 1;
+ setCursorFromCoordinates(x, y);
if (!selecting) {
- int y1 = cursor.iy() - first_y;
+ int topy = bv_owner->top_y();
+ int y1 = cursor.iy() - topy;
int y2 = y1;
- y -= first_y;
- Inset * inset_hit = checkInsetHit(bview, x, y1);
+ y -= topy;
+ InsetOld * inset_hit = checkInsetHit(x, y1);
if (inset_hit && isHighlyEditableInset(inset_hit)) {
- inset_hit->edit(bview, x, y - (y2 - y1), mouse_button::none);
+ inset_hit->localDispatch(
+ FuncRequest(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none));
}
}
#else
- setCursorFromCoordinates(bview, 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
}
-void LyXText::cursorDown(BufferView * bview, bool selecting) const
+void LyXText::cursorDown(bool selecting)
{
#if 1
int x = cursor.x_fix();
- int y = cursor.y() - cursor.row()->baseline() +
- cursor.row()->height() + 1;
- setCursorFromCoordinates(bview, x, y);
- if (!selecting && cursor.row() == cursor.irow()) {
- int y1 = cursor.iy() - first_y;
+ int y = cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1;
+ setCursorFromCoordinates(x, y);
+ if (!selecting && cursorRow() == cursorIRow()) {
+ int topy = bv_owner->top_y();
+ int y1 = cursor.iy() - topy;
int y2 = y1;
- y -= first_y;
- Inset * inset_hit = checkInsetHit(bview, x, y1);
+ y -= topy;
+ InsetOld * inset_hit = checkInsetHit(x, y1);
if (inset_hit && isHighlyEditableInset(inset_hit)) {
- inset_hit->edit(bview, 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(bview, 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(BufferView * bview) const
+void LyXText::cursorUpParagraph()
{
- if (cursor.pos() > 0) {
- setCursor(bview, cursor.par(), 0);
- }
- else if (cursor.par()->previous()) {
- setCursor(bview, cursor.par()->previous(), 0);
- }
+ if (cursor.pos() > 0)
+ setCursor(cursor.par(), 0);
+ else if (cursor.par() != ownerParagraphs().begin())
+ setCursor(boost::prior(cursor.par()), 0);
}
-void LyXText::cursorDownParagraph(BufferView * bview) const
+void LyXText::cursorDownParagraph()
{
- if (cursor.par()->next()) {
- setCursor(bview, cursor.par()->next(), 0);
- } else {
- setCursor(bview, 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(BufferView * bview,
- LyXCursor & cur,
- LyXCursor const & where) const
+void LyXText::fixCursorAfterDelete(LyXCursor & cur, LyXCursor const & where)
{
// if cursor is not in the paragraph where the delete occured,
// do nothing
cur.pos(cur.par()->size());
// recompute row et al. for this cursor
- setCursor(bview, cur, cur.par(), cur.pos(), cur.boundary());
+ setCursor(cur, cur.par(), cur.pos(), cur.boundary());
}
-bool LyXText::deleteEmptyParagraphMechanism(BufferView * bview,
- LyXCursor const & old_cursor) const
+bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
{
// Would be wrong to delete anything if we have a selection.
if (selection.set())
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
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 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(bview, old_cursor, old_cursor.par()->next());
+ 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
// automated way in LyXCursor code. (JMarc 26/09/2001)
#endif
// correct all cursors held by the LyXText
- fixCursorAfterDelete(bview, cursor, old_cursor);
- fixCursorAfterDelete(bview, selection.cursor,
- old_cursor);
- fixCursorAfterDelete(bview, selection.start,
- old_cursor);
- fixCursorAfterDelete(bview, selection.end, old_cursor);
- fixCursorAfterDelete(bview, last_sel_cursor,
- old_cursor);
- fixCursorAfterDelete(bview, toggle_cursor, old_cursor);
- fixCursorAfterDelete(bview, toggle_end_cursor,
- old_cursor);
+ fixCursorAfterDelete(cursor, old_cursor);
+ fixCursorAfterDelete(selection.cursor, old_cursor);
+ fixCursorAfterDelete(selection.start, old_cursor);
+ fixCursorAfterDelete(selection.end, old_cursor);
return false;
}
}
// don't delete anything if this is the ONLY paragraph!
- if (!old_cursor.par()->next() && !old_cursor.par()->previous())
+ if (ownerParagraphs().size() == 1)
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
// we can't possibly have deleted a paragraph before this point
bool deleted = false;
- if ((old_cursor.par()->empty()
- || (old_cursor.par()->size() == 1
- && old_cursor.par()->isLineSeparator(0)))) {
- // ok, we will delete anything
+ if (old_cursor.par()->empty() ||
+ (old_cursor.par()->size() == 1 &&
+ old_cursor.par()->isLineSeparator(0))) {
+ // ok, we will delete something
LyXCursor tmpcursor;
- // make sure that you do not delete any environments
- status(bview, LyXText::NEED_MORE_REFRESH);
deleted = true;
- if (old_cursor.row()->previous()) {
- refresh_row = old_cursor.row()->previous();
- refresh_y = old_cursor.y() - old_cursor.row()->baseline() - refresh_row->height();
- tmpcursor = cursor;
- cursor = old_cursor; // that undo can restore the right cursor position
- Paragraph * endpar = old_cursor.par()->next();
- if (endpar && endpar->getDepth()) {
- while (endpar && endpar->getDepth()) {
- endpar = endpar->next();
- }
- }
- setUndo(bview, Undo::DELETE, old_cursor.par(), endpar);
- cursor = tmpcursor;
+ bool selection_position_was_oldcursor_position = (
+ selection.cursor.par() == old_cursor.par()
+ && selection.cursor.pos() == old_cursor.pos());
- // delete old row
- removeRow(old_cursor.row());
- if (ownerParagraph() == old_cursor.par()) {
- ownerParagraph(ownerParagraph()->next());
- }
- // delete old par
- delete 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 (refresh_row->next()) {
- breakAgain(bview, refresh_row->next());
- updateCounters(bview);
- }
- setHeightOfRow(bview, refresh_row);
- } else {
- refresh_row = old_cursor.row()->next();
- refresh_y = old_cursor.y() - old_cursor.row()->baseline();
-
- tmpcursor = cursor;
- cursor = old_cursor; // that undo can restore the right cursor position
- Paragraph * endpar = old_cursor.par()->next();
- if (endpar && endpar->getDepth()) {
- while (endpar && endpar->getDepth()) {
- endpar = endpar->next();
- }
- }
- setUndo(bview, Undo::DELETE, old_cursor.par(), endpar);
- cursor = tmpcursor;
-
- // delete old row
- removeRow(old_cursor.row());
- // delete old par
- if (ownerParagraph() == old_cursor.par()) {
- ownerParagraph(ownerParagraph()->next());
- }
+ tmpcursor = cursor;
+ cursor = old_cursor; // that undo can restore the right cursor position
- delete old_cursor.par();
+ ParagraphList::iterator endpit = boost::next(old_cursor.par());
+ while (endpit != ownerParagraphs().end() && endpit->getDepth())
+ ++endpit;
- /* 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 (refresh_row) {
- breakAgain(bview, refresh_row);
- updateCounters(bview);
- }
- }
+ 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(bview, cursor.par(), cursor.pos());
+ setCursorIntern(cursor.par(), cursor.pos());
- if (selection.cursor.par() == old_cursor.par()
- && selection.cursor.pos() == old_cursor.pos()) {
+ if (selection_position_was_oldcursor_position) {
// correct selection
selection.cursor = cursor;
}
}
if (!deleted) {
if (old_cursor.par()->stripLeadingSpaces()) {
- redoParagraphs(bview, old_cursor,
- old_cursor.par()->next());
+ redoParagraph(old_cursor.par());
// correct cursor y
- setCursorIntern(bview, cursor.par(), cursor.pos());
+ setCursorIntern(cursor.par(), cursor.pos());
selection.cursor = cursor;
}
}
}
-Paragraph * LyXText::ownerParagraph() const
+ParagraphList & LyXText::ownerParagraphs() const
{
- if (inset_owner) {
- return inset_owner->paragraph();
- }
- return &*(bv_owner->buffer()->paragraphs.begin());
+ return paragraphs_;
}
-void LyXText::ownerParagraph(Paragraph * p) const
+bool LyXText::isInInset() const
{
- if (inset_owner) {
- inset_owner->paragraph(p);
- } else {
- bv_owner->buffer()->paragraphs.set(p);
- }
+ // Sub-level has non-null bv owner and non-null inset owner.
+ return inset_owner != 0;
}
-void LyXText::ownerParagraph(int id, Paragraph * p) const
+int defaultRowHeight()
{
- Paragraph * op = bv_owner->buffer()->getParFromID(id);
- if (op && op->inInset()) {
- static_cast<InsetText *>(op->inInset())->paragraph(p);
- } else {
- ownerParagraph(p);
- }
-}
-
-
-LyXText::text_status LyXText::status() const
-{
- return status_;
-}
-
-
-void LyXText::status(BufferView * bview, LyXText::text_status st) const
-{
- LyXText * t = bview->text;
-
- // We should only go up with refreshing code so this means that if
- // we have a MORE refresh we should never set it to LITTLE if we still
- // didn't handle it (and then it will be UNCHANGED. Now as long as
- // we stay inside one LyXText this may work but we need to tell the
- // outermost LyXText that it should REALLY draw us if there is some
- // change in a Inset::LyXText. So you see that when we are inside a
- // inset's LyXText we give the LITTLE to the outermost LyXText to
- // tell'em that it should redraw the actual row (where the inset
- // resides! Capito?!
-
- if (status_ != NEED_MORE_REFRESH || st != NEED_VERY_LITTLE_REFRESH) {
- status_ = st;
- if (inset_owner && st != UNCHANGED) {
- t->status(bview, NEED_VERY_LITTLE_REFRESH);
- if (!t->refresh_row) {
- t->refresh_row = t->cursor.row();
- t->refresh_y = t->cursor.y() -
- t->cursor.row()->baseline();
- }
- }
- }
+ LyXFont const font(LyXFont::ALL_SANE);
+ return int(font_metrics::maxAscent(font)
+ + font_metrics::maxDescent(font) * 1.5);
}