-/* This file is part of
- * ======================================================
+/**
+ * \file text2.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
*
- * LyX, The Document Processor
+ * \author Asger Alstrup
+ * \author Lars Gullik Bjønnes
+ * \author Alfredo Braunstein
+ * \author Jean-Marc Lasgouttes
+ * \author Angus Leeming
+ * \author John Levon
+ * \author André Pönitz
+ * \author Allan Rae
+ * \author Dekel Tsur
+ * \author Jürgen Vigna
*
- * Copyright 1995 Matthias Ettrich
- * Copyright 1995-2001 The LyX Team.
- *
- * ====================================================== */
+ * Full author contact details are available in file CREDITS.
+ */
#include <config.h>
#include "frontends/font_metrics.h"
#include "debug.h"
#include "lyxrc.h"
-#include "lyxrow.h"
#include "FloatList.h"
#include "language.h"
#include "ParagraphParameters.h"
#include "counters.h"
#include "lyxrow_funcs.h"
+#include "metricsinfo.h"
#include "paragraph_funcs.h"
#include "insets/insetbibitem.h"
#include <boost/tuple/tuple.hpp>
+#include <algorithm>
+
using namespace lyx::support;
using std::vector;
using lyx::pos_type;
-LyXText::LyXText(BufferView * bv)
- : height(0), width(0), anchor_row_offset_(0),
- inset_owner(0), the_locking_inset(0), bv_owner(bv)
+LyXText::LyXText(BufferView * bv, InsetText * inset, bool ininset,
+ ParagraphList & paragraphs)
+ : height(0), width(0), anchor_y_(0),
+ inset_owner(inset), the_locking_inset(0), bv_owner(bv),
+ in_inset_(ininset), paragraphs_(paragraphs)
{
- anchor_row_ = rows().end();
- need_break_row = rows().end();
- refresh_row = rows().end();
-
- clearPaint();
}
-LyXText::LyXText(BufferView * bv, InsetText * inset)
- : height(0), width(0), anchor_row_offset_(0),
- inset_owner(inset), the_locking_inset(0), bv_owner(bv)
+void LyXText::init(BufferView * bview)
{
- anchor_row_ = rows().end();
- need_break_row = rows().end();
- refresh_row = rows().end();
+ bv_owner = bview;
- clearPaint();
-}
+ ParagraphList::iterator const beg = ownerParagraphs().begin();
+ ParagraphList::iterator const end = ownerParagraphs().end();
+ for (ParagraphList::iterator pit = beg; pit != end; ++pit)
+ pit->rows.clear();
+ width = 0;
+ height = 0;
-void LyXText::init(BufferView * bview, bool reinit)
-{
- if (reinit) {
- rowlist_.clear();
- need_break_row = rows().end();
- width = height = 0;
- top_y(0);
- clearPaint();
- } else if (!rowlist_.empty())
- return;
-
- ParagraphList::iterator pit = ownerParagraphs().begin();
- ParagraphList::iterator end = ownerParagraphs().end();
+ anchor_y_ = 0;
- current_font = getFont(bview->buffer(), pit, 0);
+ current_font = getFont(beg, 0);
- for (; pit != end; ++pit) {
- insertParagraph(pit, rowlist_.end());
- }
- setCursorIntern(rowlist_.begin()->par(), 0);
+ redoParagraphs(beg, end);
+ setCursorIntern(beg, 0);
selection.cursor = cursor;
updateCounters();
// The difference is that this one is used for displaying, and thus we
// are allowed to make cosmetic improvements. For instance make footnotes
// smaller. (Asger)
-// If position is -1, we get the layout font of the paragraph.
-// If position is -2, we get the font of the manual label of the paragraph.
-LyXFont const LyXText::getFont(Buffer const * buf, ParagraphList::iterator pit,
- pos_type pos) const
+LyXFont LyXText::getFont(ParagraphList::iterator pit, pos_type pos) const
{
Assert(pos >= 0);
LyXLayout_ptr const & layout = pit->layout();
+#warning broken?
+ BufferParams const & params = bv()->buffer()->params;
// We specialize the 95% common case:
if (!pit->getDepth()) {
if (layout->labeltype == LABEL_MANUAL
&& pos < pit->beginningOfBody()) {
// 1% goes here
- LyXFont f = pit->getFontSettings(buf->params, pos);
+ LyXFont f = pit->getFontSettings(params, pos);
if (pit->inInset())
pit->inInset()->getDrawFont(f);
return f.realize(layout->reslabelfont);
} else {
- LyXFont f = pit->getFontSettings(buf->params, pos);
+ LyXFont f = pit->getFontSettings(params, pos);
if (pit->inInset())
pit->inInset()->getDrawFont(f);
return f.realize(layout->resfont);
layoutfont = layout->font;
}
- LyXFont tmpfont = pit->getFontSettings(buf->params, pos);
+ LyXFont tmpfont = pit->getFontSettings(params, pos);
tmpfont.realize(layoutfont);
if (pit->inInset())
// Realize with the fonts of lesser depth.
tmpfont.realize(outerFont(pit, ownerParagraphs()));
+ tmpfont.realize(defaultfont_);
- return realizeFont(tmpfont, buf->params);
+ return tmpfont;
}
-LyXFont const LyXText::getLayoutFont(Buffer const * buf,
- ParagraphList::iterator pit) const
+LyXFont LyXText::getLayoutFont(ParagraphList::iterator pit) const
{
LyXLayout_ptr const & layout = pit->layout();
- if (!pit->getDepth()) {
+ if (!pit->getDepth())
return layout->resfont;
- }
- LyXFont font(layout->font);
+ LyXFont font = layout->font;
// Realize with the fonts of lesser depth.
font.realize(outerFont(pit, ownerParagraphs()));
+ font.realize(defaultfont_);
- return realizeFont(font, buf->params);
+ return font;
}
-LyXFont const LyXText::getLabelFont(Buffer const * buf,
- ParagraphList::iterator pit) const
+LyXFont LyXText::getLabelFont(ParagraphList::iterator pit) const
{
LyXLayout_ptr const & layout = pit->layout();
- if (!pit->getDepth()) {
+ if (!pit->getDepth())
return layout->reslabelfont;
- }
- LyXFont font(layout->labelfont);
+ LyXFont font = layout->labelfont;
// Realize with the fonts of lesser depth.
font.realize(outerFont(pit, ownerParagraphs()));
+ font.realize(defaultfont_);
- return realizeFont(layout->labelfont, buf->params);
+ return font;
}
pos_type pos, LyXFont const & fnt,
bool toggleall)
{
- Buffer const * buf = bv()->buffer();
- LyXFont font = getFont(buf, pit, pos);
- font.update(fnt, buf->params.language, toggleall);
+ BufferParams const & params = bv()->buffer()->params;
+ LyXFont font = getFont(pit, pos);
+ font.update(fnt, params.language, toggleall);
// Let the insets convert their font
if (pit->isInset(pos)) {
- Inset * inset = pit->getInset(pos);
+ InsetOld * inset = pit->getInset(pos);
if (isEditableInset(inset)) {
- UpdatableInset * uinset =
- static_cast<UpdatableInset *>(inset);
- uinset->setFont(bv(), fnt, toggleall, true);
+ static_cast<UpdatableInset *>(inset)
+ ->setFont(bv(), fnt, toggleall, true);
}
}
- // Plug thru to version below:
- setCharFont(buf, pit, pos, font);
+ // Plug through to version below:
+ setCharFont(pit, pos, font);
}
-void LyXText::setCharFont(Buffer const * buf, ParagraphList::iterator pit,
- pos_type pos, LyXFont const & fnt)
+void LyXText::setCharFont(
+ ParagraphList::iterator pit, pos_type pos, LyXFont const & fnt)
{
- LyXFont font(fnt);
-
- LyXTextClass const & tclass = buf->params.getLyXTextClass();
+ LyXFont font = fnt;
LyXLayout_ptr const & layout = pit->layout();
// Get concrete layout font to reduce against
}
}
- layoutfont.realize(tclass.defaultfont());
+ layoutfont.realize(defaultfont_);
// Now, reduce font against full layout font
font.reduce(layoutfont);
}
-// removes the row and reset the touched counters
-void LyXText::removeRow(RowList::iterator rit)
-{
- /* FIXME: when we cache the bview, this should just
- * become a postPaint(), I think */
- if (refresh_row == rit) {
- if (rit == rows().begin())
- refresh_row = boost::next(rit);
- else
- refresh_row = boost::prior(rit);
-
- // what about refresh_y
- }
-
- if (anchor_row_ == rit) {
- if (rit != rows().begin()) {
- anchor_row_ = boost::prior(rit);
- anchor_row_offset_ += anchor_row_->height();
- } else {
- anchor_row_ = boost::next(rit);
- anchor_row_offset_ -= rit->height();
- }
- }
-
- // the text becomes smaller
- height -= rit->height();
-
- rowlist_.erase(rit);
-}
-
-
-// remove all following rows of the paragraph of the specified row.
-void LyXText::removeParagraph(RowList::iterator rit)
-{
- ParagraphList::iterator tmppit = rit->par();
- ++rit;
-
- while (rit != rows().end() && rit->par() == tmppit) {
- RowList::iterator tmprit = boost::next(rit);
- removeRow(rit);
- rit = tmprit;
- }
-}
-
-
-void LyXText::insertParagraph(ParagraphList::iterator pit,
- RowList::iterator rowit)
-{
- // insert a new row, starting at position 0
- Row newrow(pit, 0);
- RowList::iterator rit = rowlist_.insert(rowit, newrow);
-
- // and now append the whole paragraph before the new row
- appendParagraph(rit);
-}
-
-
-Inset * LyXText::getInset() const
+InsetOld * LyXText::getInset() const
{
ParagraphList::iterator pit = cursor.par();
pos_type const pos = cursor.pos();
void LyXText::toggleInset()
{
- Inset * inset = getInset();
+ InsetOld * inset = getInset();
// is there an editable inset at cursor position?
if (!isEditableInset(inset)) {
// No, try to see if we are inside a collapsable inset
// do we want to keep this?? (JMarc)
if (!isHighlyEditableInset(inset))
- setCursorParUndo(bv());
+ recordUndo(bv(), Undo::ATOMIC);
- if (inset->isOpen()) {
+ if (inset->isOpen())
inset->close(bv());
- } else {
+ else
inset->open(bv());
- }
bv()->updateInset(inset);
}
/* used in setlayout */
// Asger is not sure we want to do this...
-void LyXText::makeFontEntriesLayoutSpecific(Buffer const & buf,
+void LyXText::makeFontEntriesLayoutSpecific(BufferParams const & params,
Paragraph & par)
{
LyXLayout_ptr const & layout = par.layout();
else
layoutfont = layout->font;
- LyXFont tmpfont = par.getFontSettings(buf.params, pos);
+ LyXFont tmpfont = par.getFontSettings(params, pos);
tmpfont.reduce(layoutfont);
par.setFont(pos, tmpfont);
}
++endpit;
}
- setUndo(bv(), Undo::EDIT, sstart_cur.par(), boost::prior(undoendpit));
+ recordUndo(bv(), Undo::ATOMIC, sstart_cur.par(), boost::prior(undoendpit));
// ok we have a selection. This is always between sstart_cur
// and sel_end cursor
do {
pit->applyLayout(lyxlayout);
- makeFontEntriesLayoutSpecific(*bv()->buffer(), *pit);
- ParagraphList::iterator fppit = pit;
- fppit->params().spaceTop(lyxlayout->fill_top ?
+ makeFontEntriesLayoutSpecific(bv()->buffer()->params, *pit);
+ pit->params().spaceTop(lyxlayout->fill_top ?
VSpace(VSpace::VFILL)
: VSpace(VSpace::NONE));
- fppit->params().spaceBottom(lyxlayout->fill_bottom ?
+ pit->params().spaceBottom(lyxlayout->fill_bottom ?
VSpace(VSpace::VFILL)
: VSpace(VSpace::NONE));
if (lyxlayout->margintype == MARGIN_MANUAL)
bv()->owner()->dispatch(FuncRequest(LFUN_HOME));
bv()->owner()->dispatch(FuncRequest(LFUN_ENDSEL));
bv()->owner()->dispatch(FuncRequest(LFUN_CUT));
- Inset * inset = new InsetEnvironment(params, layout);
+ InsetOld * inset = new InsetEnvironment(params, layout);
if (bv()->insertInset(inset)) {
//inset->edit(bv());
//bv()->owner()->dispatch(FuncRequest(LFUN_PASTE));
ParagraphList::iterator endpit = setLayout(cursor, selection.start,
selection.end, layout);
- redoParagraphs(selection.start, endpit);
+ redoParagraphs(selection.start.par(), endpit);
// we have to reset the selection, because the
// geometry could have changed
bool LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type, bool test_only)
{
- ParagraphList::iterator pit(cursor.par());
- ParagraphList::iterator end(cursor.par());
+ ParagraphList::iterator pit = cursor.par();
+ ParagraphList::iterator end = cursor.par();
ParagraphList::iterator start = pit;
if (selection.set()) {
ParagraphList::iterator pastend = boost::next(end);
if (!test_only)
- setUndo(bv(), Undo::EDIT, start, end);
+ recordUndo(bv(), Undo::ATOMIC, start, end);
bool changed = false;
if (depth < prev_after_depth
&& pit->layout()->labeltype != LABEL_BIBLIO) {
changed = true;
- if (!test_only) {
+ if (!test_only)
pit->params().depth(depth + 1);
- }
-
}
} else if (depth) {
changed = true;
if (test_only)
return changed;
- // Wow, redoParagraphs is stupid.
- LyXCursor tmpcursor;
- setCursor(tmpcursor, start, 0);
-
- redoParagraphs(tmpcursor, pastend);
+ redoParagraphs(start, pastend);
// We need to actually move the text->cursor. I don't
// understand why ...
- tmpcursor = cursor;
+ LyXCursor tmpcursor = cursor;
// we have to reset the visual selection because the
// geometry could have changed
// Determine basis font
LyXFont layoutfont;
if (cursor.pos() < cursor.par()->beginningOfBody()) {
- layoutfont = getLabelFont(bv()->buffer(),
- cursor.par());
+ layoutfont = getLabelFont(cursor.par());
} else {
- layoutfont = getLayoutFont(bv()->buffer(),
- cursor.par());
+ layoutfont = getLayoutFont(cursor.par());
}
// Update current font
real_current_font.update(font,
// ok we have a selection. This is always between sel_start_cursor
// and sel_end cursor
- setUndo(bv(), Undo::EDIT, selection.start.par(), selection.end.par());
+ recordUndo(bv(), Undo::ATOMIC, selection.start.par(), selection.end.par());
freezeUndo();
cursor = selection.start;
while (cursor.par() != selection.end.par() ||
}
unFreezeUndo();
- redoParagraphs(selection.start, boost::next(selection.end.par()));
+ redoParagraph(selection.start.par());
// we have to reset the selection, because the
// geometry could have changed, but we keep
}
-void LyXText::redoHeightOfParagraph()
+int LyXText::redoParagraphInternal(ParagraphList::iterator pit)
{
- RowList::iterator tmprow = cursorRow();
- int y = cursor.y() - tmprow->baseline();
+ RowList::iterator rit = pit->rows.begin();
+ RowList::iterator end = pit->rows.end();
- setHeightOfRow(tmprow);
+ // remove rows of paragraph, keep track of height changes
+ for (int i = 0; rit != end; ++rit, ++i)
+ height -= rit->height();
+ pit->rows.clear();
- while (tmprow != rows().begin()
- && boost::prior(tmprow)->par() == tmprow->par()) {
- --tmprow;
- y -= tmprow->height();
- setHeightOfRow(tmprow);
+ // redo insets
+ InsetList::iterator ii = pit->insetlist.begin();
+ InsetList::iterator iend = pit->insetlist.end();
+ for (; ii != iend; ++ii) {
+ Dimension dim;
+ MetricsInfo mi(bv(), getFont(pit, ii->pos), workWidth());
+ ii->inset->metrics(mi, dim);
}
- postPaint(y);
-
- setCursor(cursor.par(), cursor.pos(), false, cursor.boundary());
-}
-
-
-void LyXText::redoDrawingOfParagraph(LyXCursor const & cur)
-{
- RowList::iterator tmprow = getRow(cur);
-
- int y = cur.y() - tmprow->baseline();
- setHeightOfRow(tmprow);
+ // 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);
+ }
- while (tmprow != rows().begin()
- && boost::prior(tmprow)->par() == tmprow->par()) {
- --tmprow;
- y -= tmprow->height();
+ 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();
}
- postPaint(y);
- setCursor(cur.par(), cur.pos());
+ //lyxerr << "redoParagraph: " << pit->rows.size() << " rows\n";
+ return par_width;
}
-// deletes and inserts again all paragraphs between the cursor
-// and the specified par
-// This function is needed after SetLayout and SetFont etc.
-void LyXText::redoParagraphs(LyXCursor const & cur,
- ParagraphList::iterator endpit)
+int LyXText::redoParagraphs(ParagraphList::iterator start,
+ ParagraphList::iterator end)
{
- RowList::iterator tmprit = getRow(cur);
- int y = cur.y() - tmprit->baseline();
-
- ParagraphList::iterator first_phys_pit;
- RowList::iterator prevrit;
- if (tmprit == rows().begin()) {
- // A trick/hack for UNDO.
- // This is needed because in an UNDO/REDO we could have
- // changed the ownerParagraph() so the paragraph inside
- // the row is NOT my really first par anymore.
- // Got it Lars ;) (Jug 20011206)
- first_phys_pit = ownerParagraphs().begin();
- prevrit = rows().end();
- } else {
- first_phys_pit = tmprit->par();
- while (tmprit != rows().begin()
- && boost::prior(tmprit)->par() == first_phys_pit)
- {
- --tmprit;
- y -= tmprit->height();
- }
- prevrit = boost::prior(tmprit);
- }
-
- // remove it
- while (tmprit != rows().end() && tmprit->par() != endpit) {
- RowList::iterator tmprit2 = tmprit++;
- removeRow(tmprit2);
+ 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;
+}
- // Reinsert the paragraphs.
- ParagraphList::iterator tmppit = first_phys_pit;
-
- while (tmppit != ownerParagraphs().end()) {
- insertParagraph(tmppit, tmprit);
- while (tmprit != rows().end()
- && tmprit->par() == tmppit) {
- ++tmprit;
- }
- ++tmppit;
- if (tmppit == endpit)
- break;
- }
- if (prevrit != rows().end()) {
- setHeightOfRow(prevrit);
- postPaint(y - prevrit->height());
- } else {
- setHeightOfRow(rows().begin());
- postPaint(0);
- }
- if (tmprit != rows().end())
- setHeightOfRow(tmprit);
- updateCounters();
+void LyXText::redoParagraph(ParagraphList::iterator pit)
+{
+ redoParagraphInternal(pit);
+ updateRowPositions();
}
void LyXText::fullRebreak()
{
- need_break_row = rows().begin();
- partialRebreak();
- setCursorIntern(cursor.par(), cursor.pos());
+ redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end());
+ redoCursor();
+ selection.cursor = cursor;
}
-void LyXText::partialRebreak()
+void LyXText::metrics(MetricsInfo & mi, Dimension & dim)
{
- if (rows().empty()) {
- init(bv());
- return;
- }
+ //lyxerr << "LyXText::metrics: width: " << mi.base.textwidth
+ // << " workWidth: " << workWidth() << endl;
+ //Assert(mi.base.textwidth);
- RowList::iterator rows_end = rows().end();
+ // rebuild row cache
+ width = 0;
+ ///height = 0;
- if (need_break_row != rows_end) {
- breakAgain(need_break_row);
- need_break_row = rows_end;
- return;
- }
+ //anchor_y_ = 0;
+ 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));
}
// need the selection cursor:
void LyXText::setSelection()
{
- bool const lsel = TextCursor::setSelection();
-
- if (inset_owner && (selection.set() || lsel))
- inset_owner->setUpdateStatus(bv(), InsetText::SELECTION);
+ TextCursor::setSelection();
}
return;
RowList::iterator rit = cursorRow();
- RowList::iterator next_rit = boost::next(rit);
- ParagraphList::iterator pit = rit->par();
- pos_type last_pos = lastPos(*this, rit);
-
- if (next_rit == rows().end() || next_rit->par() != pit) {
- ++last_pos;
- } else {
- if (pit->empty() ||
- (pit->getChar(last_pos) != ' ' && !pit->isNewline(last_pos))) {
- ++last_pos;
- }
- }
-
- setCursor(pit, last_pos);
+ ParagraphList::iterator pit = cursor.par();
+ pos_type pos = lastPos(*pit, rit);
+ /* cursor should be before a hard newline only */
+ if (!pit->isNewline(pos))
+ ++pos;
+ setCursor(pit, pos);
}
LyXCursor resetCursor = cursor;
bool implicitSelection = (font.language() == ignore_language
&& font.number() == LyXFont::IGNORE)
- ? selectWordWhenUnderCursor(WHOLE_WORD_STRICT) : false;
+ ? selectWordWhenUnderCursor(lyx::WHOLE_WORD_STRICT) : false;
// Set font
setFont(font, toggleall);
setCursor(cursor.par(), cursor.pos());
selection.cursor = cursor;
}
- if (inset_owner)
- inset_owner->setUpdateStatus(bv(), InsetText::CURSOR_PAR);
}
// If there is a change in the language the implicit word selection
// is disabled.
LyXCursor const reset_cursor = cursor;
- bool const implicitSelection = selectWordWhenUnderCursor(PREVIOUS_WORD);
+ bool const implicitSelection =
+ selectWordWhenUnderCursor(lyx::PREVIOUS_WORD);
string idxstring;
if (!selection.set())
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;
// the DTP switches for paragraphs. LyX will store them in the first
-// physicla paragraph. When a paragraph is broken, the top settings rest,
-// the bottom settings are given to the new one. So I can make shure,
+// physical paragraph. When a paragraph is broken, the top settings rest,
+// the bottom settings are given to the new one. So I can make sure,
// they do not duplicate themself and you cannnot make dirty things with
// them!
++endpit;
}
- setUndo(bv(), Undo::EDIT, selection.start.par(),
+ recordUndo(bv(), Undo::ATOMIC, selection.start.par(),
boost::prior(undoendpit));
while (tmppit != boost::prior(selection.start.par())) {
setCursor(tmppit, 0);
- postPaint(cursor.y() - cursorRow()->baseline());
ParagraphList::iterator pit = cursor.par();
ParagraphParameters & params = pit->params();
tmppit = boost::prior(pit);
}
- redoParagraphs(selection.start, endpit);
+ redoParagraphs(selection.start.par(), endpit);
clearSelection();
setCursor(selection.start.par(), selection.start.pos());
// set the counter of a paragraph. This includes the labels
-void LyXText::setCounter(Buffer const * buf, ParagraphList::iterator pit)
+void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
{
- LyXTextClass const & textclass = buf->params.getLyXTextClass();
+ LyXTextClass const & textclass = buf.params.getLyXTextClass();
LyXLayout_ptr const & layout = pit->layout();
if (pit != ownerParagraphs().begin()) {
pit->itemdepth = 0;
}
- /* Maybe we have to increment the enumeration depth.
- * BUT, enumeration in a footnote is considered in isolation from its
- * surrounding paragraph so don't increment if this is the
- * first line of the footnote
- * AND, bibliographies can't have their depth changed ie. they
- * are always of depth 0
- */
+ // Maybe we have to increment the enumeration depth.
+ // BUT, enumeration in a footnote is considered in isolation from its
+ // surrounding paragraph so don't increment if this is the
+ // first line of the footnote
+ // AND, bibliographies can't have their depth changed ie. they
+ // are always of depth 0
if (pit != ownerParagraphs().begin()
&& boost::prior(pit)->getDepth() < pit->getDepth()
&& boost::prior(pit)->layout()->labeltype == LABEL_COUNTER_ENUMI
}
if (layout->margintype == MARGIN_MANUAL) {
- if (pit->params().labelWidthString().empty()) {
+ if (pit->params().labelWidthString().empty())
pit->setLabelWidthString(layout->labelstring());
- }
} else {
pit->setLabelWidthString(string());
}
ostringstream s;
- if (i >= 0 && i <= buf->params.secnumdepth) {
+ if (i >= 0 && i <= buf.params.secnumdepth) {
string numbertype;
string langtype;
// Is there a label? Useful for Chapter layout
if (!pit->params().appendix()) {
- s << buf->B_(layout->labelstring());
+ s << buf.B_(layout->labelstring());
} else {
- s << buf->B_(layout->labelstring_appendix());
+ s << buf.B_(layout->labelstring_appendix());
}
// Use of an integer is here less than elegant. For now.
numbertype = "sectioning";
} else {
numbertype = "appendix";
- if (pit->isRightToLeftPar(buf->params))
+ if (pit->isRightToLeftPar(buf.params))
langtype = "hebrew";
else
langtype = "latin";
}
// In biblio should't be following counters but...
} else {
- string s = buf->B_(layout->labelstring());
+ string s = buf.B_(layout->labelstring());
// the caption hack:
if (layout->labeltype == LABEL_SENSITIVE) {
+ ParagraphList::iterator end = ownerParagraphs().end();
ParagraphList::iterator tmppit = pit;
- Inset * in = 0;
+ InsetOld * in = 0;
bool isOK = false;
- while (tmppit != ownerParagraphs().end() &&
- tmppit->inInset()
+ while (tmppit != end && tmppit->inInset()
// the single '=' is intended below
- && (in = tmppit->inInset()->owner())) {
- if (in->lyxCode() == Inset::FLOAT_CODE ||
- in->lyxCode() == Inset::WRAP_CODE) {
+ && (in = tmppit->inInset()->owner()))
+ {
+ if (in->lyxCode() == InsetOld::FLOAT_CODE ||
+ in->lyxCode() == InsetOld::WRAP_CODE) {
isOK = true;
break;
} else {
- tmppit = std::find(ownerParagraphs().begin(), ownerParagraphs().end(), *in->parOwner());
+ Paragraph const * owner = &ownerPar(buf, in);
+ tmppit = ownerParagraphs().begin();
+ for ( ; tmppit != end; ++tmppit)
+ if (&*tmppit == owner)
+ break;
}
}
if (isOK) {
string type;
- if (in->lyxCode() == Inset::FLOAT_CODE)
+ if (in->lyxCode() == InsetOld::FLOAT_CODE)
type = static_cast<InsetFloat*>(in)->params().type;
- else if (in->lyxCode() == Inset::WRAP_CODE)
+ else if (in->lyxCode() == InsetOld::WRAP_CODE)
type = static_cast<InsetWrap*>(in)->params().type;
else
Assert(0);
textclass.counters().step(fl.type());
// Doesn't work... yet.
- s = bformat(_("%1$s #:"), buf->B_(fl.name()));
+ s = bformat(_("%1$s #:"), buf.B_(fl.name()));
} else {
// par->SetLayout(0);
// s = layout->labelstring;
// Updates all counters. Paragraphs with changed label string will be rebroken
void LyXText::updateCounters()
{
- RowList::iterator rowit = rows().begin();
- ParagraphList::iterator pit = rowit->par();
-
- // CHECK if this is really needed. (Lgb)
+ // start over
bv()->buffer()->params.getLyXTextClass().counters().reset();
ParagraphList::iterator beg = ownerParagraphs().begin();
ParagraphList::iterator end = ownerParagraphs().end();
- for (; pit != end; ++pit) {
- while (rowit->par() != pit)
- ++rowit;
-
+ for (ParagraphList::iterator pit = beg; pit != end; ++pit) {
string const oldLabel = pit->params().labelString();
size_t maxdepth = 0;
pit->params().depth(maxdepth);
// setCounter can potentially change the labelString.
- setCounter(bv()->buffer(), pit);
+ setCounter(*bv()->buffer(), pit);
string const & newLabel = pit->params().labelString();
- if (oldLabel.empty() && !newLabel.empty()) {
- removeParagraph(rowit);
- appendParagraph(rowit);
- }
+ if (oldLabel != newLabel)
+ redoParagraph(pit);
}
}
-void LyXText::insertInset(Inset * inset)
+void LyXText::insertInset(InsetOld * inset)
{
if (!cursor.par()->insetAllowed(inset->lyxCode()))
return;
- setUndo(bv(), Undo::FINISH, cursor.par());
+ recordUndo(bv(), Undo::ATOMIC, cursor.par());
freezeUndo();
cursor.par()->insertInset(cursor.pos(), inset);
// Just to rebreak and refresh correctly.
// The character will not be inserted a second time
insertChar(Paragraph::META_INSET);
- // If we enter a highly editable inset the cursor should be to before
- // the inset. This couldn't happen before as Undo was not handled inside
- // inset now after the Undo LyX tries to call inset->Edit(...) again
- // and cannot do this as the cursor is behind the inset and GetInset
+ // If we enter a highly editable inset the cursor should be before
+ // the inset. After an Undo LyX tries to call inset->edit(...)
+ // and fails if the cursor is behind the inset and getInset
// does not return the inset!
- if (isHighlyEditableInset(inset)) {
+ if (isHighlyEditableInset(inset))
cursorLeft(true);
- }
unFreezeUndo();
}
// 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())
++endpit;
}
- setUndo(bv(), Undo::DELETE, selection.start.par(),
- boost::prior(undoendpit));
-
+ recordUndo(bv(), Undo::DELETE, selection.start.par(),
+ boost::prior(undoendpit));
endpit = selection.end.par();
int endpos = selection.end.pos();
if (doclear)
selection.start.par()->stripLeadingSpaces();
- redoParagraphs(selection.start, boost::next(endpit));
-#warning FIXME latent bug
- // endpit will be invalidated on redoParagraphs once ParagraphList
- // becomes a std::list? There are maybe other places on which this
- // can happend? (Ab)
+ redoParagraphs(selection.start.par(), boost::next(endpit));
// cutSelection can invalidate the cursor so we need to set
// it anew. (Lgb)
// we prefer the end for when tracking changes
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())
if (!CutAndPaste::checkPastePossible())
return;
- setUndo(bv(), Undo::INSERT, cursor.par());
+ recordUndo(bv(), Undo::INSERT, cursor.par());
ParagraphList::iterator endpit;
PitPosPair ppp;
cursor.par(), cursor.pos(),
bv()->buffer()->params.textclass,
sel_index, el);
- parseErrors(*bv()->buffer(), el);
+ bufferErrors(*bv()->buffer(), el);
bv()->showErrorList(_("Paste"));
- redoParagraphs(cursor, endpit);
+ redoParagraphs(cursor.par(), endpit);
setCursor(cursor.par(), cursor.pos());
clearSelection();
// simple replacing. The font of the first selected character is used
void LyXText::replaceSelectionWithString(string const & str)
{
- setCursorParUndo(bv());
+ recordUndo(bv(), Undo::ATOMIC);
freezeUndo();
if (!selection.set()) { // create a dummy selection
pos_type pos = cursor.pos();
ParagraphList::iterator endpit = boost::next(cursor.par());
- setCursorParUndo(bv());
+ recordUndo(bv(), Undo::ATOMIC);
// only to be sure, should not be neccessary
clearSelection();
bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
- redoParagraphs(cursor, endpit);
+ redoParagraphs(cursor.par(), endpit);
setCursor(cursor.par(), cursor.pos());
selection.cursor = cursor;
setCursor(pit, pos);
}
-void LyXText::checkParagraph(ParagraphList::iterator pit, pos_type pos)
-{
- LyXCursor tmpcursor;
-
- int y = 0;
- pos_type z;
- RowList::iterator row = getRow(pit, pos, y);
- RowList::iterator beg = rows().begin();
-
- // is there a break one row above
- if (row != beg
- && boost::prior(row)->par() == row->par()) {
- z = rowBreakPoint(*boost::prior(row));
- if (z >= row->pos()) {
- // set the dimensions of the row above
- y -= boost::prior(row)->height();
- postPaint(y);
-
- breakAgain(boost::prior(row));
-
- // set the cursor again. Otherwise
- // dangling pointers are possible
- setCursor(cursor.par(), cursor.pos(),
- false, cursor.boundary());
- selection.cursor = cursor;
- return;
- }
- }
-
- int const tmpheight = row->height();
- pos_type const tmplast = lastPos(*this, row);
-
- breakAgain(row);
- if (row->height() == tmpheight && lastPos(*this, row) == tmplast) {
- postRowPaint(row, y);
- } else {
- postPaint(y);
- }
-
- // check the special right address boxes
- if (pit->layout()->margintype == MARGIN_RIGHT_ADDRESS_BOX) {
- tmpcursor.par(pit);
- tmpcursor.y(y);
- tmpcursor.x(0);
- tmpcursor.x_fix(0);
- tmpcursor.pos(pos);
- redoDrawingOfParagraph(tmpcursor);
- }
-
- // set the cursor again. Otherwise dangling pointers are possible
- // also set the selection
-
- if (selection.set()) {
- tmpcursor = cursor;
- setCursorIntern(selection.cursor.par(), selection.cursor.pos(),
- false, selection.cursor.boundary());
- selection.cursor = cursor;
- setCursorIntern(selection.start.par(),
- selection.start.pos(),
- false, selection.start.boundary());
- selection.start = cursor;
- setCursorIntern(selection.end.par(),
- selection.end.pos(),
- false, selection.end.boundary());
- selection.end = cursor;
- setCursorIntern(last_sel_cursor.par(),
- last_sel_cursor.pos(),
- false, last_sel_cursor.boundary());
- last_sel_cursor = cursor;
- cursor = tmpcursor;
- }
- setCursorIntern(cursor.par(), cursor.pos(),
- false, cursor.boundary());
-}
-
-
-// returns false if inset wasn't found
-bool LyXText::updateInset(Inset * inset)
-{
- // first check the current paragraph
- int pos = cursor.par()->getPositionOfInset(inset);
- if (pos != -1) {
- checkParagraph(cursor.par(), pos);
- return true;
- }
-
- // check every paragraph
-
- ParagraphList::iterator par = ownerParagraphs().begin();
- ParagraphList::iterator end = ownerParagraphs().end();
- for (; par != end; ++par) {
- pos = par->getPositionOfInset(inset);
- if (pos != -1) {
- checkParagraph(par, pos);
- return true;
- }
- };
-
- return false;
-}
-
-
bool LyXText::setCursor(ParagraphList::iterator pit,
pos_type pos,
bool setfont, bool boundary)
}
+void LyXText::redoCursor()
+{
+#warning maybe the same for selections?
+ setCursor(cursor, cursor.par(), cursor.pos(), cursor.boundary());
+}
+
+
void LyXText::setCursor(LyXCursor & cur, ParagraphList::iterator pit,
pos_type pos, bool boundary)
{
cur.par(pit);
cur.pos(pos);
cur.boundary(boundary);
+ if (noRows())
+ return;
// get the cursor y position in text
- int y = 0;
- RowList::iterator row = getRow(pit, pos, y);
- RowList::iterator beg = rows().begin();
+
+ RowList::iterator row = getRow(pit, pos);
+ int y = row->y();
RowList::iterator old_row = row;
- cur.irow(row);
// if we are before the first char of this row and are still in the
// same paragraph and there is a previous row then put the cursor on
// the end of the previous row
cur.iy(y + row->baseline());
- if (row != beg &&
- pos &&
- boost::prior(row)->par() == row->par() &&
- pos < pit->size() &&
- pit->getChar(pos) == Paragraph::META_INSET) {
- Inset * ins = pit->getInset(pos);
- if (ins && (ins->needFullRow() || ins->display())) {
- --row;
- y -= row->height();
- }
- }
// y is now the beginning of the cursor row
y += row->baseline();
// y is now the cursor baseline
cur.y(y);
- pos_type last = lastPrintablePos(*this, old_row);
+ pos_type last = lastPrintablePos(*pit, old_row);
// None of these should happen, but we're scaredy-cats
if (pos > pit->size()) {
- lyxerr << "dont like 1 please report" << endl;
+ lyxerr << "dont like 1, pos: " << pos << " size: " << pit->size() << endl;
pos = 0;
cur.pos(0);
} else if (pos > last + 1) {
}
// now get the cursors x position
- float x = getCursorX(row, pos, last, boundary);
+ float x = getCursorX(pit, row, pos, last, boundary);
cur.x(int(x));
cur.x_fix(cur.x());
if (old_row != row) {
- x = getCursorX(old_row, pos, last, boundary);
+ x = getCursorX(pit, old_row, pos, last, boundary);
cur.ix(int(x));
} else
cur.ix(cur.x());
-/* We take out this for the time being because 1) the redraw code is not
- prepared to this yet and 2) because some good policy has yet to be decided
- while editting: for instance how to act on rows being created/deleted
- because of DEPM.
-*/
-#if 0
- //if the cursor is in a visible row, anchor to it
- int topy = top_y();
- if (topy < y && y < topy + bv()->workHeight())
- anchor_row(row);
-#endif
}
-float LyXText::getCursorX(RowList::iterator rit,
+float LyXText::getCursorX(ParagraphList::iterator pit, RowList::iterator rit,
pos_type pos, pos_type last, bool boundary) const
{
- pos_type cursor_vpos = 0;
- float x;
- float fill_separator;
- float fill_hfill;
- float fill_label_hfill;
- // This call HAS to be here because of the BidiTables!!!
- prepareToPrint(rit, x, fill_separator, fill_hfill,
- fill_label_hfill);
-
- ParagraphList::iterator rit_par = rit->par();
- pos_type const rit_pos = rit->pos();
+ pos_type cursor_vpos = 0;
+ double x = rit->x();
+ double fill_separator = rit->fill_separator();
+ double fill_hfill = rit->fill_hfill();
+ double fill_label_hfill = rit->fill_label_hfill();
+ pos_type const rit_pos = rit->pos();
if (last < rit_pos)
cursor_vpos = rit_pos;
else if (pos > last && !boundary)
- cursor_vpos = (rit_par->isRightToLeftPar(bv()->buffer()->params))
+ cursor_vpos = (pit->isRightToLeftPar(bv()->buffer()->params))
? rit_pos : last + 1;
else if (pos > rit_pos && (pos > last || boundary))
- /// Place cursor after char at (logical) position pos - 1
+ // Place cursor after char at (logical) position pos - 1
cursor_vpos = (bidi_level(pos - 1) % 2 == 0)
? log2vis(pos - 1) + 1 : log2vis(pos - 1);
else
- /// Place cursor before char at (logical) position pos
+ // Place cursor before char at (logical) position pos
cursor_vpos = (bidi_level(pos) % 2 == 0)
? log2vis(pos) : log2vis(pos) + 1;
- pos_type body_pos = rit_par->beginningOfBody();
- if ((body_pos > 0) &&
- ((body_pos - 1 > last) || !rit_par->isLineSeparator(body_pos - 1)))
+ pos_type body_pos = pit->beginningOfBody();
+ if (body_pos > 0 &&
+ (body_pos - 1 > last || !pit->isLineSeparator(body_pos - 1)))
body_pos = 0;
for (pos_type vpos = rit_pos; vpos < cursor_vpos; ++vpos) {
if (body_pos > 0 && pos == body_pos - 1) {
x += fill_label_hfill +
font_metrics::width(
- rit_par->layout()->labelsep,
- getLabelFont(bv()->buffer(), rit_par));
- if (rit_par->isLineSeparator(body_pos - 1))
- x -= singleWidth(rit_par, body_pos - 1);
+ pit->layout()->labelsep, getLabelFont(pit));
+ if (pit->isLineSeparator(body_pos - 1))
+ x -= singleWidth(pit, body_pos - 1);
}
- if (hfillExpansion(*this, rit, pos)) {
- x += singleWidth(rit_par, pos);
+ if (hfillExpansion(*pit, rit, pos)) {
+ x += singleWidth(pit, pos);
if (pos >= body_pos)
x += fill_hfill;
else
x += fill_label_hfill;
- } else if (rit_par->isSeparator(pos)) {
- x += singleWidth(rit_par, pos);
+ } else if (pit->isSeparator(pos)) {
+ x += singleWidth(pit, pos);
if (pos >= body_pos)
x += fill_separator;
} else
- x += singleWidth(rit_par, pos);
+ x += singleWidth(pit, pos);
}
return x;
}
void LyXText::setCursorIntern(ParagraphList::iterator pit,
pos_type pos, bool setfont, bool boundary)
{
- UpdatableInset * it = pit->inInset();
- if (it) {
- if (it != inset_owner) {
- lyxerr[Debug::INSETS] << "InsetText is " << it
- << endl
- << "inset_owner is "
- << inset_owner << endl;
-#ifdef WITH_WARNINGS
-#warning I believe this code is wrong. (Lgb)
-#warning Jürgen, have a look at this. (Lgb)
-#warning Hmmm, I guess you are right but we
-#warning should verify when this is needed
-#endif
- // Jürgen, would you like to have a look?
- // I guess we need to move the outer cursor
- // and open and lock the inset (bla bla bla)
- // stuff I don't know... so can you have a look?
- // (Lgb)
- // I moved the lyxerr stuff in here so we can see if
- // this is actually really needed and where!
- // (Jug)
- // it->getLyXText(bv())->setCursorIntern(bv(), par, pos, setfont, boundary);
- return;
- }
- }
-
setCursor(cursor, pit, pos, boundary);
if (setfont)
setCurrentFont();
}
}
- current_font =
- pit->getFontSettings(bv()->buffer()->params, pos);
- real_current_font = getFont(bv()->buffer(), pit, pos);
+ current_font = pit->getFontSettings(bv()->buffer()->params, pos);
+ real_current_font = getFont(pit, pos);
if (cursor.pos() == pit->size() &&
- isBoundary(bv()->buffer(), *pit, cursor.pos()) &&
+ isBoundary(*bv()->buffer(), *pit, cursor.pos()) &&
!cursor.boundary()) {
Language const * lang =
pit->getParLanguage(bv()->buffer()->params);
// returns the column near the specified x-coordinate of the row
// x is set to the real beginning of this column
-pos_type
-LyXText::getColumnNearX(RowList::iterator rit, int & x, bool & boundary) const
+pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
+ RowList::iterator rit, int & x, bool & boundary) const
{
- float tmpx = 0.0;
- float fill_separator;
- float fill_hfill;
- float fill_label_hfill;
-
- prepareToPrint(rit, tmpx, fill_separator,
- fill_hfill, fill_label_hfill);
+ double tmpx = rit->x();
+ double fill_separator = rit->fill_separator();
+ double fill_hfill = rit->fill_hfill();
+ double fill_label_hfill = rit->fill_label_hfill();
pos_type vc = rit->pos();
- pos_type last = lastPrintablePos(*this, rit);
+ pos_type last = lastPrintablePos(*pit, rit);
pos_type c = 0;
-
- ParagraphList::iterator rit_par = rit->par();
- LyXLayout_ptr const & layout = rit->par()->layout();
+ LyXLayout_ptr const & layout = pit->layout();
bool left_side = false;
- pos_type body_pos = rit_par->beginningOfBody();
- float last_tmpx = tmpx;
+ pos_type body_pos = pit->beginningOfBody();
+ double last_tmpx = tmpx;
if (body_pos > 0 &&
(body_pos - 1 > last ||
- !rit_par->isLineSeparator(body_pos - 1)))
+ !pit->isLineSeparator(body_pos - 1)))
body_pos = 0;
// check for empty row
- if (!rit_par->size()) {
+ if (!pit->size()) {
x = int(tmpx);
return 0;
}
last_tmpx = tmpx;
if (body_pos > 0 && c == body_pos - 1) {
tmpx += fill_label_hfill +
- font_metrics::width(layout->labelsep,
- getLabelFont(bv()->buffer(), rit_par));
- if (rit_par->isLineSeparator(body_pos - 1))
- tmpx -= singleWidth(rit_par, body_pos - 1);
+ font_metrics::width(layout->labelsep, getLabelFont(pit));
+ if (pit->isLineSeparator(body_pos - 1))
+ tmpx -= singleWidth(pit, body_pos - 1);
}
- if (hfillExpansion(*this, rit, c)) {
- tmpx += singleWidth(rit_par, c);
+ if (hfillExpansion(*pit, rit, c)) {
+ tmpx += singleWidth(pit, c);
if (c >= body_pos)
tmpx += fill_hfill;
else
tmpx += fill_label_hfill;
- } else if (rit_par->isSeparator(c)) {
- tmpx += singleWidth(rit_par, c);
+ } else if (pit->isSeparator(c)) {
+ tmpx += singleWidth(pit, c);
if (c >= body_pos)
- tmpx+= fill_separator;
+ tmpx += fill_separator;
} else {
- tmpx += singleWidth(rit_par, c);
+ tmpx += singleWidth(pit, c);
}
++vc;
}
boundary = false;
// This (rtl_support test) is not needed, but gives
- // some speedup if rtl_support=false
- RowList::iterator next_rit = boost::next(rit);
-
- bool const lastrow = lyxrc.rtl_support &&
- (next_rit == rowlist_.end() ||
- next_rit->par() != rit_par);
+ // some speedup if rtl_support == false
+ bool const lastrow = lyxrc.rtl_support
+ && boost::next(rit) == pit->rows.end();
// If lastrow is false, we don't need to compute
// the value of rtl.
bool const rtl = (lastrow)
- ? rit_par->isRightToLeftPar(bv()->buffer()->params)
+ ? pit->isRightToLeftPar(bv()->buffer()->params)
: false;
if (lastrow &&
- ((rtl && left_side && vc == rit->pos() && x < tmpx - 5) ||
- (!rtl && !left_side && vc == last + 1 && x > tmpx + 5)))
+ ((rtl && left_side && vc == rit->pos() && x < tmpx - 5) ||
+ (!rtl && !left_side && vc == last + 1 && x > tmpx + 5)))
c = last + 1;
else if (vc == rit->pos()) {
c = vis2log(vc);
bool const rtl = (bidi_level(c) % 2 == 1);
if (left_side == rtl) {
++c;
- boundary = isBoundary(bv()->buffer(), *rit_par, c);
+ boundary = isBoundary(*bv()->buffer(), *pit, c);
}
}
- if (rit->pos() <= last && c > last
- && rit_par->isNewline(last)) {
+ if (rit->pos() <= last && c > last && pit->isNewline(last)) {
if (bidi_level(last) % 2 == 0)
- tmpx -= singleWidth(rit_par, last);
+ tmpx -= singleWidth(pit, last);
else
- tmpx += singleWidth(rit_par, last);
+ tmpx += singleWidth(pit, last);
c = last;
}
void LyXText::setCursorFromCoordinates(int x, int y)
{
LyXCursor old_cursor = cursor;
-
setCursorFromCoordinates(cursor, x, y);
setCurrentFont();
deleteEmptyParagraphMechanism(old_cursor);
}
-namespace {
-
- /**
- * return true if the cursor given is at the end of a row,
- * and the next row is filled by an inset that spans an entire
- * row.
- */
- bool beforeFullRowInset(LyXText & lt, LyXCursor const & cur)
- {
- RowList::iterator row = lt.getRow(cur);
- if (boost::next(row) == lt.rows().end())
- return false;
-
- Row const & next = *boost::next(row);
-
- if (next.pos() != cur.pos() || next.par() != cur.par())
- return false;
-
- if (cur.pos() == cur.par()->size()
- || !cur.par()->isInset(cur.pos()))
- return false;
-
- Inset 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 rit = getRowNearY(y, pit);
+ y = rit->y();
- RowList::iterator row = getRowNearY(y);
bool bound = false;
- pos_type const column = getColumnNearX(row, x, bound);
- cur.par(row->par());
- cur.pos(row->pos() + column);
+ pos_type const column = getColumnNearX(pit, rit, x, bound);
+ cur.par(pit);
+ cur.pos(rit->pos() + column);
cur.x(x);
- cur.y(y + row->baseline());
+ cur.y(y + rit->baseline());
- if (beforeFullRowInset(*this, cur)) {
- pos_type const last = lastPrintablePos(*this, row);
- RowList::iterator next_row = boost::next(row);
+ cur.iy(cur.y());
+ cur.ix(cur.x());
- float x = getCursorX(next_row, cur.pos(), last, bound);
- cur.ix(int(x));
- cur.iy(y + row->height() + next_row->baseline());
- cur.irow(next_row);
- } else {
- cur.iy(cur.y());
- cur.ix(cur.x());
- cur.irow(row);
- }
cur.boundary(bound);
}
bool boundary = cursor.boundary();
setCursor(cursor.par(), cursor.pos() - 1, true, false);
if (!internal && !boundary &&
- isBoundary(bv()->buffer(), *cursor.par(), cursor.pos() + 1))
+ isBoundary(*bv()->buffer(), *cursor.par(), cursor.pos() + 1))
setCursor(cursor.par(), cursor.pos() + 1, true, true);
- } else if (cursor.par() != ownerParagraphs().begin()) { // steps into the above paragraph.
+ } else if (cursor.par() != ownerParagraphs().begin()) {
+ // steps into the paragraph above
ParagraphList::iterator pit = boost::prior(cursor.par());
setCursor(pit, pit->size());
}
else if (!at_end) {
setCursor(cursor.par(), cursor.pos() + 1, true, false);
if (!internal &&
- isBoundary(bv()->buffer(), *cursor.par(), cursor.pos()))
+ isBoundary(*bv()->buffer(), *cursor.par(), cursor.pos()))
setCursor(cursor.par(), cursor.pos(), true, true);
} else if (boost::next(cursor.par()) != ownerParagraphs().end())
setCursor(boost::next(cursor.par()), 0);
int y = cursor.y() - cursorRow()->baseline() - 1;
setCursorFromCoordinates(x, y);
if (!selecting) {
- int topy = top_y();
+ int topy = bv_owner->top_y();
int y1 = cursor.iy() - topy;
int y2 = y1;
y -= topy;
- Inset * inset_hit = checkInsetHit(x, y1);
+ InsetOld * inset_hit = checkInsetHit(x, y1);
if (inset_hit && isHighlyEditableInset(inset_hit)) {
inset_hit->localDispatch(
FuncRequest(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none));
}
}
#else
- setCursorFromCoordinates(bv(), cursor.x_fix(),
- cursor.y() - cursorRow()->baseline() - 1);
+ lyxerr << "cursorUp: y " << cursor.y() << " bl: " <<
+ cursorRow()->baseline() << endl;
+ setCursorFromCoordinates(cursor.x_fix(),
+ cursor.y() - cursorRow()->baseline() - 1);
#endif
}
{
#if 1
int x = cursor.x_fix();
- int y = cursor.y() - cursorRow()->baseline() +
- cursorRow()->height() + 1;
+ int y = cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1;
setCursorFromCoordinates(x, y);
- if (!selecting && cursorRow() == cursor.irow()) {
- int topy = top_y();
+ if (!selecting && cursorRow() == cursorIRow()) {
+ int topy = bv_owner->top_y();
int y1 = cursor.iy() - topy;
int y2 = y1;
y -= topy;
- Inset * inset_hit = checkInsetHit(x, y1);
+ InsetOld * inset_hit = checkInsetHit(x, y1);
if (inset_hit && isHighlyEditableInset(inset_hit)) {
FuncRequest cmd(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none);
inset_hit->localDispatch(cmd);
}
}
#else
- setCursorFromCoordinates(bv(), cursor.x_fix(),
- cursor.y() - cursorRow()->baseline()
- + cursorRow()->height() + 1);
+ setCursorFromCoordinates(cursor.x_fix(),
+ cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1);
#endif
}
void LyXText::cursorUpParagraph()
{
- if (cursor.pos() > 0) {
+ if (cursor.pos() > 0)
setCursor(cursor.par(), 0);
- }
- else if (cursor.par() != ownerParagraphs().begin()) {
+ else if (cursor.par() != ownerParagraphs().begin())
setCursor(boost::prior(cursor.par()), 0);
- }
}
ParagraphList::iterator par = cursor.par();
ParagraphList::iterator next_par = boost::next(par);
- if (next_par != ownerParagraphs().end()) {
+ if (next_par != ownerParagraphs().end())
setCursor(next_par, 0);
- } else {
+ else
setCursor(par, par->size());
- }
}
+
// fix the cursor `cur' after a characters has been deleted at `where'
// position. Called by deleteEmptyParagraphMechanism
-void LyXText::fixCursorAfterDelete(LyXCursor & cur,
- LyXCursor const & where)
+void LyXText::fixCursorAfterDelete(LyXCursor & cur, LyXCursor const & where)
{
// if cursor is not in the paragraph where the delete occured,
// do nothing
return false;
// We allow all kinds of "mumbo-jumbo" when freespacing.
- if (old_cursor.par()->layout()->free_spacing
- || old_cursor.par()->isFreeSpacing()) {
+ if (old_cursor.par()->isFreeSpacing())
return false;
- }
/* Ok I'll put some comments here about what is missing.
I have fixed BackSpace (and thus Delete) to not delete
There are still some small problems that can lead to
double spaces stored in the document file or space at
the beginning of paragraphs. This happens if you have
- the cursor betwenn to spaces and then save. Or if you
+ the cursor between to spaces and then save. Or if you
cut and paste and the selection have a space at the
beginning and then save right after the paste. I am
sure none of these are very hard to fix, but I will
// If the pos around the old_cursor were spaces, delete one of them.
if (old_cursor.par() != cursor.par()
|| old_cursor.pos() != cursor.pos()) {
- // Only if the cursor has really moved
+ // Only if the cursor has really moved
if (old_cursor.pos() > 0
&& old_cursor.pos() < old_cursor.par()->size()
&& old_cursor.par()->isLineSeparator(old_cursor.pos())
&& old_cursor.par()->isLineSeparator(old_cursor.pos() - 1)) {
- old_cursor.par()->erase(old_cursor.pos() - 1);
- redoParagraphs(old_cursor, boost::next(old_cursor.par()));
+ bool erased = old_cursor.par()->erase(old_cursor.pos() - 1);
+ redoParagraph(old_cursor.par());
+ if (!erased)
+ return false;
#ifdef WITH_WARNINGS
#warning This will not work anymore when we have multiple views of the same buffer
// In this case, we will have to correct also the cursors held by
#endif
// correct all cursors held by the LyXText
fixCursorAfterDelete(cursor, old_cursor);
- fixCursorAfterDelete(selection.cursor,
- old_cursor);
- fixCursorAfterDelete(selection.start,
- old_cursor);
+ fixCursorAfterDelete(selection.cursor, old_cursor);
+ fixCursorAfterDelete(selection.start, old_cursor);
fixCursorAfterDelete(selection.end, old_cursor);
- fixCursorAfterDelete(last_sel_cursor,
- old_cursor);
- fixCursorAfterDelete(toggle_cursor, old_cursor);
- fixCursorAfterDelete(toggle_end_cursor,
- old_cursor);
return false;
}
}
if (old_cursor.par()->empty() ||
(old_cursor.par()->size() == 1 &&
old_cursor.par()->isLineSeparator(0))) {
- // ok, we will delete anything
+ // ok, we will delete something
LyXCursor tmpcursor;
deleted = true;
selection.cursor.par() == old_cursor.par()
&& selection.cursor.pos() == old_cursor.pos());
- if (getRow(old_cursor) != rows().begin()) {
- RowList::iterator
- prevrow = boost::prior(getRow(old_cursor));
- postPaint(old_cursor.y() - getRow(old_cursor)->baseline() - prevrow->height());
- tmpcursor = cursor;
- cursor = old_cursor; // that undo can restore the right cursor position
- #warning FIXME. --end() iterator is usable here
- ParagraphList::iterator endpit = boost::next(old_cursor.par());
- while (endpit != ownerParagraphs().end() &&
- endpit->getDepth()) {
- ++endpit;
- }
+ tmpcursor = cursor;
+ cursor = old_cursor; // that undo can restore the right cursor position
- setUndo(bv(), Undo::DELETE, old_cursor.par(),
- boost::prior(endpit));
- cursor = tmpcursor;
-
- // delete old row
- removeRow(getRow(old_cursor));
- // delete old par
- ownerParagraphs().erase(old_cursor.par());
-
- /* Breakagain the next par. Needed because of
- * the parindent that can occur or dissappear.
- * The next row can change its height, if
- * there is another layout before */
- RowList::iterator tmprit = boost::next(prevrow);
- if (tmprit != rows().end()) {
- breakAgain(tmprit);
- updateCounters();
- }
- setHeightOfRow(prevrow);
- } else {
- RowList::iterator nextrow = boost::next(getRow(old_cursor));
- postPaint(old_cursor.y() - getRow(old_cursor)->baseline());
-
- tmpcursor = cursor;
- cursor = old_cursor; // that undo can restore the right cursor position
-#warning FIXME. --end() iterator is usable here
- ParagraphList::iterator endpit = boost::next(old_cursor.par());
- while (endpit != ownerParagraphs().end() &&
- endpit->getDepth()) {
- ++endpit;
- }
+ ParagraphList::iterator endpit = boost::next(old_cursor.par());
+ while (endpit != ownerParagraphs().end() && endpit->getDepth())
+ ++endpit;
- setUndo(bv(), Undo::DELETE, old_cursor.par(), boost::prior(endpit));
- cursor = tmpcursor;
-
- // delete old row
- removeRow(getRow(old_cursor));
- // delete old par
- ownerParagraphs().erase(old_cursor.par());
-
- /* Breakagain the next par. Needed because of
- the parindent that can occur or dissappear.
- The next row can change its height, if
- there is another layout before */
- if (nextrow != rows().end()) {
- breakAgain(nextrow);
- updateCounters();
- }
- }
+ recordUndo(bv(), Undo::DELETE, old_cursor.par(), boost::prior(endpit));
+ cursor = tmpcursor;
+
+ // delete old par
+ ownerParagraphs().erase(old_cursor.par());
+ redoParagraph();
// correct cursor y
setCursorIntern(cursor.par(), cursor.pos());
}
if (!deleted) {
if (old_cursor.par()->stripLeadingSpaces()) {
- redoParagraphs(old_cursor, boost::next(old_cursor.par()));
+ redoParagraph(old_cursor.par());
// correct cursor y
setCursorIntern(cursor.par(), cursor.pos());
selection.cursor = cursor;
ParagraphList & LyXText::ownerParagraphs() const
{
- if (inset_owner) {
- return inset_owner->paragraphs;
- }
- return bv_owner->buffer()->paragraphs;
-}
-
-
-LyXText::refresh_status LyXText::refreshStatus() const
-{
- return refresh_status_;
-}
-
-
-void LyXText::clearPaint()
-{
- refresh_status_ = REFRESH_NONE;
- refresh_row = rows().end();
- refresh_y = 0;
-}
-
-
-void LyXText::postPaint(int start_y)
-{
- refresh_status old = refresh_status_;
-
- refresh_status_ = REFRESH_AREA;
- refresh_row = rows().end();
-
- if (old != REFRESH_NONE && refresh_y < start_y)
- return;
-
- refresh_y = start_y;
-
- if (!inset_owner)
- return;
-
- // We are an inset's lyxtext. Tell the top-level lyxtext
- // it needs to update the row we're in.
- LyXText * t = bv()->text;
- t->postRowPaint(t->cursorRow(), t->cursor.y() - t->cursorRow()->baseline());
-}
-
-
-// FIXME: we should probably remove this y parameter,
-// make refresh_y be 0, and use row->y etc.
-void LyXText::postRowPaint(RowList::iterator rit, int start_y)
-{
- if (refresh_status_ != REFRESH_NONE && refresh_y < start_y) {
- refresh_status_ = REFRESH_AREA;
- return;
- } else {
- refresh_y = start_y;
- }
-
- if (refresh_status_ == REFRESH_AREA)
- return;
-
- refresh_status_ = REFRESH_ROW;
- refresh_row = rit;
-
- if (!inset_owner)
- return;
-
- // We are an inset's lyxtext. Tell the top-level lyxtext
- // it needs to update the row we're in.
- LyXText * t = bv()->text;
- t->postRowPaint(t->cursorRow(), t->cursor.y() - t->cursorRow()->baseline());
+ return paragraphs_;
}
bool LyXText::isInInset() const
{
- // Sub-level has non-null bv owner and
- // non-null inset owner.
- return inset_owner != 0 && bv_owner != 0;
+ // Sub-level has non-null bv owner and non-null inset owner.
+ return inset_owner != 0;
}
projects / lyx.git / blobdiff