-/* This file is part of
- * ======================================================
+/**
+ * \file text2.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
*
- * LyX, The Document Processor
+ * \author Asger Alstrup
+ * \author Lars Gullik Bjønnes
+ * \author Alfredo Braunstein
+ * \author Jean-Marc Lasgouttes
+ * \author Angus Leeming
+ * \author John Levon
+ * \author André Pönitz
+ * \author Allan Rae
+ * \author Dekel Tsur
+ * \author Jürgen Vigna
*
- * Copyright 1995 Matthias Ettrich
- * Copyright 1995-2001 The LyX Team.
- *
- * ====================================================== */
+ * Full author contact details are available in file CREDITS.
+ */
#include <config.h>
#include "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 "Bullet.h"
+#include "counters.h"
#include "CutAndPaste.h"
-#include "frontends/Painter.h"
-#include "frontends/font_metrics.h"
#include "debug.h"
-#include "lyxrc.h"
+#include "dispatchresult.h"
+#include "errorlist.h"
+#include "Floating.h"
#include "FloatList.h"
+#include "funcrequest.h"
+#include "gettext.h"
#include "language.h"
-#include "ParagraphParameters.h"
-#include "counters.h"
+#include "lyxrc.h"
+#include "lyxrow.h"
#include "lyxrow_funcs.h"
-#include "metricsinfo.h"
+#include "paragraph.h"
#include "paragraph_funcs.h"
+#include "ParagraphParameters.h"
+#include "undo.h"
+#include "vspace.h"
+
+#include "frontends/font_metrics.h"
+#include "frontends/LyXView.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/textutils.h"
+#include "support/tostr.h"
+#include "support/std_sstream.h"
#include <boost/tuple/tuple.hpp>
-#include <algorithm>
-
-using namespace lyx::support;
-
-using std::vector;
-using std::copy;
-using std::endl;
-using std::find;
-using std::pair;
using lyx::pos_type;
+using lyx::paroffset_type;
+using lyx::support::bformat;
-
-LyXText::LyXText(BufferView * bv)
- : height(0), width(0), anchor_y_(0),
- inset_owner(0), the_locking_inset(0), bv_owner(bv)
-{}
+using std::endl;
+using std::ostringstream;
+using std::string;
-LyXText::LyXText(BufferView * bv, InsetText * inset)
- : height(0), width(0), anchor_y_(0),
- inset_owner(inset), the_locking_inset(0), bv_owner(bv)
-{}
+LyXText::LyXText(BufferView * bv, InsetText * inset, bool ininset,
+ ParagraphList & paragraphs)
+ : height(0), width(0),
+ inset_owner(inset), the_locking_inset(0), bv_owner(bv),
+ in_inset_(ininset), paragraphs_(¶graphs),
+ cache_pos_(-1)
+{
+}
void LyXText::init(BufferView * bview)
width = 0;
height = 0;
-
- anchor_y_ = 0;
+ cache_pos_ = -1;
current_font = getFont(beg, 0);
redoParagraphs(beg, end);
- setCursorIntern(beg, 0);
+ setCursorIntern(0, 0);
selection.cursor = cursor;
updateCounters();
// smaller. (Asger)
LyXFont LyXText::getFont(ParagraphList::iterator pit, pos_type pos) const
{
- Assert(pos >= 0);
+ BOOST_ASSERT(pos >= 0);
LyXLayout_ptr const & layout = pit->layout();
#warning broken?
- BufferParams const & params = bv()->buffer()->params;
+ BufferParams const & params = bv()->buffer()->params();
+ pos_type const body_pos = pit->beginningOfBody();
// We specialize the 95% common case:
if (!pit->getDepth()) {
- if (layout->labeltype == LABEL_MANUAL
- && pos < pit->beginningOfBody()) {
- // 1% goes here
- LyXFont f = pit->getFontSettings(params, pos);
- if (pit->inInset())
- pit->inInset()->getDrawFont(f);
+ LyXFont f = pit->getFontSettings(params, pos);
+ if (pit->inInset())
+ pit->inInset()->getDrawFont(f);
+ if (layout->labeltype == LABEL_MANUAL && pos < body_pos)
return f.realize(layout->reslabelfont);
- } else {
- LyXFont f = pit->getFontSettings(params, pos);
- if (pit->inInset())
- pit->inInset()->getDrawFont(f);
+ else
return f.realize(layout->resfont);
- }
}
// The uncommon case need not be optimized as much
-
LyXFont layoutfont;
-
- if (pos < pit->beginningOfBody()) {
- // 1% goes here
+ if (pos < body_pos)
layoutfont = layout->labelfont;
- } else {
- // 99% goes here
+ else
layoutfont = layout->font;
- }
- LyXFont tmpfont = pit->getFontSettings(params, pos);
- tmpfont.realize(layoutfont);
+ LyXFont font = pit->getFontSettings(params, pos);
+ font.realize(layoutfont);
if (pit->inInset())
- pit->inInset()->getDrawFont(tmpfont);
+ pit->inInset()->getDrawFont(font);
// Realize with the fonts of lesser depth.
- tmpfont.realize(outerFont(pit, ownerParagraphs()));
- tmpfont.realize(defaultfont_);
+ //font.realize(outerFont(pit, ownerParagraphs()));
+ font.realize(defaultfont_);
- return tmpfont;
+ return font;
}
LyXFont font = layout->font;
// Realize with the fonts of lesser depth.
- font.realize(outerFont(pit, ownerParagraphs()));
+ //font.realize(outerFont(pit, ownerParagraphs()));
font.realize(defaultfont_);
return font;
pos_type pos, LyXFont const & fnt,
bool toggleall)
{
- BufferParams const & params = bv()->buffer()->params;
+ BufferParams const & params = bv()->buffer()->params();
LyXFont font = getFont(pit, pos);
font.update(fnt, params.language, toggleall);
// Let the insets convert their font
InsetOld * LyXText::getInset() const
{
- ParagraphList::iterator pit = cursor.par();
+ ParagraphList::iterator pit = cursorPar();
pos_type const pos = cursor.pos();
if (pos < pit->size() && pit->isInset(pos)) {
// do we want to keep this?? (JMarc)
if (!isHighlyEditableInset(inset))
- recordUndo(bv(), Undo::ATOMIC);
+ recUndo(cursor.par());
if (inset->isOpen())
inset->close(bv());
else
inset->open(bv());
- bv()->updateInset();
+ bv()->updateInset(inset);
}
LyXCursor & send_cur,
string const & layout)
{
- ParagraphList::iterator endpit = boost::next(send_cur.par());
+ ParagraphList::iterator endpit = boost::next(getPar(send_cur));
ParagraphList::iterator undoendpit = endpit;
ParagraphList::iterator pars_end = ownerParagraphs().end();
++endpit;
}
- recordUndo(bv(), Undo::ATOMIC, sstart_cur.par(), boost::prior(undoendpit));
+ recUndo(sstart_cur.par(), parOffset(undoendpit) - 1);
// ok we have a selection. This is always between sstart_cur
// and sel_end cursor
cur = sstart_cur;
- ParagraphList::iterator pit = sstart_cur.par();
- ParagraphList::iterator epit = boost::next(send_cur.par());
+ ParagraphList::iterator pit = getPar(sstart_cur);
+ ParagraphList::iterator epit = boost::next(getPar(send_cur));
+ BufferParams const & bufparams = bv()->buffer()->params();
LyXLayout_ptr const & lyxlayout =
- bv()->buffer()->params.getLyXTextClass()[layout];
+ bufparams.getLyXTextClass()[layout];
do {
pit->applyLayout(lyxlayout);
- makeFontEntriesLayoutSpecific(bv()->buffer()->params, *pit);
+ makeFontEntriesLayoutSpecific(bufparams, *pit);
pit->params().spaceTop(lyxlayout->fill_top ?
VSpace(VSpace::VFILL)
: VSpace(VSpace::NONE));
: VSpace(VSpace::NONE));
if (lyxlayout->margintype == MARGIN_MANUAL)
pit->setLabelWidthString(lyxlayout->labelstring());
- cur.par(pit);
+ cur.par(std::distance(ownerParagraphs().begin(), pit));
++pit;
} while (pit != epit);
}
// special handling of new environment insets
- BufferParams const & params = bv()->buffer()->params;
+ BufferParams const & params = bv()->buffer()->params();
LyXLayout_ptr const & lyxlayout = params.getLyXTextClass()[layout];
if (lyxlayout->is_environment) {
// move everything in a new environment inset
ParagraphList::iterator endpit = setLayout(cursor, selection.start,
selection.end, layout);
- redoParagraphs(selection.start.par(), endpit);
+ redoParagraphs(getPar(selection.start), endpit);
// we have to reset the selection, because the
// geometry could have changed
bool LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type, bool test_only)
{
- ParagraphList::iterator pit = cursor.par();
- ParagraphList::iterator end = cursor.par();
+ ParagraphList::iterator pit = cursorPar();
+ ParagraphList::iterator end = cursorPar();
ParagraphList::iterator start = pit;
if (selection.set()) {
- pit = selection.start.par();
- end = selection.end.par();
+ pit = getPar(selection.start);
+ end = getPar(selection.end);
start = pit;
}
ParagraphList::iterator pastend = boost::next(end);
if (!test_only)
- recordUndo(bv(), Undo::ATOMIC, start, end);
+ recUndo(parOffset(start), parOffset(end));
bool changed = false;
if (!selection.set()) {
// Determine basis font
LyXFont layoutfont;
- if (cursor.pos() < cursor.par()->beginningOfBody()) {
- layoutfont = getLabelFont(cursor.par());
+ if (cursor.pos() < cursorPar()->beginningOfBody()) {
+ layoutfont = getLabelFont(cursorPar());
} else {
- layoutfont = getLayoutFont(cursor.par());
+ layoutfont = getLayoutFont(cursorPar());
}
// Update current font
real_current_font.update(font,
- bv()->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
- recordUndo(bv(), Undo::ATOMIC, selection.start.par(), selection.end.par());
+ recUndo(selection.start.par(), selection.end.par());
freezeUndo();
cursor = selection.start;
while (cursor.par() != selection.end.par() ||
cursor.pos() < selection.end.pos())
{
- if (cursor.pos() < cursor.par()->size()) {
+ if (cursor.pos() < cursorPar()->size()) {
// an open footnote should behave like a closed one
- setCharFont(cursor.par(), cursor.pos(),
- font, toggleall);
+ setCharFont(cursorPar(), cursor.pos(), font, toggleall);
cursor.pos(cursor.pos() + 1);
} else {
cursor.pos(0);
- cursor.par(boost::next(cursor.par()));
+ cursor.par(cursor.par() + 1);
}
}
unFreezeUndo();
- redoParagraph(selection.start.par());
+ redoParagraph(getPar(selection.start));
// we have to reset the selection, because the
// geometry could have changed, but we keep
}
-// 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)
-{
- for ( ; start != end; ++start)
- redoParagraph(start);
-}
-
-
-void LyXText::redoParagraph(ParagraphList::iterator pit)
-{
- RowList::iterator rit = pit->rows.begin();
- RowList::iterator end = pit->rows.end();
-
- // remove rows of paragraph
- for (int i = 0; rit != end; ++rit, ++i)
- height -= rit->height();
-
- pit->rows.clear();
-
- // 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());
-
- RowList::iterator tmprow = boost::prior(pit->rows.end());
-
- if (z >= pit->size())
- done = true;
- else {
- ++z;
- pit->rows.push_back(Row(z));
- }
-
- tmprow->fill(fill(pit, tmprow, workWidth()));
- setHeightOfRow(pit, tmprow);
- }
-
- //lyxerr << "redoParagraph: " << pit->rows.size() << " rows\n";
-}
-
-
-void LyXText::fullRebreak()
-{
- redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end());
- redoCursor();
- selection.cursor = cursor;
-}
-
-
-void LyXText::metrics(MetricsInfo & mi, Dimension & dim)
-{
- //lyxerr << "LyXText::metrics: width: " << mi.base.textwidth << endl;
- //Assert(mi.base.textwidth);
-
- // rebuild row cache
- width = 0;
- height = 0;
-
- //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));
-}
-
-
// important for the screen
// the cursor set functions have a special mechanism. When they
// realize, that you left an empty paragraph, they will delete it.
-// They also delete the corresponding row
// need the selection cursor:
void LyXText::setSelection()
void LyXText::cursorHome()
{
- setCursor(cursor.par(), cursorRow()->pos());
+ ParagraphList::iterator cpit = cursorPar();
+ setCursor(cpit, cpit->getRow(cursor.pos())->pos());
}
void LyXText::cursorEnd()
{
- if (cursor.par()->empty())
- return;
-
- RowList::iterator rit = cursorRow();
- RowList::iterator next_rit = boost::next(rit);
- RowList::iterator end = boost::next(rit);
- ParagraphList::iterator pit = cursor.par();
- pos_type last_pos = lastPos(*pit, rit);
-
- if (next_rit == end) {
- ++last_pos;
- } else {
- if (pit->empty() ||
- (pit->getChar(last_pos) != ' ' && !pit->isNewline(last_pos))) {
- ++last_pos;
- }
- }
-
- setCursor(pit, last_pos);
+ ParagraphList::iterator cpit = cursorPar();
+ pos_type end = cpit->getRow(cursor.pos())->endpos();
+ /* if not on the last row of the par, put the cursor before
+ the final space */
+ setCursor(cpit, end == cpit->size() ? end : end - 1);
}
// If there is a change in the language the implicit word selection
// is disabled.
LyXCursor resetCursor = cursor;
- bool implicitSelection = (font.language() == ignore_language
- && font.number() == LyXFont::IGNORE)
- ? selectWordWhenUnderCursor(lyx::WHOLE_WORD_STRICT) : false;
+ bool implicitSelection =
+ font.language() == ignore_language
+ && font.number() == LyXFont::IGNORE
+ && selectWordWhenUnderCursor(lyx::WHOLE_WORD_STRICT);
// Set font
setFont(font, toggleall);
if (implicitSelection) {
clearSelection();
cursor = resetCursor;
- setCursor(cursor.par(), cursor.pos());
+ setCursor(cursorPar(), cursor.pos());
selection.cursor = cursor;
}
}
else if (selection.start.par() != selection.end.par())
bv()->owner()->message(_("Cannot index more than one paragraph!"));
else
- idxstring = selectionAsString(bv()->buffer(), false);
+ idxstring = selectionAsString(*bv()->buffer(), false);
// Reset cursors to their original position.
cursor = reset_cursor;
- setCursor(cursor.par(), cursor.pos());
+ setCursor(cursorPar(), cursor.pos());
selection.cursor = cursor;
// Clear the implicit selection.
// they do not duplicate themself and you cannnot make dirty things with
// them!
-void LyXText::setParagraph(bool line_top, bool line_bottom,
- bool pagebreak_top, bool pagebreak_bottom,
+void LyXText::setParagraph(
VSpace const & space_top,
VSpace const & space_bottom,
Spacing const & spacing,
}
// make sure that the depth behind the selection are restored, too
- ParagraphList::iterator endpit = boost::next(selection.end.par());
+ ParagraphList::iterator endpit = boost::next(getPar(selection.end));
ParagraphList::iterator undoendpit = endpit;
ParagraphList::iterator pars_end = ownerParagraphs().end();
++endpit;
}
- recordUndo(bv(), Undo::ATOMIC, selection.start.par(),
- boost::prior(undoendpit));
+ recUndo(selection.start.par(), parOffset(undoendpit) - 1);
- ParagraphList::iterator tmppit = selection.end.par();
+ int tmppit = selection.end.par();
- while (tmppit != boost::prior(selection.start.par())) {
+ while (tmppit != selection.start.par() - 1) {
setCursor(tmppit, 0);
- ParagraphList::iterator pit = cursor.par();
+ ParagraphList::iterator const pit = cursorPar();
ParagraphParameters & params = pit->params();
-
- 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 = pit->layout();
}
pit->setLabelWidthString(labelwidthstring);
params.noindent(noindent);
- tmppit = boost::prior(pit);
+ --tmppit;
}
- redoParagraphs(selection.start.par(), endpit);
+ redoParagraphs(getPar(selection.start), endpit);
clearSelection();
setCursor(selection.start.par(), selection.start.pos());
setSelection();
setCursor(tmpcursor.par(), tmpcursor.pos());
if (inset_owner)
- bv()->updateInset();
+ bv()->updateInset(inset_owner);
+}
+
+
+namespace {
+
+string expandLabel(LyXTextClass const & textclass,
+ LyXLayout_ptr const & layout, bool appendix)
+{
+ string fmt = appendix ?
+ layout->labelstring_appendix() : layout->labelstring();
+
+ // handle 'inherited level parts' in 'fmt',
+ // i.e. the stuff between '@' in '@Section@.\arabic{subsection}'
+ size_t const i = fmt.find('@', 0);
+ if (i != string::npos) {
+ size_t const j = fmt.find('@', i + 1);
+ if (j != string::npos) {
+ string parent(fmt, i + 1, j - i - 1);
+ string label = expandLabel(textclass, textclass[parent], appendix);
+ fmt = string(fmt, 0, i) + label + string(fmt, j + 1, string::npos);
+ }
+ }
+
+ return textclass.counters().counterLabel(fmt);
+}
+
+
+void incrementItemDepth(ParagraphList::iterator pit,
+ ParagraphList::iterator first_pit)
+{
+ int const cur_labeltype = pit->layout()->labeltype;
+
+ if (cur_labeltype != LABEL_ENUMERATE &&
+ cur_labeltype != LABEL_ITEMIZE)
+ return;
+
+ int const cur_depth = pit->getDepth();
+
+ ParagraphList::iterator prev_pit = boost::prior(pit);
+ while (true) {
+ int const prev_depth = prev_pit->getDepth();
+ int const prev_labeltype = prev_pit->layout()->labeltype;
+ if (prev_depth == 0 && cur_depth > 0) {
+ if (prev_labeltype == cur_labeltype) {
+ pit->itemdepth = prev_pit->itemdepth + 1;
+ }
+ break;
+ } else if (prev_depth < cur_depth) {
+ if (prev_labeltype == cur_labeltype) {
+ pit->itemdepth = prev_pit->itemdepth + 1;
+ break;
+ }
+ } else if (prev_depth == cur_depth) {
+ if (prev_labeltype == cur_labeltype) {
+ pit->itemdepth = prev_pit->itemdepth;
+ break;
+ }
+ }
+ if (prev_pit == first_pit)
+ break;
+
+ --prev_pit;
+ }
}
+void resetEnumCounterIfNeeded(ParagraphList::iterator pit,
+ ParagraphList::iterator firstpit,
+ Counters & counters)
+{
+ if (pit == firstpit)
+ return;
+
+ int const cur_depth = pit->getDepth();
+ ParagraphList::iterator prev_pit = boost::prior(pit);
+ while (true) {
+ int const prev_depth = prev_pit->getDepth();
+ int const prev_labeltype = prev_pit->layout()->labeltype;
+ if (prev_depth <= cur_depth) {
+ if (prev_labeltype != LABEL_ENUMERATE) {
+ switch (pit->itemdepth) {
+ case 0:
+ counters.reset("enumi");
+ case 1:
+ counters.reset("enumii");
+ case 2:
+ counters.reset("enumiii");
+ case 3:
+ counters.reset("enumiv");
+ }
+ }
+ break;
+ }
+
+ if (prev_pit == firstpit)
+ break;
+
+ --prev_pit;
+ }
+}
+
+} // anon namespace
+
+
// set the counter of a paragraph. This includes the labels
-void LyXText::setCounter(Buffer const * buf, ParagraphList::iterator pit)
+void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
{
- LyXTextClass const & textclass = buf->params.getLyXTextClass();
+ BufferParams const & bufparams = buf.params();
+ LyXTextClass const & textclass = bufparams.getLyXTextClass();
LyXLayout_ptr const & layout = pit->layout();
+ ParagraphList::iterator first_pit = ownerParagraphs().begin();
+ Counters & counters = textclass.counters();
- if (pit != ownerParagraphs().begin()) {
+ // Always reset
+ pit->itemdepth = 0;
+ if (pit == first_pit) {
+ pit->params().appendix(pit->params().startOfAppendix());
+ } else {
pit->params().appendix(boost::prior(pit)->params().appendix());
if (!pit->params().appendix() &&
pit->params().startOfAppendix()) {
pit->params().appendix(true);
textclass.counters().reset();
}
- pit->enumdepth = boost::prior(pit)->enumdepth;
- pit->itemdepth = boost::prior(pit)->itemdepth;
- } else {
- 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) {
- pit->enumdepth++;
+ // Maybe we have to increment the item depth.
+ incrementItemDepth(pit, first_pit);
}
- // Maybe we have to decrement the enumeration depth, see note above
- if (pit != ownerParagraphs().begin()
- && boost::prior(pit)->getDepth() > pit->getDepth()
- && layout->labeltype != LABEL_BIBLIO) {
- pit->enumdepth = depthHook(pit, ownerParagraphs(),
- pit->getDepth())->enumdepth;
- }
-
- if (!pit->params().labelString().empty()) {
- pit->params().labelString(string());
- }
+ // erase what was there before
+ pit->params().labelString(string());
if (layout->margintype == MARGIN_MANUAL) {
if (pit->params().labelWidthString().empty())
}
// is it a layout that has an automatic label?
- if (layout->labeltype >= LABEL_COUNTER_CHAPTER) {
- int const i = layout->labeltype - LABEL_COUNTER_CHAPTER;
-
- ostringstream s;
-
- if (i >= 0 && i <= buf->params.secnumdepth) {
- string numbertype;
- string langtype;
+ if (layout->labeltype == LABEL_COUNTER) {
+ BufferParams const & bufparams = buf.params();
+ LyXTextClass const & textclass = bufparams.getLyXTextClass();
+ counters.step(layout->counter);
+ string label = expandLabel(textclass, layout, pit->params().appendix());
+ pit->params().labelString(label);
+ } else if (layout->labeltype == LABEL_ITEMIZE) {
+ // At some point of time we should do something more
+ // clever here, like:
+ // pit->params().labelString(
+ // bufparams.user_defined_bullet(pit->itemdepth).getText());
+ // for now, use a simple hardcoded label
+ string itemlabel;
+ switch (pit->itemdepth) {
+ case 0:
+ itemlabel = "*";
+ break;
+ case 1:
+ itemlabel = "-";
+ break;
+ case 2:
+ itemlabel = "@";
+ break;
+ case 3:
+ itemlabel = "·";
+ break;
+ }
- textclass.counters().step(layout->latexname());
+ pit->params().labelString(itemlabel);
+ } else if (layout->labeltype == LABEL_ENUMERATE) {
+ // Maybe we have to reset the enumeration counter.
+ resetEnumCounterIfNeeded(pit, first_pit, counters);
- // Is there a label? Useful for Chapter layout
- if (!pit->params().appendix()) {
- s << buf->B_(layout->labelstring());
- } else {
- s << buf->B_(layout->labelstring_appendix());
- }
+ // FIXME
+ // Yes I know this is a really, really! bad solution
+ // (Lgb)
+ string enumcounter = "enum";
- // Use of an integer is here less than elegant. For now.
- int head = textclass.maxcounter() - LABEL_COUNTER_CHAPTER;
- if (!pit->params().appendix()) {
- numbertype = "sectioning";
- } else {
- numbertype = "appendix";
- if (pit->isRightToLeftPar(buf->params))
- langtype = "hebrew";
- else
- langtype = "latin";
- }
-
- s << " "
- << textclass.counters()
- .numberLabel(layout->latexname(),
- numbertype, langtype, head);
-
- pit->params().labelString(STRCONV(s.str()));
-
- // reset enum counters
- textclass.counters().reset("enum");
- } else if (layout->labeltype < LABEL_COUNTER_ENUMI) {
- textclass.counters().reset("enum");
- } else if (layout->labeltype == LABEL_COUNTER_ENUMI) {
- // FIXME
- // Yes I know this is a really, really! bad solution
- // (Lgb)
- string enumcounter("enum");
-
- switch (pit->enumdepth) {
- case 2:
- enumcounter += 'i';
- case 1:
- enumcounter += 'i';
- case 0:
- enumcounter += 'i';
- break;
- case 3:
- enumcounter += "iv";
- break;
- default:
- // not a valid enumdepth...
- break;
- }
+ switch (pit->itemdepth) {
+ case 2:
+ enumcounter += 'i';
+ case 1:
+ enumcounter += 'i';
+ case 0:
+ enumcounter += 'i';
+ break;
+ case 3:
+ enumcounter += "iv";
+ break;
+ default:
+ // not a valid enumdepth...
+ break;
+ }
- textclass.counters().step(enumcounter);
+ counters.step(enumcounter);
- s << textclass.counters()
- .numberLabel(enumcounter, "enumeration");
- pit->params().labelString(STRCONV(s.str()));
- }
+ pit->params().labelString(counters.enumLabel(enumcounter));
} else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
- textclass.counters().step("bibitem");
- int number = textclass.counters().value("bibitem");
+ counters.step("bibitem");
+ int number = counters.value("bibitem");
if (pit->bibitem()) {
pit->bibitem()->setCounter(number);
pit->params().labelString(layout->labelstring());
}
// In biblio should't be following counters but...
} else {
- string s = buf->B_(layout->labelstring());
+ string s = buf.B_(layout->labelstring());
// the caption hack:
if (layout->labeltype == LABEL_SENSITIVE) {
isOK = true;
break;
} else {
- tmppit = ownerParagraphs().begin();
+ Paragraph const * owner = &ownerPar(buf, in);
+ tmppit = first_pit;
for ( ; tmppit != end; ++tmppit)
- if (&*tmppit == in->parOwner())
+ if (&*tmppit == owner)
break;
}
}
else if (in->lyxCode() == InsetOld::WRAP_CODE)
type = static_cast<InsetWrap*>(in)->params().type;
else
- Assert(0);
+ BOOST_ASSERT(false);
Floating const & fl = textclass.floats().getType(type);
- textclass.counters().step(fl.type());
+ counters.step(fl.type());
// Doesn't work... yet.
- s = bformat(_("%1$s #:"), buf->B_(fl.name()));
+ s = bformat(_("%1$s #:"), buf.B_(fl.name()));
} else {
// par->SetLayout(0);
// s = layout->labelstring;
}
pit->params().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 (pit->enumdepth) {
- case 0:
- textclass.counters().reset("enumi");
- case 1:
- textclass.counters().reset("enumii");
- case 2:
- textclass.counters().reset("enumiii");
- case 3:
- textclass.counters().reset("enumiv");
- }
}
}
void LyXText::updateCounters()
{
// start over
- bv()->buffer()->params.getLyXTextClass().counters().reset();
+ bv()->buffer()->params().getLyXTextClass().counters().reset();
ParagraphList::iterator beg = ownerParagraphs().begin();
ParagraphList::iterator end = ownerParagraphs().end();
pit->params().depth(maxdepth);
// setCounter can potentially change the labelString.
- setCounter(bv()->buffer(), pit);
+ setCounter(*bv()->buffer(), pit);
string const & newLabel = pit->params().labelString();
void LyXText::insertInset(InsetOld * inset)
{
- if (!cursor.par()->insetAllowed(inset->lyxCode()))
+ if (!cursorPar()->insetAllowed(inset->lyxCode()))
return;
- recordUndo(bv(), Undo::ATOMIC, cursor.par());
+ recUndo(cursor.par());
freezeUndo();
- cursor.par()->insertInset(cursor.pos(), inset);
+ cursorPar()->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 before
- // the inset. After an Undo LyX tries to call inset->edit(...)
+ // the inset. After an Undo LyX tries to call inset->edit(...)
// and fails if the cursor is behind the inset and getInset
// does not return the inset!
if (isHighlyEditableInset(inset))
// finished. The solution used currently just works, to make it
// faster we need to be more clever and probably also have more
// calls to stuffClipboard. (Lgb)
- bv()->stuffClipboard(selectionAsString(bv()->buffer(), true));
+ bv()->stuffClipboard(selectionAsString(*bv()->buffer(), true));
// This doesn't make sense, if there is no selection
if (!selection.set())
// and selection.end
// make sure that the depth behind the selection are restored, too
- ParagraphList::iterator endpit = boost::next(selection.end.par());
+ ParagraphList::iterator endpit = boost::next(getPar(selection.end.par()));
ParagraphList::iterator undoendpit = endpit;
ParagraphList::iterator pars_end = ownerParagraphs().end();
++endpit;
}
- recordUndo(bv(), Undo::DELETE, selection.start.par(),
- boost::prior(undoendpit));
+ recUndo(selection.start.par(), parOffset(undoendpit) - 1);
- endpit = selection.end.par();
+ endpit = getPar(selection.end.par());
int endpos = selection.end.pos();
+ BufferParams const & bufparams = bv()->buffer()->params();
boost::tie(endpit, endpos) = realcut ?
- CutAndPaste::cutSelection(bv()->buffer()->params,
+ CutAndPaste::cutSelection(bufparams,
ownerParagraphs(),
- selection.start.par(), endpit,
+ getPar(selection.start.par()), endpit,
selection.start.pos(), endpos,
- bv()->buffer()->params.textclass,
+ bufparams.textclass,
doclear)
- : CutAndPaste::eraseSelection(bv()->buffer()->params,
+ : CutAndPaste::eraseSelection(bufparams,
ownerParagraphs(),
- selection.start.par(), endpit,
+ getPar(selection.start.par()), endpit,
selection.start.pos(), endpos,
doclear);
// sometimes necessary
if (doclear)
- selection.start.par()->stripLeadingSpaces();
+ getPar(selection.start.par())->stripLeadingSpaces();
- redoParagraphs(selection.start.par(), boost::next(endpit));
+ redoParagraphs(getPar(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
cursor.pos(endpos);
- cursor.par(endpit);
+ cursor.par(parOffset(endpit));
// need a valid cursor. (Lgb)
clearSelection();
- setCursor(cursor.par(), cursor.pos());
+ setCursor(cursorPar(), cursor.pos());
selection.cursor = cursor;
updateCounters();
}
void LyXText::copySelection()
{
// stuff the selection onto the X clipboard, from an explicit copy request
- bv()->stuffClipboard(selectionAsString(bv()->buffer(), true));
+ bv()->stuffClipboard(selectionAsString(*bv()->buffer(), true));
// this doesnt make sense, if there is no selection
if (!selection.set())
// and sel_end cursor
// copy behind a space if there is one
- while (selection.start.par()->size() > selection.start.pos()
- && selection.start.par()->isLineSeparator(selection.start.pos())
+ while (getPar(selection.start)->size() > selection.start.pos()
+ && getPar(selection.start)->isLineSeparator(selection.start.pos())
&& (selection.start.par() != selection.end.par()
|| selection.start.pos() < selection.end.pos()))
selection.start.pos(selection.start.pos() + 1);
- CutAndPaste::copySelection(selection.start.par(),
- selection.end.par(),
+ CutAndPaste::copySelection(getPar(selection.start.par()),
+ getPar(selection.end.par()),
selection.start.pos(), selection.end.pos(),
- bv()->buffer()->params.textclass);
+ bv()->buffer()->params().textclass);
}
if (!CutAndPaste::checkPastePossible())
return;
- recordUndo(bv(), Undo::INSERT, cursor.par());
+ recUndo(cursor.par());
ParagraphList::iterator endpit;
PitPosPair ppp;
boost::tie(ppp, endpit) =
CutAndPaste::pasteSelection(*bv()->buffer(),
ownerParagraphs(),
- cursor.par(), cursor.pos(),
- bv()->buffer()->params.textclass,
+ cursorPar(), cursor.pos(),
+ bv()->buffer()->params().textclass,
sel_index, el);
bufferErrors(*bv()->buffer(), el);
bv()->showErrorList(_("Paste"));
- redoParagraphs(cursor.par(), endpit);
+ redoParagraphs(cursorPar(), endpit);
setCursor(cursor.par(), cursor.pos());
clearSelection();
// simple replacing. The font of the first selected character is used
void LyXText::replaceSelectionWithString(string const & str)
{
- recordUndo(bv(), Undo::ATOMIC);
+ recUndo(cursor.par());
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(bv()->buffer()->params,
+ LyXFont const font = getPar(selection.start)
+ ->getFontSettings(bv()->buffer()->params(),
selection.start.pos());
// Insert the new string
string::const_iterator cit = str.begin();
string::const_iterator end = str.end();
for (; cit != end; ++cit) {
- selection.end.par()->insertChar(pos, (*cit), font);
+ getPar(selection.end)->insertChar(pos, (*cit), font);
++pos;
}
// needed to insert the selection
void LyXText::insertStringAsLines(string const & str)
{
- ParagraphList::iterator pit = cursor.par();
+ ParagraphList::iterator pit = cursorPar();
pos_type pos = cursor.pos();
- ParagraphList::iterator endpit = boost::next(cursor.par());
+ ParagraphList::iterator endpit = boost::next(cursorPar());
- recordUndo(bv(), Undo::ATOMIC);
+ recUndo(cursor.par());
// only to be sure, should not be neccessary
clearSelection();
bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
- redoParagraphs(cursor.par(), endpit);
- setCursor(cursor.par(), cursor.pos());
+ redoParagraphs(cursorPar(), endpit);
+ setCursor(cursorPar(), cursor.pos());
selection.cursor = cursor;
setCursor(pit, pos);
setSelection();
}
-bool LyXText::setCursor(ParagraphList::iterator pit,
- pos_type pos,
- bool setfont, bool boundary)
+void LyXText::setCursor(ParagraphList::iterator pit, pos_type pos)
+{
+ setCursor(parOffset(pit), pos);
+}
+
+
+bool LyXText::setCursor(paroffset_type par, pos_type pos, bool setfont, bool boundary)
{
LyXCursor old_cursor = cursor;
- setCursorIntern(pit, pos, setfont, boundary);
+ setCursorIntern(par, pos, setfont, boundary);
return deleteEmptyParagraphMechanism(old_cursor);
}
}
-void LyXText::setCursor(LyXCursor & cur, ParagraphList::iterator pit,
- pos_type pos, bool boundary)
+void LyXText::setCursor(LyXCursor & cur, paroffset_type par,
+ pos_type pos, bool boundary)
{
- Assert(pit != ownerParagraphs().end());
+ BOOST_ASSERT(par != int(ownerParagraphs().size()));
- cur.par(pit);
+ cur.par(par);
cur.pos(pos);
cur.boundary(boundary);
- if (noRows())
+
+ // no rows, no fun...
+ if (ownerParagraphs().begin()->rows.empty())
return;
// get the cursor y position in text
- int y = 0;
- RowList::iterator row = getRow(pit, pos, 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());
- 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();
- }
- }
+
+ ParagraphList::iterator pit = getPar(par);
+ Row const & row = *pit->getRow(pos);
+ int y = pit->y + row.y_offset();
// y is now the beginning of the cursor row
- y += row->baseline();
+ y += row.baseline();
// y is now the cursor baseline
cur.y(y);
- pos_type last = lastPrintablePos(*pit, old_row);
+ pos_type const end = row.endpos();
// None of these should happen, but we're scaredy-cats
- if (pos > pit->size()) {
- lyxerr << "dont like 1, pos: " << pos << " size: " << pit->size() << endl;
+ if (pos < 0) {
+ lyxerr << "dont like -1" << endl;
pos = 0;
cur.pos(0);
- } else if (pos > last + 1) {
+ BOOST_ASSERT(false);
+ } else if (pos > pit->size()) {
+ lyxerr << "dont like 1, pos: " << pos
+ << " size: " << pit->size()
+ << " row.pos():" << row.pos()
+ << " paroffset: " << par << endl;
+ pos = 0;
+ cur.pos(0);
+ BOOST_ASSERT(false);
+ } else if (pos > end) {
lyxerr << "dont like 2 please report" << endl;
// This shouldn't happen.
- pos = last + 1;
+ pos = end;
cur.pos(pos);
- } else if (pos < row->pos()) {
- lyxerr << "dont like 3 please report" << endl;
- pos = row->pos();
+ BOOST_ASSERT(false);
+ } else if (pos < row.pos()) {
+ lyxerr << "dont like 3 please report pos:" << pos
+ << " size: " << pit->size()
+ << " row.pos():" << row.pos()
+ << " paroffset: " << par << endl;
+ pos = row.pos();
cur.pos(pos);
+ BOOST_ASSERT(false);
}
-
// now get the cursors x position
- float x = getCursorX(pit, row, pos, last, boundary);
- cur.x(int(x));
- cur.x_fix(cur.x());
- if (old_row != row) {
- x = getCursorX(pit, old_row, pos, last, boundary);
- cur.ix(int(x));
- } else
- cur.ix(cur.x());
-/* We take out this for the time being because 1) the redraw code is not
- prepared to this yet and 2) because some good policy has yet to be decided
- while editting: for instance how to act on rows being created/deleted
- because of DEPM.
-*/
-#if 0
- //if the cursor is in a visible row, anchor to it
- int topy = top_y();
- if (topy < y && y < topy + bv()->workHeight())
- anchor_row(row);
-#endif
+ cur.x(int(getCursorX(pit, row, pos, boundary)));
+ bv()->x_target(cur.x());
}
-float LyXText::getCursorX(ParagraphList::iterator pit, RowList::iterator rit,
- pos_type pos, pos_type last, bool boundary) const
+float LyXText::getCursorX(ParagraphList::iterator pit, Row const & row,
+ pos_type pos, bool boundary) const
{
- pos_type cursor_vpos = 0;
- double x;
- double fill_separator;
- double fill_hfill;
- double fill_label_hfill;
- // This call HAS to be here because of the BidiTables!!!
- prepareToPrint(pit, rit, x, fill_separator, fill_hfill,
- 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 = (pit->isRightToLeftPar(bv()->buffer()->params))
- ? rit_pos : last + 1;
- else if (pos > rit_pos && (pos > last || boundary))
+ pos_type cursor_vpos = 0;
+ double x = row.x();
+ double fill_separator = row.fill_separator();
+ double fill_hfill = row.fill_hfill();
+ double fill_label_hfill = row.fill_label_hfill();
+ pos_type const row_pos = row.pos();
+ pos_type const end = row.endpos();
+
+ if (end <= row_pos)
+ cursor_vpos = row_pos;
+ else if (pos >= end && !boundary)
+ cursor_vpos = (pit->isRightToLeftPar(bv()->buffer()->params()))
+ ? row_pos : end;
+ else if (pos > row_pos && (pos >= end || 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);
+ cursor_vpos = (bidi.level(pos - 1) % 2 == 0)
+ ? bidi.log2vis(pos - 1) + 1 : bidi.log2vis(pos - 1);
else
// Place cursor before char at (logical) position pos
- cursor_vpos = (bidi_level(pos) % 2 == 0)
- ? log2vis(pos) : log2vis(pos) + 1;
+ cursor_vpos = (bidi.level(pos) % 2 == 0)
+ ? bidi.log2vis(pos) : bidi.log2vis(pos) + 1;
pos_type body_pos = pit->beginningOfBody();
if (body_pos > 0 &&
- (body_pos - 1 > last || !pit->isLineSeparator(body_pos - 1)))
+ (body_pos > end || !pit->isLineSeparator(body_pos - 1)))
body_pos = 0;
- for (pos_type vpos = rit_pos; vpos < cursor_vpos; ++vpos) {
- pos_type pos = vis2log(vpos);
+ for (pos_type vpos = row_pos; vpos < cursor_vpos; ++vpos) {
+ pos_type pos = bidi.vis2log(vpos);
if (body_pos > 0 && pos == body_pos - 1) {
- x += fill_label_hfill +
- font_metrics::width(
- pit->layout()->labelsep, getLabelFont(pit));
+ x += fill_label_hfill
+ + font_metrics::width(pit->layout()->labelsep,
+ getLabelFont(pit));
if (pit->isLineSeparator(body_pos - 1))
x -= singleWidth(pit, body_pos - 1);
}
- if (hfillExpansion(*pit, rit, pos)) {
+ if (hfillExpansion(*pit, row, pos)) {
x += singleWidth(pit, pos);
if (pos >= body_pos)
x += fill_hfill;
}
-void LyXText::setCursorIntern(ParagraphList::iterator pit,
+void LyXText::setCursorIntern(paroffset_type par,
pos_type pos, bool setfont, bool boundary)
{
- setCursor(cursor, pit, pos, boundary);
+ setCursor(cursor, par, pos, boundary);
if (setfont)
setCurrentFont();
}
void LyXText::setCurrentFont()
{
pos_type pos = cursor.pos();
- ParagraphList::iterator pit = cursor.par();
+ ParagraphList::iterator pit = cursorPar();
if (cursor.boundary() && pos > 0)
--pos;
--pos;
else // potentional bug... BUG (Lgb)
if (pit->isSeparator(pos)) {
- if (pos > cursorRow()->pos() &&
- bidi_level(pos) % 2 ==
- bidi_level(pos - 1) % 2)
+ if (pos > pit->getRow(pos)->pos() &&
+ bidi.level(pos) % 2 ==
+ bidi.level(pos - 1) % 2)
--pos;
else if (pos + 1 < pit->size())
++pos;
}
}
- current_font = pit->getFontSettings(bv()->buffer()->params, pos);
+ BufferParams const & bufparams = bv()->buffer()->params();
+ current_font = pit->getFontSettings(bufparams, pos);
real_current_font = getFont(pit, pos);
if (cursor.pos() == pit->size() &&
- isBoundary(bv()->buffer(), *pit, cursor.pos()) &&
+ bidi.isBoundary(*bv()->buffer(), *pit, cursor.pos()) &&
!cursor.boundary()) {
Language const * lang =
- pit->getParLanguage(bv()->buffer()->params);
+ pit->getParLanguage(bufparams);
current_font.setLanguage(lang);
current_font.setNumber(LyXFont::OFF);
real_current_font.setLanguage(lang);
// 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
+ Row const & row, int & x, bool & boundary) const
{
- double tmpx = 0;
- double fill_separator;
- double fill_hfill;
- double fill_label_hfill;
+ double tmpx = row.x();
+ double fill_separator = row.fill_separator();
+ double fill_hfill = row.fill_hfill();
+ double fill_label_hfill = row.fill_label_hfill();
- prepareToPrint(pit, rit, tmpx, fill_separator, fill_hfill, fill_label_hfill);
-
- pos_type vc = rit->pos();
- pos_type last = lastPrintablePos(*pit, rit);
+ pos_type vc = row.pos();
+ pos_type end = row.endpos();
pos_type c = 0;
LyXLayout_ptr const & layout = pit->layout();
double last_tmpx = tmpx;
if (body_pos > 0 &&
- (body_pos - 1 > last ||
+ (body_pos > end ||
!pit->isLineSeparator(body_pos - 1)))
body_pos = 0;
// check for empty row
- if (!pit->size()) {
+ if (vc == end) {
x = int(tmpx);
return 0;
}
- while (vc <= last && tmpx <= x) {
- c = vis2log(vc);
+ while (vc < end && tmpx <= x) {
+ c = bidi.vis2log(vc);
last_tmpx = tmpx;
if (body_pos > 0 && c == body_pos - 1) {
tmpx += fill_label_hfill +
tmpx -= singleWidth(pit, body_pos - 1);
}
- if (hfillExpansion(*pit, rit, c)) {
+ if (hfillExpansion(*pit, row, c)) {
tmpx += singleWidth(pit, c);
if (c >= body_pos)
tmpx += fill_hfill;
left_side = true;
}
- if (vc > last + 1) // This shouldn't happen.
- vc = last + 1;
+ BOOST_ASSERT(vc <= end); // This shouldn't happen.
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();
+ bool const lastrow = lyxrc.rtl_support && row.endpos() == pit->size();
// If lastrow is false, we don't need to compute
// the value of rtl.
bool const rtl = (lastrow)
- ? pit->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)))
- c = last + 1;
- else if (vc == rit->pos()) {
- c = vis2log(vc);
- if (bidi_level(c) % 2 == 1)
+ ((rtl && left_side && vc == row.pos() && x < tmpx - 5) ||
+ (!rtl && !left_side && vc == end && x > tmpx + 5)))
+ c = end;
+ else if (vc == row.pos()) {
+ c = bidi.vis2log(vc);
+ if (bidi.level(c) % 2 == 1)
++c;
} else {
- c = vis2log(vc - 1);
- bool const rtl = (bidi_level(c) % 2 == 1);
+ c = bidi.vis2log(vc - 1);
+ bool const rtl = (bidi.level(c) % 2 == 1);
if (left_side == rtl) {
++c;
- boundary = isBoundary(bv()->buffer(), *pit, c);
+ boundary = bidi.isBoundary(*bv()->buffer(), *pit, c);
}
}
- if (rit->pos() <= last && c > last && pit->isNewline(last)) {
- if (bidi_level(last) % 2 == 0)
- tmpx -= singleWidth(pit, last);
+ if (row.pos() < end && c >= end && pit->isNewline(end - 1)) {
+ if (bidi.level(end -1) % 2 == 0)
+ tmpx -= singleWidth(pit, end - 1);
else
- tmpx += singleWidth(pit, last);
- c = last;
+ tmpx += singleWidth(pit, end - 1);
+ c = end - 1;
}
- c -= rit->pos();
+ c -= row.pos();
x = int(tmpx);
return c;
}
}
-namespace {
-
- /**
- * return true if the cursor given is at the end of a row,
- * and the next row is filled by an inset that spans an entire
- * row.
- */
- bool beforeFullRowInset(LyXText & lt, LyXCursor const & cur)
- {
- RowList::iterator row = lt.getRow(cur);
- RowList::iterator next = boost::next(row);
-
- if (next == cur.par()->rows.end() || next->pos() != cur.pos())
- return false;
-
- if (cur.pos() == cur.par()->size() || !cur.par()->isInset(cur.pos()))
- return false;
-
- InsetOld const * inset = cur.par()->getInset(cur.pos());
- if (inset->needFullRow() || inset->display())
- return true;
-
- return false;
- }
-}
-
-
void LyXText::setCursorFromCoordinates(LyXCursor & cur, int x, int y)
{
// Get the row first.
ParagraphList::iterator pit;
- RowList::iterator row = getRowNearY(y, pit);
+ Row const & row = *getRowNearY(y, pit);
+ y = pit->y + row.y_offset();
+
bool bound = false;
pos_type const column = getColumnNearX(pit, row, x, bound);
- cur.par(pit);
- cur.pos(row->pos() + column);
+ cur.par(parOffset(pit));
+ cur.pos(row.pos() + column);
cur.x(x);
- cur.y(y + row->baseline());
-
-// 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.y(y + row.baseline());
+
cur.boundary(bound);
}
bool boundary = cursor.boundary();
setCursor(cursor.par(), cursor.pos() - 1, true, false);
if (!internal && !boundary &&
- isBoundary(bv()->buffer(), *cursor.par(), cursor.pos() + 1))
+ bidi.isBoundary(*bv()->buffer(), *cursorPar(), cursor.pos() + 1))
setCursor(cursor.par(), cursor.pos() + 1, true, true);
- } else if (cursor.par() != ownerParagraphs().begin()) {
+ } else if (cursor.par() != 0) {
// steps into the paragraph above
- ParagraphList::iterator pit = boost::prior(cursor.par());
- setCursor(pit, pit->size());
+ setCursor(cursor.par() - 1, boost::prior(cursorPar())->size());
}
}
void LyXText::cursorRight(bool internal)
{
- bool const at_end = (cursor.pos() == cursor.par()->size());
+ bool const at_end = (cursor.pos() == cursorPar()->size());
bool const at_newline = !at_end &&
- cursor.par()->isNewline(cursor.pos());
+ cursorPar()->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(bv()->buffer(), *cursor.par(), cursor.pos()))
+ if (!internal && bidi.isBoundary(*bv()->buffer(), *cursorPar(),
+ cursor.pos()))
setCursor(cursor.par(), cursor.pos(), true, true);
- } else if (boost::next(cursor.par()) != ownerParagraphs().end())
- setCursor(boost::next(cursor.par()), 0);
+ } else if (cursor.par() + 1 != int(ownerParagraphs().size()))
+ setCursor(cursor.par() + 1, 0);
}
void LyXText::cursorUp(bool selecting)
{
+ ParagraphList::iterator cpit = cursorPar();
+ Row const & crow = *cpit->getRow(cursor.pos());
#if 1
- int x = cursor.x_fix();
- int y = cursor.y() - cursorRow()->baseline() - 1;
+ int x = bv()->x_target();
+ int y = cursor.y() - crow.baseline() - 1;
setCursorFromCoordinates(x, y);
if (!selecting) {
- int topy = top_y();
- int y1 = cursor.iy() - topy;
+ int topy = bv_owner->top_y();
+ int y1 = cursor.y() - topy;
int y2 = y1;
y -= topy;
InsetOld * inset_hit = checkInsetHit(x, y1);
if (inset_hit && isHighlyEditableInset(inset_hit)) {
- inset_hit->localDispatch(
+ inset_hit->dispatch(
FuncRequest(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none));
}
}
#else
lyxerr << "cursorUp: y " << cursor.y() << " bl: " <<
- cursorRow()->baseline() << endl;
- setCursorFromCoordinates(cursor.x_fix(),
- cursor.y() - cursorRow()->baseline() - 1);
+ crow.baseline() << endl;
+ setCursorFromCoordinates(bv()->x_target(),
+ cursor.y() - crow.baseline() - 1);
#endif
}
void LyXText::cursorDown(bool selecting)
{
+ ParagraphList::iterator cpit = cursorPar();
+ Row const & crow = *cpit->getRow(cursor.pos());
#if 1
- int x = cursor.x_fix();
- int y = cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1;
+ int x = bv()->x_target();
+ int y = cursor.y() - crow.baseline() + crow.height() + 1;
setCursorFromCoordinates(x, y);
- if (!selecting && cursorRow() == cursorIRow()) {
- int topy = top_y();
- int y1 = cursor.iy() - topy;
+ if (!selecting) {
+ int topy = bv_owner->top_y();
+ int y1 = cursor.y() - topy;
int y2 = y1;
y -= topy;
InsetOld * inset_hit = checkInsetHit(x, y1);
if (inset_hit && isHighlyEditableInset(inset_hit)) {
FuncRequest cmd(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none);
- inset_hit->localDispatch(cmd);
+ inset_hit->dispatch(cmd);
}
}
#else
- setCursorFromCoordinates(cursor.x_fix(),
- cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1);
+ setCursorFromCoordinates(bv()->x_target(),
+ cursor.y() - crow.baseline() + crow.height() + 1);
#endif
}
void LyXText::cursorUpParagraph()
{
+ ParagraphList::iterator cpit = cursorPar();
if (cursor.pos() > 0)
- setCursor(cursor.par(), 0);
- else if (cursor.par() != ownerParagraphs().begin())
- setCursor(boost::prior(cursor.par()), 0);
+ setCursor(cpit, 0);
+ else if (cpit != ownerParagraphs().begin())
+ setCursor(boost::prior(cpit), 0);
}
void LyXText::cursorDownParagraph()
{
- ParagraphList::iterator par = cursor.par();
- ParagraphList::iterator next_par = boost::next(par);
+ ParagraphList::iterator pit = cursorPar();
+ ParagraphList::iterator next_pit = boost::next(pit);
- if (next_par != ownerParagraphs().end())
- setCursor(next_par, 0);
+ if (next_pit != ownerParagraphs().end())
+ setCursor(next_pit, 0);
else
- setCursor(par, par->size());
+ setCursor(pit, pit->size());
}
// check also if we don't want to set the cursor on a spot behind the
// pagragraph because we erased the last character.
- if (cur.pos() > cur.par()->size())
- cur.pos(cur.par()->size());
+ if (cur.pos() > getPar(cur)->size())
+ cur.pos(getPar(cur)->size());
// recompute row et al. for this cursor
setCursor(cur, cur.par(), cur.pos(), cur.boundary());
if (selection.set())
return false;
+ // Don't do anything if the cursor is invalid
+ if (old_cursor.par() == -1)
+ return false;
+
// We allow all kinds of "mumbo-jumbo" when freespacing.
- if (old_cursor.par()->isFreeSpacing())
+ ParagraphList::iterator const old_pit = getPar(old_cursor);
+ if (old_pit->isFreeSpacing())
return false;
/* Ok I'll put some comments here about what is missing.
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
// 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)) {
- bool erased = old_cursor.par()->erase(old_cursor.pos() - 1);
- redoParagraph(old_cursor.par());
+ && old_cursor.pos() < old_pit->size()
+ && old_pit->isLineSeparator(old_cursor.pos())
+ && old_pit->isLineSeparator(old_cursor.pos() - 1)) {
+ bool erased = old_pit->erase(old_cursor.pos() - 1);
+ redoParagraph(old_pit);
if (!erased)
return false;
return false;
// Do not delete empty paragraphs with keepempty set.
- if (old_cursor.par()->allowEmpty())
+ if (old_pit->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_pit->empty()
+ || (old_pit->size() == 1 && old_pit->isLineSeparator(0))) {
+ // ok, we will delete something
LyXCursor tmpcursor;
deleted = true;
- bool selection_position_was_oldcursor_position = (
- selection.cursor.par() == old_cursor.par()
- && selection.cursor.pos() == old_cursor.pos());
+ bool selection_position_was_oldcursor_position =
+ selection.cursor.par() == old_cursor.par()
+ && selection.cursor.pos() == old_cursor.pos();
tmpcursor = cursor;
cursor = old_cursor; // that undo can restore the right cursor position
- ParagraphList::iterator endpit = boost::next(old_cursor.par());
+ ParagraphList::iterator endpit = boost::next(old_pit);
while (endpit != ownerParagraphs().end() && endpit->getDepth())
++endpit;
-
- recordUndo(bv(), Undo::DELETE, old_cursor.par(), boost::prior(endpit));
+
+ recUndo(parOffset(old_pit), parOffset(endpit) - 1);
cursor = tmpcursor;
// delete old par
- ownerParagraphs().erase(old_cursor.par());
+ ownerParagraphs().erase(old_pit);
redoParagraph();
// correct cursor y
selection.cursor = cursor;
}
}
- if (!deleted) {
- if (old_cursor.par()->stripLeadingSpaces()) {
- redoParagraph(old_cursor.par());
- // correct cursor y
- setCursorIntern(cursor.par(), cursor.pos());
- selection.cursor = cursor;
- }
+
+ if (deleted)
+ return true;
+
+ if (old_pit->stripLeadingSpaces()) {
+ redoParagraph(old_pit);
+ // correct cursor y
+ setCursorIntern(cursor.par(), cursor.pos());
+ selection.cursor = cursor;
}
- return deleted;
+ return false;
}
ParagraphList & LyXText::ownerParagraphs() const
{
- if (inset_owner) {
- return inset_owner->paragraphs;
- }
- return bv_owner->buffer()->paragraphs;
+ return *paragraphs_;
+}
+
+
+void LyXText::recUndo(paroffset_type first, paroffset_type last) const
+{
+ recordUndo(Undo::ATOMIC, this, first, last);
+}
+
+
+void LyXText::recUndo(lyx::paroffset_type par) const
+{
+ recordUndo(Undo::ATOMIC, this, par, par);
}
bool LyXText::isInInset() const
{
// Sub-level has non-null bv owner and non-null inset owner.
- return inset_owner != 0 && bv_owner != 0;
+ return inset_owner != 0;
}
int defaultRowHeight()
{
LyXFont const font(LyXFont::ALL_SANE);
- return int(font_metrics::maxAscent(font)
- + font_metrics::maxDescent(font) * 1.5);
+ return int(font_metrics::maxHeight(font) * 1.2);
}