X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftext2.C;h=938d9fd3a201fea559db7fc53fa9f8fff6538588;hb=757e2c55d8c15db0db5b4127bb3f6f22e4d7d81b;hp=7121831aac3fa2fbdb540f56ca7021ff84df21eb;hpb=7521b5d20f42102cf444e3fd8718a088a60d0098;p=lyx.git diff --git a/src/text2.C b/src/text2.C index 7121831aac..938d9fd3a2 100644 --- a/src/text2.C +++ b/src/text2.C @@ -25,6 +25,7 @@ #include "layout.h" #include "LyXView.h" #include "support/textutils.h" +#include "support/lstrings.h" #include "undo_funcs.h" #include "buffer.h" #include "bufferparams.h" @@ -51,21 +52,35 @@ using std::pair; LyXText::LyXText(BufferView * bv) : number_of_rows(0), height(0), width(0), first(0), bv_owner(bv), inset_owner(0), the_locking_inset(0), - need_break_row(0), refresh_y(0), status_(LyXText::UNCHANGED), - firstrow(0), lastrow(0), copylayouttype(0) + need_break_row(0), refresh_y(0), refresh_row(0), + status_(LyXText::UNCHANGED), firstrow(0), lastrow(0), + copylayouttype(0) {} LyXText::LyXText(InsetText * inset) : number_of_rows(0), height(0), width(0), first(0), bv_owner(0), inset_owner(inset), the_locking_inset(0), - need_break_row(0), refresh_y(0), status_(LyXText::UNCHANGED), - firstrow(0), lastrow(0), copylayouttype(0) + need_break_row(0), refresh_y(0), refresh_row(0), + status_(LyXText::UNCHANGED), firstrow(0), lastrow(0), + copylayouttype(0) {} -void LyXText::init(BufferView * bview) +void LyXText::init(BufferView * bview, bool reinit) { - if (firstrow) + if (reinit) { + // Delete all rows, this does not touch the paragraphs! + Row * tmprow = firstrow; + while (firstrow) { + tmprow = firstrow->next(); + delete firstrow; + firstrow = tmprow; + } + lastrow = refresh_row = need_break_row = 0; + width = height = copylayouttype = 0; + number_of_rows = first = refresh_y = 0; + status_ = LyXText::UNCHANGED; + } else if (firstrow) return; Paragraph * par = ownerParagraph(); @@ -99,7 +114,7 @@ LyXText::~LyXText() // 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 + Paragraph::size_type pos) const { LyXLayout const & layout = textclasslist.Style(buf->params.textclass, par->getLayout()); @@ -114,10 +129,10 @@ LyXFont const LyXText::getFont(Buffer const * buf, Paragraph * par, // 1% goes here LyXFont f = par->getFontSettings(buf->params, pos); - return f.realize(layout.reslabelfont); + return f.realize(layout.reslabelfont, buf->params.language); } else { LyXFont f = par->getFontSettings(buf->params, pos); - return f.realize(layout.resfont); + return f.realize(layout.resfont, buf->params.language); } } else { @@ -144,7 +159,7 @@ LyXFont const LyXText::getFont(Buffer const * buf, Paragraph * par, layoutfont = layout.font; } tmpfont = par->getFontSettings(buf->params, pos); - tmpfont.realize(layoutfont); + tmpfont.realize(layoutfont, buf->params.language); } else { // 5% goes here. // process layoutfont for pos == -1 and labelfont for pos < -1 @@ -160,12 +175,14 @@ LyXFont const LyXText::getFont(Buffer const * buf, Paragraph * par, if (par) { tmpfont.realize(textclasslist. Style(buf->params.textclass, - par->getLayout()).font); + par->getLayout()).font, + buf->params.language); par_depth = par->getDepth(); } } - tmpfont.realize(textclasslist.TextClass(buf->params.textclass).defaultfont()); + tmpfont.realize(textclasslist.TextClass(buf->params.textclass).defaultfont(), + buf->params.language); return tmpfont; } @@ -177,13 +194,14 @@ void LyXText::setCharFont(BufferView * bv, Paragraph * par, { Buffer const * buf = bv->buffer(); LyXFont font = getFont(buf, par, pos); - font.update(fnt, buf->params.language, toggleall); + font.update(fnt, toggleall); // Let the insets convert their font if (par->getChar(pos) == Paragraph::META_INSET) { Inset * inset = par->getInset(pos); if (inset) { - if (inset->editable()==Inset::HIGHLY_EDITABLE) { - UpdatableInset * uinset = static_cast(inset); + if (inset->editable()==Inset::IS_EDITABLE) { + UpdatableInset * uinset = + static_cast(inset); uinset->setFont(bv, fnt, toggleall, true); } font = inset->convertFont(font); @@ -209,12 +227,14 @@ void LyXText::setCharFont(BufferView * bv, Paragraph * par, tp = tp->outerHook(); if (tp) layoutfont.realize(textclasslist. - Style(buf->params.textclass, - tp->getLayout()).font); + Style(buf->params.textclass, + tp->getLayout()).font, + buf->params.language); } } - layoutfont.realize(textclasslist.TextClass(buf->params.textclass).defaultfont()); + layoutfont.realize(textclasslist.TextClass(buf->params.textclass).defaultfont(), + buf->params.language); // Now, reduce font against full layout font font.reduce(layoutfont); @@ -251,12 +271,14 @@ void LyXText::setCharFont(Buffer const * buf, Paragraph * par, tp = tp->outerHook(); if (tp) layoutfont.realize(textclasslist. - Style(buf->params.textclass, - tp->getLayout()).font); + Style(buf->params.textclass, + tp->getLayout()).font, + buf->params.language); } } - layoutfont.realize(textclasslist.TextClass(buf->params.textclass).defaultfont()); + layoutfont.realize(textclasslist.TextClass(buf->params.textclass).defaultfont(), + buf->params.language); // Now, reduce font against full layout font font.reduce(layoutfont); @@ -265,10 +287,10 @@ void LyXText::setCharFont(Buffer const * buf, Paragraph * par, } -/* inserts a new row behind the specified row, increments - * the touched counters */ +// inserts a new row behind the specified row, increments +// the touched counters void LyXText::insertRow(Row * row, Paragraph * par, - Paragraph::size_type pos) const + Paragraph::size_type pos) const { Row * tmprow = new Row; if (!row) { @@ -293,7 +315,7 @@ void LyXText::insertRow(Row * row, Paragraph * par, if (row == lastrow) lastrow = tmprow; - ++number_of_rows; // one more row + ++number_of_rows; } @@ -340,10 +362,10 @@ void LyXText::removeParagraph(Row * row) const // insert the specified paragraph behind the specified row void LyXText::insertParagraph(BufferView * bview, Paragraph * par, - Row * row) const + Row * row) const { - insertRow(row, par, 0); /* insert a new row, starting - * at postition 0 */ + insertRow(row, par, 0); /* insert a new row, starting + * at postition 0 */ setCounter(bview->buffer(), par); // set the counters @@ -358,24 +380,57 @@ void LyXText::insertParagraph(BufferView * bview, Paragraph * par, } +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) { + inset = cursor.par()->getInset(cursor.pos()); + } + return inset; +} + + +void LyXText::toggleInset(BufferView * bview) +{ + Inset * inset = getInset(); + if (!inset->editable()) + return; + //bview->owner()->message(inset->editMessage()); + + // do we want to keep this?? (JMarc) + if (inset->editable() != Inset::HIGHLY_EDITABLE) + setCursorParUndo(bview); + + if (inset->isOpen()) { + inset->close(bview); + } else { + inset->open(bview); + } +#if 0 + inset->open(bview, !inset->isOpen()); +#endif +} + + /* used in setlayout */ // Asger is not sure we want to do this... void LyXText::makeFontEntriesLayoutSpecific(Buffer const * buf, Paragraph * par) { - LyXLayout const & layout = textclasslist.Style(buf->params.textclass, par->getLayout()); - LyXFont layoutfont, tmpfont; - for (Paragraph::size_type pos = 0; - pos < par->size(); ++pos) { + LyXFont layoutfont; + for (Paragraph::size_type pos = 0; pos < par->size(); ++pos) { if (pos < beginningOfMainBody(buf, par)) layoutfont = layout.labelfont; else layoutfont = layout.font; - tmpfont = par->getFontSettings(buf->params, pos); + LyXFont tmpfont = par->getFontSettings(buf->params, pos); tmpfont.reduce(layoutfont); par->setFont(pos, tmpfont); } @@ -383,9 +438,9 @@ void LyXText::makeFontEntriesLayoutSpecific(Buffer const * buf, Paragraph * LyXText::setLayout(BufferView * bview, - LyXCursor & cur, LyXCursor & sstart_cur, - LyXCursor & send_cur, - LyXTextClass::size_type layout) + LyXCursor & cur, LyXCursor & sstart_cur, + LyXCursor & send_cur, + LyXTextClass::size_type layout) { Paragraph * endpar = send_cur.par()->next(); Paragraph * undoendpar = endpar; @@ -402,8 +457,8 @@ Paragraph * LyXText::setLayout(BufferView * bview, setUndo(bview, Undo::EDIT, sstart_cur.par(), undoendpar); - /* ok we have a selection. This is always between sstart_cur - * and sel_end cursor */ + // ok we have a selection. This is always between sstart_cur + // and sel_end cursor cur = sstart_cur; LyXLayout const & lyxlayout = @@ -414,11 +469,11 @@ Paragraph * LyXText::setLayout(BufferView * bview, makeFontEntriesLayoutSpecific(bview->buffer(), cur.par()); Paragraph * fppar = cur.par(); fppar->params().spaceTop(lyxlayout.fill_top ? - VSpace(VSpace::VFILL) - : VSpace(VSpace::NONE)); + VSpace(VSpace::VFILL) + : VSpace(VSpace::NONE)); fppar->params().spaceBottom(lyxlayout.fill_bottom ? - VSpace(VSpace::VFILL) - : VSpace(VSpace::NONE)); + VSpace(VSpace::VFILL) + : VSpace(VSpace::NONE)); if (lyxlayout.margintype == MARGIN_MANUAL) cur.par()->setLabelWidthString(lyxlayout.labelstring()); if (lyxlayout.labeltype != LABEL_BIBLIO @@ -432,9 +487,9 @@ Paragraph * LyXText::setLayout(BufferView * bview, makeFontEntriesLayoutSpecific(bview->buffer(), cur.par()); Paragraph * fppar = cur.par(); fppar->params().spaceTop(lyxlayout.fill_top ? - VSpace(VSpace::VFILL) : VSpace(VSpace::NONE)); + VSpace(VSpace::VFILL) : VSpace(VSpace::NONE)); fppar->params().spaceBottom(lyxlayout.fill_bottom ? - VSpace(VSpace::VFILL) : VSpace(VSpace::NONE)); + VSpace(VSpace::VFILL) : VSpace(VSpace::NONE)); if (lyxlayout.margintype == MARGIN_MANUAL) cur.par()->setLabelWidthString(lyxlayout.labelstring()); if (lyxlayout.labeltype != LABEL_BIBLIO @@ -458,7 +513,7 @@ void LyXText::setLayout(BufferView * bview, LyXTextClass::size_type layout) selection.end = cursor; } Paragraph * endpar = setLayout(bview, cursor, selection.start, - selection.end, layout); + selection.end, layout); redoParagraphs(bview, selection.start, endpar); // we have to reset the selection, because the @@ -466,10 +521,9 @@ void LyXText::setLayout(BufferView * bview, LyXTextClass::size_type layout) setCursor(bview, selection.start.par(), selection.start.pos(), false); selection.cursor = cursor; - setCursor(bview, selection.end.par(), selection.end.pos(), - false); + setCursor(bview, selection.end.par(), selection.end.pos(), false); updateCounters(bview, cursor.row()); - clearSelection(bview); + clearSelection(); setSelection(bview); setCursor(bview, tmpcursor.par(), tmpcursor.pos(), true); } @@ -495,8 +549,7 @@ void LyXText::incDepth(BufferView * bview) endpar = endpar->next(); undoendpar = endpar; } - } - else if (endpar) { + } else if (endpar) { endpar = endpar->next(); // because of parindents etc. } @@ -514,22 +567,22 @@ void LyXText::incDepth(BufferView * bview) 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) { + textclasslist.Style(bview->buffer()->params.textclass, + cursor.par()->getLayout() + ).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()))) { + prev->getLayout()).isEnvironment()))) { cursor.par()->params().depth(cursor.par()->params().depth() + 1); anything_changed = true; - } + } } if (cursor.par() == selection.end.par()) - break; + break; cursor.par(cursor.par()->next()); } @@ -551,7 +604,7 @@ void LyXText::incDepth(BufferView * bview) selection.cursor = cursor; setCursor(bview, selection.end.par(), selection.end.pos()); updateCounters(bview, cursor.row()); - clearSelection(bview); + clearSelection(); setSelection(bview); setCursor(bview, tmpcursor.par(), tmpcursor.pos()); } @@ -589,10 +642,13 @@ void LyXText::decDepth(BufferView * bview) cursor = selection.start; while (true) { - if (cursor.par()->params().depth()) - cursor.par()->params().depth(cursor.par()->params().depth() - 1); - if (cursor.par() == selection.end.par()) + if (cursor.par()->params().depth()) { + cursor.par()->params() + .depth(cursor.par()->params().depth() - 1); + } + if (cursor.par() == selection.end.par()) { break; + } cursor.par(cursor.par()->next()); } @@ -605,7 +661,7 @@ void LyXText::decDepth(BufferView * bview) selection.cursor = cursor; setCursor(bview, selection.end.par(), selection.end.pos()); updateCounters(bview, cursor.row()); - clearSelection(bview); + clearSelection(); setSelection(bview); setCursor(bview, tmpcursor.par(), tmpcursor.pos()); } @@ -624,15 +680,14 @@ void LyXText::setFont(BufferView * bview, LyXFont const & font, bool toggleall) else layoutfont = getFont(bview->buffer(), cursor.par(),-1); // Update current font - real_current_font.update(font, - bview->buffer()->params.language, - toggleall); + real_current_font.update(font, toggleall); // Reduce to implicit settings current_font = real_current_font; current_font.reduce(layoutfont); // And resolve it completely - real_current_font.realize(layoutfont); + real_current_font.realize(layoutfont, + bview->buffer()->params.language); return; } @@ -651,7 +706,8 @@ void LyXText::setFont(BufferView * bview, LyXFont const & font, bool toggleall) if (cursor.pos() < cursor.par()->size()) { // an open footnote should behave // like a closed one - setCharFont(bview, cursor.par(), cursor.pos(), font, toggleall); + setCharFont(bview, cursor.par(), cursor.pos(), + font, toggleall); cursor.pos(cursor.pos() + 1); } else { cursor.pos(0); @@ -667,7 +723,7 @@ void LyXText::setFont(BufferView * bview, LyXFont const & font, bool toggleall) setCursor(bview, selection.start.par(), selection.start.pos()); selection.cursor = cursor; setCursor(bview, selection.end.par(), selection.end.pos()); - clearSelection(bview); + clearSelection(); setSelection(bview); setCursor(bview, tmpcursor.par(), tmpcursor.pos(), true, tmpcursor.boundary()); @@ -681,29 +737,12 @@ void LyXText::redoHeightOfParagraph(BufferView * bview, LyXCursor const & cur) setHeightOfRow(bview, tmprow); -#if 0 - Paragraph * first_phys_par = tmprow->par(); - - // find the first row of the paragraph - if (first_phys_par != tmprow->par()) - while (tmprow->previous() - && tmprow->previous()->par() != first_phys_par) { - tmprow = tmprow->previous(); - y -= tmprow->height(); - setHeightOfRow(bview, tmprow); - } - while (tmprow->previous() && tmprow->previous()->par() == first_phys_par) { + while (tmprow->previous() + && tmprow->previous()->par() == tmprow->par()) { tmprow = tmprow->previous(); y -= tmprow->height(); setHeightOfRow(bview, tmprow); } -#else - while (tmprow->previous() && tmprow->previous()->par() == tmprow->par()) { - tmprow = tmprow->previous(); - y -= tmprow->height(); - setHeightOfRow(bview, tmprow); - } -#endif // we can set the refreshing parameters now status(bview, LyXText::NEED_MORE_REFRESH); @@ -720,25 +759,12 @@ void LyXText::redoDrawingOfParagraph(BufferView * bview, LyXCursor const & cur) int y = cur.y() - tmprow->baseline(); setHeightOfRow(bview, tmprow); -#if 0 - Paragraph * first_phys_par = tmprow->par(); - - // find the first row of the paragraph - if (first_phys_par != tmprow->par()) - while (tmprow->previous() && tmprow->previous()->par() != first_phys_par) { - tmprow = tmprow->previous(); - y -= tmprow->height(); - } - while (tmprow->previous() && tmprow->previous()->par() == first_phys_par) { - tmprow = tmprow->previous(); - y -= tmprow->height(); - } -#else - while (tmprow->previous() && tmprow->previous()->par() == tmprow->par()) { + while (tmprow->previous() + && tmprow->previous()->par() == tmprow->par()) { tmprow = tmprow->previous(); y -= tmprow->height(); } -#endif + // we can set the refreshing parameters now if (status_ == LyXText::UNCHANGED || y < refresh_y) { refresh_y = y; @@ -749,11 +775,11 @@ void LyXText::redoDrawingOfParagraph(BufferView * bview, LyXCursor const & cur) } -/* deletes and inserts again all paragaphs between the cursor -* and the specified par -* This function is needed after SetLayout and SetFont etc. */ +// deletes and inserts again all paragaphs between the cursor +// 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; @@ -763,25 +789,6 @@ void LyXText::redoParagraphs(BufferView * bview, LyXCursor const & cur, int y = cur.y() - tmprow->baseline(); -#if 0 - if (!tmprow->previous()) { - first_phys_par = firstParagraph(); // a trick/hack for UNDO - } else { - first_phys_par = tmprow->par(); - // find the first row of the paragraph - if (first_phys_par != tmprow->par()) - while (tmprow->previous() && - (tmprow->previous()->par() != first_phys_par)) { - tmprow = tmprow->previous(); - y -= tmprow->height(); - } - while (tmprow->previous() - && tmprow->previous()->par() == first_phys_par) { - tmprow = tmprow->previous(); - y -= tmprow->height(); - } - } -#else if (!tmprow->previous()) { // a trick/hack for UNDO // Can somebody please tell me _why_ this solves @@ -790,19 +797,19 @@ void LyXText::redoParagraphs(BufferView * bview, LyXCursor const & cur, } else { first_phys_par = tmprow->par(); while (tmprow->previous() - && tmprow->previous()->par() == first_phys_par) { + && tmprow->previous()->par() == first_phys_par) + { tmprow = tmprow->previous(); y -= tmprow->height(); } } -#endif // 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(); @@ -818,7 +825,7 @@ void LyXText::redoParagraphs(BufferView * bview, LyXCursor const & cur, // remove the first one tmprow2 = tmprow; /* this is because tmprow->previous() - can be 0 */ + can be 0 */ tmprow = tmprow->previous(); removeRow(tmprow2); @@ -827,10 +834,13 @@ void LyXText::redoParagraphs(BufferView * bview, LyXCursor const & cur, do { if (tmppar) { insertParagraph(bview, tmppar, tmprow); - if (!tmprow) + if (!tmprow) { tmprow = firstrow; - while (tmprow->next() && tmprow->next()->par() == tmppar) + } + while (tmprow->next() + && tmprow->next()->par() == tmppar) { tmprow = tmprow->next(); + } tmppar = tmppar->next(); } } while (tmppar && tmppar != endpar); @@ -865,7 +875,7 @@ bool LyXText::fullRebreak(BufferView * bview) } -/* important for the screen */ +// important for the screen /* the cursor set functions have a special mechanism. When they @@ -888,7 +898,7 @@ void LyXText::setSelection(BufferView * bview) // first the toggling area if (cursor.y() < last_sel_cursor.y() || (cursor.y() == last_sel_cursor.y() - && cursor.x() < last_sel_cursor.x())) { + && cursor.x() < last_sel_cursor.x())) { toggle_end_cursor = last_sel_cursor; toggle_cursor = cursor; } else { @@ -901,15 +911,16 @@ void LyXText::setSelection(BufferView * bview) // and now the whole selection if (selection.cursor.par() == cursor.par()) - if (selection.cursor.pos() < cursor.pos()) { - selection.end = cursor; - selection.start = selection.cursor; - } else { - selection.end = selection.cursor; - selection.start = cursor; - } + if (selection.cursor.pos() < cursor.pos()) { + selection.end = cursor; + selection.start = selection.cursor; + } else { + selection.end = selection.cursor; + selection.start = cursor; + } else if (selection.cursor.y() < cursor.y() || - (selection.cursor.y() == cursor.y() && selection.cursor.x() < cursor.x())) { + (selection.cursor.y() == cursor.y() + && selection.cursor.x() < cursor.x())) { selection.end = cursor; selection.start = selection.cursor; } @@ -936,8 +947,8 @@ string const LyXText::selectionAsString(Buffer const * buffer) const // 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()); + selection.start.pos(), + selection.end.pos()); return result; } @@ -945,30 +956,32 @@ string const LyXText::selectionAsString(Buffer const * buffer) const // First paragraph in selection result += selection.start.par()->asString(buffer, - selection.start.pos(), - selection.start.par()->size()) + selection.start.pos(), + selection.start.par()->size()) + "\n\n"; // The paragraphs in between (if any) LyXCursor tmpcur(selection.start); tmpcur.par(tmpcur.par()->next()); while (tmpcur.par() != selection.end.par()) { - result += tmpcur.par()->asString(buffer, 0, tmpcur.par()->size()) + "\n\n"; - tmpcur.par(tmpcur.par()->next()); // Or NextAfterFootnote?? + result += tmpcur.par()->asString(buffer, 0, + tmpcur.par()->size()) +"\n\n"; + tmpcur.par(tmpcur.par()->next()); } // Last paragraph in selection - result += selection.end.par()->asString(buffer, 0, selection.end.pos()); + result += selection.end.par()->asString(buffer, 0, + selection.end.pos()); return result; } -void LyXText::clearSelection(BufferView * /*bview*/) const +void LyXText::clearSelection() const { selection.set(false); selection.mark(false); - selection.end = selection.start = cursor; + selection.end = selection.start = selection.cursor = cursor; } @@ -980,15 +993,18 @@ void LyXText::cursorHome(BufferView * bview) const void LyXText::cursorEnd(BufferView * bview) const { - if (!cursor.row()->next() || cursor.row()->next()->par() != cursor.row()->par()) + if (!cursor.row()->next() + || cursor.row()->next()->par() != cursor.row()->par()) { setCursor(bview, cursor.par(), rowLast(cursor.row()) + 1); - else { + } else { if (cursor.par()->size() && (cursor.par()->getChar(rowLast(cursor.row())) == ' ' - || cursor.par()->isNewline(rowLast(cursor.row())))) + || cursor.par()->isNewline(rowLast(cursor.row())))) { setCursor(bview, cursor.par(), rowLast(cursor.row())); - else - setCursor(bview,cursor.par(), rowLast(cursor.row()) + 1); + } else { + setCursor(bview,cursor.par(), + rowLast(cursor.row()) + 1); + } } } @@ -1024,16 +1040,16 @@ void LyXText::toggleFree(BufferView * bview, // is disabled. LyXCursor resetCursor = cursor; bool implicitSelection = (font.language() == ignore_language - && font.number() == LyXFont::IGNORE) - ? selectWordWhenUnderCursor(bview) : false; + && font.number() == LyXFont::IGNORE) + ? selectWordWhenUnderCursor(bview, WHOLE_WORD_STRICT) : false; // Set font setFont(bview, font, toggleall); - /* Implicit selections are cleared afterwards and cursor is set to the - original position. */ + // Implicit selections are cleared afterwards + //and cursor is set to the original position. if (implicitSelection) { - clearSelection(bview); + clearSelection(); cursor = resetCursor; setCursor(bview, cursor.par(), cursor.pos()); selection.cursor = cursor; @@ -1043,6 +1059,39 @@ 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 + // is disabled. + LyXCursor resetCursor = cursor; + bool implicitSelection = selectWordWhenUnderCursor(bview, PREVIOUS_WORD); + + if (!selection.set()) { + bview->owner()->message(_("Nothing to index!")); + return string(); + } + if (selection.start.par() != selection.end.par()) { + bview->owner()->message(_("Cannot index more than one paragraph!")); + return string(); + } + + idxstring = selectionAsString(bview->buffer()); + + // Implicit selections are cleared afterwards + //and cursor is set to the original position. + if (implicitSelection) { + clearSelection(); + cursor = resetCursor; + setCursor(bview, cursor.par(), cursor.pos()); + selection.cursor = cursor; + } + return idxstring; +} + Paragraph::size_type LyXText::beginningOfMainBody(Buffer const * buf, Paragraph const * par) const @@ -1087,7 +1136,8 @@ void LyXText::setParagraph(BufferView * bview, } } else if (endpar) { - endpar = endpar->next(); // because of parindents etc. + // because of parindents etc. + endpar = endpar->next(); } setUndo(bview, Undo::EDIT, selection.start.par(), undoendpar); @@ -1099,42 +1149,42 @@ void LyXText::setParagraph(BufferView * bview, status(bview, LyXText::NEED_MORE_REFRESH); refresh_row = cursor.row(); refresh_y = cursor.y() - cursor.row()->baseline(); - cursor.par()->params().lineTop(line_top); - cursor.par()->params().lineBottom(line_bottom); - cursor.par()->params().pagebreakTop(pagebreak_top); - cursor.par()->params().pagebreakBottom(pagebreak_bottom); - cursor.par()->params().spaceTop(space_top); - cursor.par()->params().spaceBottom(space_bottom); - // does the layout allow the new alignment? - if (align == LYX_ALIGN_LAYOUT) - align = textclasslist - .Style(bview->buffer()->params.textclass, - cursor.par()->getLayout()).align; - if (align & textclasslist + cursor.par()->params().lineTop(line_top); + cursor.par()->params().lineBottom(line_bottom); + cursor.par()->params().pagebreakTop(pagebreak_top); + cursor.par()->params().pagebreakBottom(pagebreak_bottom); + cursor.par()->params().spaceTop(space_top); + cursor.par()->params().spaceBottom(space_bottom); + // does the layout allow the new alignment? + 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()).alignpossible) { - if (align == textclasslist - .Style(bview->buffer()->params.textclass, - cursor.par()->getLayout()).align) - cursor.par()->params().align(LYX_ALIGN_LAYOUT); - else - cursor.par()->params().align(align); - } - cursor.par()->setLabelWidthString(labelwidthstring); - cursor.par()->params().noindent(noindent); + cursor.par()->getLayout()).align) + cursor.par()->params().align(LYX_ALIGN_LAYOUT); + else + cursor.par()->params().align(align); + } + cursor.par()->setLabelWidthString(labelwidthstring); + cursor.par()->params().noindent(noindent); tmppar = cursor.par()->previous(); } redoParagraphs(bview, selection.start, endpar); - clearSelection(bview); + clearSelection(); setCursor(bview, selection.start.par(), selection.start.pos()); selection.cursor = cursor; setCursor(bview, selection.end.par(), selection.end.pos()); setSelection(bview); setCursor(bview, tmpcursor.par(), tmpcursor.pos()); if (inset_owner) - bview->updateInset(inset_owner, true); + bview->updateInset(inset_owner, true); } @@ -1202,22 +1252,18 @@ void LyXText::setCounter(Buffer const * buf, Paragraph * par) const LyXTextClass const & textclass = textclasslist.TextClass(buf->params.textclass); - /* copy the prev-counters to this one, unless this is the start of a - footnote or of a bibliography or the very first paragraph */ - if (par->previous() - && !(textclasslist.Style(buf->params.textclass, - par->previous()->getLayout() - ).labeltype != LABEL_BIBLIO - && layout.labeltype == LABEL_BIBLIO)) { + // 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); - } + par->params().appendix(true); + for (int i = 0; i < 10; ++i) { + par->setCounter(i, 0); + } } par->enumdepth = par->previous()->enumdepth; par->itemdepth = par->previous()->itemdepth; @@ -1240,20 +1286,20 @@ 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()->getLayout() + ).labeltype == LABEL_COUNTER_ENUMI && par->enumdepth < 3 && layout.labeltype != LABEL_BIBLIO) { par->enumdepth++; } - /* Maybe we have to decrement the enumeration depth, see note above */ + // Maybe we have to decrement the enumeration depth, see note above if (par->previous() && par->previous()->getDepth() > par->getDepth() && layout.labeltype != LABEL_BIBLIO) { par->enumdepth = par->depthHook(par->getDepth())->enumdepth; par->setCounter(6 + par->enumdepth, - par->depthHook(par->getDepth())->getCounter(6 + par->enumdepth)); + par->depthHook(par->getDepth())->getCounter(6 + par->enumdepth)); /* reset the counters. * A depth change is like a breaking layout */ @@ -1273,7 +1319,7 @@ void LyXText::setCounter(Buffer const * buf, Paragraph * par) const par->setLabelWidthString(string()); } - /* is it a layout that has an automatic label ? */ + // is it a layout that has an automatic label? if (layout.labeltype >= LABEL_COUNTER_CHAPTER) { int i = layout.labeltype - LABEL_COUNTER_CHAPTER; @@ -1293,7 +1339,7 @@ void LyXText::setCounter(Buffer const * buf, Paragraph * par) const par->params().labelString(string()); } - std::ostringstream s; + ostringstream s; if (!par->params().appendix()) { switch (2 * LABEL_COUNTER_CHAPTER - @@ -1303,7 +1349,7 @@ void LyXText::setCounter(Buffer const * buf, Paragraph * par) const break; case LABEL_COUNTER_SECTION: s << par->getCounter(i - 1) << '.' - << par->getCounter(i); + << par->getCounter(i); break; case LABEL_COUNTER_SUBSECTION: s << par->getCounter(i - 2) << '.' @@ -1435,7 +1481,7 @@ void LyXText::setCounter(Buffer const * buf, Paragraph * par) const par->incCounter(i + par->enumdepth); int number = par->getCounter(i + par->enumdepth); - std::ostringstream s; + ostringstream s; switch (par->enumdepth) { case 1: @@ -1471,11 +1517,12 @@ void LyXText::setCounter(Buffer const * buf, Paragraph * par) const } par->params().labelString(s.str().c_str()); - // we really want to get rid of that c_str() - for (i += par->enumdepth + 1; i < 10; ++i) - par->setCounter(i, 0); /* reset the following counters */ - + 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; @@ -1494,11 +1541,11 @@ void LyXText::setCounter(Buffer const * buf, Paragraph * par) const // the caption hack: if (layout.labeltype == LABEL_SENSITIVE) { - bool isOK (par->InInset() && par->InInset()->owner() && - (par->InInset()->owner()->lyxCode() == Inset::FLOAT_CODE)); + bool isOK (par->inInset() && par->inInset()->owner() && + (par->inInset()->owner()->lyxCode() == Inset::FLOAT_CODE)); if (isOK) { - InsetFloat * tmp = static_cast(par->InInset()->owner()); + InsetFloat * tmp = static_cast(par->inInset()->owner()); Floating const & fl = floatList.getType(tmp->type()); // We should get the correct number here too. @@ -1520,8 +1567,8 @@ void LyXText::setCounter(Buffer const * buf, Paragraph * par) const } -/* Updates all counters BEHIND the row. Changed paragraphs -* with a dynamic left margin will be rebroken. */ +// Updates all counters BEHIND the row. Changed paragraphs +// with a dynamic left margin will be rebroken. void LyXText::updateCounters(BufferView * bview, Row * row) const { Paragraph * par; @@ -1539,14 +1586,14 @@ void LyXText::updateCounters(BufferView * bview, Row * row) const setCounter(bview->buffer(), par); - /* now check for the headline layouts. remember that they - * have a dynamic left margin */ + // 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 */ + // Rebreak the paragraph removeParagraph(row); appendParagraph(bview, row); } @@ -1555,17 +1602,16 @@ void LyXText::updateCounters(BufferView * bview, Row * row) const } -/* insets an inset. */ void LyXText::insertInset(BufferView * bview, Inset * inset) { - if (!cursor.par()->insertInsetAllowed(inset)) + if (!cursor.par()->insetAllowed(inset->lyxCode())) return; setUndo(bview, Undo::INSERT, cursor.par(), cursor.par()->next()); cursor.par()->insertInset(cursor.pos(), inset); - insertChar(bview, Paragraph::META_INSET); /* just to rebreak and refresh correctly. - * The character will not be inserted a - * second time */ + // 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 @@ -1633,15 +1679,15 @@ void LyXText::cutSelection(BufferView * bview, bool doclear) endpar = selection.end.par(); int pos = selection.end.pos(); CutAndPaste::cutSelection(selection.start.par(), &endpar, - selection.start.pos(), pos, - bview->buffer()->params.textclass, doclear); + selection.start.pos(), pos, + bview->buffer()->params.textclass, doclear); 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); + selection.start.pos(), pos, + bview->buffer()->params.textclass, doclear); cursor.par(endpar); selection.end.par(endpar); selection.end.pos(pos); @@ -1660,7 +1706,7 @@ void LyXText::cutSelection(BufferView * bview, bool doclear) cursor = selection.start; // need a valid cursor. (Lgb) - clearSelection(bview); + clearSelection(); setCursor(bview, cursor.par(), cursor.pos()); selection.cursor = cursor; @@ -1714,12 +1760,12 @@ void LyXText::pasteSelection(BufferView * bview) int pos = cursor.pos(); CutAndPaste::pasteSelection(&actpar, &endpar, pos, - bview->buffer()->params.textclass); + bview->buffer()->params.textclass); redoParagraphs(bview, cursor, endpar); setCursor(bview, cursor.par(), cursor.pos()); - clearSelection(bview); + clearSelection(); selection.cursor = cursor; setCursor(bview, actpar, pos); @@ -1788,65 +1834,10 @@ void LyXText::insertStringAsLines(BufferView * bview, string const & str) setCursorParUndo(bview); - bool isEnvironment = - textclasslist.Style(bview->buffer()->params.textclass, - cursor.par()->getLayout()).isEnvironment(); - bool free_spacing = - textclasslist.Style(bview->buffer()->params.textclass, - cursor.par()->getLayout()).free_spacing; - bool keepempty = - textclasslist.Style(bview->buffer()->params.textclass, - cursor.par()->getLayout()).keepempty; - // only to be sure, should not be neccessary - clearSelection(bview); + clearSelection(); - // insert the string, don't insert doublespace - bool space_inserted = true; - for(string::const_iterator cit = str.begin(); - cit != str.end(); ++cit) { - if (*cit == '\n') { - if (par->size() || keepempty) { - par->breakParagraph(bview->buffer()->params, - pos, isEnvironment); - par = par->next(); - pos = 0; - space_inserted = true; - } else { - continue; - } - // do not insert consecutive spaces if !free_spacing - } else if ((*cit == ' ' || *cit == '\t') - && space_inserted && !free_spacing) { - continue; - } else if (*cit == '\t') { - if (!free_spacing) { - // tabs are like spaces here - par->insertChar(pos, ' ', - current_font); - ++pos; - space_inserted = true; - } else { - const Paragraph::value_type nb = 8 - pos % 8; - for (Paragraph::size_type a = 0; - a < nb ; ++a) { - par->insertChar(pos, ' ', - current_font); - ++pos; - } - space_inserted = true; - } - } else if (!IsPrintable(*cit)) { - // Ignore unprintables - continue; - } else { - // just insert the character - par->insertChar(pos, *cit, current_font); - ++pos; - space_inserted = (*cit == ' '); - } - - } + bview->buffer()->insertStringAsLines(par, pos, current_font, str); redoParagraphs(bview, cursor, endpar); setCursor(bview, cursor.par(), cursor.pos()); @@ -1856,8 +1847,8 @@ void LyXText::insertStringAsLines(BufferView * bview, string const & str) } -/* turns double-CR to single CR, others where converted into one - blank. Then InsertStringAsLines is called */ +// turns double-CR to single CR, others where converted into one +// blank. Then InsertStringAsLines is called void LyXText::insertStringAsParagraphs(BufferView * bview, string const & str) { string linestr(str); @@ -1900,7 +1891,7 @@ bool LyXText::gotoNextInset(BufferView * bview, !(res.par()->getChar(res.pos()) == Paragraph::META_INSET && (inset = res.par()->getInset(res.pos())) != 0 && find(codes.begin(), codes.end(), inset->lyxCode()) - != codes.end() + != codes.end() && (contents.empty() || static_cast(res.par()->getInset(res.pos()))->getContents() == contents))); @@ -2008,11 +1999,11 @@ bool LyXText::updateInset(BufferView * bview, Inset * inset) Paragraph * par = firstParagraph(); do { - pos = par->getPositionOfInset(inset); - if (pos != -1){ - checkParagraph(bview, par, pos); - return true; - } + pos = par->getPositionOfInset(inset); + if (pos != -1){ + checkParagraph(bview, par, pos); + return true; + } par = par->next(); } while (par); @@ -2037,15 +2028,15 @@ void LyXText::setCursor(BufferView *bview, LyXCursor & cur, Paragraph * par, cur.pos(pos); cur.boundary(boundary); - /* get the cursor y position in text */ + // get the cursor y position in text int y = 0; Row * row = getRow(par, pos, y); - /* y is now the beginning of the cursor 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 */ + // now get the cursors x position float x; float fill_separator; float fill_hfill; @@ -2119,10 +2110,10 @@ void LyXText::setCursorIntern(BufferView * bview, Paragraph * par, Paragraph::size_type pos, bool setfont, bool boundary) const { - InsetText * it = static_cast(par->InInset()); + InsetText * it = static_cast(par->inInset()); if (it && (it != inset_owner)) { it->getLyXText(bview)->setCursorIntern(bview, par, pos, setfont, - boundary); + boundary); } else { setCursor(bview, cursor, par, pos, boundary); if (setfont) @@ -2141,14 +2132,14 @@ void LyXText::setCurrentFont(BufferView * bview) const if (pos == cursor.par()->size()) --pos; else // potentional bug... BUG (Lgb) - if (cursor.par()->isSeparator(pos)) { - if (pos > cursor.row()->pos() && - bidi_level(pos) % 2 == - bidi_level(pos - 1) % 2) - --pos; - else if (pos + 1 < cursor.par()->size()) - ++pos; - } + if (cursor.par()->isSeparator(pos)) { + if (pos > cursor.row()->pos() && + bidi_level(pos) % 2 == + bidi_level(pos - 1) % 2) + --pos; + else if (pos + 1 < cursor.par()->size()) + ++pos; + } } current_font = @@ -2171,19 +2162,24 @@ void LyXText::setCurrentFont(BufferView * bview) const void LyXText::setCursorFromCoordinates(BufferView * bview, int x, int y) const { LyXCursor old_cursor = cursor; - - /* get the row first */ + +#if 0 + // Get the row first. Row * row = getRowNearY(y); - cursor.par(row->par()); bool bound = false; int column = getColumnNearX(bview, row, x, bound); + + cursor.par(row->par()); cursor.pos(row->pos() + column); cursor.x(x); cursor.y(y + row->baseline()); cursor.row(row); cursor.boundary(bound); +#else + setCursorFromCoordinates(bview, cursor, x, y); +#endif setCurrentFont(bview); deleteEmptyParagraphMechanism(bview, old_cursor); } @@ -2192,11 +2188,11 @@ void LyXText::setCursorFromCoordinates(BufferView * bview, int x, int y) const void LyXText::setCursorFromCoordinates(BufferView * bview, LyXCursor & cur, int x, int y) const { - /* get the row first */ + // Get the row first. Row * row = getRowNearY(y); bool bound = false; - int column = getColumnNearX(bview, row, x, bound); + int const column = getColumnNearX(bview, row, x, bound); cur.par(row->par()); cur.pos(row->pos() + column); @@ -2340,95 +2336,95 @@ void LyXText::deleteEmptyParagraphMechanism(BufferView * bview, if (old_cursor.par() != cursor.par()) { if ((old_cursor.par()->size() == 0 - || (old_cursor.par()->size() == 1 - && old_cursor.par()->isLineSeparator(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; + 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()); + 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(); } - // delete old par - delete old_cursor.par(); + } + 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(); + /* 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()); + 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()); + } - delete old_cursor.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) { - breakAgain(bview, refresh_row); - updateCounters(bview, refresh_row->previous()); - } + /* 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()); } + } // correct cursor y - setCursorIntern(bview, cursor.par(), cursor.pos()); + setCursorIntern(bview, cursor.par(), cursor.pos()); - if (selection.cursor.par() == old_cursor.par() - && selection.cursor.pos() == selection.cursor.pos()) { - // correct selection - selection.cursor = cursor; - } + if (selection.cursor.par() == old_cursor.par() + && selection.cursor.pos() == selection.cursor.pos()) { + // correct selection + selection.cursor = cursor; + } } if (!deleted) { if (old_cursor.par()->stripLeadingSpaces(bview->buffer()->params.textclass)) { @@ -2442,20 +2438,6 @@ void LyXText::deleteEmptyParagraphMechanism(BufferView * bview, } -Paragraph * LyXText::getParFromID(int id) const -{ - if (id < 0) - return 0; - Paragraph * result = firstParagraph(); - Paragraph * ires = 0; - while (result && result->id() != id) { - if ((ires = result->getParFromID(id))) - return ires; - result = result->next(); - } - return result; -} - void LyXText::toggleAppendix(BufferView * bview) { Paragraph * par = cursor.par(); @@ -2463,9 +2445,10 @@ void LyXText::toggleAppendix(BufferView * bview) // ensure that we have only one start_of_appendix in this document Paragraph * tmp = firstParagraph(); - for (; tmp; tmp = tmp->next()) + for (; tmp; tmp = tmp->next()) { tmp->params().startOfAppendix(false); - + } + par->params().startOfAppendix(start); // we can set the refreshing parameters now @@ -2479,32 +2462,34 @@ void LyXText::toggleAppendix(BufferView * bview) Paragraph * LyXText::ownerParagraph() const { - if (inset_owner) + if (inset_owner) { return inset_owner->paragraph(); - + } return bv_owner->buffer()->paragraph; } Paragraph * LyXText::ownerParagraph(Paragraph * p) const { - if (inset_owner) + if (inset_owner) { inset_owner->paragraph(p); - else + } else { bv_owner->buffer()->paragraph = p; + } return 0; } Paragraph * LyXText::ownerParagraph(int id, Paragraph * p) const { - Paragraph * op = getParFromID(id); - if (op && op->InInset()) { - static_cast(op->InInset())->paragraph(p); + Paragraph * op = bv_owner->buffer()->getParFromID(id); + if (op && op->inInset()) { + static_cast(op->inInset())->paragraph(p); } else { - if (inset_owner) + if (inset_owner) { inset_owner->paragraph(p); - else + } else { bv_owner->buffer()->paragraph = p; + } } return 0; } @@ -2518,11 +2503,46 @@ LyXText::text_status LyXText::status() const void LyXText::status(BufferView * bview, LyXText::text_status st) const { - if ((status_ != NEED_MORE_REFRESH) || - (status_ == NEED_MORE_REFRESH) && (st != NEED_VERY_LITTLE_REFRESH)) +#if 0 + if ((status_ != NEED_MORE_REFRESH) + || (status_ == NEED_MORE_REFRESH) + && (st != NEED_VERY_LITTLE_REFRESH)) { + status_ = st; + if (inset_owner && st != UNCHANGED) { + bview->text->status(bview, NEED_VERY_LITTLE_REFRESH); + } + } +#else +#warning Please tell what the intention is here. (Lgb) + // The above does not make any sense, I changed it to what is here, + // but it still does not make much sense. (Lgb) +#warning Sure have a look now! (Jug) + // 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: + // 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 + // we stay inside one LyXText this may work but we need to tell the + // outermost LyXText that it should REALLY draw us if there is some + // change in a Inset::LyXText. So you see that when we are inside a + // inset's LyXText we give the LITTLE to the outermost LyXText to + // 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)) { status_ = st; - if (inset_owner && st != UNCHANGED) + 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(); + } + } } +#endif }