X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Ftext2.C;h=fc29b3646d6384c05a52d95b661e8164a5a4140a;hb=176b5ef3577e06b95448d28a55dce9858e4273ad;hp=718e9af3a1290eb832c1c626082851c49e67f78c;hpb=6635cee7ce9390401f581a09eb3e301c9cf24c4a;p=lyx.git diff --git a/src/text2.C b/src/text2.C index 718e9af3a1..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,30 +17,29 @@ #include "lyxtext.h" #include "LString.h" #include "paragraph.h" -#include "lyxtextclasslist.h" -#include "LyXView.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" @@ -48,7 +47,6 @@ using std::vector; using std::copy; -using std::find; using std::endl; using std::find; using std::pair; @@ -56,22 +54,21 @@ 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) { @@ -82,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); } @@ -118,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; } @@ -160,97 +151,78 @@ 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, - pos_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); 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 + return f.realize(layout->reslabelfont); } 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 + 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()); - - 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, - pos_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); @@ -265,67 +237,26 @@ void LyXText::setCharFont(BufferView * bv, Paragraph * par, } } - 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 - } - } - -#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, - pos_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()) { @@ -333,25 +264,11 @@ void LyXText::setCharFont(Buffer const * buf, Paragraph * 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); @@ -363,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, - pos_type pos) const + pos_type pos) const { Row * tmprow = new Row; if (!row) { @@ -375,20 +292,19 @@ 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; } @@ -414,9 +330,8 @@ void LyXText::removeRow(Row * row) const } height -= row->height(); // the text becomes smaller - + delete row; - --number_of_rows; // one row less } @@ -425,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(); @@ -433,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); @@ -460,7 +373,7 @@ 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() + } else if (cursor.pos() < cursor.par()->size() && cursor.par()->isInset(cursor.pos())) { inset = cursor.par()->getInset(cursor.pos()); } @@ -478,6 +391,7 @@ void LyXText::toggleInset(BufferView * bview) && inset_owner->owner()->isOpen()) { bview->unlockInset(static_cast(inset_owner->owner())); inset_owner->owner()->close(bview); + bview->getLyXText()->cursorRight(bview); } return; } @@ -503,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 (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); @@ -523,11 +436,11 @@ void LyXText::makeFontEntriesLayoutSpecific(Buffer const * buf, Paragraph * LyXText::setLayout(BufferView * bview, LyXCursor & cur, LyXCursor & sstart_cur, LyXCursor & send_cur, - lyx::layout_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(); @@ -536,44 +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); - + Paragraph * par = sstart_cur.par(); + Paragraph * epar = send_cur.par()->next(); + + LyXLayout_ptr const & lyxlayout = + bview->buffer()->params.getLyXTextClass()[layout]; + do { - cur.par()->setLayout(layout); - makeFontEntriesLayoutSpecific(bview->buffer(), cur.par()); - Paragraph * fppar = cur.par(); - fppar->params().spaceTop(lyxlayout.fill_top ? + 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; } - if (cur.par() != send_cur.par()) - cur.par(cur.par()->next()); - } while (cur.par() != send_cur.par()); + 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, lyx::layout_type layout) +void LyXText::setLayout(BufferView * bview, string const & layout) { LyXCursor tmpcursor = cursor; /* store the current cursor */ @@ -586,14 +500,14 @@ void LyXText::setLayout(BufferView * bview, lyx::layout_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); @@ -623,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); @@ -632,29 +546,16 @@ 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) { - const int depth_diff - = prev->getDepth() - cursor.par()->getDepth(); - // go deeper only if - // (1) the previous para is already - // deeper (depth_diff > 0) - // (2) the previous para is a - // list-environment at the same - // depth as this para. - if (depth_diff > 0 || (depth_diff > -1 - && 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); } } } @@ -662,25 +563,15 @@ void LyXText::incDepth(BufferView * bview) 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()); @@ -708,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); @@ -730,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()); @@ -752,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 { @@ -760,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); @@ -768,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); @@ -801,9 +687,9 @@ 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, but we keep // it for user convenience @@ -812,7 +698,7 @@ void LyXText::setFont(BufferView * bview, LyXFont const & font, bool toggleall) setCursor(bview, selection.end.par(), selection.end.pos()); setSelection(bview); setCursor(bview, tmpcursor.par(), tmpcursor.pos(), true, - tmpcursor.boundary()); + tmpcursor.boundary()); } @@ -822,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; @@ -841,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); @@ -862,17 +748,17 @@ 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()) { @@ -895,8 +781,8 @@ void LyXText::redoParagraphs(BufferView * bview, LyXCursor const & cur, 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(); @@ -910,13 +796,13 @@ void LyXText::redoParagraphs(BufferView * bview, LyXCursor const & cur, 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 { @@ -932,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) { @@ -980,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() @@ -993,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()) @@ -1003,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() || @@ -1013,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); @@ -1028,33 +914,29 @@ void LyXText::setSelection(BufferView * bview) string const LyXText::selectionAsString(Buffer const * buffer, - bool label) const + 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"; @@ -1062,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; } @@ -1074,6 +955,9 @@ void LyXText::clearSelection() const selection.set(false); selection.mark(false); 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); } @@ -1089,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())); @@ -1115,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)) { @@ -1128,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 @@ -1154,12 +1038,12 @@ void LyXText::toggleFree(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!")); @@ -1171,12 +1055,12 @@ string 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; } @@ -1184,22 +1068,21 @@ string LyXText::getStringToIndex(BufferView * bview) } -pos_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, @@ -1207,9 +1090,9 @@ void LyXText::setParagraph(BufferView * bview, VSpace const & space_top, VSpace const & space_bottom, Spacing const & spacing, - LyXAlignment align, + LyXAlignment align, string labelwidthstring, - bool noindent) + bool noindent) { LyXCursor tmpcursor = cursor; if (!selection.set()) { @@ -1231,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); @@ -1247,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); @@ -1267,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; @@ -1281,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; @@ -1378,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(); } } @@ -1699,13 +1397,12 @@ void LyXText::insertInset(BufferView * bview, Inset * inset) { if (!cursor.par()->insetAllowed(inset->lyxCode())) return; - // I don't know if this is necessary here (Jug 20020102) - 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 @@ -1714,13 +1411,13 @@ void LyXText::insertInset(BufferView * bview, Inset * inset) if (isHighlyEditableInset(inset)) { cursorLeft(bview, true); } -#endif + unFreezeUndo(); } void LyXText::copyEnvironmentType() { - copylayouttype = cursor.par()->getLayout(); + copylayouttype = cursor.par()->layout()->name(); } @@ -1745,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(); @@ -1761,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()) { @@ -1772,16 +1469,16 @@ 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, + 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, + selection.start.pos(), pos, + bview->buffer()->params.textclass, doclear, realcut); cursor.par(endpar); selection.end.par(endpar); @@ -1792,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); @@ -1805,7 +1502,7 @@ void LyXText::cutSelection(BufferView * bview, bool doclear, bool realcut) setCursor(bview, cursor.par(), cursor.pos()); selection.cursor = cursor; - updateCounters(bview, cursor.row()); + updateCounters(bview); } @@ -1826,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); } @@ -1841,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(); @@ -1849,14 +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(); - + + selection.cursor = cursor; setCursor(bview, actpar, pos); - updateCounters(bview, cursor.row()); + setSelection(bview); + updateCounters(bview); } @@ -1865,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); @@ -1896,7 +1595,7 @@ void LyXText::replaceSelectionWithString(BufferView * bview, selection.end.par()->insertChar(pos, (*cit), font); ++pos; } - + // Cut the selection cutSelection(bview, true, false); @@ -1910,12 +1609,12 @@ void LyXText::insertStringAsLines(BufferView * bview, string const & str) Paragraph * par = cursor.par(); 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); @@ -1943,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; } @@ -1952,46 +1651,15 @@ void LyXText::insertStringAsParagraphs(BufferView * bview, string const & str) } -bool LyXText::gotoNextInset(BufferView * bview, - 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()->isInset(res.pos()) - && (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(), false); - return true; - } - return false; -} - - void LyXText::checkParagraph(BufferView * bview, Paragraph * par, - pos_type pos) + pos_type pos) { - LyXCursor tmpcursor; + LyXCursor tmpcursor; int y = 0; 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)); @@ -2001,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(), @@ -2017,47 +1685,44 @@ void LyXText::checkParagraph(BufferView * bview, Paragraph * par, 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(), @@ -2074,9 +1739,9 @@ bool LyXText::updateInset(BufferView * bview, Inset * inset) checkParagraph(bview, cursor.par(), pos); return true; } - + // check every paragraph - + Paragraph * par = ownerParagraph(); do { pos = par->getPositionOfInset(inset); @@ -2086,14 +1751,14 @@ bool LyXText::updateInset(BufferView * bview, Inset * inset) } par = par->next(); } while (par); - + return false; } bool LyXText::setCursor(BufferView * bview, Paragraph * par, - pos_type pos, - bool setfont, bool boundary) const + pos_type pos, + bool setfont, bool boundary) const { LyXCursor old_cursor = cursor; setCursorIntern(bview, par, pos, setfont, boundary); @@ -2106,7 +1771,7 @@ void LyXText::setCursor(BufferView * bview, LyXCursor & cur, Paragraph * par, { lyx::Assert(par); lyx::Assert(bview); - + cur.par(par); cur.pos(pos); cur.boundary(boundary); @@ -2114,20 +1779,29 @@ 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); - // now get the cursors x position - float x; - float fill_separator; - float fill_hfill; - float fill_label_hfill; - prepareToPrint(bview, row, x, fill_separator, fill_hfill, - fill_label_hfill); - pos_type cursor_vpos = 0; - pos_type last = rowLastPrintable(row); + pos_type last = rowLastPrintable(old_row); if (pos > last + 1) { // This shouldn't happen. @@ -2137,12 +1811,36 @@ void LyXText::setCursor(BufferView * bview, LyXCursor & cur, Paragraph * par, 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); + 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 @@ -2152,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; - + 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 (pos_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); @@ -2186,21 +1883,20 @@ 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, - pos_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) @@ -2219,7 +1915,7 @@ void LyXText::setCursorIntern(BufferView * bview, Paragraph * par, return; } } - + setCursor(bview, cursor, par, pos, boundary); if (setfont) setCurrentFont(bview); @@ -2238,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()) @@ -2273,11 +1969,35 @@ 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; pos_type const column = getColumnNearX(bview, row, x, bound); @@ -2285,7 +2005,19 @@ void LyXText::setCursorFromCoordinates(BufferView * bview, LyXCursor & cur, 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); } @@ -2320,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 } @@ -2371,6 +2134,11 @@ 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()); } @@ -2380,16 +2148,15 @@ 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 false; + 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 - || old_cursor.par()->isFreeSpacing()) - { + if (old_cursor.par()->layout()->free_spacing + || old_cursor.par()->isFreeSpacing()) { return false; } - + /* Ok I'll put some comments here about what is missing. I have fixed BackSpace (and thus Delete) to not delete double-spaces automagically. I have also changed Cut, @@ -2415,9 +2182,9 @@ bool LyXText::deleteEmptyParagraphMechanism(BufferView * bview, // If the pos around the old_cursor were spaces, delete one of them. if (old_cursor.par() != cursor.par() - || old_cursor.pos() != cursor.pos()) { + || 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()) @@ -2450,30 +2217,29 @@ bool LyXText::deleteEmptyParagraphMechanism(BufferView * bview, // 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) + if (old_cursor.par()->layout()->keepempty) return false; // only do our magic if we changed paragraph - if (old_cursor.par() == cursor.par()) + if (old_cursor.par() == cursor.par()) return false; - + // 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()->size() == 0 + 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(); @@ -2495,20 +2261,20 @@ bool LyXText::deleteEmptyParagraphMechanism(BufferView * bview, } // 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); + 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(); @@ -2528,17 +2294,17 @@ bool LyXText::deleteEmptyParagraphMechanism(BufferView * bview, } 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()); + updateCounters(bview); } } - + // correct cursor y setCursorIntern(bview, cursor.par(), cursor.pos()); @@ -2549,7 +2315,7 @@ bool LyXText::deleteEmptyParagraphMechanism(BufferView * bview, } } if (!deleted) { - if (old_cursor.par()->stripLeadingSpaces(bview->buffer()->params.textclass)) { + if (old_cursor.par()->stripLeadingSpaces()) { redoParagraphs(bview, old_cursor, old_cursor.par()->next()); // correct cursor y @@ -2561,34 +2327,12 @@ bool LyXText::deleteEmptyParagraphMechanism(BufferView * bview, } -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 = ownerParagraph(); - for (; tmp; tmp = tmp->next()) { - tmp->params().startOfAppendix(false); - } - - 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()); -} - - Paragraph * LyXText::ownerParagraph() const { if (inset_owner) { return inset_owner->paragraph(); } - return bv_owner->buffer()->paragraph; + return &*(bv_owner->buffer()->paragraphs.begin()); } @@ -2597,7 +2341,7 @@ 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); } } @@ -2621,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 @@ -2634,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(); } } }