#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 lyx::pos_type;
+using lyx::paroffset_type;
+using lyx::support::bformat;
-using std::vector;
-using std::copy;
using std::endl;
-using std::find;
-using std::pair;
-using lyx::pos_type;
+using std::ostringstream;
+using std::string;
LyXText::LyXText(BufferView * bv, InsetText * inset, bool ininset,
ParagraphList & paragraphs)
- : height(0), width(0), anchor_y_(0),
+ : height(0), width(0),
inset_owner(inset), the_locking_inset(0), bv_owner(bv),
- in_inset_(ininset), paragraphs_(paragraphs)
+ in_inset_(ininset), paragraphs_(¶graphs),
+ cache_pos_(-1)
{
}
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
}
-int LyXText::redoParagraphInternal(ParagraphList::iterator pit)
-{
- RowList::iterator rit = pit->rows.begin();
- RowList::iterator end = pit->rows.end();
-
- // remove rows of paragraph, keep track of height changes
- for (int i = 0; rit != end; ++rit, ++i)
- height -= rit->height();
- pit->rows.clear();
-
- // redo insets
- InsetList::iterator ii = pit->insetlist.begin();
- InsetList::iterator iend = pit->insetlist.end();
- for (; ii != iend; ++ii) {
- Dimension dim;
- MetricsInfo mi(bv(), getFont(pit, ii->pos), workWidth());
- ii->inset->metrics(mi, dim);
- }
-
- // rebreak the paragraph
- for (pos_type z = 0; z < pit->size() + 1; ) {
- Row row(z);
- z = rowBreakPoint(pit, row) + 1;
- row.end(z);
- pit->rows.push_back(row);
- }
-
- int par_width = 0;
- // set height and fill and width of rows
- int const ww = workWidth();
- for (rit = pit->rows.begin(); rit != end; ++rit) {
- int const f = fill(pit, rit, ww);
- int const w = ww - f;
- par_width = std::max(par_width, w);
- rit->fill(f);
- rit->width(w);
- prepareToPrint(pit, rit);
- setHeightOfRow(pit, rit);
- height += rit->height();
- }
-
- //lyxerr << "redoParagraph: " << pit->rows.size() << " rows\n";
- return par_width;
-}
-
-
-int LyXText::redoParagraphs(ParagraphList::iterator start,
- ParagraphList::iterator end)
-{
- int pars_width = 0;
- for ( ; start != end; ++start) {
- int par_width = redoParagraphInternal(start);
- pars_width = std::max(par_width, pars_width);
- }
- updateRowPositions();
- return pars_width;
-}
-
-
-void LyXText::redoParagraph(ParagraphList::iterator pit)
-{
- redoParagraphInternal(pit);
- updateRowPositions();
-}
-
-
-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
- // << " 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));
-}
-
-
// 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 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;
+ // Maybe we have to increment the item depth.
+ incrementItemDepth(pit, first_pit);
}
- 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;
-
- textclass.counters().step(layout->latexname());
+ 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;
+ }
- // Is there a label? Useful for Chapter layout
- if (!pit->params().appendix()) {
- s << buf->B_(layout->labelstring());
- } else {
- s << buf->B_(layout->labelstring_appendix());
- }
+ pit->params().labelString(itemlabel);
+ } else if (layout->labeltype == LABEL_ENUMERATE) {
+ // Maybe we have to reset the enumeration counter.
+ resetEnumCounterIfNeeded(pit, first_pit, counters);
- // 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";
- }
+ // FIXME
+ // Yes I know this is a really, really! bad solution
+ // (Lgb)
+ string enumcounter = "enum";
- 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 {
- Paragraph const * owner = &ownerPar(*buf, in);
- tmppit = ownerParagraphs().begin();
+ Paragraph const * owner = &ownerPar(buf, in);
+ tmppit = first_pit;
for ( ; tmppit != end; ++tmppit)
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
- 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());
+ 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);
+ 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);
- } else if (pos > last + 1) {
+ 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 = 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 = (pit->isRightToLeftPar(bv()->buffer()->params))
- ? rit_pos : last + 1;
- else if (pos > rit_pos && (pos > last || boundary))
+ 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 = rit->x();
- double fill_separator = rit->fill_separator();
- double fill_hfill = rit->fill_hfill();
- double fill_label_hfill = rit->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();
- 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;
}
{
// Get the row first.
ParagraphList::iterator pit;
- RowList::iterator rit = getRowNearY(y, pit);
- y = rit->y();
+ Row const & row = *getRowNearY(y, pit);
+ y = pit->y + row.y_offset();
bool bound = false;
- pos_type const column = getColumnNearX(pit, rit, x, bound);
- cur.par(pit);
- cur.pos(rit->pos() + column);
+ pos_type const column = getColumnNearX(pit, row, x, bound);
+ cur.par(parOffset(pit));
+ cur.pos(row.pos() + column);
cur.x(x);
- cur.y(y + rit->baseline());
-
- 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.
// 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))) {
+ 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
{
- return 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);
}
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);
}