X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Ftext2.C;h=fc29b3646d6384c05a52d95b661e8164a5a4140a;hb=176b5ef3577e06b95448d28a55dce9858e4273ad;hp=fbd32326a578115d994e8e4daad142f0d76fb4ec;hpb=7cf094f99eea8341d421bc3b3f9baa023cc48b97;p=lyx.git diff --git a/src/text2.C b/src/text2.C index fbd32326a5..fc29b3646d 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,58 @@ #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 "insets/insetwrap.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), + : 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), + : 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,21 +79,28 @@ 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(); + first_y = refresh_y = 0; status_ = LyXText::UNCHANGED; } else if (firstrow) return; Paragraph * par = ownerParagraph(); current_font = getFont(bview->buffer(), par, 0); + while (par) { insertParagraph(bview, par, lastrow); par = par->next(); } setCursorIntern(bview, firstrow->par(), 0); selection.cursor = cursor; + + updateCounters(bview); } @@ -113,33 +122,20 @@ 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) { -#ifndef INHERIT_LANGUAGE - tmpfont.realize(textclasslist. - Style(buf->params.textclass, - par->getLayout()).font); -#else - tmpfont.realize(textclasslist. - Style(buf->params.textclass, - par->getLayout()).font, - buf->params.language); -#endif + tmpfont.realize(par->layout()->font); par_depth = par->getDepth(); } } -#ifndef INHERIT_LANGUAGE - tmpfont.realize(textclasslist.TextClass(buf->params.textclass).defaultfont()); -#else - tmpfont.realize(textclasslist.TextClass(buf->params.textclass).defaultfont(), - buf->params.language); -#endif + tmpfont.realize(tclass.defaultfont()); return tmpfont; } @@ -155,195 +151,124 @@ 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); -#ifndef INHERIT_LANGUAGE - return f.realize(layout.reslabelfont); -#else - return f.realize(layout.reslabelfont, buf->params.language); -#endif + // 1% goes here + LyXFont f = par->getFontSettings(buf->params, pos); + if (par->inInset()) + par->inInset()->getDrawFont(f); + return f.realize(layout->reslabelfont); } else { LyXFont f = par->getFontSettings(buf->params, pos); -#ifndef INHERIT_LANGUAGE - return f.realize(layout.resfont); -#else - return f.realize(layout.resfont, buf->params.language); -#endif + if (par->inInset()) + par->inInset()->getDrawFont(f); + return f.realize(layout->resfont); } } - + // 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()); + LyXLayout_ptr const & layout = par->layout(); - Paragraph::depth_type par_depth = par->getDepth(); - - 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, 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) -#ifndef INHERIT_LANGUAGE - layoutfont.realize(textclasslist. - Style(buf->params.textclass, - tp->getLayout()).font); -#else - layoutfont.realize(textclasslist. - Style(buf->params.textclass, - tp->getLayout()).font, - buf->params.language); -#endif + if (isEditableInset(inset)) { + UpdatableInset * uinset = + static_cast(inset); + uinset->setFont(bv, fnt, toggleall, true); } } -#ifndef INHERIT_LANGUAGE - layoutfont.realize(textclasslist.TextClass(buf->params.textclass).defaultfont()); -#else - layoutfont.realize(textclasslist.TextClass(buf->params.textclass).defaultfont(), - buf->params.language); -#endif - - // 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) -#ifndef INHERIT_LANGUAGE - layoutfont.realize(textclasslist. - Style(buf->params.textclass, - tp->getLayout()).font); -#else - layoutfont.realize(textclasslist. - Style(buf->params.textclass, - tp->getLayout()).font, - buf->params.language); -#endif + layoutfont.realize(tp->layout()->font); } } -#ifndef INHERIT_LANGUAGE - layoutfont.realize(textclasslist.TextClass(buf->params.textclass).defaultfont()); -#else - layoutfont.realize(textclasslist.TextClass(buf->params.textclass).defaultfont(), - buf->params.language); -#endif + layoutfont.realize(tclass.defaultfont()); // Now, reduce font against full layout font font.reduce(layoutfont); @@ -355,7 +280,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) { @@ -367,46 +292,46 @@ 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); if (row == lastrow) lastrow = tmprow; - ++number_of_rows; } // 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 } @@ -415,7 +340,7 @@ void LyXText::removeParagraph(Row * row) const { Paragraph * tmppar = row->par(); row = row->next(); - + Row * tmprow; while (row && row->par() == tmppar) { tmprow = row->next(); @@ -423,17 +348,15 @@ 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 */ + // insert a new row, starting at position 0 + insertRow(row, par, 0); - setCounter(bview->buffer(), par); // set the counters - // and now append the whole paragraph behind the new row if (!row) { firstrow->height(0); @@ -450,8 +373,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; @@ -461,12 +384,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()) { @@ -485,16 +417,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); @@ -505,11 +436,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(); @@ -518,56 +449,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 */ @@ -580,14 +500,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); @@ -617,7 +537,7 @@ void LyXText::incDepth(BufferView * bview) } else if (endpar) { endpar = endpar->next(); // because of parindents etc. } - + setUndo(bview, Undo::EDIT, selection.start.par(), undoendpar); @@ -626,49 +546,32 @@ 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); + } } } 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; - while (cursor.par() != selection.end.par()) { - cursor.par()->params().depth(0); - cursor.par(cursor.par()->next()); - } - 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()); @@ -696,7 +599,7 @@ void LyXText::decDepth(BufferView * bview) } else if (endpar) { endpar = endpar->next(); // because of parindents etc. } - + setUndo(bview, Undo::EDIT, selection.start.par(), undoendpar); @@ -718,14 +621,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()); @@ -740,7 +643,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 { @@ -748,7 +651,7 @@ void LyXText::setFont(BufferView * bview, LyXFont const & font, bool toggleall) cursor.par()); } // Update current font - real_current_font.update(font, + real_current_font.update(font, bview->buffer()->params.language, toggleall); @@ -756,30 +659,25 @@ void LyXText::setFont(BufferView * bview, LyXFont const & font, bool toggleall) 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); -#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); @@ -789,18 +687,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()); } @@ -810,14 +708,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; @@ -829,7 +727,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); @@ -850,24 +748,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() @@ -877,32 +776,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 { @@ -918,44 +818,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) { @@ -966,9 +866,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() @@ -979,9 +879,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()) @@ -989,7 +889,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() || @@ -999,12 +899,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); @@ -1017,30 +917,26 @@ 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(), - label); - 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(), - label) - + "\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(), label) + "\n\n"; @@ -1048,9 +944,8 @@ string const LyXText::selectionAsString(Buffer const * buffer, } // Last paragraph in selection - result += selection.end.par()->asString(buffer, 0, - selection.end.pos(), label); - + result += endpar->asString(buffer, 0, endpos, label); + return result; } @@ -1059,7 +954,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); } @@ -1075,7 +973,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())); @@ -1101,10 +999,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)) { @@ -1114,11 +1012,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 @@ -1137,16 +1035,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!")); @@ -1158,45 +1055,44 @@ LyXText::getStringToIndex(BufferView * bview) } 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, - Spacing const & spacing, - LyXAlignment align, + Spacing const & spacing, + LyXAlignment align, string labelwidthstring, - bool noindent) + bool noindent) { LyXCursor tmpcursor = cursor; if (!selection.set()) { @@ -1218,11 +1114,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); @@ -1234,18 +1131,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); + 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); @@ -1254,9 +1147,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; @@ -1268,89 +1161,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); - } + textclass.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; @@ -1365,318 +1191,203 @@ 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 (i >= 0 && i<= buf->params.secnumdepth) { - par->incCounter(i); // increment the counter - + if (layout->labeltype >= LABEL_COUNTER_CHAPTER) { + + int i = layout->labeltype - LABEL_COUNTER_CHAPTER; + string numbertype; + string langtype; + ostringstream s; + + if (i >= 0 && i <= buf->params.secnumdepth) { + + textclass.counters().step(layout->latexname()); + // 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()); - // 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); + s << textclass.counters() + .numberLabel(layout->latexname(), + numbertype, langtype, head); - ostringstream s; + par->params().labelString(par->params().labelString() + + STRCONV(s.str())); + + // reset enum counters + textclass.counters().reset("enum"); + } else if (layout->labeltype < LABEL_COUNTER_ENUMI) { + textclass.counters().reset("enum"); + } else if (layout->labeltype == LABEL_COUNTER_ENUMI) { + // FIXME + // Yes I know this is a really, really! bad solution + // (Lgb) + string enumcounter("enum"); switch (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) << '.'; + enumcounter += 'i'; + case 1: + enumcounter += 'i'; + case 0: + enumcounter += 'i'; break; case 3: - if (par->isRightToLeftPar(buf->params)) - s << '.' - << alphaCounter(number); - else - s << alphaCounter(number) - << '.'; + enumcounter += "iv"; break; default: - if (par->isRightToLeftPar(buf->params)) - s << '.' << number; - else - s << number << '.'; + // not a valid enumdepth... break; } - par->params().labelString(s.str().c_str()); + textclass.counters().step(enumcounter); - 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); + s << textclass.counters() + .numberLabel(enumcounter, + "enumeration", langtype); + par->params().labelString(STRCONV(s.str())); + } + } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302 + textclass.counters().step("bibitem"); + int number = textclass.counters().value("bibitem"); if (!par->bibkey) { - InsetCommandParams p( "bibitem" ); + 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 || + in->lyxCode() == Inset::WRAP_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() + " #:"; + = textclass.floats().getType(static_cast(in)->type()); + + textclass.counters().step(fl.type()); + + // Doesn't work... yet. + ostringstream o; + //o << fl.name() << " " << buf->counters().value(fl.name()) << ":"; + o << fl.name() << " #:"; + s = STRCONV(o.str()); } else { - /* par->SetLayout(0); - s = layout->labelstring; */ + // 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); + + // reset the enumeration counter. They are always reset + // when there is any other layout between + // Just fall-through between the cases so that all + // enum counters deeper than enumdepth is also reset. + switch (par->enumdepth) { + case 0: + textclass.counters().reset("enumi"); + case 1: + textclass.counters().reset("enumii"); + case 2: + textclass.counters().reset("enumiii"); + case 3: + textclass.counters().reset("enumiv"); + } } } -// Updates all counters BEHIND the row. Changed paragraphs -// with a dynamic left margin will be rebroken. -void LyXText::updateCounters(BufferView * bview, Row * row) const +// Updates all counters. Paragraphs with changed label string will be rebroken +void LyXText::updateCounters(BufferView * bview) const { Paragraph * par; - if (!row) { - row = firstrow; - par = row->par(); - } else { - par = row->par()->next(); - } + Row * row = firstrow; + par = row->par(); + + // CHECK if this is really needed. (Lgb) + bview->buffer()->params.getLyXTextClass().counters().reset(); while (par) { while (row->par() != par) row = row->next(); - + + string const oldLabel = par->params().labelString(); + 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)) { - - // Rebreak the paragraph + + string const & newLabel = par->params().labelString(); + + if (oldLabel.empty() && !newLabel.empty()) { removeParagraph(row); appendParagraph(bview, row); } + par = par->next(); } } @@ -1686,28 +1397,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(); } @@ -1732,14 +1442,14 @@ void LyXText::cutSelection(BufferView * bview, bool doclear, bool realcut) // 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(); @@ -1748,10 +1458,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()) { @@ -1759,17 +1469,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); @@ -1779,7 +1489,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); @@ -1792,20 +1502,13 @@ 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) + // 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 @@ -1820,11 +1523,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); } @@ -1835,7 +1538,7 @@ 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(); @@ -1843,21 +1546,16 @@ void LyXText::pasteSelection(BufferView * bview) CutAndPaste::pasteSelection(&actpar, &endpar, pos, bview->buffer()->params.textclass); - + redoParagraphs(bview, cursor, endpar); - + setCursor(bview, cursor.par(), cursor.pos()); clearSelection(); - - setCursor(bview, actpar, pos); - updateCounters(bview, cursor.row()); -} - -// returns a pointer to the very first Paragraph -Paragraph * LyXText::firstParagraph() const -{ - return ownerParagraph(); + selection.cursor = cursor; + setCursor(bview, actpar, pos); + setSelection(bview); + updateCounters(bview); } @@ -1866,7 +1564,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); @@ -1887,7 +1585,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()); @@ -1897,7 +1595,7 @@ void LyXText::replaceSelectionWithString(BufferView * bview, selection.end.par()->insertChar(pos, (*cit), font); ++pos; } - + // Cut the selection cutSelection(bview, true, false); @@ -1909,14 +1607,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); @@ -1944,7 +1642,7 @@ void LyXText::insertStringAsParagraphs(BufferView * bview, string const & str) } else { linestr[i] = ' '; newline_inserted = true; - } + } } else if (IsPrintable(linestr[i])) { newline_inserted = false; } @@ -1953,46 +1651,15 @@ void LyXText::insertStringAsParagraphs(BufferView * bview, string const & str) } -bool LyXText::gotoNextInset(BufferView * bview, - std::vector const & codes, - string const & contents) const -{ - LyXCursor res = cursor; - Inset * inset; - do { - if (res.pos() < res.par()->size() - 1) { - res.pos(res.pos() + 1); - } else { - res.par(res.par()->next()); - res.pos(0); - } - - } while (res.par() && - !(res.par()->getChar(res.pos()) == Paragraph::META_INSET - && (inset = res.par()->getInset(res.pos())) != 0 - && find(codes.begin(), codes.end(), inset->lyxCode()) - != codes.end() - && (contents.empty() || - static_cast(res.par()->getInset(res.pos()))->getContents() - == contents))); - - if (res.par()) { - setCursor(bview, res.par(), res.pos()); - return true; - } - return false; -} - - 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)); @@ -2002,9 +1669,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(), @@ -2015,49 +1682,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(), @@ -2070,40 +1735,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); @@ -2111,31 +1779,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 @@ -2145,32 +1850,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); @@ -2179,26 +1883,26 @@ 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; + 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) @@ -2207,12 +1911,11 @@ void LyXText::setCursorIntern(BufferView * bview, Paragraph * par, // 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); @@ -2221,7 +1924,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; @@ -2231,7 +1934,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()) @@ -2266,20 +1969,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); } @@ -2314,18 +2052,49 @@ 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 = checkInsetHit(bview, 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 = checkInsetHit(bview, 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 } @@ -2365,24 +2134,29 @@ void LyXText::fixCursorAfterDelete(BufferView * bview, 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, @@ -2407,9 +2181,10 @@ 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()) @@ -2435,140 +2210,120 @@ void LyXText::deleteEmptyParagraphMechanism(BufferView * bview, fixCursorAfterDelete(bview, toggle_cursor, old_cursor); fixCursorAfterDelete(bview, toggle_end_cursor, old_cursor); - return; + 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; + /* 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); } } - 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; - } - } - } -} - -void LyXText::toggleAppendix(BufferView * bview) -{ - Paragraph * par = cursor.par(); - bool start = !par->params().startOfAppendix(); + // correct cursor y + setCursorIntern(bview, cursor.par(), cursor.pos()); - // 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; } @@ -2577,33 +2332,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; } @@ -2615,9 +2365,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 @@ -2628,17 +2377,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(); } } }