X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftext2.C;h=04d3b35de579343b146223feab67e59ef4ff1887;hb=55ef679c8b8fdad62f45944b75d997d274c6ac47;hp=7d4172e5ffa6ec01b3b3288919ac3e4d24653bf4;hpb=0756c7aed167314658fd77c993f223f4054f65bd;p=lyx.git diff --git a/src/text2.C b/src/text2.C index 7d4172e5ff..04d3b35de5 100644 --- a/src/text2.C +++ b/src/text2.C @@ -1,8 +1,8 @@ /* This file is part of * ====================================================== - * + * * LyX, The Document Processor - * + * * Copyright 1995 Matthias Ettrich * Copyright 1995-2001 The LyX Team. * @@ -17,56 +17,57 @@ #include "lyxtext.h" #include "LString.h" #include "paragraph.h" -#include "insets/inseterror.h" -#include "insets/insetbib.h" -#include "insets/insetspecialchar.h" -#include "insets/insettext.h" -#include "insets/insetfloat.h" -#include "layout.h" -#include "LyXView.h" -#include "support/textutils.h" -#include "support/lstrings.h" +#include "frontends/LyXView.h" #include "undo_funcs.h" #include "buffer.h" #include "bufferparams.h" -#include "lyx_gui_misc.h" #include "gettext.h" #include "BufferView.h" -#include "LyXView.h" #include "CutAndPaste.h" -#include "Painter.h" -#include "font.h" +#include "frontends/Painter.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 "insets/inseterror.h" +#include "insets/insetbib.h" +#include "insets/insetspecialchar.h" +#include "insets/insettext.h" +#include "insets/insetfloat.h" + #include "support/LAssert.h" +#include "support/textutils.h" +#include "support/lstrings.h" +using std::vector; using std::copy; -using std::find; using std::endl; using std::find; using std::pair; +using lyx::pos_type; LyXText::LyXText(BufferView * bv) - : number_of_rows(0), height(0), width(0), first(0), + : number_of_rows(0), height(0), width(0), first_y(0), bv_owner(bv), inset_owner(0), the_locking_inset(0), need_break_row(0), refresh_y(0), refresh_row(0), - status_(LyXText::UNCHANGED), firstrow(0), lastrow(0), - copylayouttype(0) + status_(LyXText::UNCHANGED), firstrow(0), lastrow(0) {} LyXText::LyXText(InsetText * inset) - : number_of_rows(0), height(0), width(0), first(0), + : number_of_rows(0), height(0), width(0), first_y(0), bv_owner(0), inset_owner(inset), the_locking_inset(0), need_break_row(0), refresh_y(0), refresh_row(0), - status_(LyXText::UNCHANGED), firstrow(0), lastrow(0), - copylayouttype(0) + status_(LyXText::UNCHANGED), firstrow(0), lastrow(0) {} + void LyXText::init(BufferView * bview, bool reinit) { if (reinit) { @@ -77,15 +78,20 @@ void LyXText::init(BufferView * bview, bool reinit) delete firstrow; firstrow = tmprow; } - lastrow = refresh_row = need_break_row = 0; - width = height = copylayouttype = 0; - number_of_rows = first = refresh_y = 0; + + lastrow = 0; + refresh_row = 0; + need_break_row = 0; + width = height = 0; + copylayouttype.erase(); + number_of_rows = first_y = refresh_y = 0; status_ = LyXText::UNCHANGED; } else if (firstrow) return; Paragraph * par = ownerParagraph(); current_font = getFont(bview->buffer(), par, 0); + while (par) { insertParagraph(bview, par, lastrow); par = par->next(); @@ -113,23 +119,29 @@ LyXFont const realizeFont(LyXFont const & font, Buffer const * buf, Paragraph * par) { + LyXTextClass const & tclass = buf->params.getLyXTextClass(); LyXFont tmpfont(font); Paragraph::depth_type par_depth = par->getDepth(); - + // Resolve against environment font information while (par && par_depth && !tmpfont.resolved()) { par = par->outerHook(); if (par) { - tmpfont.realize(textclasslist. - Style(buf->params.textclass, - par->getLayout()).font, - buf->params.language); +#ifndef INHERIT_LANGUAGE + tmpfont.realize(par->layout()->font); +#else + tmpfont.realize(tclass[par->layout()]->font, + buf->params.language); +#endif par_depth = par->getDepth(); } } - tmpfont.realize(textclasslist.TextClass(buf->params.textclass).defaultfont(), - buf->params.language); +#ifndef INHERIT_LANGUAGE + tmpfont.realize(tclass.defaultfont()); +#else + tmpfont.realize(tclass.defaultfont(), buf->params.language); +#endif return tmpfont; } @@ -145,163 +157,144 @@ LyXFont const realizeFont(LyXFont const & font, // If position is -1, we get the layout font of the paragraph. // If position is -2, we get the font of the manual label of the paragraph. LyXFont const LyXText::getFont(Buffer const * buf, Paragraph * par, - Paragraph::size_type pos) const + pos_type pos) const { lyx::Assert(pos >= 0); - - LyXLayout const & layout = - textclasslist.Style(buf->params.textclass, par->getLayout()); - - Paragraph::depth_type par_depth = par->getDepth(); + + LyXLayout_ptr const & layout = par->layout(); + // We specialize the 95% common case: - if (!par_depth) { - if (layout.labeltype == LABEL_MANUAL + if (!par->getDepth()) { + if (layout->labeltype == LABEL_MANUAL && pos < beginningOfMainBody(buf, par)) { - // 1% goes here - LyXFont f = par->getFontSettings(buf->params, - pos); + // 1% goes here + LyXFont f = par->getFontSettings(buf->params, pos); + if (par->inInset()) + par->inInset()->getDrawFont(f); +#ifndef INHERIT_LANGUAGE + return f.realize(layout->reslabelfont); +#else return f.realize(layout.reslabelfont, buf->params.language); +#endif } else { LyXFont f = par->getFontSettings(buf->params, pos); + if (par->inInset()) + par->inInset()->getDrawFont(f); +#ifndef INHERIT_LANGUAGE + return f.realize(layout->resfont); +#else return f.realize(layout.resfont, buf->params.language); +#endif } } - + // The uncommon case need not be optimized as much - + LyXFont layoutfont; - + if (pos < beginningOfMainBody(buf, par)) { // 1% goes here - layoutfont = layout.labelfont; + layoutfont = layout->labelfont; } else { // 99% goes here - layoutfont = layout.font; + layoutfont = layout->font; } LyXFont tmpfont = par->getFontSettings(buf->params, pos); +#ifndef INHERIT_LANGUAGE + tmpfont.realize(layoutfont); +#else tmpfont.realize(layoutfont, buf->params.language); - +#endif + if (par->inInset()) + par->inInset()->getDrawFont(tmpfont); + return realizeFont(tmpfont, buf, par); } LyXFont const LyXText::getLayoutFont(Buffer const * buf, Paragraph * par) const { - LyXLayout const & layout = - textclasslist.Style(buf->params.textclass, par->getLayout()); - - Paragraph::depth_type par_depth = par->getDepth(); + LyXLayout_ptr const & layout = par->layout(); - if (!par_depth) { - return layout.resfont; + if (!par->getDepth()) { + return layout->resfont; } - return realizeFont(layout.font, buf, par); + return realizeFont(layout->font, buf, par); } LyXFont const LyXText::getLabelFont(Buffer const * buf, Paragraph * par) const { - LyXLayout const & layout = - textclasslist.Style(buf->params.textclass, par->getLayout()); + LyXLayout_ptr const & layout = par->layout(); - Paragraph::depth_type par_depth = par->getDepth(); - - if (!par_depth) { - return layout.reslabelfont; + if (!par->getDepth()) { + return layout->reslabelfont; } - return realizeFont(layout.labelfont, buf, par); + return realizeFont(layout->labelfont, buf, par); } void LyXText::setCharFont(BufferView * bv, Paragraph * par, - Paragraph::size_type pos, LyXFont const & fnt, - bool toggleall) + pos_type pos, LyXFont const & fnt, + bool toggleall) { Buffer const * buf = bv->buffer(); LyXFont font = getFont(buf, par, pos); - font.update(fnt, toggleall); + font.update(fnt, buf->params.language, toggleall); // Let the insets convert their font - if (par->getChar(pos) == Paragraph::META_INSET) { + if (par->isInset(pos)) { Inset * inset = par->getInset(pos); - if (inset) { - if (inset->editable()==Inset::IS_EDITABLE) { - UpdatableInset * uinset = - static_cast(inset); - uinset->setFont(bv, fnt, toggleall, true); - } - } - } - - LyXLayout const & layout = - textclasslist.Style(buf->params.textclass, - par->getLayout()); - - // Get concrete layout font to reduce against - LyXFont layoutfont; - - if (pos < beginningOfMainBody(buf, par)) - layoutfont = layout.labelfont; - else - layoutfont = layout.font; - - // Realize against environment font information - if (par->getDepth()){ - Paragraph * tp = par; - while (!layoutfont.resolved() && tp && tp->getDepth()) { - tp = tp->outerHook(); - if (tp) - layoutfont.realize(textclasslist. - Style(buf->params.textclass, - tp->getLayout()).font, - buf->params.language); + if (isEditableInset(inset)) { + UpdatableInset * uinset = + static_cast(inset); + uinset->setFont(bv, fnt, toggleall, true); } } - layoutfont.realize(textclasslist.TextClass(buf->params.textclass).defaultfont(), - buf->params.language); - - // Now, reduce font against full layout font - font.reduce(layoutfont); - - par->setFont(pos, font); + // Plug thru to version below: + setCharFont(buf, par, pos, font); } void LyXText::setCharFont(Buffer const * buf, Paragraph * par, - Paragraph::size_type pos, LyXFont const & fnt) + pos_type pos, LyXFont const & fnt) { LyXFont font(fnt); - LyXLayout const & layout = - textclasslist.Style(buf->params.textclass, - par->getLayout()); + LyXTextClass const & tclass = buf->params.getLyXTextClass(); + LyXLayout_ptr const & layout = par->layout(); // Get concrete layout font to reduce against LyXFont layoutfont; if (pos < beginningOfMainBody(buf, par)) - layoutfont = layout.labelfont; + layoutfont = layout->labelfont; else - layoutfont = layout.font; + layoutfont = layout->font; // Realize against environment font information - if (par->getDepth()){ + if (par->getDepth()) { Paragraph * tp = par; while (!layoutfont.resolved() && tp && tp->getDepth()) { tp = tp->outerHook(); if (tp) - layoutfont.realize(textclasslist. - Style(buf->params.textclass, - tp->getLayout()).font, - buf->params.language); +#ifndef INHERIT_LANGUAGE + layoutfont.realize(tp->layout()->font); +#else + layoutfont.realize(tclass[tp->layout()].font, + buf->params.language); +#endif } } - layoutfont.realize(textclasslist.TextClass(buf->params.textclass).defaultfont(), - buf->params.language); +#ifndef INHERIT_LANGUAGE + layoutfont.realize(tclass.defaultfont()); +#else + layoutfont.realize(tclass.defaultfont(), buf->params.language); +#endif // Now, reduce font against full layout font font.reduce(layoutfont); @@ -313,7 +306,7 @@ void LyXText::setCharFont(Buffer const * buf, Paragraph * par, // inserts a new row behind the specified row, increments // the touched counters void LyXText::insertRow(Row * row, Paragraph * par, - Paragraph::size_type pos) const + pos_type pos) const { Row * tmprow = new Row; if (!row) { @@ -325,14 +318,14 @@ void LyXText::insertRow(Row * row, Paragraph * par, tmprow->next(row->next()); row->next(tmprow); } - + if (tmprow->next()) tmprow->next()->previous(tmprow); - + if (tmprow->previous()) tmprow->previous()->next(tmprow); - - + + tmprow->par(par); tmprow->pos(pos); @@ -345,24 +338,26 @@ void LyXText::insertRow(Row * row, Paragraph * par, // removes the row and reset the touched counters void LyXText::removeRow(Row * row) const { - /* this must not happen before the currentrow for clear reasons. - so the trick is just to set the current row onto the previous - row of this row */ - int unused_y; - getRow(row->par(), row->pos(), unused_y); - + Row * row_prev = row->previous(); if (row->next()) - row->next()->previous(row->previous()); - if (!row->previous()) { + row->next()->previous(row_prev); + if (!row_prev) { firstrow = row->next(); +// lyx::Assert(firstrow); } else { - row->previous()->next(row->next()); + row_prev->next(row->next()); } - if (row == lastrow) - lastrow = row->previous(); - + if (row == lastrow) { + lyx::Assert(!row->next()); + lastrow = row_prev; + } + if (refresh_row == row) { + refresh_row = row_prev ? row_prev : row->next(); + // what about refresh_y, refresh_height + } + height -= row->height(); // the text becomes smaller - + delete row; --number_of_rows; // one row less } @@ -373,7 +368,7 @@ void LyXText::removeParagraph(Row * row) const { Paragraph * tmppar = row->par(); row = row->next(); - + Row * tmprow; while (row && row->par() == tmppar) { tmprow = row->next(); @@ -381,17 +376,17 @@ void LyXText::removeParagraph(Row * row) const row = tmprow; } } - + // insert the specified paragraph behind the specified row void LyXText::insertParagraph(BufferView * bview, Paragraph * par, - Row * row) const + Row * row) const { - insertRow(row, par, 0); /* insert a new row, starting - * at postition 0 */ + insertRow(row, par, 0); /* insert a new row, starting + * at position 0 */ setCounter(bview->buffer(), par); // set the counters - + // and now append the whole paragraph behind the new row if (!row) { firstrow->height(0); @@ -408,8 +403,8 @@ Inset * LyXText::getInset() const Inset * inset = 0; if (cursor.pos() == 0 && cursor.par()->bibkey) { inset = cursor.par()->bibkey; - } else if (cursor.pos() < cursor.par()->size() - && cursor.par()->getChar(cursor.pos()) == Paragraph::META_INSET) { + } else if (cursor.pos() < cursor.par()->size() + && cursor.par()->isInset(cursor.pos())) { inset = cursor.par()->getInset(cursor.pos()); } return inset; @@ -419,12 +414,21 @@ Inset * LyXText::getInset() const void LyXText::toggleInset(BufferView * bview) { Inset * inset = getInset(); - if (!inset->editable()) + // is there an editable inset at cursor position? + if (!isEditableInset(inset)) { + // No, try to see if we are inside a collapsable inset + if (inset_owner && inset_owner->owner() + && inset_owner->owner()->isOpen()) { + bview->unlockInset(static_cast(inset_owner->owner())); + inset_owner->owner()->close(bview); + bview->getLyXText()->cursorRight(bview); + } return; + } //bview->owner()->message(inset->editMessage()); // do we want to keep this?? (JMarc) - if (inset->editable() != Inset::HIGHLY_EDITABLE) + if (!isHighlyEditableInset(inset)) setCursorParUndo(bview); if (inset->isOpen()) { @@ -443,16 +447,15 @@ void LyXText::toggleInset(BufferView * bview) void LyXText::makeFontEntriesLayoutSpecific(Buffer const * buf, Paragraph * par) { - LyXLayout const & layout = - textclasslist.Style(buf->params.textclass, par->getLayout()); + LyXLayout_ptr const & layout = par->layout(); LyXFont layoutfont; - for (Paragraph::size_type pos = 0; pos < par->size(); ++pos) { + for (pos_type pos = 0; pos < par->size(); ++pos) { if (pos < beginningOfMainBody(buf, par)) - layoutfont = layout.labelfont; + layoutfont = layout->labelfont; else - layoutfont = layout.font; - + layoutfont = layout->font; + LyXFont tmpfont = par->getFontSettings(buf->params, pos); tmpfont.reduce(layoutfont); par->setFont(pos, tmpfont); @@ -463,11 +466,11 @@ void LyXText::makeFontEntriesLayoutSpecific(Buffer const * buf, Paragraph * LyXText::setLayout(BufferView * bview, LyXCursor & cur, LyXCursor & sstart_cur, LyXCursor & send_cur, - LyXTextClass::size_type layout) + string const & layout) { Paragraph * endpar = send_cur.par()->next(); Paragraph * undoendpar = endpar; - + if (endpar && endpar->getDepth()) { while (endpar && endpar->getDepth()) { endpar = endpar->next(); @@ -476,56 +479,45 @@ Paragraph * LyXText::setLayout(BufferView * bview, } else if (endpar) { endpar = endpar->next(); // because of parindents etc. } - - setUndo(bview, Undo::EDIT, - sstart_cur.par(), undoendpar); - + + setUndo(bview, Undo::EDIT, sstart_cur.par(), undoendpar); + // ok we have a selection. This is always between sstart_cur // and sel_end cursor cur = sstart_cur; - - LyXLayout const & lyxlayout = - textclasslist.Style(bview->buffer()->params.textclass, layout); - - while (cur.par() != send_cur.par()) { - cur.par()->setLayout(layout); - makeFontEntriesLayoutSpecific(bview->buffer(), cur.par()); - Paragraph * fppar = cur.par(); - fppar->params().spaceTop(lyxlayout.fill_top ? + Paragraph * par = sstart_cur.par(); + Paragraph * epar = send_cur.par()->next(); + + LyXLayout_ptr const & lyxlayout = + bview->buffer()->params.getLyXTextClass()[layout]; + + do { + par->applyLayout(lyxlayout); + makeFontEntriesLayoutSpecific(bview->buffer(), par); + Paragraph * fppar = par; + fppar->params().spaceTop(lyxlayout->fill_top ? VSpace(VSpace::VFILL) : VSpace(VSpace::NONE)); - fppar->params().spaceBottom(lyxlayout.fill_bottom ? + fppar->params().spaceBottom(lyxlayout->fill_bottom ? VSpace(VSpace::VFILL) : VSpace(VSpace::NONE)); - if (lyxlayout.margintype == MARGIN_MANUAL) - cur.par()->setLabelWidthString(lyxlayout.labelstring()); - if (lyxlayout.labeltype != LABEL_BIBLIO + if (lyxlayout->margintype == MARGIN_MANUAL) + par->setLabelWidthString(lyxlayout->labelstring()); + if (lyxlayout->labeltype != LABEL_BIBLIO && fppar->bibkey) { delete fppar->bibkey; fppar->bibkey = 0; } - cur.par(cur.par()->next()); - } - cur.par()->setLayout(layout); - makeFontEntriesLayoutSpecific(bview->buffer(), cur.par()); - Paragraph * fppar = cur.par(); - fppar->params().spaceTop(lyxlayout.fill_top ? - VSpace(VSpace::VFILL) : VSpace(VSpace::NONE)); - fppar->params().spaceBottom(lyxlayout.fill_bottom ? - VSpace(VSpace::VFILL) : VSpace(VSpace::NONE)); - if (lyxlayout.margintype == MARGIN_MANUAL) - cur.par()->setLabelWidthString(lyxlayout.labelstring()); - if (lyxlayout.labeltype != LABEL_BIBLIO - && fppar->bibkey) { - delete fppar->bibkey; - fppar->bibkey = 0; - } + cur.par(par); + par = par->next(); + } while (par != epar); + return endpar; } // set layout over selection and make a total rebreak of those paragraphs -void LyXText::setLayout(BufferView * bview, LyXTextClass::size_type layout) +void LyXText::setLayout(BufferView * bview, string const & layout) { LyXCursor tmpcursor = cursor; /* store the current cursor */ @@ -538,14 +530,14 @@ void LyXText::setLayout(BufferView * bview, LyXTextClass::size_type layout) Paragraph * endpar = setLayout(bview, cursor, selection.start, selection.end, layout); redoParagraphs(bview, selection.start, endpar); - + // we have to reset the selection, because the // geometry could have changed setCursor(bview, selection.start.par(), selection.start.pos(), false); selection.cursor = cursor; setCursor(bview, selection.end.par(), selection.end.pos(), false); - updateCounters(bview, cursor.row()); + updateCounters(bview); clearSelection(); setSelection(bview); setCursor(bview, tmpcursor.par(), tmpcursor.pos(), true); @@ -575,7 +567,7 @@ void LyXText::incDepth(BufferView * bview) } else if (endpar) { endpar = endpar->next(); // because of parindents etc. } - + setUndo(bview, Undo::EDIT, selection.start.par(), undoendpar); @@ -584,31 +576,27 @@ void LyXText::incDepth(BufferView * bview) // ok we have a selection. This is always between sel_start_cursor // and sel_end cursor cursor = selection.start; - + bool anything_changed = false; - + while (true) { // NOTE: you can't change the depth of a bibliography entry - if ( - textclasslist.Style(bview->buffer()->params.textclass, - cursor.par()->getLayout() - ).labeltype != LABEL_BIBLIO) { + if (cursor.par()->layout()->labeltype != LABEL_BIBLIO) { Paragraph * prev = cursor.par()->previous(); - if (prev - && (prev->getDepth() - cursor.par()->getDepth() > 0 - || (prev->getDepth() == cursor.par()->getDepth() - && textclasslist.Style(bview->buffer()->params.textclass, - prev->getLayout()).isEnvironment()))) { - cursor.par()->params().depth(cursor.par()->params().depth() + 1); - anything_changed = true; + if (prev) { + if (cursor.par()->getDepth() + < prev->getMaxDepthAfter()) { + cursor.par()->params().depth(cursor.par()->getDepth() + 1); + anything_changed = true; + } } } if (cursor.par() == selection.end.par()) break; cursor.par(cursor.par()->next()); } - + // if nothing changed set all depth to 0 if (!anything_changed) { cursor = selection.start; @@ -618,15 +606,15 @@ void LyXText::incDepth(BufferView * bview) } cursor.par()->params().depth(0); } - + redoParagraphs(bview, selection.start, endpar); - + // we have to reset the selection, because the // geometry could have changed setCursor(bview, selection.start.par(), selection.start.pos()); selection.cursor = cursor; setCursor(bview, selection.end.par(), selection.end.pos()); - updateCounters(bview, cursor.row()); + updateCounters(bview); clearSelection(); setSelection(bview); setCursor(bview, tmpcursor.par(), tmpcursor.pos()); @@ -654,7 +642,7 @@ void LyXText::decDepth(BufferView * bview) } else if (endpar) { endpar = endpar->next(); // because of parindents etc. } - + setUndo(bview, Undo::EDIT, selection.start.par(), undoendpar); @@ -676,14 +664,14 @@ void LyXText::decDepth(BufferView * bview) } redoParagraphs(bview, selection.start, endpar); - + // we have to reset the selection, because the // geometry could have changed setCursor(bview, selection.start.par(), selection.start.pos()); selection.cursor = cursor; setCursor(bview, selection.end.par(), selection.end.pos()); - updateCounters(bview, cursor.row()); + updateCounters(bview); clearSelection(); setSelection(bview); setCursor(bview, tmpcursor.par(), tmpcursor.pos()); @@ -698,7 +686,7 @@ void LyXText::setFont(BufferView * bview, LyXFont const & font, bool toggleall) // Determine basis font LyXFont layoutfont; if (cursor.pos() < beginningOfMainBody(bview->buffer(), - cursor.par())) { + cursor.par())) { layoutfont = getLabelFont(bview->buffer(), cursor.par()); } else { @@ -706,32 +694,37 @@ void LyXText::setFont(BufferView * bview, LyXFont const & font, bool toggleall) cursor.par()); } // Update current font - real_current_font.update(font, toggleall); + real_current_font.update(font, + bview->buffer()->params.language, + toggleall); // Reduce to implicit settings current_font = real_current_font; current_font.reduce(layoutfont); // And resolve it completely +#ifndef INHERIT_LANGUAGE + real_current_font.realize(layoutfont); +#else real_current_font.realize(layoutfont, - bview->buffer()->params.language); + bview->buffer()->params.language); +#endif return; } LyXCursor tmpcursor = cursor; // store the current cursor - + // ok we have a selection. This is always between sel_start_cursor // and sel_end cursor - + setUndo(bview, Undo::EDIT, - selection.start.par(), selection.end.par()->next()); + selection.start.par(), selection.end.par()->next()); freezeUndo(); cursor = selection.start; while (cursor.par() != selection.end.par() || - (cursor.pos() < selection.end.pos())) + cursor.pos() < selection.end.pos()) { if (cursor.pos() < cursor.par()->size()) { - // an open footnote should behave - // like a closed one + // an open footnote should behave like a closed one setCharFont(bview, cursor.par(), cursor.pos(), font, toggleall); cursor.pos(cursor.pos() + 1); @@ -741,18 +734,18 @@ void LyXText::setFont(BufferView * bview, LyXFont const & font, bool toggleall) } } unFreezeUndo(); - + redoParagraphs(bview, selection.start, selection.end.par()->next()); - + // we have to reset the selection, because the - // geometry could have changed + // geometry could have changed, but we keep + // it for user convenience setCursor(bview, selection.start.par(), selection.start.pos()); selection.cursor = cursor; setCursor(bview, selection.end.par(), selection.end.pos()); - clearSelection(); setSelection(bview); setCursor(bview, tmpcursor.par(), tmpcursor.pos(), true, - tmpcursor.boundary()); + tmpcursor.boundary()); } @@ -762,14 +755,14 @@ void LyXText::redoHeightOfParagraph(BufferView * bview, LyXCursor const & cur) int y = cur.y() - tmprow->baseline(); setHeightOfRow(bview, tmprow); - + while (tmprow->previous() && tmprow->previous()->par() == tmprow->par()) { tmprow = tmprow->previous(); y -= tmprow->height(); setHeightOfRow(bview, tmprow); } - + // we can set the refreshing parameters now status(bview, LyXText::NEED_MORE_REFRESH); refresh_y = y; @@ -781,7 +774,7 @@ void LyXText::redoHeightOfParagraph(BufferView * bview, LyXCursor const & cur) void LyXText::redoDrawingOfParagraph(BufferView * bview, LyXCursor const & cur) { Row * tmprow = cur.row(); - + int y = cur.y() - tmprow->baseline(); setHeightOfRow(bview, tmprow); @@ -802,24 +795,25 @@ void LyXText::redoDrawingOfParagraph(BufferView * bview, LyXCursor const & cur) // deletes and inserts again all paragaphs between the cursor -// and the specified par +// and the specified par // This function is needed after SetLayout and SetFont etc. void LyXText::redoParagraphs(BufferView * bview, LyXCursor const & cur, - Paragraph const * endpar) const + Paragraph const * endpar) const { Row * tmprow2; Paragraph * tmppar = 0; Paragraph * first_phys_par = 0; - + Row * tmprow = cur.row(); - + int y = cur.y() - tmprow->baseline(); if (!tmprow->previous()) { // a trick/hack for UNDO - // Can somebody please tell me _why_ this solves - // anything. (Lgb) - first_phys_par = firstParagraph(); + // This is needed because in an UNDO/REDO we could have changed + // the ownerParagrah() so the paragraph inside the row is NOT + // my really first par anymore. Got it Lars ;) (Jug 20011206) + first_phys_par = ownerParagraph(); } else { first_phys_par = tmprow->par(); while (tmprow->previous() @@ -829,32 +823,33 @@ void LyXText::redoParagraphs(BufferView * bview, LyXCursor const & cur, y -= tmprow->height(); } } - + // we can set the refreshing parameters now status(bview, LyXText::NEED_MORE_REFRESH); refresh_y = y; refresh_row = tmprow->previous(); /* the real refresh row will - be deleted, so I store - the previous here */ + be deleted, so I store + the previous here */ // remove it if (tmprow->next()) tmppar = tmprow->next()->par(); else tmppar = 0; - while (tmppar != endpar) { + while (tmprow->next() && tmppar != endpar) { removeRow(tmprow->next()); - if (tmprow->next()) + if (tmprow->next()) { tmppar = tmprow->next()->par(); - else + } else { tmppar = 0; - } - + } + } + // remove the first one tmprow2 = tmprow; /* this is because tmprow->previous() - can be 0 */ + can be 0 */ tmprow = tmprow->previous(); removeRow(tmprow2); - + tmppar = first_phys_par; do { @@ -870,44 +865,44 @@ void LyXText::redoParagraphs(BufferView * bview, LyXCursor const & cur, tmppar = tmppar->next(); } } while (tmppar && tmppar != endpar); - + // this is because of layout changes if (refresh_row) { refresh_y -= refresh_row->height(); - setHeightOfRow(bview, refresh_row); + setHeightOfRow(bview, refresh_row); } else { refresh_row = firstrow; refresh_y = 0; - setHeightOfRow(bview, refresh_row); + setHeightOfRow(bview, refresh_row); } - + if (tmprow && tmprow->next()) setHeightOfRow(bview, tmprow->next()); + updateCounters(bview); } -bool LyXText::fullRebreak(BufferView * bview) +void LyXText::fullRebreak(BufferView * bview) { if (!firstrow) { init(bview); - return true; + return; } if (need_break_row) { breakAgain(bview, need_break_row); need_break_row = 0; - return true; + return; } - return false; } // 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 */ - +// 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(BufferView * bview) { @@ -918,9 +913,9 @@ void LyXText::setSelection(BufferView * bview) selection.start = selection.cursor; selection.end = selection.cursor; } - + selection.set(true); - + // first the toggling area if (cursor.y() < last_sel_cursor.y() || (cursor.y() == last_sel_cursor.y() @@ -931,9 +926,9 @@ void LyXText::setSelection(BufferView * bview) toggle_end_cursor = cursor; toggle_cursor = last_sel_cursor; } - + last_sel_cursor = cursor; - + // and now the whole selection if (selection.cursor.par() == cursor.par()) @@ -941,7 +936,7 @@ void LyXText::setSelection(BufferView * bview) selection.end = cursor; selection.start = selection.cursor; } else { - selection.end = selection.cursor; + selection.end = selection.cursor; selection.start = cursor; } else if (selection.cursor.y() < cursor.y() || @@ -951,12 +946,12 @@ void LyXText::setSelection(BufferView * bview) selection.start = selection.cursor; } else { - selection.end = selection.cursor; + selection.end = selection.cursor; selection.start = cursor; } - + // a selection with no contents is not a selection - if (selection.start.par() == selection.end.par() && + if (selection.start.par() == selection.end.par() && selection.start.pos() == selection.end.pos()) selection.set(false); @@ -965,40 +960,39 @@ void LyXText::setSelection(BufferView * bview) } -string const LyXText::selectionAsString(Buffer const * buffer) const +string const LyXText::selectionAsString(Buffer const * buffer, + bool label) const { if (!selection.set()) return string(); - string result; - - // Special handling if the whole selection is within one paragraph - if (selection.start.par() == selection.end.par()) { - result += selection.start.par()->asString(buffer, - selection.start.pos(), - selection.end.pos()); - return result; + + // should be const ... + Paragraph * startpar(selection.start.par()); + Paragraph * endpar(selection.end.par()); + pos_type const startpos(selection.start.pos()); + pos_type const endpos(selection.end.pos()); + + if (startpar == endpar) { + return startpar->asString(buffer, startpos, endpos, label); } - - // The selection spans more than one paragraph + + string result; // First paragraph in selection - result += selection.start.par()->asString(buffer, - selection.start.pos(), - selection.start.par()->size()) - + "\n\n"; - + result += startpar->asString(buffer, startpos, startpar->size(), label) + "\n\n"; + // The paragraphs in between (if any) LyXCursor tmpcur(selection.start); tmpcur.par(tmpcur.par()->next()); - while (tmpcur.par() != selection.end.par()) { + while (tmpcur.par() != endpar) { result += tmpcur.par()->asString(buffer, 0, - tmpcur.par()->size()) +"\n\n"; + tmpcur.par()->size(), + label) + "\n\n"; tmpcur.par(tmpcur.par()->next()); } // Last paragraph in selection - result += selection.end.par()->asString(buffer, 0, - selection.end.pos()); - + result += endpar->asString(buffer, 0, endpos, label); + return result; } @@ -1007,7 +1001,10 @@ void LyXText::clearSelection() const { selection.set(false); selection.mark(false); - selection.end = selection.start = selection.cursor = cursor; + last_sel_cursor = selection.end = selection.start = selection.cursor = cursor; + // reset this in the bv_owner! + if (bv_owner && bv_owner->text) + bv_owner->text->xsel_cache.set(false); } @@ -1023,7 +1020,7 @@ void LyXText::cursorEnd(BufferView * bview) const || cursor.row()->next()->par() != cursor.row()->par()) { setCursor(bview, cursor.par(), rowLast(cursor.row()) + 1); } else { - if (cursor.par()->size() && + if (!cursor.par()->empty() && (cursor.par()->getChar(rowLast(cursor.row())) == ' ' || cursor.par()->isNewline(rowLast(cursor.row())))) { setCursor(bview, cursor.par(), rowLast(cursor.row())); @@ -1049,10 +1046,10 @@ void LyXText::cursorBottom(BufferView * bview) const cursor.par(cursor.par()->next()); setCursor(bview, cursor.par(), cursor.par()->size()); } - - + + void LyXText::toggleFree(BufferView * bview, - LyXFont const & font, bool toggleall) + LyXFont const & font, bool toggleall) { // If the mask is completely neutral, tell user if (font == LyXFont(LyXFont::ALL_IGNORE)) { @@ -1062,11 +1059,11 @@ void LyXText::toggleFree(BufferView * bview, } // Try implicit word selection - // If there is a change in the language the implicit word selection + // 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) + && font.number() == LyXFont::IGNORE) ? selectWordWhenUnderCursor(bview, WHOLE_WORD_STRICT) : false; // Set font @@ -1085,16 +1082,15 @@ void LyXText::toggleFree(BufferView * bview, } -string -LyXText::getStringToIndex(BufferView * bview) +string LyXText::getStringToIndex(BufferView * bview) { string idxstring; - + // Try implicit word selection - // If there is a change in the language the implicit word selection + // If there is a change in the language the implicit word selection // is disabled. - LyXCursor resetCursor = cursor; - bool implicitSelection = selectWordWhenUnderCursor(bview, PREVIOUS_WORD); + LyXCursor const reset_cursor = cursor; + bool const implicitSelection = selectWordWhenUnderCursor(bview, PREVIOUS_WORD); if (!selection.set()) { bview->owner()->message(_("Nothing to index!")); @@ -1105,45 +1101,45 @@ LyXText::getStringToIndex(BufferView * bview) return string(); } - idxstring = selectionAsString(bview->buffer()); - + idxstring = selectionAsString(bview->buffer(), false); + // Implicit selections are cleared afterwards //and cursor is set to the original position. if (implicitSelection) { clearSelection(); - cursor = resetCursor; + cursor = reset_cursor; setCursor(bview, cursor.par(), cursor.pos()); selection.cursor = cursor; } return idxstring; } -Paragraph::size_type -LyXText::beginningOfMainBody(Buffer const * buf, + +pos_type LyXText::beginningOfMainBody(Buffer const * /*buf*/, Paragraph const * par) const { - if (textclasslist.Style(buf->params.textclass, - par->getLayout()).labeltype != LABEL_MANUAL) + if (par->layout()->labeltype != LABEL_MANUAL) return 0; else return par->beginningOfMainBody(); } -/* 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, -* they do not duplicate themself and you cannnot make dirty things with -* them! */ +// 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, +// they do not duplicate themself and you cannnot make dirty things with +// them! void LyXText::setParagraph(BufferView * bview, bool line_top, bool line_bottom, bool pagebreak_top, bool pagebreak_bottom, VSpace const & space_top, VSpace const & space_bottom, - LyXAlignment align, + Spacing const & spacing, + LyXAlignment align, string labelwidthstring, - bool noindent) + bool noindent) { LyXCursor tmpcursor = cursor; if (!selection.set()) { @@ -1165,11 +1161,12 @@ void LyXText::setParagraph(BufferView * bview, // because of parindents etc. endpar = endpar->next(); } - + setUndo(bview, Undo::EDIT, selection.start.par(), undoendpar); - + Paragraph * tmppar = selection.end.par(); + while (tmppar != selection.start.par()->previous()) { setCursor(bview, tmppar, 0); status(bview, LyXText::NEED_MORE_REFRESH); @@ -1181,17 +1178,14 @@ void LyXText::setParagraph(BufferView * bview, cursor.par()->params().pagebreakBottom(pagebreak_bottom); cursor.par()->params().spaceTop(space_top); cursor.par()->params().spaceBottom(space_bottom); + cursor.par()->params().spacing(spacing); // does the layout allow the new alignment? + LyXLayout_ptr const & layout = cursor.par()->layout(); + if (align == LYX_ALIGN_LAYOUT) - align = textclasslist - .Style(bview->buffer()->params.textclass, - cursor.par()->getLayout()).align; - if (align & textclasslist - .Style(bview->buffer()->params.textclass, - cursor.par()->getLayout()).alignpossible) { - if (align == textclasslist - .Style(bview->buffer()->params.textclass, - cursor.par()->getLayout()).align) + align = layout->align; + if (align & layout->alignpossible) { + if (align == layout->align) cursor.par()->params().align(LYX_ALIGN_LAYOUT); else cursor.par()->params().align(align); @@ -1200,9 +1194,9 @@ void LyXText::setParagraph(BufferView * bview, cursor.par()->params().noindent(noindent); tmppar = cursor.par()->previous(); } - + redoParagraphs(bview, selection.start, endpar); - + clearSelection(); setCursor(bview, selection.start.par(), selection.start.pos()); selection.cursor = cursor; @@ -1214,89 +1208,22 @@ void LyXText::setParagraph(BufferView * bview, } -char loweralphaCounter(int n) -{ - if (n < 1 || n > 26) - return '?'; - else - return 'a' + n - 1; -} - - -namespace { - -inline -char alphaCounter(int n) -{ - if (n < 1 || n > 26) - return '?'; - else - return 'A' + n - 1; -} - - -inline -char hebrewCounter(int n) -{ - static const char hebrew[22] = { - 'à', 'á', 'â', 'ã', 'ä', 'å', 'æ', 'ç', 'è', - 'é', 'ë', 'ì', 'î', 'ð', 'ñ', 'ò', 'ô', 'ö', - '÷', 'ø', 'ù', 'ú' - }; - if (n < 1 || n > 22) - return '?'; - else - return hebrew[n-1]; -} - - -inline -string const romanCounter(int n) -{ - static char const * roman[20] = { - "i", "ii", "iii", "iv", "v", - "vi", "vii", "viii", "ix", "x", - "xi", "xii", "xiii", "xiv", "xv", - "xvi", "xvii", "xviii", "xix", "xx" - }; - if (n < 1 || n > 20) - return "??"; - else - return roman[n-1]; -} - -} // namespace anon - - // set the counter of a paragraph. This includes the labels void LyXText::setCounter(Buffer const * buf, Paragraph * par) const { - LyXLayout const & layout = - textclasslist.Style(buf->params.textclass, - par->getLayout()); - - LyXTextClass const & textclass = - textclasslist.TextClass(buf->params.textclass); + LyXTextClass const & textclass = buf->params.getLyXTextClass(); + LyXLayout_ptr const & layout = par->layout(); - // copy the prev-counters to this one, - // unless this is the first paragraph if (par->previous()) { - for (int i = 0; i < 10; ++i) { - par->setCounter(i, par->previous()->getFirstCounter(i)); - } + par->params().appendix(par->previous()->params().appendix()); if (!par->params().appendix() && par->params().startOfAppendix()) { par->params().appendix(true); - for (int i = 0; i < 10; ++i) { - par->setCounter(i, 0); - } + buf->counters().reset(); } par->enumdepth = par->previous()->enumdepth; par->itemdepth = par->previous()->itemdepth; } else { - for (int i = 0; i < 10; ++i) { - par->setCounter(i, 0); - } par->params().appendix(par->params().startOfAppendix()); par->enumdepth = 0; par->itemdepth = 0; @@ -1311,314 +1238,167 @@ void LyXText::setCounter(Buffer const * buf, Paragraph * par) const */ if (par->previous() && par->previous()->getDepth() < par->getDepth() - && textclasslist.Style(buf->params.textclass, - par->previous()->getLayout() - ).labeltype == LABEL_COUNTER_ENUMI + && par->previous()->layout()->labeltype == LABEL_COUNTER_ENUMI && par->enumdepth < 3 - && layout.labeltype != LABEL_BIBLIO) { + && layout->labeltype != LABEL_BIBLIO) { par->enumdepth++; } // Maybe we have to decrement the enumeration depth, see note above if (par->previous() && par->previous()->getDepth() > par->getDepth() - && layout.labeltype != LABEL_BIBLIO) { + && layout->labeltype != LABEL_BIBLIO) { par->enumdepth = par->depthHook(par->getDepth())->enumdepth; - par->setCounter(6 + par->enumdepth, - par->depthHook(par->getDepth())->getCounter(6 + par->enumdepth)); - /* reset the counters. - * A depth change is like a breaking layout - */ - for (int i = 6 + par->enumdepth + 1; i < 10; ++i) - par->setCounter(i, 0); - } - + } + if (!par->params().labelString().empty()) { par->params().labelString(string()); } - - if (layout.margintype == MARGIN_MANUAL) { + + if (layout->margintype == MARGIN_MANUAL) { if (par->params().labelWidthString().empty()) { - par->setLabelWidthString(layout.labelstring()); + par->setLabelWidthString(layout->labelstring()); } } else { par->setLabelWidthString(string()); } - + // is it a layout that has an automatic label? - if (layout.labeltype >= LABEL_COUNTER_CHAPTER) { - - int i = layout.labeltype - LABEL_COUNTER_CHAPTER; + if (layout->labeltype >= LABEL_COUNTER_CHAPTER) { + + int i = layout->labeltype - LABEL_COUNTER_CHAPTER; + string numbertype, langtype; + ostringstream s; + if (i >= 0 && i<= buf->params.secnumdepth) { - par->incCounter(i); // increment the counter - + + buf->counters().step(buf->counters().sects[i]); + // Is there a label? Useful for Chapter layout if (!par->params().appendix()) { - if (!layout.labelstring().empty()) - par->params().labelString(layout.labelstring()); + if (!layout->labelstring().empty()) + par->params().labelString(layout->labelstring()); else par->params().labelString(string()); - } else { - if (!layout.labelstring_appendix().empty()) - par->params().labelString(layout.labelstring_appendix()); + } else { + if (!layout->labelstring_appendix().empty()) + par->params().labelString(layout->labelstring_appendix()); else par->params().labelString(string()); } - ostringstream s; - + // Use if an integer is here less than elegant. For now. + int head = textclass.maxcounter() - LABEL_COUNTER_CHAPTER; if (!par->params().appendix()) { - switch (2 * LABEL_COUNTER_CHAPTER - - textclass.maxcounter() + i) { - case LABEL_COUNTER_CHAPTER: - s << par->getCounter(i); - break; - case LABEL_COUNTER_SECTION: - s << par->getCounter(i - 1) << '.' - << par->getCounter(i); - break; - case LABEL_COUNTER_SUBSECTION: - s << par->getCounter(i - 2) << '.' - << par->getCounter(i - 1) << '.' - << par->getCounter(i); - break; - case LABEL_COUNTER_SUBSUBSECTION: - s << par->getCounter(i - 3) << '.' - << par->getCounter(i - 2) << '.' - << par->getCounter(i - 1) << '.' - << par->getCounter(i); - - break; - case LABEL_COUNTER_PARAGRAPH: - s << par->getCounter(i - 4) << '.' - << par->getCounter(i - 3) << '.' - << par->getCounter(i - 2) << '.' - << par->getCounter(i - 1) << '.' - << par->getCounter(i); - break; - case LABEL_COUNTER_SUBPARAGRAPH: - s << par->getCounter(i - 5) << '.' - << par->getCounter(i - 4) << '.' - << par->getCounter(i - 3) << '.' - << par->getCounter(i - 2) << '.' - << par->getCounter(i - 1) << '.' - << par->getCounter(i); - - break; - default: - // Can this ever be reached? And in the - // case it is, how can this be correct? - // (Lgb) - s << par->getCounter(i) << '.'; - break; - } - } else { // appendix - switch (2 * LABEL_COUNTER_CHAPTER - textclass.maxcounter() + i) { - case LABEL_COUNTER_CHAPTER: - if (par->isRightToLeftPar(buf->params)) - s << hebrewCounter(par->getCounter(i)); - else - s << alphaCounter(par->getCounter(i)); - break; - case LABEL_COUNTER_SECTION: - if (par->isRightToLeftPar(buf->params)) - s << hebrewCounter(par->getCounter(i - 1)); - else - s << alphaCounter(par->getCounter(i - 1)); - - s << '.' - << par->getCounter(i); - - break; - case LABEL_COUNTER_SUBSECTION: - if (par->isRightToLeftPar(buf->params)) - s << hebrewCounter(par->getCounter(i - 2)); - else - s << alphaCounter(par->getCounter(i - 2)); - - s << '.' - << par->getCounter(i-1) << '.' - << par->getCounter(i); - - break; - case LABEL_COUNTER_SUBSUBSECTION: - if (par->isRightToLeftPar(buf->params)) - s << hebrewCounter(par->getCounter(i-3)); - else - s << alphaCounter(par->getCounter(i-3)); - - s << '.' - << par->getCounter(i-2) << '.' - << par->getCounter(i-1) << '.' - << par->getCounter(i); - - break; - case LABEL_COUNTER_PARAGRAPH: - if (par->isRightToLeftPar(buf->params)) - s << hebrewCounter(par->getCounter(i-4)); - else - s << alphaCounter(par->getCounter(i-4)); - - s << '.' - << par->getCounter(i-3) << '.' - << par->getCounter(i-2) << '.' - << par->getCounter(i-1) << '.' - << par->getCounter(i); - - break; - case LABEL_COUNTER_SUBPARAGRAPH: - if (par->isRightToLeftPar(buf->params)) - s << hebrewCounter(par->getCounter(i-5)); - else - s << alphaCounter(par->getCounter(i-5)); - - s << '.' - << par->getCounter(i-4) << '.' - << par->getCounter(i-3) << '.' - << par->getCounter(i-2) << '.' - << par->getCounter(i-1) << '.' - << par->getCounter(i); - - break; - default: - // Can this ever be reached? And in the - // case it is, how can this be correct? - // (Lgb) - s << par->getCounter(i) << '.'; - - break; - } + numbertype = "sectioning"; + } else { + numbertype = "appendix"; + if (par->isRightToLeftPar(buf->params)) + langtype = "hebrew"; + else + langtype = "latin"; } - par->params().labelString(par->params().labelString() +s.str().c_str()); + s << buf->counters().numberLabel(buf->counters().sects[i], + numbertype, langtype, head); + + par->params().labelString(par->params().labelString() + s.str().c_str()); // We really want to remove the c_str as soon as // possible... - - for (i++; i < 10; ++i) { - // reset the following counters - par->setCounter(i, 0); - } - } else if (layout.labeltype < LABEL_COUNTER_ENUMI) { - for (i++; i < 10; ++i) { - // reset the following counters - par->setCounter(i, 0); - } - } else if (layout.labeltype == LABEL_COUNTER_ENUMI) { - par->incCounter(i + par->enumdepth); - int number = par->getCounter(i + par->enumdepth); - - ostringstream s; - switch (par->enumdepth) { - case 1: - if (par->isRightToLeftPar(buf->params)) - s << '(' - << hebrewCounter(number) - << ')'; - else - s << '(' - << loweralphaCounter(number) - << ')'; - break; - case 2: - if (par->isRightToLeftPar(buf->params)) - s << '.' << romanCounter(number); - else - s << romanCounter(number) << '.'; - break; - case 3: - if (par->isRightToLeftPar(buf->params)) - s << '.' - << alphaCounter(number); - else - s << alphaCounter(number) - << '.'; - break; - default: - if (par->isRightToLeftPar(buf->params)) - s << '.' << number; - else - s << number << '.'; - break; - } + // reset enum counters + buf->counters().reset("enum"); + } else if (layout->labeltype < LABEL_COUNTER_ENUMI) { + buf->counters().reset("enum"); + } else if (layout->labeltype == LABEL_COUNTER_ENUMI) { + buf->counters().step(buf->counters().enums[par->enumdepth]); + s << buf->counters().numberLabel(buf->counters().enums[par->enumdepth], + "enumeration", langtype); par->params().labelString(s.str().c_str()); - for (i += par->enumdepth + 1; i < 10; ++i) { - // reset the following counters - par->setCounter(i, 0); - } - - } - } else if (layout.labeltype == LABEL_BIBLIO) {// ale970302 - int i = LABEL_COUNTER_ENUMI - LABEL_COUNTER_CHAPTER + par->enumdepth; - par->incCounter(i); - int number = par->getCounter(i); + } + } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302 + buf->counters().step("bibitem"); + int number = buf->counters().value("bibitem"); if (!par->bibkey) { - InsetCommandParams p( "bibitem" ); + InsetCommandParams p("bibitem" ); par->bibkey = new InsetBibKey(p); } par->bibkey->setCounter(number); - par->params().labelString(layout.labelstring()); - + par->params().labelString(layout->labelstring()); + // In biblio should't be following counters but... } else { - string s = layout.labelstring(); - + string s = layout->labelstring(); + // the caption hack: - if (layout.labeltype == LABEL_SENSITIVE) { - bool isOK (par->inInset() && par->inInset()->owner() && - (par->inInset()->owner()->lyxCode() == Inset::FLOAT_CODE)); - + if (layout->labeltype == LABEL_SENSITIVE) { + Paragraph * tmppar = par; + Inset * in = 0; + bool isOK = false; + while (tmppar && tmppar->inInset() + // the single '=' is intended below + && (in = tmppar->inInset()->owner())) { + if (in->lyxCode() == Inset::FLOAT_CODE) { + isOK = true; + break; + } else { + tmppar = in->parOwner(); + } + } + if (isOK) { - InsetFloat * tmp = static_cast(par->inInset()->owner()); Floating const & fl - = floatList.getType(tmp->type()); - // We should get the correct number here too. - s = fl.name() + " #:"; + = floatList.getType(static_cast(in)->type()); + + buf->counters().step(fl.name()); + + // Doesn't work... yet. + ostringstream o; + //o << fl.name() << " " << buf->counters().value(fl.name()) << ":"; + o << fl.name() << " #:"; + s = o.str(); } else { - /* par->SetLayout(0); + /* par->SetLayout(0); s = layout->labelstring; */ s = (par->getParLanguage(buf->params)->lang() == "hebrew") ? " :úåòîùî øñç" : "Senseless: "; } } par->params().labelString(s); - + /* reset the enumeration counter. They are always resetted - * when there is any other layout between */ - for (int i = 6 + par->enumdepth; i < 10; ++i) - par->setCounter(i, 0); + * when there is any other layout between */ + for (int i = par->enumdepth + 1; i < 4; i++) { + buf->counters().set(buf->counters().enums[i], 0); + } } } // Updates all counters BEHIND the row. Changed paragraphs // with a dynamic left margin will be rebroken. -void LyXText::updateCounters(BufferView * bview, Row * row) const +void LyXText::updateCounters(BufferView * bview) const { Paragraph * par; + + Row * row = firstrow; + par = row->par(); - if (!row) { - row = firstrow; - par = row->par(); - } else { - par = row->par()->next(); - } - + bview->buffer()->counters().reset(); while (par) { while (row->par() != par) row = row->next(); setCounter(bview->buffer(), par); - + // now check for the headline layouts. remember that they // have a dynamic left margin - if ((textclasslist.Style(bview->buffer()->params.textclass, - par->layout).margintype == MARGIN_DYNAMIC - || textclasslist.Style(bview->buffer()->params.textclass, - par->layout).labeltype == LABEL_SENSITIVE)) { - + LyXLayout_ptr const & layout = par->layout(); + + if (layout->margintype == MARGIN_DYNAMIC + || layout->labeltype == LABEL_SENSITIVE) { // Rebreak the paragraph removeParagraph(row); appendParagraph(bview, row); @@ -1632,28 +1412,27 @@ void LyXText::insertInset(BufferView * bview, Inset * inset) { if (!cursor.par()->insetAllowed(inset->lyxCode())) return; - setUndo(bview, Undo::INSERT, - cursor.par(), cursor.par()->next()); + setUndo(bview, Undo::FINISH, cursor.par(), cursor.par()->next()); + freezeUndo(); cursor.par()->insertInset(cursor.pos(), inset); // Just to rebreak and refresh correctly. // The character will not be inserted a second time insertChar(bview, Paragraph::META_INSET); -#if 1 // 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 // does not return the inset! - if (inset->editable() == Inset::HIGHLY_EDITABLE) { + if (isHighlyEditableInset(inset)) { cursorLeft(bview, true); } -#endif + unFreezeUndo(); } void LyXText::copyEnvironmentType() { - copylayouttype = cursor.par()->getLayout(); + copylayouttype = cursor.par()->layout()->name(); } @@ -1673,19 +1452,19 @@ void LyXText::cutSelection(BufferView * bview, bool doclear, bool realcut) // finished. The solution used currently just works, to make it // faster we need to be more clever and probably also have more // calls to stuffClipboard. (Lgb) - bview->stuffClipboard(selectionAsString(bview->buffer())); + bview->stuffClipboard(selectionAsString(bview->buffer(), true)); // This doesn't make sense, if there is no selection if (!selection.set()) return; - + // OK, we have a selection. This is always between selection.start // and selection.end // make sure that the depth behind the selection are restored, too Paragraph * endpar = selection.end.par()->next(); Paragraph * undoendpar = endpar; - + if (endpar && endpar->getDepth()) { while (endpar && endpar->getDepth()) { endpar = endpar->next(); @@ -1694,10 +1473,10 @@ void LyXText::cutSelection(BufferView * bview, bool doclear, bool realcut) } else if (endpar) { endpar = endpar->next(); // because of parindents etc. } - + setUndo(bview, Undo::DELETE, selection.start.par(), undoendpar); - + // there are two cases: cut only within one paragraph or // more than one paragraph if (selection.start.par() == selection.end.par()) { @@ -1705,17 +1484,17 @@ void LyXText::cutSelection(BufferView * bview, bool doclear, bool realcut) endpar = selection.end.par(); int pos = selection.end.pos(); CutAndPaste::cutSelection(selection.start.par(), &endpar, - selection.start.pos(), pos, - bview->buffer()->params.textclass, doclear, - realcut); + selection.start.pos(), pos, + bview->buffer()->params.textclass, + doclear, realcut); selection.end.pos(pos); } else { endpar = selection.end.par(); int pos = selection.end.pos(); CutAndPaste::cutSelection(selection.start.par(), &endpar, - selection.start.pos(), pos, - bview->buffer()->params.textclass, doclear, - realcut); + selection.start.pos(), pos, + bview->buffer()->params.textclass, + doclear, realcut); cursor.par(endpar); selection.end.par(endpar); selection.end.pos(pos); @@ -1725,7 +1504,7 @@ void LyXText::cutSelection(BufferView * bview, bool doclear, bool realcut) // sometimes necessary if (doclear) - selection.start.par()->stripLeadingSpaces(bview->buffer()->params.textclass); + selection.start.par()->stripLeadingSpaces(); redoParagraphs(bview, selection.start, endpar); @@ -1738,21 +1517,14 @@ void LyXText::cutSelection(BufferView * bview, bool doclear, bool realcut) setCursor(bview, cursor.par(), cursor.pos()); selection.cursor = cursor; - updateCounters(bview, cursor.row()); + updateCounters(bview); } void LyXText::copySelection(BufferView * bview) { - // Stuff what we got on the clipboard. Even if there is no selection. - - // There is a problem with having the stuffing here in that the - // larger the selection the slower LyX will get. This can be - // solved by running the line below only when the selection has - // finished. The solution used currently just works, to make it - // faster we need to be more clever and probably also have more - // calls to stuffClipboard. (Lgb) - bview->stuffClipboard(selectionAsString(bview->buffer())); + // stuff the selection onto the X clipboard, from an explicit copy request + bview->stuffClipboard(selectionAsString(bview->buffer(), true)); // this doesnt make sense, if there is no selection if (!selection.set()) @@ -1766,11 +1538,11 @@ void LyXText::copySelection(BufferView * bview) && selection.start.par()->isLineSeparator(selection.start.pos()) && (selection.start.par() != selection.end.par() || selection.start.pos() < selection.end.pos())) - selection.start.pos(selection.start.pos() + 1); + selection.start.pos(selection.start.pos() + 1); CutAndPaste::copySelection(selection.start.par(), selection.end.par(), - selection.start.pos(), selection.end.pos(), - bview->buffer()->params.textclass); + selection.start.pos(), selection.end.pos(), + bview->buffer()->params.textclass); } @@ -1781,31 +1553,24 @@ void LyXText::pasteSelection(BufferView * bview) return; setUndo(bview, Undo::INSERT, - cursor.par(), cursor.par()->next()); + cursor.par(), cursor.par()->next()); Paragraph * endpar; Paragraph * actpar = cursor.par(); - int pos = cursor.pos(); + CutAndPaste::pasteSelection(&actpar, &endpar, pos, bview->buffer()->params.textclass); - + redoParagraphs(bview, cursor, endpar); - + setCursor(bview, cursor.par(), cursor.pos()); clearSelection(); - + selection.cursor = cursor; setCursor(bview, actpar, pos); setSelection(bview); - updateCounters(bview, cursor.row()); -} - - -// returns a pointer to the very first Paragraph -Paragraph * LyXText::firstParagraph() const -{ - return ownerParagraph(); + updateCounters(bview); } @@ -1814,7 +1579,7 @@ void LyXText::setSelectionOverString(BufferView * bview, string const & str) { if (str.empty()) return; - + selection.cursor = cursor; for (string::size_type i = 0; i < str.length(); ++i) cursorRight(bview); @@ -1835,7 +1600,7 @@ void LyXText::replaceSelectionWithString(BufferView * bview, } // Get font setting before we cut - Paragraph::size_type pos = selection.end.pos(); + pos_type pos = selection.end.pos(); LyXFont const font = selection.start.par() ->getFontSettings(bview->buffer()->params, selection.start.pos()); @@ -1845,7 +1610,7 @@ void LyXText::replaceSelectionWithString(BufferView * bview, selection.end.par()->insertChar(pos, (*cit), font); ++pos; } - + // Cut the selection cutSelection(bview, true, false); @@ -1857,14 +1622,14 @@ void LyXText::replaceSelectionWithString(BufferView * bview, void LyXText::insertStringAsLines(BufferView * bview, string const & str) { Paragraph * par = cursor.par(); - Paragraph::size_type pos = cursor.pos(); + pos_type pos = cursor.pos(); Paragraph * endpar = cursor.par()->next(); - + setCursorParUndo(bview); - + // only to be sure, should not be neccessary clearSelection(); - + bview->buffer()->insertStringAsLines(par, pos, current_font, str); redoParagraphs(bview, cursor, endpar); @@ -1892,7 +1657,7 @@ void LyXText::insertStringAsParagraphs(BufferView * bview, string const & str) } else { linestr[i] = ' '; newline_inserted = true; - } + } } else if (IsPrintable(linestr[i])) { newline_inserted = false; } @@ -1902,7 +1667,7 @@ void LyXText::insertStringAsParagraphs(BufferView * bview, string const & str) bool LyXText::gotoNextInset(BufferView * bview, - std::vector const & codes, + vector const & codes, string const & contents) const { LyXCursor res = cursor; @@ -1914,9 +1679,9 @@ bool LyXText::gotoNextInset(BufferView * bview, res.par(res.par()->next()); res.pos(0); } - - } while (res.par() && - !(res.par()->getChar(res.pos()) == Paragraph::META_INSET + + } while (res.par() && + !(res.par()->isInset(res.pos()) && (inset = res.par()->getInset(res.pos())) != 0 && find(codes.begin(), codes.end(), inset->lyxCode()) != codes.end() @@ -1925,7 +1690,7 @@ bool LyXText::gotoNextInset(BufferView * bview, == contents))); if (res.par()) { - setCursor(bview, res.par(), res.pos()); + setCursor(bview, res.par(), res.pos(), false); return true; } return false; @@ -1933,14 +1698,14 @@ bool LyXText::gotoNextInset(BufferView * bview, void LyXText::checkParagraph(BufferView * bview, Paragraph * par, - Paragraph::size_type pos) + pos_type pos) { - LyXCursor tmpcursor; + LyXCursor tmpcursor; int y = 0; - Paragraph::size_type z; + pos_type z; Row * row = getRow(par, pos, y); - + // is there a break one row above if (row->previous() && row->previous()->par() == row->par()) { z = nextBreakPoint(bview, row->previous(), workWidth(bview)); @@ -1950,9 +1715,9 @@ void LyXText::checkParagraph(BufferView * bview, Paragraph * par, refresh_y = y; refresh_row = row->previous(); status(bview, LyXText::NEED_MORE_REFRESH); - + breakAgain(bview, row->previous()); - + // set the cursor again. Otherwise // dangling pointers are possible setCursor(bview, cursor.par(), cursor.pos(), @@ -1963,49 +1728,47 @@ void LyXText::checkParagraph(BufferView * bview, Paragraph * par, } int const tmpheight = row->height(); - Paragraph::size_type const tmplast = rowLast(row); + pos_type const tmplast = rowLast(row); refresh_y = y; refresh_row = row; - + breakAgain(bview, row); if (row->height() == tmpheight && rowLast(row) == tmplast) status(bview, LyXText::NEED_VERY_LITTLE_REFRESH); else - status(bview, LyXText::NEED_MORE_REFRESH); - + status(bview, LyXText::NEED_MORE_REFRESH); + // check the special right address boxes - if (textclasslist.Style(bview->buffer()->params.textclass, - par->getLayout()).margintype - == MARGIN_RIGHT_ADDRESS_BOX) { + if (par->layout()->margintype == MARGIN_RIGHT_ADDRESS_BOX) { tmpcursor.par(par); tmpcursor.row(row); tmpcursor.y(y); tmpcursor.x(0); tmpcursor.x_fix(0); tmpcursor.pos(pos); - redoDrawingOfParagraph(bview, tmpcursor); + redoDrawingOfParagraph(bview, tmpcursor); } // set the cursor again. Otherwise dangling pointers are possible // also set the selection - + if (selection.set()) { tmpcursor = cursor; setCursorIntern(bview, selection.cursor.par(), selection.cursor.pos(), false, selection.cursor.boundary()); - selection.cursor = cursor; + selection.cursor = cursor; setCursorIntern(bview, selection.start.par(), selection.start.pos(), false, selection.start.boundary()); - selection.start = cursor; + selection.start = cursor; setCursorIntern(bview, selection.end.par(), selection.end.pos(), false, selection.end.boundary()); - selection.end = cursor; + selection.end = cursor; setCursorIntern(bview, last_sel_cursor.par(), last_sel_cursor.pos(), false, last_sel_cursor.boundary()); - last_sel_cursor = cursor; + last_sel_cursor = cursor; cursor = tmpcursor; } setCursorIntern(bview, cursor.par(), cursor.pos(), @@ -2018,40 +1781,43 @@ bool LyXText::updateInset(BufferView * bview, Inset * inset) { // first check the current paragraph int pos = cursor.par()->getPositionOfInset(inset); - if (pos != -1){ + if (pos != -1) { checkParagraph(bview, cursor.par(), pos); return true; } - + // check every paragraph - - Paragraph * par = firstParagraph(); + + Paragraph * par = ownerParagraph(); do { pos = par->getPositionOfInset(inset); - if (pos != -1){ + if (pos != -1) { checkParagraph(bview, par, pos); return true; } par = par->next(); } while (par); - + return false; } -void LyXText::setCursor(BufferView * bview, Paragraph * par, - Paragraph::size_type pos, - bool setfont, bool boundary) const +bool LyXText::setCursor(BufferView * bview, Paragraph * par, + pos_type pos, + bool setfont, bool boundary) const { LyXCursor old_cursor = cursor; setCursorIntern(bview, par, pos, setfont, boundary); - deleteEmptyParagraphMechanism(bview, old_cursor); + return deleteEmptyParagraphMechanism(bview, old_cursor); } -void LyXText::setCursor(BufferView *bview, LyXCursor & cur, Paragraph * par, - Paragraph::size_type pos, bool boundary) const +void LyXText::setCursor(BufferView * bview, LyXCursor & cur, Paragraph * par, + pos_type pos, bool boundary) const { + lyx::Assert(par); + lyx::Assert(bview); + cur.par(par); cur.pos(pos); cur.boundary(boundary); @@ -2059,31 +1825,68 @@ void LyXText::setCursor(BufferView *bview, LyXCursor & cur, Paragraph * par, // get the cursor y position in text int y = 0; Row * row = getRow(par, pos, y); + Row * 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()); + Inset * ins; + if (row->previous() && pos && + row->previous()->par() == row->par() && + par->getChar(pos) == Paragraph::META_INSET && + (ins=par->getInset(pos)) && (ins->needFullRow() || ins->display())) + { + row = row->previous(); + y -= row->height(); + } + + cur.row(row); // y is now the beginning of the cursor row y += row->baseline(); - // y is now the cursor baseline + // y is now the cursor baseline cur.y(y); - + + pos_type last = rowLastPrintable(old_row); + + if (pos > last + 1) { + // This shouldn't happen. + pos = last + 1; + cur.pos(pos); + } else if (pos < row->pos()) { + pos = row->pos(); + cur.pos(pos); + } + // now get the cursors x position + float x = getCursorX(bview, row, pos, last, boundary); + cur.x(int(x)); + cur.x_fix(cur.x()); + if (old_row != row) { + x = getCursorX(bview, old_row, pos, last, boundary); + cur.ix(int(x)); + } else + cur.ix(cur.x()); +} + + +float LyXText::getCursorX(BufferView * bview, Row * row, + pos_type pos, pos_type last, bool boundary) const +{ + pos_type cursor_vpos = 0; float x; float fill_separator; float fill_hfill; float fill_label_hfill; + // This call HAS to be here because of the BidiTables!!! prepareToPrint(bview, row, x, fill_separator, fill_hfill, fill_label_hfill); - Paragraph::size_type cursor_vpos = 0; - Paragraph::size_type last = rowLastPrintable(row); - - if (pos > last + 1) // This shouldn't happen. - pos = last + 1; - else if (pos < row->pos()) - pos = row->pos(); if (last < row->pos()) - cursor_vpos = row->pos(); + cursor_vpos = row->pos(); else if (pos > last && !boundary) cursor_vpos = (row->par()->isRightToLeftPar(bview->buffer()->params)) - ? row->pos() : last + 1; + ? row->pos() : last + 1; else if (pos > row->pos() && (pos > last || boundary)) /// Place cursor after char at (logical) position pos - 1 @@ -2093,32 +1896,31 @@ void LyXText::setCursor(BufferView *bview, LyXCursor & cur, Paragraph * par, /// Place cursor before char at (logical) position pos cursor_vpos = (bidi_level(pos) % 2 == 0) ? log2vis(pos) : log2vis(pos) + 1; - - Paragraph::size_type main_body = + + pos_type main_body = beginningOfMainBody(bview->buffer(), row->par()); if ((main_body > 0) && - ((main_body-1 > last) || + ((main_body-1 > last) || !row->par()->isLineSeparator(main_body-1))) main_body = 0; - - for (Paragraph::size_type vpos = row->pos(); - vpos < cursor_vpos; ++vpos) { - pos = vis2log(vpos); + + for (pos_type vpos = row->pos(); vpos < cursor_vpos; ++vpos) { + pos_type pos = vis2log(vpos); if (main_body > 0 && pos == main_body - 1) { x += fill_label_hfill + - lyxfont::width(textclasslist.Style( - bview->buffer()->params.textclass, - row->par()->getLayout()) - .labelsep, - getLabelFont(bview->buffer(), row->par())); - if (row->par()->isLineSeparator(main_body-1)) - x -= singleWidth(bview, row->par(),main_body-1); + font_metrics::width( + row->par()->layout()->labelsep, + getLabelFont(bview->buffer(), + row->par())); + if (row->par()->isLineSeparator(main_body - 1)) + x -= singleWidth(bview, + row->par(), main_body - 1); } if (hfillExpansion(bview->buffer(), row, pos)) { x += singleWidth(bview, row->par(), pos); if (pos >= main_body) x += fill_hfill; - else + else x += fill_label_hfill; } else if (row->par()->isSeparator(pos)) { x += singleWidth(bview, row->par(), pos); @@ -2127,40 +1929,39 @@ void LyXText::setCursor(BufferView *bview, LyXCursor & cur, Paragraph * par, } else x += singleWidth(bview, row->par(), pos); } - - cur.x(int(x)); - cur.x_fix(cur.x()); - cur.row(row); + return x; } void LyXText::setCursorIntern(BufferView * bview, Paragraph * par, - Paragraph::size_type pos, - bool setfont, bool boundary) const + pos_type pos, bool setfont, bool boundary) const { InsetText * it = static_cast(par->inInset()); if (it) { if (it != inset_owner) { - lyxerr << "InsetText is " << it << endl; - lyxerr << "inset_owner is " << inset_owner << endl; -#warning I belive this code is wrong. (Lgb) + 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! + // I moved the lyxerr stuff in here so we can see if + // this is actually really needed and where! // (Jug) - it->getLyXText(bview)->setCursorIntern(bview, par, pos, setfont, - boundary); + // it->getLyXText(bview)->setCursorIntern(bview, par, pos, setfont, boundary); return; } } - + setCursor(bview, cursor, par, pos, boundary); if (setfont) setCurrentFont(bview); @@ -2169,7 +1970,7 @@ void LyXText::setCursorIntern(BufferView * bview, Paragraph * par, void LyXText::setCurrentFont(BufferView * bview) const { - Paragraph::size_type pos = cursor.pos(); + pos_type pos = cursor.pos(); if (cursor.boundary() && pos > 0) --pos; @@ -2179,7 +1980,7 @@ void LyXText::setCurrentFont(BufferView * bview) const else // potentional bug... BUG (Lgb) if (cursor.par()->isSeparator(pos)) { if (pos > cursor.row()->pos() && - bidi_level(pos) % 2 == + bidi_level(pos) % 2 == bidi_level(pos - 1) % 2) --pos; else if (pos + 1 < cursor.par()->size()) @@ -2214,20 +2015,55 @@ void LyXText::setCursorFromCoordinates(BufferView * bview, int x, int y) const } +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(Row & row, LyXCursor & cur) { + if (!row.next()) + return false; + Row const & next = *row.next(); + + if (next.pos() != cur.pos() || next.par() != cur.par()) + return false; + if (!cur.par()->isInset(cur.pos())) + return false; + Inset const * inset = cur.par()->getInset(cur.pos()); + if (inset->needFullRow() || inset->display()) + return true; + return false; + } +} + + void LyXText::setCursorFromCoordinates(BufferView * bview, LyXCursor & cur, int x, int y) const { // Get the row first. - + Row * row = getRowNearY(y); bool bound = false; - int const column = getColumnNearX(bview, row, x, bound); - + pos_type const column = getColumnNearX(bview, row, x, bound); cur.par(row->par()); cur.pos(row->pos() + column); cur.x(x); cur.y(y + row->baseline()); - cur.row(row); + cur.row(row); + + if (beforeFullRowInset(*row, cur)) { + pos_type last = rowLastPrintable(row); + float x = getCursorX(bview, row->next(), cur.pos(), last, bound); + cur.ix(int(x)); + cur.iy(y + row->height() + row->next()->baseline()); + cur.irow(row->next()); + } else { + cur.iy(cur.y()); + cur.ix(cur.x()); + cur.irow(row); + } cur.boundary(bound); } @@ -2262,18 +2098,51 @@ void LyXText::cursorRight(BufferView * bview, bool internal) const } -void LyXText::cursorUp(BufferView * bview) const +void LyXText::cursorUp(BufferView * bview, bool selecting) const { - setCursorFromCoordinates(bview, cursor.x_fix(), +#if 1 + int x = cursor.x_fix(); + int y = cursor.y() - cursor.row()->baseline() - 1; + setCursorFromCoordinates(bview, x, y); + if (!selecting) { + int y1 = cursor.iy() - first_y; + int y2 = y1; + y -= first_y; + Inset * inset_hit = + bview->checkInsetHit(const_cast(this), x, y1); + if (inset_hit && isHighlyEditableInset(inset_hit)) { + inset_hit->edit(bview, x, y - (y2 - y1), mouse_button::none); + } + } +#else + setCursorFromCoordinates(bview, cursor.x_fix(), cursor.y() - cursor.row()->baseline() - 1); +#endif } -void LyXText::cursorDown(BufferView * bview) const +void LyXText::cursorDown(BufferView * bview, bool selecting) const { - setCursorFromCoordinates(bview, cursor.x_fix(), +#if 1 + int x = cursor.x_fix(); + int y = cursor.y() - cursor.row()->baseline() + + cursor.row()->height() + 1; + setCursorFromCoordinates(bview, x, y); + if (!selecting && cursor.row() == cursor.irow()) { + int y1 = cursor.iy() - first_y; + int y2 = y1; + y -= first_y; + Inset * inset_hit = + bview->checkInsetHit(const_cast(this), x, y1); + if (inset_hit && isHighlyEditableInset(inset_hit)) { + inset_hit->edit(bview, x, y - (y2 - y1), mouse_button::none); + } + } +#else + setCursorFromCoordinates(bview, cursor.x_fix(), cursor.y() - cursor.row()->baseline() + cursor.row()->height() + 1); +#endif } @@ -2297,20 +2166,45 @@ void LyXText::cursorDownParagraph(BufferView * bview) const } } +// fix the cursor `cur' after a characters has been deleted at `where' +// position. Called by deleteEmptyParagraphMechanism +void LyXText::fixCursorAfterDelete(BufferView * bview, + LyXCursor & cur, + LyXCursor const & where) const +{ + // if cursor is not in the paragraph where the delete occured, + // do nothing + if (cur.par() != where.par()) + return; + + // if cursor position is after the place where the delete occured, + // update it + if (cur.pos() > where.pos()) + cur.pos(cur.pos()-1); + + // 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()); + + // recompute row et al. for this cursor + setCursor(bview, cur, cur.par(), cur.pos(), cur.boundary()); +} + -void LyXText::deleteEmptyParagraphMechanism(BufferView * bview, +bool LyXText::deleteEmptyParagraphMechanism(BufferView * bview, LyXCursor const & old_cursor) const { // Would be wrong to delete anything if we have a selection. - if (selection.set()) return; + if (selection.set()) + return false; // We allow all kinds of "mumbo-jumbo" when freespacing. - if (textclasslist.Style(bview->buffer()->params.textclass, - old_cursor.par()->getLayout()).free_spacing) - return; + if (old_cursor.par()->layout()->free_spacing + || old_cursor.par()->isFreeSpacing()) { + return false; + } - bool deleted = false; - /* Ok I'll put some comments here about what is missing. I have fixed BackSpace (and thus Delete) to not delete double-spaces automagically. I have also changed Cut, @@ -2335,157 +2229,149 @@ void LyXText::deleteEmptyParagraphMechanism(BufferView * bview, // MISSING // If the pos around the old_cursor were spaces, delete one of them. - if (old_cursor.par() != cursor.par() || old_cursor.pos() != cursor.pos()) { + if (old_cursor.par() != cursor.par() + || old_cursor.pos() != cursor.pos()) { // Only if the cursor has really moved - + if (old_cursor.pos() > 0 && old_cursor.pos() < old_cursor.par()->size() && old_cursor.par()->isLineSeparator(old_cursor.pos()) && old_cursor.par()->isLineSeparator(old_cursor.pos() - 1)) { old_cursor.par()->erase(old_cursor.pos() - 1); redoParagraphs(bview, old_cursor, old_cursor.par()->next()); - // correct cursor - if (old_cursor.par() == cursor.par() && - cursor.pos() > old_cursor.pos()) { - setCursorIntern(bview, cursor.par(), - cursor.pos() - 1); - } else - setCursorIntern(bview, cursor.par(), - cursor.pos()); - return; + +#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 +// other bufferviews. It will probably be easier to do that in a more +// automated way in LyXCursor code. (JMarc 26/09/2001) +#endif + // correct all cursors held by the LyXText + fixCursorAfterDelete(bview, cursor, old_cursor); + fixCursorAfterDelete(bview, selection.cursor, + old_cursor); + fixCursorAfterDelete(bview, selection.start, + old_cursor); + fixCursorAfterDelete(bview, selection.end, old_cursor); + fixCursorAfterDelete(bview, last_sel_cursor, + old_cursor); + fixCursorAfterDelete(bview, toggle_cursor, old_cursor); + fixCursorAfterDelete(bview, toggle_end_cursor, + old_cursor); + return false; } } + // don't delete anything if this is the ONLY paragraph! + if (!old_cursor.par()->next() && !old_cursor.par()->previous()) + return false; + // Do not delete empty paragraphs with keepempty set. - if ((textclasslist.Style(bview->buffer()->params.textclass, - old_cursor.par()->getLayout())).keepempty) - return; + if (old_cursor.par()->layout()->keepempty) + return false; - LyXCursor tmpcursor; + // only do our magic if we changed paragraph + if (old_cursor.par() == cursor.par()) + return false; - if (old_cursor.par() != cursor.par()) { - if ((old_cursor.par()->size() == 0 - || (old_cursor.par()->size() == 1 - && old_cursor.par()->isLineSeparator(0)))) { - // ok, we will delete anything - - // make sure that you do not delete any environments - status(bview, LyXText::NEED_MORE_REFRESH); - deleted = true; - - if (old_cursor.row()->previous()) { - refresh_row = old_cursor.row()->previous(); - refresh_y = old_cursor.y() - old_cursor.row()->baseline() - refresh_row->height(); - tmpcursor = cursor; - cursor = old_cursor; // that undo can restore the right cursor position - Paragraph * endpar = old_cursor.par()->next(); - if (endpar && endpar->getDepth()) { - while (endpar && endpar->getDepth()) { - endpar = endpar->next(); - } - } - setUndo(bview, Undo::DELETE, - old_cursor.par(), - endpar); - cursor = tmpcursor; - - // delete old row - removeRow(old_cursor.row()); - if (ownerParagraph() == old_cursor.par()) { - ownerParagraph(ownerParagraph()->next()); - } - // delete old par - delete old_cursor.par(); - - /* Breakagain the next par. Needed - * because of the parindent that - * can occur or dissappear. The - * next row can change its height, - * if there is another layout before */ - if (refresh_row->next()) { - breakAgain(bview, refresh_row->next()); - updateCounters(bview, refresh_row); - } - setHeightOfRow(bview, refresh_row); - } else { - refresh_row = old_cursor.row()->next(); - refresh_y = old_cursor.y() - old_cursor.row()->baseline(); - - tmpcursor = cursor; - cursor = old_cursor; // that undo can restore the right cursor position - Paragraph * endpar = old_cursor.par()->next(); - if (endpar && endpar->getDepth()) { - while (endpar && endpar->getDepth()) { - endpar = endpar->next(); - } - } - setUndo(bview, Undo::DELETE, - old_cursor.par(), - endpar); - cursor = tmpcursor; - - // delete old row - removeRow(old_cursor.row()); - // delete old par - if (ownerParagraph() == old_cursor.par()) { - ownerParagraph(ownerParagraph()->next()); + // record if we have deleted a paragraph + // we can't possibly have deleted a paragraph before this point + bool deleted = false; + + if ((old_cursor.par()->empty() + || (old_cursor.par()->size() == 1 + && old_cursor.par()->isLineSeparator(0)))) { + // ok, we will delete anything + LyXCursor tmpcursor; + + // make sure that you do not delete any environments + status(bview, LyXText::NEED_MORE_REFRESH); + deleted = true; + + if (old_cursor.row()->previous()) { + refresh_row = old_cursor.row()->previous(); + refresh_y = old_cursor.y() - old_cursor.row()->baseline() - refresh_row->height(); + tmpcursor = cursor; + cursor = old_cursor; // that undo can restore the right cursor position + Paragraph * endpar = old_cursor.par()->next(); + if (endpar && endpar->getDepth()) { + while (endpar && endpar->getDepth()) { + endpar = endpar->next(); } + } + setUndo(bview, Undo::DELETE, old_cursor.par(), endpar); + cursor = tmpcursor; - delete old_cursor.par(); - - /* Breakagain the next par. Needed - because of the parindent that can - occur or dissappear. - The next row can change its height, - if there is another layout before - */ - if (refresh_row) { - breakAgain(bview, refresh_row); - updateCounters(bview, refresh_row->previous()); + // delete old row + removeRow(old_cursor.row()); + if (ownerParagraph() == old_cursor.par()) { + ownerParagraph(ownerParagraph()->next()); + } + // delete old par + delete old_cursor.par(); + + /* Breakagain the next par. Needed because of + * the parindent that can occur or dissappear. + * The next row can change its height, if + * there is another layout before */ + if (refresh_row->next()) { + breakAgain(bview, refresh_row->next()); + updateCounters(bview); + } + setHeightOfRow(bview, refresh_row); + } else { + refresh_row = old_cursor.row()->next(); + refresh_y = old_cursor.y() - old_cursor.row()->baseline(); + + tmpcursor = cursor; + cursor = old_cursor; // that undo can restore the right cursor position + Paragraph * endpar = old_cursor.par()->next(); + if (endpar && endpar->getDepth()) { + while (endpar && endpar->getDepth()) { + endpar = endpar->next(); } } - - // correct cursor y + setUndo(bview, Undo::DELETE, old_cursor.par(), endpar); + cursor = tmpcursor; + + // delete old row + removeRow(old_cursor.row()); + // delete old par + if (ownerParagraph() == old_cursor.par()) { + ownerParagraph(ownerParagraph()->next()); + } - setCursorIntern(bview, cursor.par(), cursor.pos()); + delete old_cursor.par(); - if (selection.cursor.par() == old_cursor.par() - && selection.cursor.pos() == selection.cursor.pos()) { - // correct selection - selection.cursor = cursor; - } - } - if (!deleted) { - if (old_cursor.par()->stripLeadingSpaces(bview->buffer()->params.textclass)) { - redoParagraphs(bview, old_cursor, old_cursor.par()->next()); - // correct cursor y - setCursorIntern(bview, cursor.par(), cursor.pos()); - selection.cursor = cursor; + /* Breakagain the next par. Needed because of + the parindent that can occur or dissappear. + The next row can change its height, if + there is another layout before */ + if (refresh_row) { + breakAgain(bview, refresh_row); + updateCounters(bview); } } - } -} + // correct cursor y + setCursorIntern(bview, cursor.par(), cursor.pos()); -void LyXText::toggleAppendix(BufferView * bview) -{ - Paragraph * par = cursor.par(); - bool start = !par->params().startOfAppendix(); - - // ensure that we have only one start_of_appendix in this document - Paragraph * tmp = firstParagraph(); - for (; tmp; tmp = tmp->next()) { - tmp->params().startOfAppendix(false); + if (selection.cursor.par() == old_cursor.par() + && selection.cursor.pos() == old_cursor.pos()) { + // correct selection + selection.cursor = cursor; + } } - - par->params().startOfAppendix(start); - - // we can set the refreshing parameters now - status(bview, LyXText::NEED_MORE_REFRESH); - refresh_y = 0; - refresh_row = 0; // not needed for full update - updateCounters(bview, 0); - setCursor(bview, cursor.par(), cursor.pos()); + if (!deleted) { + if (old_cursor.par()->stripLeadingSpaces()) { + redoParagraphs(bview, old_cursor, + old_cursor.par()->next()); + // correct cursor y + setCursorIntern(bview, cursor.par(), cursor.pos()); + selection.cursor = cursor; + } + } + return deleted; } @@ -2494,33 +2380,28 @@ Paragraph * LyXText::ownerParagraph() const if (inset_owner) { return inset_owner->paragraph(); } - return bv_owner->buffer()->paragraph; + return &*(bv_owner->buffer()->paragraphs.begin()); } -Paragraph * LyXText::ownerParagraph(Paragraph * p) const +void LyXText::ownerParagraph(Paragraph * p) const { if (inset_owner) { inset_owner->paragraph(p); } else { - bv_owner->buffer()->paragraph = p; + bv_owner->buffer()->paragraphs.set(p); } - return 0; } -Paragraph * LyXText::ownerParagraph(int id, Paragraph * p) const + +void LyXText::ownerParagraph(int id, Paragraph * p) const { Paragraph * op = bv_owner->buffer()->getParFromID(id); if (op && op->inInset()) { static_cast(op->inInset())->paragraph(p); } else { - if (inset_owner) { - inset_owner->paragraph(p); - } else { - bv_owner->buffer()->paragraph = p; - } + ownerParagraph(p); } - return 0; } @@ -2532,9 +2413,8 @@ LyXText::text_status LyXText::status() const void LyXText::status(BufferView * bview, LyXText::text_status st) const { - // well as much as I know && binds more then || so the above and the - // below are identical (this for your known use of parentesis!) - // Now some explanation: + LyXText * t = bview->text; + // We should only go up with refreshing code so this means that if // we have a MORE refresh we should never set it to LITTLE if we still // didn't handle it (and then it will be UNCHANGED. Now as long as @@ -2545,17 +2425,14 @@ void LyXText::status(BufferView * bview, LyXText::text_status st) const // tell'em that it should redraw the actual row (where the inset // resides! Capito?! - if ((status_ != NEED_MORE_REFRESH) - || (status_ == NEED_MORE_REFRESH - && st != NEED_VERY_LITTLE_REFRESH)) - { + if (status_ != NEED_MORE_REFRESH || st != NEED_VERY_LITTLE_REFRESH) { status_ = st; if (inset_owner && st != UNCHANGED) { - bview->text->status(bview, NEED_VERY_LITTLE_REFRESH); - if (!bview->text->refresh_row) { - bview->text->refresh_row = bview->text->cursor.row(); - bview->text->refresh_y = bview->text->cursor.y() - - bview->text->cursor.row()->baseline(); + t->status(bview, NEED_VERY_LITTLE_REFRESH); + if (!t->refresh_row) { + t->refresh_row = t->cursor.row(); + t->refresh_y = t->cursor.y() - + t->cursor.row()->baseline(); } } }