X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftext2.C;h=938d9fd3a201fea559db7fc53fa9f8fff6538588;hb=757e2c55d8c15db0db5b4127bb3f6f22e4d7d81b;hp=18575e9d789feb325ceca9990948a1d63b137bea;hpb=b18c63a3930b128e8959151cfb58e36c48b614a8;p=lyx.git diff --git a/src/text2.C b/src/text2.C index 18575e9d78..938d9fd3a2 100644 --- a/src/text2.C +++ b/src/text2.C @@ -4,102 +4,93 @@ * LyX, The Document Processor * * Copyright 1995 Matthias Ettrich - * Copyright 1995-2000 The LyX Team. + * Copyright 1995-2001 The LyX Team. * * ====================================================== */ #include -#include FORMS_H_LOCATION - - #ifdef __GNUG__ #pragma implementation "lyxtext.h" #endif +#include "lyxtext.h" #include "LString.h" -#include "lyxparagraph.h" +#include "paragraph.h" #include "insets/inseterror.h" #include "insets/insetbib.h" #include "insets/insetspecialchar.h" +#include "insets/insettext.h" +#include "insets/insetfloat.h" #include "layout.h" #include "LyXView.h" #include "support/textutils.h" -#include "undo.h" -#include "minibuffer.h" +#include "support/lstrings.h" +#include "undo_funcs.h" #include "buffer.h" #include "bufferparams.h" #include "lyx_gui_misc.h" -#include "lyxtext.h" #include "gettext.h" #include "BufferView.h" #include "LyXView.h" -#include "lyxrow.h" #include "CutAndPaste.h" #include "Painter.h" #include "font.h" #include "debug.h" - -//#define USE_OLD_CUT_AND_PASTE 1 +#include "lyxrc.h" +#include "FloatList.h" +#include "language.h" +#include "ParagraphParameters.h" using std::copy; +using std::find; using std::endl; +using std::find; using std::pair; -LyXText::LyXText(BufferView * bv, int pw, Buffer * p) -{ - owner_ = bv; - firstrow = 0; - lastrow = 0; - paperwidth = pw; - buffer = p; - number_of_rows = 0; - refresh_y = 0; - status = LyXText::UNCHANGED; - LyXParagraph * par = p->paragraph; - current_font = GetFont(par, 0); - - height = 0; - - while (par) { - InsertParagraph(par, lastrow); - par = par->Next(); - } - - // set cursor at the very top position - selection = true; /* these setting is necessary - because of the delete-empty- - paragraph mechanism in - SetCursor */ - SetCursor(firstrow->par, 0); - sel_cursor = cursor; - selection = false; - mark_set = false; - - // no rebreak necessary - need_break_row = 0; - - undo_finished = true; - undo_frozen = false; - // Default layouttype for copy environment type - copylayouttype = 0; +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), 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), refresh_row(0), + status_(LyXText::UNCHANGED), firstrow(0), lastrow(0), + copylayouttype(0) +{} + +void LyXText::init(BufferView * bview, bool reinit) +{ + 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; -#if 0 - // Dump all rowinformation: - Row * tmprow = firstrow; - lyxerr << "Baseline Paragraph Pos Height Ascent Fill\n"; - while (tmprow) { - lyxerr << tmprow->baseline << '\t' - << tmprow->par << '\t' - << tmprow->pos << '\t' - << tmprow->height << '\t' - << tmprow->ascent_of_text << '\t' - << tmprow->fill << '\n'; - tmprow = tmprow->next; + Paragraph * par = ownerParagraph(); + current_font = getFont(bview->buffer(), par, 0); + while (par) { + insertParagraph(bview, par, lastrow); + par = par->next(); } - lyxerr.flush(); -#endif + setCursorIntern(bview, firstrow->par(), 0); + selection.cursor = cursor; } @@ -108,46 +99,42 @@ LyXText::~LyXText() // Delete all rows, this does not touch the paragraphs! Row * tmprow = firstrow; while (firstrow) { - tmprow = firstrow->next; + tmprow = firstrow->next(); delete firstrow; firstrow = tmprow; } } -void LyXText::owner(BufferView * bv) -{ - if (owner_ && bv) lyxerr << "LyXText::owner_ already set!" << endl; - owner_ = bv; -} - // Gets the fully instantiated font at a given position in a paragraph -// Basically the same routine as LyXParagraph::getFont() in paragraph.C. +// Basically the same routine as Paragraph::getFont() in paragraph.C. // The difference is that this one is used for displaying, and thus we // are allowed to make cosmetic improvements. For instance make footnotes // smaller. (Asger) // If position is -1, we get the layout font of the paragraph. // If position is -2, we get the font of the manual label of the paragraph. -LyXFont LyXText::GetFont(LyXParagraph * par, - LyXParagraph::size_type pos) const +LyXFont const LyXText::getFont(Buffer const * buf, Paragraph * par, + Paragraph::size_type pos) const { LyXLayout const & layout = - textclasslist.Style(buffer->params.textclass, - par->GetLayout()); + textclasslist.Style(buf->params.textclass, par->getLayout()); - char par_depth = par->GetDepth(); + Paragraph::depth_type par_depth = par->getDepth(); // We specialize the 95% common case: - if (par->footnoteflag == LyXParagraph::NO_FOOTNOTE && !par_depth) { + if (!par_depth) { if (pos >= 0){ // 95% goes here if (layout.labeltype == LABEL_MANUAL - && pos < BeginningOfMainBody(par)) { + && pos < beginningOfMainBody(buf, par)) { // 1% goes here - return par->GetFontSettings(pos). - realize(layout.reslabelfont); - } else - return par->GetFontSettings(pos). - realize(layout.resfont); + LyXFont f = par->getFontSettings(buf->params, + pos); + return f.realize(layout.reslabelfont, buf->params.language); + } else { + LyXFont f = par->getFontSettings(buf->params, pos); + return f.realize(layout.resfont, buf->params.language); + } + } else { // 5% goes here. // process layoutfont for pos == -1 and labelfont for pos < -1 @@ -164,15 +151,15 @@ LyXFont LyXText::GetFont(LyXParagraph * par, if (pos >= 0){ // 95% goes here - if (pos < BeginningOfMainBody(par)) { + if (pos < beginningOfMainBody(buf, par)) { // 1% goes here layoutfont = layout.labelfont; } else { // 99% goes here layoutfont = layout.font; } - tmpfont = par->GetFontSettings(pos); - tmpfont.realize(layoutfont); + tmpfont = par->getFontSettings(buf->params, pos); + tmpfont.realize(layoutfont, buf->params.language); } else { // 5% goes here. // process layoutfont for pos == -1 and labelfont for pos < -1 @@ -184,129 +171,174 @@ LyXFont LyXText::GetFont(LyXParagraph * par, // Resolve against environment font information while (par && par_depth && !tmpfont.resolved()) { - par = par->DepthHook(par_depth - 1); + par = par->outerHook(); if (par) { tmpfont.realize(textclasslist. - Style(buffer->params.textclass, - par->GetLayout()).font); - par_depth = par->GetDepth(); + Style(buf->params.textclass, + par->getLayout()).font, + buf->params.language); + par_depth = par->getDepth(); } } - tmpfont.realize(textclasslist.TextClass(buffer->params.textclass).defaultfont()); - - // Cosmetic improvement: If this is an open footnote, make the font - // smaller. - if (par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE - && par->footnotekind == LyXParagraph::FOOTNOTE) { - tmpfont.decSize(); - } + tmpfont.realize(textclasslist.TextClass(buf->params.textclass).defaultfont(), + buf->params.language); return tmpfont; } -void LyXText::SetCharFont(LyXParagraph * par, - LyXParagraph::size_type pos, - LyXFont const & fnt) +void LyXText::setCharFont(BufferView * bv, Paragraph * par, + Paragraph::size_type pos, LyXFont const & fnt, + bool toggleall) { - LyXFont font(fnt); + Buffer const * buf = bv->buffer(); + LyXFont font = getFont(buf, par, pos); + font.update(fnt, toggleall); // Let the insets convert their font - if (par->GetChar(pos) == LyXParagraph::META_INSET) { - if (par->GetInset(pos)) - font = par->GetInset(pos)->ConvertFont(font); + if (par->getChar(pos) == Paragraph::META_INSET) { + Inset * inset = par->getInset(pos); + if (inset) { + if (inset->editable()==Inset::IS_EDITABLE) { + UpdatableInset * uinset = + static_cast(inset); + uinset->setFont(bv, fnt, toggleall, true); + } + font = inset->convertFont(font); + } } LyXLayout const & layout = - textclasslist.Style(buffer->params.textclass, - par->GetLayout()); + textclasslist.Style(buf->params.textclass, + par->getLayout()); // Get concrete layout font to reduce against LyXFont layoutfont; - if (pos < BeginningOfMainBody(par)) + if (pos < beginningOfMainBody(buf, par)) layoutfont = layout.labelfont; else layoutfont = layout.font; // Realize against environment font information - if (par->GetDepth()){ - LyXParagraph * tp = par; - while (!layoutfont.resolved() && tp && tp->GetDepth()) { - tp = tp->DepthHook(tp->GetDepth()-1); + if (par->getDepth()){ + Paragraph * tp = par; + while (!layoutfont.resolved() && tp && tp->getDepth()) { + tp = tp->outerHook(); if (tp) layoutfont.realize(textclasslist. - Style(buffer->params.textclass, - tp->GetLayout()).font); + Style(buf->params.textclass, + tp->getLayout()).font, + buf->params.language); } } - layoutfont.realize(textclasslist.TextClass(buffer->params.textclass).defaultfont()); + layoutfont.realize(textclasslist.TextClass(buf->params.textclass).defaultfont(), + buf->params.language); + + // Now, reduce font against full layout font + font.reduce(layoutfont); + + par->setFont(pos, font); +} + + +void LyXText::setCharFont(Buffer const * buf, Paragraph * par, + Paragraph::size_type pos, LyXFont const & fnt) +{ + LyXFont font(fnt); + // Let the insets convert their font + if (par->getChar(pos) == Paragraph::META_INSET) { + font = par->getInset(pos)->convertFont(font); + } + + 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; - if (par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE - && par->footnotekind == LyXParagraph::FOOTNOTE) { - layoutfont.decSize(); + // Realize against environment font information + if (par->getDepth()){ + Paragraph * tp = par; + while (!layoutfont.resolved() && tp && tp->getDepth()) { + tp = tp->outerHook(); + if (tp) + layoutfont.realize(textclasslist. + Style(buf->params.textclass, + tp->getLayout()).font, + buf->params.language); + } } + layoutfont.realize(textclasslist.TextClass(buf->params.textclass).defaultfont(), + buf->params.language); + // Now, reduce font against full layout font font.reduce(layoutfont); - par->SetFont(pos, font); + par->setFont(pos, font); } -/* inserts a new row behind the specified row, increments - * the touched counters */ -void LyXText::InsertRow(Row * row, LyXParagraph * par, - LyXParagraph::size_type pos) const +// inserts a new row behind the specified row, increments +// the touched counters +void LyXText::insertRow(Row * row, Paragraph * par, + Paragraph::size_type pos) const { Row * tmprow = new Row; if (!row) { - tmprow->previous = 0; - tmprow->next = firstrow; + tmprow->previous(0); + tmprow->next(firstrow); firstrow = tmprow; } else { - tmprow->previous = row; - tmprow->next = row->next; - row->next = tmprow; + tmprow->previous(row); + tmprow->next(row->next()); + row->next(tmprow); } - if (tmprow->next) - tmprow->next->previous = tmprow; + if (tmprow->next()) + tmprow->next()->previous(tmprow); - if (tmprow->previous) - tmprow->previous->next = tmprow; + if (tmprow->previous()) + tmprow->previous()->next(tmprow); - tmprow->par = par; - tmprow->pos = pos; + tmprow->par(par); + tmprow->pos(pos); if (row == lastrow) lastrow = tmprow; - ++number_of_rows; // one more row + ++number_of_rows; } // removes the row and reset the touched counters -void LyXText::RemoveRow(Row * row) const +void LyXText::removeRow(Row * row) const { /* this must not happen before the currentrow for clear reasons. so the trick is just to set the current row onto the previous row of this row */ - long unused_y; - GetRow(row->par, row->pos, unused_y); + int unused_y; + getRow(row->par(), row->pos(), unused_y); - if (row->next) - row->next->previous = row->previous; - if (!row->previous) { - firstrow = row->next; + if (row->next()) + row->next()->previous(row->previous()); + if (!row->previous()) { + firstrow = row->next(); } else { - row->previous->next = row->next; + row->previous()->next(row->next()); } if (row == lastrow) - lastrow = row->previous; + lastrow = row->previous(); - height -= row->height; // the text becomes smaller + height -= row->height(); // the text becomes smaller delete row; --number_of_rows; // one row less @@ -314,496 +346,348 @@ void LyXText::RemoveRow(Row * row) const // remove all following rows of the paragraph of the specified row. -void LyXText::RemoveParagraph(Row * row) const +void LyXText::removeParagraph(Row * row) const { - LyXParagraph * tmppar = row->par; - row = row->next; + Paragraph * tmppar = row->par(); + row = row->next(); Row * tmprow; - while (row && row->par == tmppar) { - tmprow = row->next; - RemoveRow(row); + while (row && row->par() == tmppar) { + tmprow = row->next(); + removeRow(row); row = tmprow; } } // insert the specified paragraph behind the specified row -void LyXText::InsertParagraph(LyXParagraph * par, Row * row) const +void LyXText::insertParagraph(BufferView * bview, Paragraph * par, + 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(par); // set the counters + setCounter(bview->buffer(), par); // set the counters // and now append the whole paragraph behind the new row if (!row) { - firstrow->height = 0; - AppendParagraph(firstrow); + firstrow->height(0); + appendParagraph(bview, firstrow); } else { - row->next->height = 0; - AppendParagraph(row->next); - } -} - - -void LyXText::ToggleFootnote() -{ - LyXParagraph * par = cursor.par->ParFromPos(cursor.pos); - if (par->next - && par->next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { - OpenFootnote(); - owner_->owner()->getMiniBuffer()->Set(_("Opened float")); - } else { - owner_->owner()->getMiniBuffer()->Set(_("Closed float")); - CloseFootnote(); + row->next()->height(0); + appendParagraph(bview, row->next()); } } -void LyXText::OpenStuff() +Inset * LyXText::getInset() const { - if (cursor.pos == 0 && cursor.par->bibkey){ - cursor.par->bibkey->Edit(owner_, 0, 0, 0); - } - else if (cursor.pos < cursor.par->Last() - && cursor.par->GetChar(cursor.pos) == LyXParagraph::META_INSET - && cursor.par->GetInset(cursor.pos)->Editable()) { - owner_->owner()->getMiniBuffer() - ->Set(cursor.par->GetInset(cursor.pos)->EditMessage()); - if (cursor.par->GetInset(cursor.pos)->Editable() != Inset::HIGHLY_EDITABLE) - SetCursorParUndo(); - cursor.par->GetInset(cursor.pos)->Edit(owner_, 0, 0, 0); - } else { - ToggleFootnote(); + 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::CloseFootnote() +void LyXText::toggleInset(BufferView * bview) { - LyXParagraph * tmppar; - LyXParagraph * par = cursor.par->ParFromPos(cursor.pos); - - // if the cursor is not in an open footnote, or - // there is no open footnote in this paragraph, just return. - if (cursor.par->footnoteflag != LyXParagraph::OPEN_FOOTNOTE) { - - if (!par->next || - par->next->footnoteflag != LyXParagraph::OPEN_FOOTNOTE) { - owner_->owner()->getMiniBuffer() - ->Set(_("Nothing to do")); - return; - } - - // ok, move the cursor right before the footnote - // just a little faster than using CursorRight() - for (cursor.pos = 0; - cursor.par->ParFromPos(cursor.pos) != par; - cursor.pos++) - {} - - // now the cursor is at the beginning of the physical par - SetCursor(cursor.par, - cursor.pos + - cursor.par->ParFromPos(cursor.pos)->size()); - } else { - /* we are in a footnote, so let us move at the beginning */ - /* this is just faster than using just CursorLeft() */ - - tmppar = cursor.par; - while (tmppar->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) { - // just a little bit faster than movin the cursor - tmppar = tmppar->Previous(); - } - SetCursor(tmppar, tmppar->Last()); - } - - // the cursor must be exactly before the footnote - par = cursor.par->ParFromPos(cursor.pos); - - status = LyXText::NEED_MORE_REFRESH; - refresh_row = cursor.row; - refresh_y = cursor.y - cursor.row->baseline; - - tmppar = cursor.par; - LyXParagraph * endpar = par->NextAfterFootnote()->Next(); - Row * row = cursor.row; - - tmppar->CloseFootnote(cursor.pos); + Inset * inset = getInset(); + if (!inset->editable()) + return; + //bview->owner()->message(inset->editMessage()); - while (tmppar != endpar) { - RemoveRow(row->next); - if (row->next) - tmppar = row->next->par; - else - tmppar = 0; + // 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); } - - AppendParagraph(cursor.row); - - SetCursor(cursor.par, cursor.pos); - sel_cursor = cursor; - - // just necessary - if (cursor.row->next) - SetHeightOfRow(cursor.row->next); +#if 0 + inset->open(bview, !inset->isOpen()); +#endif } /* used in setlayout */ // Asger is not sure we want to do this... -void LyXText::MakeFontEntriesLayoutSpecific(LyXParagraph * par) +void LyXText::makeFontEntriesLayoutSpecific(Buffer const * buf, + Paragraph * par) { - LyXLayout const & layout = - textclasslist.Style(buffer->params.textclass, - par->GetLayout()); + textclasslist.Style(buf->params.textclass, par->getLayout()); - LyXFont layoutfont, tmpfont; - for (LyXParagraph::size_type pos = 0; - pos < par->Last(); ++pos) { - if (pos < BeginningOfMainBody(par)) + 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(pos); + LyXFont tmpfont = par->getFontSettings(buf->params, pos); tmpfont.reduce(layoutfont); - par->SetFont(pos, tmpfont); + par->setFont(pos, tmpfont); } } -LyXParagraph * LyXText::SetLayout(LyXCursor & cur, LyXCursor & sstart_cur, - LyXCursor & send_cur, - LyXTextClass::size_type layout) -{ - LyXParagraph * endpar = send_cur.par->LastPhysicalPar()->Next(); - LyXParagraph * undoendpar = endpar; - if (endpar && endpar->GetDepth()) { - while (endpar && endpar->GetDepth()) { - endpar = endpar->LastPhysicalPar()->Next(); +Paragraph * LyXText::setLayout(BufferView * bview, + LyXCursor & cur, LyXCursor & sstart_cur, + LyXCursor & send_cur, + LyXTextClass::size_type layout) +{ + Paragraph * endpar = send_cur.par()->next(); + Paragraph * undoendpar = endpar; + + if (endpar && endpar->getDepth()) { + while (endpar && endpar->getDepth()) { + endpar = endpar->next(); undoendpar = endpar; } } else if (endpar) { - endpar = endpar->Next(); // because of parindents etc. + endpar = endpar->next(); // because of parindents etc. } - - SetUndo(Undo::EDIT, - sstart_cur.par->ParFromPos(sstart_cur.pos)->previous, - undoendpar); - - /* ok we have a selection. This is always between sstart_cur - * and sel_end cursor */ + + 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(buffer->params.textclass, layout); - - while (cur.par != send_cur.par) { - if (cur.par->footnoteflag == sstart_cur.par->footnoteflag) { - cur.par->SetLayout(layout); - MakeFontEntriesLayoutSpecific(cur.par); - LyXParagraph* fppar = cur.par->FirstPhysicalPar(); - fppar->added_space_top = lyxlayout.fill_top ? - VSpace(VSpace::VFILL) : VSpace(VSpace::NONE); - fppar->added_space_bottom = lyxlayout.fill_bottom ? - VSpace(VSpace::VFILL) : VSpace(VSpace::NONE); - if (lyxlayout.margintype == MARGIN_MANUAL) - cur.par->SetLabelWidthString(lyxlayout.labelstring()); - if (lyxlayout.labeltype != LABEL_BIBLIO - && fppar->bibkey) { - delete fppar->bibkey; - fppar->bibkey = 0; - } - } - cur.par = cur.par->Next(); - } - if (cur.par->footnoteflag == sstart_cur.par->footnoteflag) { - cur.par->SetLayout(layout); - MakeFontEntriesLayoutSpecific(cur.par); - LyXParagraph* fppar = cur.par->FirstPhysicalPar(); - fppar->added_space_top = lyxlayout.fill_top ? - VSpace(VSpace::VFILL) : VSpace(VSpace::NONE); - fppar->added_space_bottom = lyxlayout.fill_bottom ? - VSpace(VSpace::VFILL) : VSpace(VSpace::NONE); + textclasslist.Style(bview->buffer()->params.textclass, layout); + + while (cur.par() != send_cur.par()) { + cur.par()->setLayout(layout); + makeFontEntriesLayoutSpecific(bview->buffer(), cur.par()); + Paragraph * fppar = cur.par(); + fppar->params().spaceTop(lyxlayout.fill_top ? + VSpace(VSpace::VFILL) + : VSpace(VSpace::NONE)); + fppar->params().spaceBottom(lyxlayout.fill_bottom ? + VSpace(VSpace::VFILL) + : VSpace(VSpace::NONE)); if (lyxlayout.margintype == MARGIN_MANUAL) - cur.par->SetLabelWidthString(lyxlayout.labelstring()); + cur.par()->setLabelWidthString(lyxlayout.labelstring()); if (lyxlayout.labeltype != LABEL_BIBLIO && fppar->bibkey) { delete fppar->bibkey; fppar->bibkey = 0; } + cur.par(cur.par()->next()); + } + cur.par()->setLayout(layout); + makeFontEntriesLayoutSpecific(bview->buffer(), cur.par()); + Paragraph * fppar = cur.par(); + fppar->params().spaceTop(lyxlayout.fill_top ? + VSpace(VSpace::VFILL) : VSpace(VSpace::NONE)); + fppar->params().spaceBottom(lyxlayout.fill_bottom ? + VSpace(VSpace::VFILL) : VSpace(VSpace::NONE)); + if (lyxlayout.margintype == MARGIN_MANUAL) + cur.par()->setLabelWidthString(lyxlayout.labelstring()); + if (lyxlayout.labeltype != LABEL_BIBLIO + && fppar->bibkey) { + delete fppar->bibkey; + fppar->bibkey = 0; } return endpar; } + // set layout over selection and make a total rebreak of those paragraphs -void LyXText::SetLayout(LyXTextClass::size_type layout) +void LyXText::setLayout(BufferView * bview, LyXTextClass::size_type layout) { - LyXCursor - tmpcursor = cursor; /* store the current cursor */ - -#ifdef USE_OLD_SET_LAYOUT - // if there is no selection just set the layout - // of the current paragraph */ - if (!selection) { - sel_start_cursor = cursor; // dummy selection - sel_end_cursor = cursor; - } - - LyXParagraph * endpar = sel_end_cursor.par->LastPhysicalPar()->Next(); - LyXParagraph * undoendpar = endpar; + LyXCursor tmpcursor = cursor; /* store the current cursor */ - if (endpar && endpar->GetDepth()) { - while (endpar && endpar->GetDepth()) { - endpar = endpar->LastPhysicalPar()->Next(); - undoendpar = endpar; - } - } - else if (endpar) { - endpar = endpar->Next(); // because of parindents etc. - } - - SetUndo(Undo::EDIT, - sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->previous, - undoendpar); - - /* ok we have a selection. This is always between sel_start_cursor - * and sel_end cursor */ - cursor = sel_start_cursor; - - LyXLayout const & lyxlayout = - textclasslist.Style(buffer->params.textclass, layout); - - while (cursor.par != sel_end_cursor.par) { - if (cursor.par->footnoteflag == - sel_start_cursor.par->footnoteflag) { - cursor.par->SetLayout(layout); - MakeFontEntriesLayoutSpecific(cursor.par); - LyXParagraph* fppar = cursor.par->FirstPhysicalPar(); - fppar->added_space_top = lyxlayout.fill_top ? - VSpace(VSpace::VFILL) : VSpace(VSpace::NONE); - fppar->added_space_bottom = lyxlayout.fill_bottom ? - VSpace(VSpace::VFILL) : VSpace(VSpace::NONE); - if (lyxlayout.margintype == MARGIN_MANUAL) - cursor.par->SetLabelWidthString(lyxlayout.labelstring()); - if (lyxlayout.labeltype != LABEL_BIBLIO - && fppar->bibkey) { - delete fppar->bibkey; - fppar->bibkey = 0; - } - } - cursor.par = cursor.par->Next(); - } - if (cursor.par->footnoteflag == - sel_start_cursor.par->footnoteflag) { - cursor.par->SetLayout(layout); - MakeFontEntriesLayoutSpecific(cursor.par); - LyXParagraph* fppar = cursor.par->FirstPhysicalPar(); - fppar->added_space_top = lyxlayout.fill_top ? - VSpace(VSpace::VFILL) : VSpace(VSpace::NONE); - fppar->added_space_bottom = lyxlayout.fill_bottom ? - VSpace(VSpace::VFILL) : VSpace(VSpace::NONE); - if (lyxlayout.margintype == MARGIN_MANUAL) - cursor.par->SetLabelWidthString(lyxlayout.labelstring()); - if (lyxlayout.labeltype != LABEL_BIBLIO - && fppar->bibkey) { - delete fppar->bibkey; - fppar->bibkey = 0; - } - } -#else // if there is no selection just set the layout // of the current paragraph */ - if (!selection) { - sel_start_cursor = cursor; // dummy selection - sel_end_cursor = cursor; + if (!selection.set()) { + selection.start = cursor; // dummy selection + selection.end = cursor; } - LyXParagraph * - endpar = SetLayout(cursor, sel_start_cursor, sel_end_cursor, layout); -#endif - RedoParagraphs(sel_start_cursor, endpar); + 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(sel_start_cursor.par, sel_start_cursor.pos, false); - sel_cursor = cursor; - SetCursor(sel_end_cursor.par, sel_end_cursor.pos, false); - UpdateCounters(cursor.row); - ClearSelection(); - SetSelection(); - SetCursor(tmpcursor.par, tmpcursor.pos, true); + // 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()); + clearSelection(); + setSelection(bview); + setCursor(bview, tmpcursor.par(), tmpcursor.pos(), true); } // increment depth over selection and // make a total rebreak of those paragraphs -void LyXText::IncDepth() +void LyXText::incDepth(BufferView * bview) { // If there is no selection, just use the current paragraph - if (!selection) { - sel_start_cursor = cursor; // dummy selection - sel_end_cursor = cursor; + if (!selection.set()) { + selection.start = cursor; // dummy selection + selection.end = cursor; } // We end at the next paragraph with depth 0 - LyXParagraph * endpar = sel_end_cursor.par->LastPhysicalPar()->Next(); - LyXParagraph * undoendpar = endpar; + Paragraph * endpar = selection.end.par()->next(); + + Paragraph * undoendpar = endpar; - if (endpar && endpar->GetDepth()) { - while (endpar && endpar->GetDepth()) { - endpar = endpar->LastPhysicalPar()->Next(); + if (endpar && endpar->getDepth()) { + while (endpar && endpar->getDepth()) { + endpar = endpar->next(); undoendpar = endpar; } - } - else if (endpar) { - endpar = endpar->Next(); // because of parindents etc. + } else if (endpar) { + endpar = endpar->next(); // because of parindents etc. } - SetUndo(Undo::EDIT, - sel_start_cursor - .par->ParFromPos(sel_start_cursor.pos)->previous, - undoendpar); + setUndo(bview, Undo::EDIT, + selection.start.par(), undoendpar); LyXCursor tmpcursor = cursor; // store the current cursor // ok we have a selection. This is always between sel_start_cursor // and sel_end cursor - cursor = sel_start_cursor; + cursor = selection.start; bool anything_changed = false; while (true) { // NOTE: you can't change the depth of a bibliography entry - if (cursor.par->footnoteflag == - sel_start_cursor.par->footnoteflag - && textclasslist.Style(buffer->params.textclass, - cursor.par->GetLayout() - ).labeltype != LABEL_BIBLIO) { - LyXParagraph * prev = - cursor.par->FirstPhysicalPar()->Previous(); + if ( + 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(buffer->params.textclass, - prev->GetLayout()).isEnvironment()))) { - cursor.par->FirstPhysicalPar()->depth++; + && (prev->getDepth() - cursor.par()->getDepth() > 0 + || (prev->getDepth() == cursor.par()->getDepth() + && textclasslist.Style(bview->buffer()->params.textclass, + prev->getLayout()).isEnvironment()))) { + cursor.par()->params().depth(cursor.par()->params().depth() + 1); anything_changed = true; - } + } } - if (cursor.par == sel_end_cursor.par) - break; - cursor.par = cursor.par->Next(); + if (cursor.par() == selection.end.par()) + break; + cursor.par(cursor.par()->next()); } // if nothing changed set all depth to 0 if (!anything_changed) { - cursor = sel_start_cursor; - while (cursor.par != sel_end_cursor.par) { - cursor.par->FirstPhysicalPar()->depth = 0; - cursor.par = cursor.par->Next(); + cursor = selection.start; + while (cursor.par() != selection.end.par()) { + cursor.par()->params().depth(0); + cursor.par(cursor.par()->next()); } - if (cursor.par->footnoteflag == sel_start_cursor.par->footnoteflag) - cursor.par->FirstPhysicalPar()->depth = 0; + cursor.par()->params().depth(0); } - RedoParagraphs(sel_start_cursor, endpar); + redoParagraphs(bview, selection.start, endpar); // we have to reset the selection, because the // geometry could have changed - SetCursor(sel_start_cursor.par, sel_start_cursor.pos); - sel_cursor = cursor; - SetCursor(sel_end_cursor.par, sel_end_cursor.pos); - UpdateCounters(cursor.row); - ClearSelection(); - SetSelection(); - SetCursor(tmpcursor.par, tmpcursor.pos); + setCursor(bview, selection.start.par(), selection.start.pos()); + selection.cursor = cursor; + setCursor(bview, selection.end.par(), selection.end.pos()); + updateCounters(bview, cursor.row()); + clearSelection(); + setSelection(bview); + setCursor(bview, tmpcursor.par(), tmpcursor.pos()); } // decrement depth over selection and // make a total rebreak of those paragraphs -void LyXText::DecDepth() +void LyXText::decDepth(BufferView * bview) { // if there is no selection just set the layout // of the current paragraph - if (!selection) { - sel_start_cursor = cursor; // dummy selection - sel_end_cursor = cursor; + if (!selection.set()) { + selection.start = cursor; // dummy selection + selection.end = cursor; } - - LyXParagraph * endpar = sel_end_cursor.par->LastPhysicalPar()->Next(); - LyXParagraph * undoendpar = endpar; + Paragraph * endpar = selection.end.par()->next(); + Paragraph * undoendpar = endpar; - if (endpar && endpar->GetDepth()) { - while (endpar && endpar->GetDepth()) { - endpar = endpar->LastPhysicalPar()->Next(); + if (endpar && endpar->getDepth()) { + while (endpar && endpar->getDepth()) { + endpar = endpar->next(); undoendpar = endpar; } - } - else if (endpar) { - endpar = endpar->Next(); // because of parindents etc. + } else if (endpar) { + endpar = endpar->next(); // because of parindents etc. } - SetUndo(Undo::EDIT, - sel_start_cursor - .par->ParFromPos(sel_start_cursor.pos)->previous, - undoendpar); + setUndo(bview, Undo::EDIT, + selection.start.par(), undoendpar); LyXCursor tmpcursor = cursor; // store the current cursor // ok we have a selection. This is always between sel_start_cursor // and sel_end cursor - cursor = sel_start_cursor; + cursor = selection.start; while (true) { - if (cursor.par->footnoteflag == - sel_start_cursor.par->footnoteflag) { - if (cursor.par->FirstPhysicalPar()->depth) - cursor.par->FirstPhysicalPar()->depth--; + if (cursor.par()->params().depth()) { + cursor.par()->params() + .depth(cursor.par()->params().depth() - 1); } - if (cursor.par == sel_end_cursor.par) + if (cursor.par() == selection.end.par()) { break; - cursor.par = cursor.par->Next(); + } + cursor.par(cursor.par()->next()); } - RedoParagraphs(sel_start_cursor, endpar); + redoParagraphs(bview, selection.start, endpar); // we have to reset the selection, because the // geometry could have changed - SetCursor(sel_start_cursor.par, sel_start_cursor.pos); - sel_cursor = cursor; - SetCursor(sel_end_cursor.par, sel_end_cursor.pos); - UpdateCounters(cursor.row); - ClearSelection(); - SetSelection(); - SetCursor(tmpcursor.par, tmpcursor.pos); + setCursor(bview, selection.start.par(), + selection.start.pos()); + selection.cursor = cursor; + setCursor(bview, selection.end.par(), selection.end.pos()); + updateCounters(bview, cursor.row()); + clearSelection(); + setSelection(bview); + setCursor(bview, tmpcursor.par(), tmpcursor.pos()); } // set font over selection and make a total rebreak of those paragraphs -void LyXText::SetFont(LyXFont const & font, bool toggleall) +void LyXText::setFont(BufferView * bview, LyXFont const & font, bool toggleall) { // if there is no selection just set the current_font - if (!selection) { + if (!selection.set()) { // Determine basis font LyXFont layoutfont; - if (cursor.pos < BeginningOfMainBody(cursor.par)) - layoutfont = GetFont(cursor.par, -2); + if (cursor.pos() < beginningOfMainBody(bview->buffer(), + cursor.par())) + layoutfont = getFont(bview->buffer(), cursor.par(),-2); else - layoutfont = GetFont(cursor.par, -1); + layoutfont = getFont(bview->buffer(), cursor.par(),-1); // Update current font - real_current_font.update(font, - buffer->params.language_info, - 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; } @@ -812,189 +696,178 @@ void LyXText::SetFont(LyXFont const & font, bool toggleall) // ok we have a selection. This is always between sel_start_cursor // and sel_end cursor - SetUndo(Undo::EDIT, - sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->previous, - sel_end_cursor.par->ParFromPos(sel_end_cursor.pos)->next); - cursor = sel_start_cursor; - while (cursor.par != sel_end_cursor.par || - (cursor.par->footnoteflag == sel_start_cursor.par->footnoteflag - && cursor.pos < sel_end_cursor.pos)) - { - if (cursor.pos < cursor.par->Last() - && cursor.par->footnoteflag - == sel_start_cursor.par->footnoteflag) { + setUndo(bview, Undo::EDIT, + selection.start.par(), + selection.end.par()->next()); + freezeUndo(); + cursor = selection.start; + while (cursor.par() != selection.end.par() || + (cursor.pos() < selection.end.pos())) { + if (cursor.pos() < cursor.par()->size()) { // an open footnote should behave // like a closed one - LyXFont newfont = GetFont(cursor.par, cursor.pos); - newfont.update(font, - buffer->params.language_info, - toggleall); - SetCharFont(cursor.par, cursor.pos, newfont); - cursor.pos++; + setCharFont(bview, cursor.par(), cursor.pos(), + font, toggleall); + cursor.pos(cursor.pos() + 1); } else { - cursor.pos = 0; - cursor.par = cursor.par->Next(); + cursor.pos(0); + cursor.par(cursor.par()->next()); } } + unFreezeUndo(); - RedoParagraphs(sel_start_cursor, sel_end_cursor.par->Next()); + redoParagraphs(bview, selection.start, selection.end.par()->next()); // we have to reset the selection, because the // geometry could have changed - SetCursor(sel_start_cursor.par, sel_start_cursor.pos); - sel_cursor = cursor; - SetCursor(sel_end_cursor.par, sel_end_cursor.pos); - ClearSelection(); - SetSelection(); - SetCursor(tmpcursor.par, tmpcursor.pos); + setCursor(bview, selection.start.par(), selection.start.pos()); + selection.cursor = cursor; + setCursor(bview, selection.end.par(), selection.end.pos()); + clearSelection(); + setSelection(bview); + setCursor(bview, tmpcursor.par(), tmpcursor.pos(), true, + tmpcursor.boundary()); } -void LyXText::RedoHeightOfParagraph(LyXCursor const & cur) +void LyXText::redoHeightOfParagraph(BufferView * bview, LyXCursor const & cur) { - Row * tmprow = cur.row; - long y = cur.y - tmprow->baseline; - - SetHeightOfRow(tmprow); - LyXParagraph * first_phys_par = tmprow->par->FirstPhysicalPar(); - // 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(tmprow); - } - while (tmprow->previous && tmprow->previous->par == first_phys_par) { - tmprow = tmprow->previous; - y -= tmprow->height; - SetHeightOfRow(tmprow); + Row * tmprow = cur.row(); + 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 = LyXText::NEED_MORE_REFRESH; + status(bview, LyXText::NEED_MORE_REFRESH); refresh_y = y; refresh_row = tmprow; - SetCursor(cur.par, cur.pos); + setCursor(bview, cur.par(), cur.pos(), false, cursor.boundary()); } -void LyXText::RedoDrawingOfParagraph(LyXCursor const & cur) +void LyXText::redoDrawingOfParagraph(BufferView * bview, LyXCursor const & cur) { - Row * tmprow = cur.row; + Row * tmprow = cur.row(); - long y = cur.y - tmprow->baseline; - SetHeightOfRow(tmprow); - LyXParagraph * first_phys_par = tmprow->par->FirstPhysicalPar(); - // 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; + int y = cur.y() - tmprow->baseline(); + setHeightOfRow(bview, tmprow); + + while (tmprow->previous() + && tmprow->previous()->par() == tmprow->par()) { + tmprow = tmprow->previous(); + y -= tmprow->height(); } - + // we can set the refreshing parameters now - if (status == LyXText::UNCHANGED || y < refresh_y) { + if (status_ == LyXText::UNCHANGED || y < refresh_y) { refresh_y = y; refresh_row = tmprow; } - status = LyXText::NEED_MORE_REFRESH; - SetCursor(cur.par, cur.pos); + status(bview, LyXText::NEED_MORE_REFRESH); + setCursor(bview, cur.par(), cur.pos()); } -/* 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(LyXCursor const & cur, - LyXParagraph const * endpar) const +// 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 { Row * tmprow2; - LyXParagraph * tmppar, * first_phys_par; + Paragraph * tmppar = 0; + Paragraph * first_phys_par = 0; - Row * tmprow = cur.row; + Row * tmprow = cur.row(); - long y = cur.y - tmprow->baseline; - - if (!tmprow->previous){ - first_phys_par = FirstParagraph(); // a trick/hack for UNDO + int y = cur.y() - tmprow->baseline(); + + if (!tmprow->previous()) { + // a trick/hack for UNDO + // Can somebody please tell me _why_ this solves + // anything. (Lgb) + first_phys_par = firstParagraph(); } else { - first_phys_par = tmprow->par->FirstPhysicalPar(); - // 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; + first_phys_par = tmprow->par(); + while (tmprow->previous() + && tmprow->previous()->par() == first_phys_par) + { + tmprow = tmprow->previous(); + y -= tmprow->height(); } } - + // we can set the refreshing parameters now - status = LyXText::NEED_MORE_REFRESH; + 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 */ + refresh_row = tmprow->previous(); /* the real refresh row will + be deleted, so I store + the previous here */ // remove it - if (tmprow->next) - tmppar = tmprow->next->par; + if (tmprow->next()) + tmppar = tmprow->next()->par(); else tmppar = 0; while (tmppar != endpar) { - RemoveRow(tmprow->next); - if (tmprow->next) - tmppar = tmprow->next->par; + removeRow(tmprow->next()); + if (tmprow->next()) + tmppar = tmprow->next()->par(); else tmppar = 0; } // remove the first one - tmprow2 = tmprow; /* this is because tmprow->previous - can be 0 */ - tmprow = tmprow->previous; - RemoveRow(tmprow2); + tmprow2 = tmprow; /* this is because tmprow->previous() + can be 0 */ + tmprow = tmprow->previous(); + removeRow(tmprow2); tmppar = first_phys_par; do { if (tmppar) { - InsertParagraph(tmppar, tmprow); - if (!tmprow) + insertParagraph(bview, tmppar, tmprow); + if (!tmprow) { tmprow = firstrow; - while (tmprow->next && tmprow->next->par == tmppar) - tmprow = tmprow->next; - tmppar = tmppar->Next(); + } + while (tmprow->next() + && tmprow->next()->par() == tmppar) { + tmprow = tmprow->next(); + } + tmppar = tmppar->next(); } - } while (tmppar != endpar); + } while (tmppar && tmppar != endpar); // this is because of layout changes if (refresh_row) { - refresh_y -= refresh_row->height; - SetHeightOfRow(refresh_row); + refresh_y -= refresh_row->height(); + setHeightOfRow(bview, refresh_row); } else { refresh_row = firstrow; refresh_y = 0; - SetHeightOfRow(refresh_row); + setHeightOfRow(bview, refresh_row); } - if (tmprow && tmprow->next) - SetHeightOfRow(tmprow->next); + if (tmprow && tmprow->next()) + setHeightOfRow(bview, tmprow->next()); } -bool LyXText::FullRebreak() +bool LyXText::fullRebreak(BufferView * bview) { + if (!firstrow) { + init(bview); + return true; + } if (need_break_row) { - BreakAgain(need_break_row); + breakAgain(bview, need_break_row); need_break_row = 0; return true; } @@ -1002,7 +875,7 @@ bool LyXText::FullRebreak() } -/* important for the screen */ +// important for the screen /* the cursor set functions have a special mechanism. When they @@ -1010,20 +883,22 @@ bool LyXText::FullRebreak() * They also delete the corresponding row */ // need the selection cursor: -void LyXText::SetSelection() +void LyXText::setSelection(BufferView * bview) { - if (!selection) { - last_sel_cursor = sel_cursor; - sel_start_cursor = sel_cursor; - sel_end_cursor = sel_cursor; + bool const lsel = selection.set(); + + if (!selection.set()) { + last_sel_cursor = selection.cursor; + selection.start = selection.cursor; + selection.end = selection.cursor; } - selection = true; + selection.set(true); // first the toggling area - if (cursor.y < last_sel_cursor.y - || (cursor.y == last_sel_cursor.y - && cursor.x < last_sel_cursor.x)) { + if (cursor.y() < last_sel_cursor.y() + || (cursor.y() == last_sel_cursor.y() + && cursor.x() < last_sel_cursor.x())) { toggle_end_cursor = last_sel_cursor; toggle_cursor = cursor; } else { @@ -1035,161 +910,128 @@ void LyXText::SetSelection() // and now the whole selection - if (sel_cursor.par == cursor.par) - if (sel_cursor.pos < cursor.pos) { - sel_end_cursor = cursor; - sel_start_cursor = sel_cursor; - } else { - sel_end_cursor = sel_cursor; - sel_start_cursor = cursor; - } - else if (sel_cursor.y < cursor.y || - (sel_cursor.y == cursor.y && sel_cursor.x < cursor.x)) { - sel_end_cursor = cursor; - sel_start_cursor = sel_cursor; + 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; + } + else if (selection.cursor.y() < cursor.y() || + (selection.cursor.y() == cursor.y() + && selection.cursor.x() < cursor.x())) { + selection.end = cursor; + selection.start = selection.cursor; } else { - sel_end_cursor = sel_cursor; - sel_start_cursor = cursor; + selection.end = selection.cursor; + selection.start = cursor; } // a selection with no contents is not a selection - if (sel_start_cursor.x == sel_end_cursor.x && - sel_start_cursor.y == sel_end_cursor.y) - selection = false; - - // Stuff what we got on the clipboard. Even if there is no selection. + if (selection.start.par() == selection.end.par() && + selection.start.pos() == selection.end.pos()) + selection.set(false); - // There is a problem with having the stuffing here in that the - // larger the selection the slower LyX will get. This can be - // solved by running the line below only when the selection has - // finished. The solution used currently just works, to make it - // faster we need to be more clever and probably also have more - // calls to stuffClipboard. (Lgb) - owner_->stuffClipboard(selectionAsString()); + if (inset_owner && (selection.set() || lsel)) + inset_owner->setUpdateStatus(bview, InsetText::SELECTION); } -string LyXText::selectionAsString() const +string const LyXText::selectionAsString(Buffer const * buffer) const { - if (!selection) return string(); + if (!selection.set()) return string(); string result; // Special handling if the whole selection is within one paragraph - if (sel_start_cursor.par == sel_end_cursor.par) { - result += sel_start_cursor.par->String(sel_start_cursor.pos, - sel_end_cursor.pos); + if (selection.start.par() == selection.end.par()) { + result += selection.start.par()->asString(buffer, + selection.start.pos(), + selection.end.pos()); return result; } // The selection spans more than one paragraph // First paragraph in selection - result += sel_start_cursor.par->String(sel_start_cursor.pos, - sel_start_cursor.par->Last()) + result += selection.start.par()->asString(buffer, + selection.start.pos(), + selection.start.par()->size()) + "\n\n"; // The paragraphs in between (if any) - LyXCursor tmpcur(sel_start_cursor); - tmpcur.par = tmpcur.par->Next(); - while (tmpcur.par != sel_end_cursor.par) { - result += tmpcur.par->String(0, tmpcur.par->Last()) + "\n\n"; - tmpcur.par = tmpcur.par->Next(); // Or NextAfterFootnote?? + 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()); } // Last paragraph in selection - result += sel_end_cursor.par->String(0, sel_end_cursor.pos); + result += selection.end.par()->asString(buffer, 0, + selection.end.pos()); return result; } -void LyXText::ClearSelection() const +void LyXText::clearSelection() const { - selection = false; - mark_set = false; + selection.set(false); + selection.mark(false); + selection.end = selection.start = selection.cursor = cursor; } -void LyXText::CursorHome() const +void LyXText::cursorHome(BufferView * bview) const { - SetCursor(cursor.par, cursor.row->pos); + setCursor(bview, cursor.par(), cursor.row()->pos()); } -void LyXText::CursorEnd() const +void LyXText::cursorEnd(BufferView * bview) const { - if (!cursor.row->next || cursor.row->next->par != cursor.row->par) - SetCursor(cursor.par, RowLast(cursor.row) + 1); - else { - if (cursor.par->Last() && - (cursor.par->GetChar(RowLast(cursor.row)) == ' ' - || cursor.par->IsNewline(RowLast(cursor.row)))) - SetCursor(cursor.par, RowLast(cursor.row)); - else - SetCursor(cursor.par, RowLast(cursor.row) + 1); + if (!cursor.row()->next() + || cursor.row()->next()->par() != cursor.row()->par()) { + setCursor(bview, cursor.par(), rowLast(cursor.row()) + 1); + } else { + if (cursor.par()->size() && + (cursor.par()->getChar(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); + } } - if (cursor.par->table) { - int cell = NumberOfCell(cursor.par, cursor.pos); - if (cursor.par->table->RowHasContRow(cell) && - cursor.par->table->CellHasContRow(cell)<0) { - if (!cursor.row->next || cursor.row->next->par != cursor.row->par) - SetCursor(cursor.par, RowLast(cursor.row) + 1); - else { - if (cursor.par->Last() && - (cursor.par->GetChar(RowLast(cursor.row)) == ' ' - || cursor.par->IsNewline(RowLast(cursor.row)))) - SetCursor(cursor.par, RowLast(cursor.row)); - else - SetCursor(cursor.par, RowLast(cursor.row) + 1); - } - } - } } -void LyXText::CursorTop() const +void LyXText::cursorTop(BufferView * bview) const { - while (cursor.par->Previous()) - cursor.par = cursor.par->Previous(); - SetCursor(cursor.par, 0); + while (cursor.par()->previous()) + cursor.par(cursor.par()->previous()); + setCursor(bview, cursor.par(), 0); } -void LyXText::CursorBottom() const +void LyXText::cursorBottom(BufferView * bview) const { - while (cursor.par->Next()) - cursor.par = cursor.par->Next(); - SetCursor(cursor.par, cursor.par->Last()); + while (cursor.par()->next()) + cursor.par(cursor.par()->next()); + setCursor(bview, cursor.par(), cursor.par()->size()); } -/* returns a pointer to the row near the specified y-coordinate -* (relative to the whole text). y is set to the real beginning -* of this row */ -Row * LyXText::GetRowNearY(long & y) const -{ - Row * tmprow = firstrow; - long tmpy = 0; - - while (tmprow->next && tmpy + tmprow->height <= y) { - tmpy += tmprow->height; - tmprow = tmprow->next; - } - - y = tmpy; // return the real y - return tmprow; -} - - -void LyXText::ToggleFree(LyXFont const & font, bool toggleall) +void LyXText::toggleFree(BufferView * bview, + LyXFont const & font, bool toggleall) { // If the mask is completely neutral, tell user if (font == LyXFont(LyXFont::ALL_IGNORE)) { // Could only happen with user style - owner_->owner()->getMiniBuffer() - ->Set(_("No font change defined. Use Character under" - " the Layout menu to define font change.")); + bview->owner()->message(_("No font change defined. Use Character under the Layout menu to define font change.")); return; } @@ -1197,126 +1039,68 @@ void LyXText::ToggleFree(LyXFont const & font, bool toggleall) // If there is a change in the language the implicit word selection // is disabled. LyXCursor resetCursor = cursor; - bool implicitSelection = (font.language() == ignore_language) - ? SelectWordWhenUnderCursor() : false; + bool implicitSelection = (font.language() == ignore_language + && font.number() == LyXFont::IGNORE) + ? selectWordWhenUnderCursor(bview, WHOLE_WORD_STRICT) : false; // Set font - SetFont(font, toggleall); + 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(); + clearSelection(); cursor = resetCursor; - SetCursor( cursor.par, cursor.pos ); - sel_cursor = cursor; + setCursor(bview, cursor.par(), cursor.pos()); + selection.cursor = cursor; } + if (inset_owner) + inset_owner->setUpdateStatus(bview, InsetText::CURSOR_PAR); } -LyXParagraph::size_type LyXText::BeginningOfMainBody(LyXParagraph * par) const -{ - if (textclasslist.Style(buffer->params.textclass, - par->GetLayout()).labeltype != LABEL_MANUAL) - return 0; - else - return par->BeginningOfMainBody(); -} - - -/* if there is a selection, reset every environment you can find -* in the selection, otherwise just the environment you are in */ -void LyXText::MeltFootnoteEnvironment() +string +LyXText::getStringToIndex(BufferView * bview) { - LyXParagraph * tmppar, * firsttmppar; - - ClearSelection(); - - /* is is only allowed, if the cursor is IN an open footnote. - * Otherwise it is too dangerous */ - if (cursor.par->footnoteflag != LyXParagraph::OPEN_FOOTNOTE) - return; - - SetUndo(Undo::FINISH, - cursor.par->PreviousBeforeFootnote()->previous, - cursor.par->NextAfterFootnote()->next); - - /* ok, move to the beginning of the footnote. */ - while (cursor.par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) - cursor.par = cursor.par->Previous(); - - SetCursor(cursor.par, cursor.par->Last()); - /* this is just faster than using CursorLeft(); */ - - firsttmppar = cursor.par->ParFromPos(cursor.pos); - tmppar = firsttmppar; - /* tmppar is now the paragraph right before the footnote */ + 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); - bool first_footnote_par_is_not_empty = tmppar->next->size(); - - while (tmppar->next - && tmppar->next->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) { - tmppar = tmppar->next; /* I use next instead of Next(), - * because there cannot be any - * footnotes in a footnote - * environment */ - tmppar->footnoteflag = LyXParagraph::NO_FOOTNOTE; - - /* remember the captions and empty paragraphs */ - if ((textclasslist.Style(buffer->params.textclass, - tmppar->GetLayout()) - .labeltype == LABEL_SENSITIVE) - || !tmppar->Last()) - tmppar->SetLayout(0); + if (!selection.set()) { + bview->owner()->message(_("Nothing to index!")); + return string(); } - - // now we will paste the ex-footnote, if the layouts allow it - // first restore the layout of the paragraph right behind - // the footnote - if (tmppar->next) - tmppar->next->MakeSameLayout(cursor.par); - - // first the end - if ((!tmppar->GetLayout() && !tmppar->table) - || (tmppar->Next() - && (!tmppar->Next()->Last() - || tmppar->Next()->HasSameLayout(tmppar)))) { - if (tmppar->Next()->Last() - && tmppar->Next()->IsLineSeparator(0)) - tmppar->Next()->Erase(0); - tmppar->PasteParagraph(); + if (selection.start.par() != selection.end.par()) { + bview->owner()->message(_("Cannot index more than one paragraph!")); + return string(); } - tmppar = tmppar->Next(); /* make sure tmppar cannot be touched - * by the pasting of the beginning */ - - /* then the beginning */ - /* if there is no space between the text and the footnote, so we insert - * a blank - * (only if the previous par and the footnotepar are not empty!) */ - if ((!firsttmppar->next->GetLayout() && !firsttmppar->next->table) - || firsttmppar->HasSameLayout(firsttmppar->next)) { - if (firsttmppar->size() - && !firsttmppar->IsSeparator(firsttmppar->size() - 1) - && first_footnote_par_is_not_empty) { - firsttmppar->next->InsertChar(0, ' '); - } - firsttmppar->PasteParagraph(); + 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; } - - /* now redo the paragaphs */ - RedoParagraphs(cursor, tmppar); - - SetCursor(cursor.par, cursor.pos); - - /* sometimes it can happen, that there is a counter change */ - Row * row = cursor.row; - while (row->next && row->par != tmppar && row->next->par != tmppar) - row = row->next; - UpdateCounters(row); - - - ClearSelection(); + return idxstring; +} + +Paragraph::size_type +LyXText::beginningOfMainBody(Buffer const * buf, + Paragraph const * par) const +{ + if (textclasslist.Style(buf->params.textclass, + par->getLayout()).labeltype != LABEL_MANUAL) + return 0; + else + return par->beginningOfMainBody(); } @@ -1326,7 +1110,8 @@ void LyXText::MeltFootnoteEnvironment() * they do not duplicate themself and you cannnot make dirty things with * them! */ -void LyXText::SetParagraph(bool line_top, bool line_bottom, +void LyXText::setParagraph(BufferView * bview, + bool line_top, bool line_bottom, bool pagebreak_top, bool pagebreak_bottom, VSpace const & space_top, VSpace const & space_bottom, @@ -1335,139 +1120,71 @@ void LyXText::SetParagraph(bool line_top, bool line_bottom, bool noindent) { LyXCursor tmpcursor = cursor; - if (!selection) { - sel_start_cursor = cursor; - sel_end_cursor = cursor; + if (!selection.set()) { + selection.start = cursor; + selection.end = cursor; } // make sure that the depth behind the selection are restored, too - LyXParagraph * endpar = sel_end_cursor.par->LastPhysicalPar()->Next(); - LyXParagraph * undoendpar = endpar; + Paragraph * endpar = selection.end.par()->next(); + Paragraph * undoendpar = endpar; - if (endpar && endpar->GetDepth()) { - while (endpar && endpar->GetDepth()) { - endpar = endpar->LastPhysicalPar()->Next(); + if (endpar && endpar->getDepth()) { + while (endpar && endpar->getDepth()) { + endpar = endpar->next(); undoendpar = endpar; } } else if (endpar) { - endpar = endpar->Next(); // because of parindents etc. + // because of parindents etc. + endpar = endpar->next(); } - SetUndo(Undo::EDIT, - sel_start_cursor - .par->ParFromPos(sel_start_cursor.pos)->previous, - undoendpar); + setUndo(bview, Undo::EDIT, selection.start.par(), undoendpar); - LyXParagraph * tmppar = sel_end_cursor.par; - while (tmppar != sel_start_cursor.par->FirstPhysicalPar()->Previous()) { - SetCursor(tmppar->FirstPhysicalPar(), 0); - status = LyXText::NEED_MORE_REFRESH; - refresh_row = cursor.row; - refresh_y = cursor.y - cursor.row->baseline; - if (cursor.par->footnoteflag == - sel_start_cursor.par->footnoteflag) { - cursor.par->line_top = line_top; - cursor.par->line_bottom = line_bottom; - cursor.par->pagebreak_top = pagebreak_top; - cursor.par->pagebreak_bottom = pagebreak_bottom; - cursor.par->added_space_top = space_top; - cursor.par->added_space_bottom = space_bottom; - // does the layout allow the new alignment? - if (align == LYX_ALIGN_LAYOUT) - align = textclasslist - .Style(buffer->params.textclass, - cursor.par->GetLayout()).align; - if (align & textclasslist - .Style(buffer->params.textclass, - cursor.par->GetLayout()).alignpossible) { - if (align == textclasslist - .Style(buffer->params.textclass, - cursor.par->GetLayout()).align) - cursor.par->align = LYX_ALIGN_LAYOUT; - else - cursor.par->align = align; - } - cursor.par->SetLabelWidthString(labelwidthstring); - cursor.par->noindent = noindent; + Paragraph * tmppar = selection.end.par(); + while (tmppar != selection.start.par()->previous()) { + setCursor(bview, tmppar, 0); + 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 + .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); } - - tmppar = cursor.par->FirstPhysicalPar()->Previous(); + cursor.par()->setLabelWidthString(labelwidthstring); + cursor.par()->params().noindent(noindent); + tmppar = cursor.par()->previous(); } - RedoParagraphs(sel_start_cursor, endpar); - - ClearSelection(); - SetCursor(sel_start_cursor.par, sel_start_cursor.pos); - sel_cursor = cursor; - SetCursor(sel_end_cursor.par, sel_end_cursor.pos); - SetSelection(); - SetCursor(tmpcursor.par, tmpcursor.pos); -} - - -void LyXText::SetParagraphExtraOpt(int type, - char const * width, - char const * widthp, - int alignment, bool hfill, - bool start_minipage) -{ - LyXCursor tmpcursor = cursor; - LyXParagraph * tmppar; - if (!selection) { - sel_start_cursor = cursor; - sel_end_cursor = cursor; - } - - // make sure that the depth behind the selection are restored, too - LyXParagraph * endpar = sel_end_cursor.par->LastPhysicalPar()->Next(); - LyXParagraph * undoendpar = endpar; - - if (endpar && endpar->GetDepth()) { - while (endpar && endpar->GetDepth()) { - endpar = endpar->LastPhysicalPar()->Next(); - undoendpar = endpar; - } - } - else if (endpar) { - endpar = endpar->Next(); // because of parindents etc. - } - - SetUndo(Undo::EDIT, - sel_start_cursor - .par->ParFromPos(sel_start_cursor.pos)->previous, - undoendpar); + redoParagraphs(bview, selection.start, endpar); - tmppar = sel_end_cursor.par; - while(tmppar != sel_start_cursor.par->FirstPhysicalPar()->Previous()) { - SetCursor(tmppar->FirstPhysicalPar(), 0); - status = LyXText::NEED_MORE_REFRESH; - refresh_row = cursor.row; - refresh_y = cursor.y - cursor.row->baseline; - if (cursor.par->footnoteflag == - sel_start_cursor.par->footnoteflag) { - if (type == LyXParagraph::PEXTRA_NONE) { - if (cursor.par->pextra_type != LyXParagraph::PEXTRA_NONE) { - cursor.par->UnsetPExtraType(); - cursor.par->pextra_type = LyXParagraph::PEXTRA_NONE; - } - } else { - cursor.par->SetPExtraType(type, width, widthp); - cursor.par->pextra_hfill = hfill; - cursor.par->pextra_start_minipage = start_minipage; - cursor.par->pextra_alignment = alignment; - } - } - tmppar = cursor.par->FirstPhysicalPar()->Previous(); - } - RedoParagraphs(sel_start_cursor, endpar); - ClearSelection(); - SetCursor(sel_start_cursor.par, sel_start_cursor.pos); - sel_cursor = cursor; - SetCursor(sel_end_cursor.par, sel_end_cursor.pos); - SetSelection(); - SetCursor(tmpcursor.par, tmpcursor.pos); + 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); } @@ -1479,6 +1196,10 @@ char loweralphaCounter(int n) return 'a' + n - 1; } + +namespace { + +inline char alphaCounter(int n) { if (n < 1 || n > 26) @@ -1487,6 +1208,8 @@ char alphaCounter(int n) return 'A' + n - 1; } + +inline char hebrewCounter(int n) { static const char hebrew[22] = { @@ -1500,7 +1223,9 @@ char hebrewCounter(int n) return hebrew[n-1]; } -static char const * romanCounter(int n) + +inline +string const romanCounter(int n) { static char const * roman[20] = { "i", "ii", "iii", "iv", "v", @@ -1514,73 +1239,43 @@ static char const * romanCounter(int n) return roman[n-1]; } +} // namespace anon + + // set the counter of a paragraph. This includes the labels -void LyXText::SetCounter(LyXParagraph * par) const +void LyXText::setCounter(Buffer const * buf, Paragraph * par) const { - // this is only relevant for the beginning of paragraph - par = par->FirstPhysicalPar(); - LyXLayout const & layout = - textclasslist.Style(buffer->params.textclass, - par->GetLayout()); + textclasslist.Style(buf->params.textclass, + par->getLayout()); LyXTextClass const & textclass = - textclasslist.TextClass(buffer->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() - && !(par->Previous()->footnoteflag == LyXParagraph::NO_FOOTNOTE - && par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE - && par->footnotekind == LyXParagraph::FOOTNOTE) - && !(textclasslist.Style(buffer->params.textclass, - par->Previous()->GetLayout() - ).labeltype != LABEL_BIBLIO - && layout.labeltype == LABEL_BIBLIO)) { + textclasslist.TextClass(buf->params.textclass); + + // 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->setCounter(i, par->previous()->getFirstCounter(i)); } - par->appendix = par->Previous()->FirstPhysicalPar()->appendix; - if (!par->appendix && par->start_of_appendix){ - par->appendix = true; - for (int i = 0; i < 10; ++i) { - par->setCounter(i, 0); - } + 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->enumdepth = par->Previous()->FirstPhysicalPar()->enumdepth; - par->itemdepth = par->Previous()->FirstPhysicalPar()->itemdepth; - } - else { + par->enumdepth = par->previous()->enumdepth; + par->itemdepth = par->previous()->itemdepth; + } else { for (int i = 0; i < 10; ++i) { par->setCounter(i, 0); } - par->appendix = par->start_of_appendix; + par->params().appendix(par->params().startOfAppendix()); par->enumdepth = 0; par->itemdepth = 0; } - // if this is an open marginnote and this is the first - // entry in the marginnote and the enclosing - // environment is an enum/item then correct for the - // LaTeX behaviour (ARRae) - if(par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE - && par->footnotekind == LyXParagraph::MARGIN - && par->Previous() - && par->Previous()->footnoteflag != LyXParagraph::OPEN_FOOTNOTE - && (par->PreviousBeforeFootnote() - && textclasslist.Style(buffer->params.textclass, - par->PreviousBeforeFootnote()->GetLayout() - ).labeltype >= LABEL_COUNTER_ENUMI)) { - // Any itemize or enumerate environment in a marginnote - // that is embedded in an itemize or enumerate - // paragraph is seen by LaTeX as being at a deeper - // level within that enclosing itemization/enumeration - // even if there is a "standard" layout at the start of - // the marginnote. - par->enumdepth++; - par->itemdepth++; - } - /* Maybe we have to increment the enumeration depth. * BUT, enumeration in a footnote is considered in isolation from its * surrounding paragraph so don't increment if this is the @@ -1588,29 +1283,23 @@ void LyXText::SetCounter(LyXParagraph * par) const * AND, bibliographies can't have their depth changed ie. they * are always of depth 0 */ - if (par->Previous() - && par->Previous()->GetDepth() < par->GetDepth() - && textclasslist.Style(buffer->params.textclass, - par->Previous()->GetLayout() - ).labeltype == LABEL_COUNTER_ENUMI + if (par->previous() + && par->previous()->getDepth() < par->getDepth() + && textclasslist.Style(buf->params.textclass, + par->previous()->getLayout() + ).labeltype == LABEL_COUNTER_ENUMI && par->enumdepth < 3 - && !(par->Previous()->footnoteflag == LyXParagraph::NO_FOOTNOTE - && par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE - && par->footnotekind == LyXParagraph::FOOTNOTE) && 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() - && !(par->Previous()->footnoteflag == LyXParagraph::NO_FOOTNOTE - && par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE - && par->footnotekind == LyXParagraph::FOOTNOTE) + // 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->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 */ @@ -1618,52 +1307,49 @@ void LyXText::SetCounter(LyXParagraph * par) const par->setCounter(i, 0); } - if (!par->labelstring.empty()) { - par->labelstring.erase(); + if (!par->params().labelString().empty()) { + par->params().labelString(string()); } if (layout.margintype == MARGIN_MANUAL) { - if (par->labelwidthstring.empty()) { - par->SetLabelWidthString(layout.labelstring()); + if (par->params().labelWidthString().empty()) { + par->setLabelWidthString(layout.labelstring()); } } else { - par->SetLabelWidthString(string()); + par->setLabelWidthString(string()); } - /* is it a layout that has an automatic label ? */ - if (layout.labeltype >= LABEL_FIRST_COUNTER) { + // is it a layout that has an automatic label? + if (layout.labeltype >= LABEL_COUNTER_CHAPTER) { - int i = layout.labeltype - LABEL_FIRST_COUNTER; - if (i >= 0 && i<= buffer->params.secnumdepth) { + int i = layout.labeltype - LABEL_COUNTER_CHAPTER; + if (i >= 0 && i<= buf->params.secnumdepth) { par->incCounter(i); // increment the counter // Is there a label? Useful for Chapter layout - if (!par->appendix){ + if (!par->params().appendix()) { if (!layout.labelstring().empty()) - par->labelstring = layout.labelstring(); + par->params().labelString(layout.labelstring()); else - par->labelstring.erase(); + par->params().labelString(string()); } else { if (!layout.labelstring_appendix().empty()) - par->labelstring = layout.labelstring_appendix(); + par->params().labelString(layout.labelstring_appendix()); else - par->labelstring.erase(); + par->params().labelString(string()); } -#ifdef HAVE_SSTREAM - std::ostringstream s; -#else - ostrstream s; -#endif - if (!par->appendix) { - switch (2 * LABEL_FIRST_COUNTER - + ostringstream s; + + 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); + << par->getCounter(i); break; case LABEL_COUNTER_SUBSECTION: s << par->getCounter(i - 2) << '.' @@ -1694,19 +1380,22 @@ void LyXText::SetCounter(LyXParagraph * par) const 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_FIRST_COUNTER - textclass.maxcounter() + i) { + switch (2 * LABEL_COUNTER_CHAPTER - textclass.maxcounter() + i) { case LABEL_COUNTER_CHAPTER: - if (par->isRightToLeftPar()) + if (par->isRightToLeftPar(buf->params)) s << hebrewCounter(par->getCounter(i)); else s << alphaCounter(par->getCounter(i)); break; case LABEL_COUNTER_SECTION: - if (par->isRightToLeftPar()) + if (par->isRightToLeftPar(buf->params)) s << hebrewCounter(par->getCounter(i - 1)); else s << alphaCounter(par->getCounter(i - 1)); @@ -1716,7 +1405,7 @@ void LyXText::SetCounter(LyXParagraph * par) const break; case LABEL_COUNTER_SUBSECTION: - if (par->isRightToLeftPar()) + if (par->isRightToLeftPar(buf->params)) s << hebrewCounter(par->getCounter(i - 2)); else s << alphaCounter(par->getCounter(i - 2)); @@ -1727,7 +1416,7 @@ void LyXText::SetCounter(LyXParagraph * par) const break; case LABEL_COUNTER_SUBSUBSECTION: - if (par->isRightToLeftPar()) + if (par->isRightToLeftPar(buf->params)) s << hebrewCounter(par->getCounter(i-3)); else s << alphaCounter(par->getCounter(i-3)); @@ -1739,7 +1428,7 @@ void LyXText::SetCounter(LyXParagraph * par) const break; case LABEL_COUNTER_PARAGRAPH: - if (par->isRightToLeftPar()) + if (par->isRightToLeftPar(buf->params)) s << hebrewCounter(par->getCounter(i-4)); else s << alphaCounter(par->getCounter(i-4)); @@ -1752,7 +1441,7 @@ void LyXText::SetCounter(LyXParagraph * par) const break; case LABEL_COUNTER_SUBPARAGRAPH: - if (par->isRightToLeftPar()) + if (par->isRightToLeftPar(buf->params)) s << hebrewCounter(par->getCounter(i-5)); else s << alphaCounter(par->getCounter(i-5)); @@ -1769,21 +1458,15 @@ void LyXText::SetCounter(LyXParagraph * par) const // Can this ever be reached? And in the // case it is, how can this be correct? // (Lgb) - s << static_cast(par->getCounter(i)) << '.'; + s << par->getCounter(i) << '.'; break; } } -#ifdef HAVE_SSTREAM - par->labelstring += s.str().c_str(); + + par->params().labelString(par->params().labelString() +s.str().c_str()); // We really want to remove the c_str as soon as // possible... -#else - s << '\0'; - char * tmps = s.str(); - par->labelstring += tmps; - delete [] tmps; -#endif for (i++; i < 10; ++i) { // reset the following counters @@ -1798,14 +1481,11 @@ void LyXText::SetCounter(LyXParagraph * par) const par->incCounter(i + par->enumdepth); int number = par->getCounter(i + par->enumdepth); -#ifdef HAVE_SSTREAM - std::ostringstream s; -#else - ostrstream s; -#endif + ostringstream s; + switch (par->enumdepth) { case 1: - if (par->isRightToLeftPar()) + if (par->isRightToLeftPar(buf->params)) s << '(' << hebrewCounter(number) << ')'; @@ -1815,13 +1495,13 @@ void LyXText::SetCounter(LyXParagraph * par) const << ')'; break; case 2: - if (par->isRightToLeftPar()) + if (par->isRightToLeftPar(buf->params)) s << '.' << romanCounter(number); else s << romanCounter(number) << '.'; break; case 3: - if (par->isRightToLeftPar()) + if (par->isRightToLeftPar(buf->params)) s << '.' << alphaCounter(number); else @@ -1829,64 +1509,55 @@ void LyXText::SetCounter(LyXParagraph * par) const << '.'; break; default: - if (par->isRightToLeftPar()) + if (par->isRightToLeftPar(buf->params)) s << '.' << number; else s << number << '.'; break; } -#ifdef HAVE_SSTREAM - par->labelstring = s.str().c_str(); - // we really want to get rid of that c_str() -#else - s << '\0'; - char * tmps = s.str(); - par->labelstring = tmps; - delete [] tmps; -#endif - for (i += par->enumdepth + 1; i < 10; ++i) - par->setCounter(i, 0); /* reset the following counters */ - + par->params().labelString(s.str().c_str()); + + for (i += par->enumdepth + 1; i < 10; ++i) { + // reset the following counters + par->setCounter(i, 0); + } + } } else if (layout.labeltype == LABEL_BIBLIO) {// ale970302 - int i = LABEL_COUNTER_ENUMI - LABEL_FIRST_COUNTER + par->enumdepth; + int i = LABEL_COUNTER_ENUMI - LABEL_COUNTER_CHAPTER + par->enumdepth; par->incCounter(i); int number = par->getCounter(i); - if (!par->bibkey) - par->bibkey = new InsetBibKey(); + if (!par->bibkey) { + InsetCommandParams p( "bibitem" ); + par->bibkey = new InsetBibKey(p); + } par->bibkey->setCounter(number); - par->labelstring = layout.labelstring(); + par->params().labelString(layout.labelstring()); // In biblio should't be following counters but... } else { string s = layout.labelstring(); // the caption hack: - if (layout.labeltype == LABEL_SENSITIVE) { - if (par->footnoteflag != LyXParagraph::NO_FOOTNOTE - && (par->footnotekind == LyXParagraph::FIG - || par->footnotekind == LyXParagraph::WIDE_FIG)) - s = (par->getParLanguage()->lang == "hebrew") - ? ":øåéà" : "Figure:"; - else if (par->footnoteflag != LyXParagraph::NO_FOOTNOTE - && (par->footnotekind == LyXParagraph::TAB - || par->footnotekind == LyXParagraph::WIDE_TAB)) - s = (par->getParLanguage()->lang == "hebrew") - ? ":äìáè" : "Table:"; - else if (par->footnoteflag != LyXParagraph::NO_FOOTNOTE - && par->footnotekind == LyXParagraph::ALGORITHM) - s = (par->getParLanguage()->lang == "hebrew") - ? ":íúéøåâìà" : "Algorithm:"; - else { + bool isOK (par->inInset() && par->inInset()->owner() && + (par->inInset()->owner()->lyxCode() == Inset::FLOAT_CODE)); + + 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() + " #:"; + } else { /* par->SetLayout(0); s = layout->labelstring; */ - s = (par->getParLanguage()->lang == "hebrew") + s = (par->getParLanguage(buf->params)->lang() == "hebrew") ? " :úåòîùî øñç" : "Senseless: "; } } - par->labelstring = s; + par->params().labelString(s); /* reset the enumeration counter. They are always resetted * when there is any other layout between */ @@ -1896,1661 +1567,717 @@ void LyXText::SetCounter(LyXParagraph * par) const } -/* Updates all counters BEHIND the row. Changed paragraphs -* with a dynamic left margin will be rebroken. */ -void LyXText::UpdateCounters(Row * row) const +// Updates all counters BEHIND the row. Changed paragraphs +// with a dynamic left margin will be rebroken. +void LyXText::updateCounters(BufferView * bview, Row * row) const { - LyXParagraph * par; + Paragraph * par; + if (!row) { row = firstrow; - par = row->par; - } - else { - if (row->par->next - && row->par->next->footnoteflag != LyXParagraph::OPEN_FOOTNOTE) { - par = row->par->LastPhysicalPar()->Next(); - } else { - par = row->par->next; - } + par = row->par(); + } else { + par = row->par()->next(); } while (par) { - while (row->par != par) - row = row->next; + while (row->par() != par) + row = row->next(); - SetCounter(par); + setCounter(bview->buffer(), par); - /* now check for the headline layouts. remember that they - * have a dynamic left margin */ - if (!par->IsDummy() - && ( textclasslist.Style(buffer->params.textclass, - par->layout).margintype == MARGIN_DYNAMIC - || textclasslist.Style(buffer->params.textclass, - par->layout).labeltype == LABEL_SENSITIVE) - ) { - - /* Rebreak the paragraph */ - RemoveParagraph(row); - AppendParagraph(row); - - /* think about the damned open footnotes! */ - while (par->Next() && - (par->Next()->footnoteflag == LyXParagraph::OPEN_FOOTNOTE - || par->Next()->IsDummy())){ - par = par->Next(); - if (par->IsDummy()) { - while (row->par != par) - row = row->next; - RemoveParagraph(row); - AppendParagraph(row); - } - } + // 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 + removeParagraph(row); + appendParagraph(bview, row); } - - par = par->LastPhysicalPar()->Next(); - + par = par->next(); } } -/* insets an inset. */ -void LyXText::InsertInset(Inset *inset) -{ - if (!cursor.par->InsertInsetAllowed(inset)) - return; - SetUndo(Undo::INSERT, - cursor.par->ParFromPos(cursor.pos)->previous, - cursor.par->ParFromPos(cursor.pos)->next); - cursor.par->InsertChar(cursor.pos, LyXParagraph::META_INSET); - cursor.par->InsertInset(cursor.pos, inset); - InsertChar(LyXParagraph::META_INSET); /* just to rebreak and refresh correctly. - * The character will not be inserted a - * second time */ -} - - -#ifdef USE_OLD_CUT_AND_PASTE -// this is for the simple cut and paste mechanism -static LyXParagraph * simple_cut_buffer = 0; -static char simple_cut_buffer_textclass = 0; - -void DeleteSimpleCutBuffer() +void LyXText::insertInset(BufferView * bview, Inset * inset) { - if (!simple_cut_buffer) + if (!cursor.par()->insetAllowed(inset->lyxCode())) return; - LyXParagraph * tmppar; - - while (simple_cut_buffer) { - tmppar = simple_cut_buffer; - simple_cut_buffer = simple_cut_buffer->next; - delete tmppar; + setUndo(bview, Undo::INSERT, + cursor.par(), cursor.par()->next()); + cursor.par()->insertInset(cursor.pos(), inset); + // Just to rebreak and refresh correctly. + // The character will not be inserted a second time + insertChar(bview, Paragraph::META_INSET); +#if 1 + // If we enter a highly editable inset the cursor should be to before + // the inset. This couldn't happen before as Undo was not handled inside + // inset now after the Undo LyX tries to call inset->Edit(...) again + // and cannot do this as the cursor is behind the inset and GetInset + // does not return the inset! + if (inset->editable() == Inset::HIGHLY_EDITABLE) { + cursorLeft(bview, true); } - simple_cut_buffer = 0; -} #endif +} + void LyXText::copyEnvironmentType() { - copylayouttype = cursor.par->GetLayout(); + copylayouttype = cursor.par()->getLayout(); } -void LyXText::pasteEnvironmentType() +void LyXText::pasteEnvironmentType(BufferView * bview) { - SetLayout(copylayouttype); + setLayout(bview, copylayouttype); } -#ifdef USE_OLD_CUT_AND_PASTE -void LyXText::CutSelection(bool doclear) + +void LyXText::cutSelection(BufferView * bview, bool doclear) { + // Stuff what we got on the clipboard. Even if there is no selection. + + // There is a problem with having the stuffing here in that the + // larger the selection the slower LyX will get. This can be + // solved by running the line below only when the selection has + // finished. The solution used currently just works, to make it + // faster we need to be more clever and probably also have more + // calls to stuffClipboard. (Lgb) + bview->stuffClipboard(selectionAsString(bview->buffer())); + // This doesn't make sense, if there is no selection - if (!selection) + if (!selection.set()) return; - // OK, we have a selection. This is always between sel_start_cursor - // and sel_end cursor - LyXParagraph * tmppar; - - // Check whether there are half footnotes in the selection - if (sel_start_cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE - || sel_end_cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE) { - tmppar = sel_start_cursor.par; - while (tmppar != sel_end_cursor.par){ - if (tmppar->footnoteflag != sel_end_cursor.par->footnoteflag) { - WriteAlert(_("Impossible operation"), - _("Don't know what to do with half floats."), - _("sorry.")); - return; - } - tmppar = tmppar->Next(); - } - } - - /* table stuff -- begin */ - if (sel_start_cursor.par->table || sel_end_cursor.par->table) { - if ( sel_start_cursor.par != sel_end_cursor.par) { - WriteAlert(_("Impossible operation"), - _("Don't know what to do with half tables."), - _("sorry.")); - return; - } - sel_start_cursor.par->table->Reinit(); - } - /* table stuff -- end */ + // 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 - LyXParagraph * endpar = sel_end_cursor.par->LastPhysicalPar()->Next(); - LyXParagraph * undoendpar = endpar; - - if (endpar && endpar->GetDepth()) { - while (endpar && endpar->GetDepth()) { - endpar = endpar->LastPhysicalPar()->Next(); + Paragraph * endpar = selection.end.par()->next(); + Paragraph * undoendpar = endpar; + + if (endpar && endpar->getDepth()) { + while (endpar && endpar->getDepth()) { + endpar = endpar->next(); undoendpar = endpar; } } else if (endpar) { - endpar = endpar->Next(); // because of parindents etc. + endpar = endpar->next(); // because of parindents etc. } - - SetUndo(Undo::DELETE, - sel_start_cursor - .par->ParFromPos(sel_start_cursor.pos)->previous, - undoendpar); - - // clear the simple_cut_buffer - DeleteSimpleCutBuffer(); - - // set the textclass - simple_cut_buffer_textclass = buffer->params.textclass; - -#ifdef WITH_WARNINGS -#warning Asger: Make cut more intelligent here. -#endif - /* - White paper for "intelligent" cutting: - - Example: "This is our text." - Using " our " as selection, cutting will give "This istext.". - Using "our" as selection, cutting will give "This is text.". - Using " our" as selection, cutting will give "This is text.". - Using "our " as selection, cutting will give "This is text.". - - All those four selections will (however) paste identically: - Pasting with the cursor right after the "is" will give the - original text with all four selections. - - The rationale is to be intelligent such that words are copied, - cut and pasted in a functional manner. - - This is not implemented yet. (Asger) - - The changes below sees to do a lot of what you want. However - I have not verified that all cases work as they should: - - cut in single row - - cut in multiple row - - cut with insets - - cut across footnotes and paragraph - My simplistic tests show that the idea are basically sound but - there are some items to fix up...we only need to find them - first. - - As do redo Asger's example above (with | beeing the cursor in the - result after cutting.): - - Example: "This is our text." - Using " our " as selection, cutting will give "This is|text.". - Using "our" as selection, cutting will give "This is | text.". - Using " our" as selection, cutting will give "This is| text.". - Using "our " as selection, cutting will give "This is |text.". - - (Lgb) - */ - + + setUndo(bview, Undo::DELETE, + selection.start.par(), undoendpar); + // there are two cases: cut only within one paragraph or // more than one paragraph - - if (sel_start_cursor.par->ParFromPos(sel_start_cursor.pos) - == sel_end_cursor.par->ParFromPos(sel_end_cursor.pos)) { + if (selection.start.par() == selection.end.par()) { // only within one paragraph - simple_cut_buffer = new LyXParagraph; - LyXParagraph::size_type i = - sel_start_cursor.pos; - for (; i < sel_end_cursor.pos; ++i) { - /* table stuff -- begin */ - if (sel_start_cursor.par->table - && sel_start_cursor.par->IsNewline(sel_start_cursor.pos)) { - sel_start_cursor.par->CopyIntoMinibuffer(sel_start_cursor.pos); - sel_start_cursor.pos++; - } else { - /* table stuff -- end */ - sel_start_cursor.par->CopyIntoMinibuffer(sel_start_cursor.pos); - sel_start_cursor.par->Erase(sel_start_cursor.pos); - } - simple_cut_buffer->InsertFromMinibuffer(simple_cut_buffer->Last()); - } - endpar = sel_end_cursor.par->Next(); + 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.end.pos(pos); } else { - // cut more than one paragraph - - sel_end_cursor.par - ->BreakParagraphConservative(sel_end_cursor.pos); - sel_end_cursor.par = sel_end_cursor.par->Next(); - sel_end_cursor.pos = 0; - - cursor = sel_end_cursor; - - sel_start_cursor.par - ->BreakParagraphConservative(sel_start_cursor.pos); - // store the endparagraph for redoing later - endpar = sel_end_cursor.par->Next(); /* needed because - the sel_end_ - cursor.par - will be pasted! */ - - // store the selection - simple_cut_buffer = sel_start_cursor.par - ->ParFromPos(sel_start_cursor.pos)->next; - simple_cut_buffer->previous = 0; - sel_end_cursor.par->previous->next = 0; - - // cut the selection - sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->next - = sel_end_cursor.par; - - sel_end_cursor.par->previous - = sel_start_cursor.par->ParFromPos(sel_start_cursor.pos); - - // care about footnotes - if (simple_cut_buffer->footnoteflag) { - LyXParagraph * tmppar = simple_cut_buffer; - while (tmppar){ - tmppar->footnoteflag = LyXParagraph::NO_FOOTNOTE; - tmppar = tmppar->next; - } - } - - // the cut selection should begin with standard layout - simple_cut_buffer->Clear(); - - // paste the paragraphs again, if possible - if (doclear) - sel_start_cursor.par->Next()->ClearParagraph(); - if (sel_start_cursor.par->FirstPhysicalPar()->HasSameLayout(sel_start_cursor.par->Next()) - || - !sel_start_cursor.par->Next()->Last()) - sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->PasteParagraph(); - } + endpar = selection.end.par(); + int pos = selection.end.pos(); + CutAndPaste::cutSelection(selection.start.par(), &endpar, + selection.start.pos(), pos, + bview->buffer()->params.textclass, doclear); + cursor.par(endpar); + selection.end.par(endpar); + selection.end.pos(pos); + cursor.pos(selection.end.pos()); + } + endpar = endpar->next(); // sometimes necessary if (doclear) - sel_start_cursor.par->ClearParagraph(); - - RedoParagraphs(sel_start_cursor, endpar); - - ClearSelection(); - cursor = sel_start_cursor; - SetCursor(cursor.par, cursor.pos); - sel_cursor = cursor; - UpdateCounters(cursor.row); -} - -#else /////////////////////////////////////////////////////////////////// - -void LyXText::CutSelection(bool doclear) -{ - // This doesn't make sense, if there is no selection - if (!selection) - return; - - // OK, we have a selection. This is always between sel_start_cursor - // and sel_end cursor - LyXParagraph * tmppar; - - // Check whether there are half footnotes in the selection - if (sel_start_cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE - || sel_end_cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE) { - tmppar = sel_start_cursor.par; - while (tmppar != sel_end_cursor.par){ - if (tmppar->footnoteflag != sel_end_cursor.par->footnoteflag) { - WriteAlert(_("Impossible operation"), - _("Don't know what to do with half floats."), - _("sorry.")); - return; - } - tmppar = tmppar->Next(); - } - } - - /* table stuff -- begin */ - if (sel_start_cursor.par->table || sel_end_cursor.par->table) { - if ( sel_start_cursor.par != sel_end_cursor.par) { - WriteAlert(_("Impossible operation"), - _("Don't know what to do with half tables."), - _("sorry.")); - return; - } - sel_start_cursor.par->table->Reinit(); - } - /* table stuff -- end */ - - // make sure that the depth behind the selection are restored, too - LyXParagraph * endpar = sel_end_cursor.par->LastPhysicalPar()->Next(); - LyXParagraph * undoendpar = endpar; - - if (endpar && endpar->GetDepth()) { - while (endpar && endpar->GetDepth()) { - endpar = endpar->LastPhysicalPar()->Next(); - undoendpar = endpar; - } - } else if (endpar) { - endpar = endpar->Next(); // because of parindents etc. - } - - SetUndo(Undo::DELETE, sel_start_cursor - .par->ParFromPos(sel_start_cursor.pos)->previous, undoendpar); - - CutAndPaste cap; - - // there are two cases: cut only within one paragraph or - // more than one paragraph - if (sel_start_cursor.par->ParFromPos(sel_start_cursor.pos) - == sel_end_cursor.par->ParFromPos(sel_end_cursor.pos)) { - // only within one paragraph - endpar = sel_start_cursor.par; - cap.cutSelection(sel_start_cursor.par, &endpar, - sel_start_cursor.pos, sel_end_cursor.pos, - buffer->params.textclass, doclear); - } else { - endpar = sel_end_cursor.par; - - cap.cutSelection(sel_start_cursor.par, &endpar, - sel_start_cursor.pos, sel_end_cursor.pos, - buffer->params.textclass, doclear); - cursor.par = sel_end_cursor.par = endpar; - cursor.pos = sel_end_cursor.pos; - } - endpar = endpar->Next(); - - // sometimes necessary - if (doclear) - sel_start_cursor.par->ClearParagraph(); - - RedoParagraphs(sel_start_cursor, endpar); - - ClearSelection(); - cursor = sel_start_cursor; - SetCursor(cursor.par, cursor.pos); - sel_cursor = cursor; - UpdateCounters(cursor.row); -} -#endif - -#ifdef USE_OLD_CUT_AND_PASTE -void LyXText::CopySelection() -{ - // this doesnt make sense, if there is no selection - if (!selection) - return; + selection.start.par()->stripLeadingSpaces(bview->buffer()->params.textclass); - // ok we have a selection. This is always between sel_start_cursor - // and sel_end cursor - LyXParagraph * tmppar; - - /* check wether there are half footnotes in the selection */ - if (sel_start_cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE - || sel_end_cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE) { - tmppar = sel_start_cursor.par; - while (tmppar != sel_end_cursor.par) { - if (tmppar->footnoteflag != - sel_end_cursor.par->footnoteflag) { - WriteAlert(_("Impossible operation"), - _("Don't know what to do" - " with half floats."), - _("sorry.")); - return; - } - tmppar = tmppar->Next(); - } - } + redoParagraphs(bview, selection.start, endpar); - /* table stuff -- begin */ - if (sel_start_cursor.par->table || sel_end_cursor.par->table){ - if ( sel_start_cursor.par != sel_end_cursor.par){ - WriteAlert(_("Impossible operation"), - _("Don't know what to do with half tables."), - _("sorry.")); - return; - } - } - /* table stuff -- end */ - - // delete the simple_cut_buffer - DeleteSimpleCutBuffer(); + // cutSelection can invalidate the cursor so we need to set + // it anew. (Lgb) + cursor = selection.start; - // set the textclass - simple_cut_buffer_textclass = buffer->params.textclass; + // need a valid cursor. (Lgb) + clearSelection(); - // copy behind a space if there is one - while (sel_start_cursor.par->Last() > sel_start_cursor.pos - && sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos) - && (sel_start_cursor.par != sel_end_cursor.par - || sel_start_cursor.pos < sel_end_cursor.pos)) - sel_start_cursor.pos++; - - // there are two cases: copy only within one paragraph - // or more than one paragraph - if (sel_start_cursor.par->ParFromPos(sel_start_cursor.pos) - == sel_end_cursor.par->ParFromPos(sel_end_cursor.pos)) { - // only within one paragraph - simple_cut_buffer = new LyXParagraph; - LyXParagraph::size_type i = 0; - for (i = sel_start_cursor.pos; i < sel_end_cursor.pos; ++i){ - sel_start_cursor.par->CopyIntoMinibuffer(i); - simple_cut_buffer->InsertFromMinibuffer(i - sel_start_cursor.pos); - } - } else { - // copy more than one paragraph - // clone the paragraphs within the selection - tmppar = - sel_start_cursor.par->ParFromPos(sel_start_cursor.pos); - simple_cut_buffer = tmppar->Clone(); - LyXParagraph *tmppar2 = simple_cut_buffer; - - while (tmppar != sel_end_cursor.par->ParFromPos(sel_end_cursor.pos) - && tmppar->next) { - tmppar = tmppar->next; - tmppar2->next = tmppar->Clone(); - tmppar2->next->previous = tmppar2; - tmppar2 = tmppar2->next; - } - tmppar2->next = 0; - - // care about footnotes - if (simple_cut_buffer->footnoteflag) { - tmppar = simple_cut_buffer; - while (tmppar){ - tmppar->footnoteflag = - LyXParagraph::NO_FOOTNOTE; - tmppar = tmppar->next; - } - } - - // the simple_cut_buffer paragraph is too big - LyXParagraph::size_type tmpi2 = - sel_start_cursor.par->PositionInParFromPos(sel_start_cursor.pos); - for (; tmpi2; --tmpi2) - simple_cut_buffer->Erase(0); - - // now tmppar 2 is too big, delete all after sel_end_cursor.pos - - tmpi2 = sel_end_cursor.par->PositionInParFromPos(sel_end_cursor.pos); - while (tmppar2->size() > tmpi2) { - tmppar2->Erase(tmppar2->size() - 1); - } - } + setCursor(bview, cursor.par(), cursor.pos()); + selection.cursor = cursor; + updateCounters(bview, cursor.row()); } -#else ////////////////////////////////////////////////////////////////////// -void LyXText::CopySelection() +void LyXText::copySelection(BufferView * bview) { + // Stuff what we got on the clipboard. Even if there is no selection. + + // There is a problem with having the stuffing here in that the + // larger the selection the slower LyX will get. This can be + // solved by running the line below only when the selection has + // finished. The solution used currently just works, to make it + // faster we need to be more clever and probably also have more + // calls to stuffClipboard. (Lgb) + bview->stuffClipboard(selectionAsString(bview->buffer())); + // this doesnt make sense, if there is no selection - if (!selection) + if (!selection.set()) return; - // ok we have a selection. This is always between sel_start_cursor + // ok we have a selection. This is always between selection.start // and sel_end cursor - LyXParagraph * tmppar; - - /* check wether there are half footnotes in the selection */ - if (sel_start_cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE - || sel_end_cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE) { - tmppar = sel_start_cursor.par; - while (tmppar != sel_end_cursor.par) { - if (tmppar->footnoteflag != - sel_end_cursor.par->footnoteflag) { - WriteAlert(_("Impossible operation"), - _("Don't know what to do" - " with half floats."), - _("sorry.")); - return; - } - tmppar = tmppar->Next(); - } - } - /* table stuff -- begin */ - if (sel_start_cursor.par->table || sel_end_cursor.par->table){ - if ( sel_start_cursor.par != sel_end_cursor.par){ - WriteAlert(_("Impossible operation"), - _("Don't know what to do with half tables."), - _("sorry.")); - return; - } - } - /* table stuff -- end */ - // copy behind a space if there is one - while (sel_start_cursor.par->Last() > sel_start_cursor.pos - && sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos) - && (sel_start_cursor.par != sel_end_cursor.par - || sel_start_cursor.pos < sel_end_cursor.pos)) - sel_start_cursor.pos++; - - CutAndPaste cap; + while (selection.start.par()->size() > selection.start.pos() + && 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); - cap.copySelection(sel_start_cursor.par, sel_end_cursor.par, - sel_start_cursor.pos, sel_end_cursor.pos, - buffer->params.textclass); + CutAndPaste::copySelection(selection.start.par(), selection.end.par(), + selection.start.pos(), selection.end.pos(), + bview->buffer()->params.textclass); } -#endif -#ifdef USE_OLD_CUT_AND_PASTE -void LyXText::PasteSelection() + +void LyXText::pasteSelection(BufferView * bview) { // this does not make sense, if there is nothing to paste - if (!simple_cut_buffer) + if (!CutAndPaste::checkPastePossible(cursor.par())) return; - LyXParagraph * tmppar; - LyXParagraph * endpar; + setUndo(bview, Undo::INSERT, + cursor.par(), cursor.par()->next()); - LyXCursor tmpcursor; - - // be carefull with footnotes in footnotes - if (cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE) { - - // check whether the cut_buffer includes a footnote - tmppar = simple_cut_buffer; - while (tmppar - && tmppar->footnoteflag == LyXParagraph::NO_FOOTNOTE) - tmppar = tmppar->next; - - if (tmppar) { - WriteAlert(_("Impossible operation"), - _("Can't paste float into float!"), - _("Sorry.")); - return; - } - } + Paragraph * endpar; + Paragraph * actpar = cursor.par(); - /* table stuff -- begin */ - if (cursor.par->table) { - if (simple_cut_buffer->next) { - WriteAlert(_("Impossible operation"), - _("Table cell cannot include more than one paragraph!"), - _("Sorry.")); - return; - } - } - /* table stuff -- end */ - - SetUndo(Undo::INSERT, - cursor.par->ParFromPos(cursor.pos)->previous, - cursor.par->ParFromPos(cursor.pos)->next); - - tmpcursor = cursor; - - // There are two cases: cutbuffer only one paragraph or many - if (!simple_cut_buffer->next) { - // only within a paragraph - - tmppar = simple_cut_buffer->Clone(); - /* table stuff -- begin */ - bool table_too_small = false; - if (tmpcursor.par->table) { - while (simple_cut_buffer->size() - && !table_too_small) { - if (simple_cut_buffer->IsNewline(0)){ - while(tmpcursor.pos < tmpcursor.par->Last() && !tmpcursor.par->IsNewline(tmpcursor.pos)) - tmpcursor.pos++; - simple_cut_buffer->Erase(0); - if (tmpcursor.pos < tmpcursor.par->Last()) - tmpcursor.pos++; - else - table_too_small = true; - } else { - // This is an attempt to fix the - // "never insert a space at the - // beginning of a paragraph" problem. - if (tmpcursor.pos == 0 - && simple_cut_buffer->IsLineSeparator(0)) { - simple_cut_buffer->Erase(0); - } else { - simple_cut_buffer->CutIntoMinibuffer(0); - simple_cut_buffer->Erase(0); - tmpcursor.par->InsertFromMinibuffer(tmpcursor.pos); - tmpcursor.pos++; - } - } - } - } else { - /* table stuff -- end */ - // Some provisions should be done here for checking - // if we are inserting at the beginning of a - // paragraph. If there are a space at the beginning - // of the text to insert and we are inserting at - // the beginning of the paragraph the space should - // be removed. - while (simple_cut_buffer->size()) { - // This is an attempt to fix the - // "never insert a space at the - // beginning of a paragraph" problem. - if (tmpcursor.pos == 0 - && simple_cut_buffer->IsLineSeparator(0)) { - simple_cut_buffer->Erase(0); - } else { - simple_cut_buffer->CutIntoMinibuffer(0); - simple_cut_buffer->Erase(0); - tmpcursor.par->InsertFromMinibuffer(tmpcursor.pos); - tmpcursor.pos++; - } - } - } - delete simple_cut_buffer; - simple_cut_buffer = tmppar; - endpar = tmpcursor.par->Next(); - } else { - // many paragraphs - CutAndPaste cap; - - // make a copy of the simple cut_buffer - tmppar = simple_cut_buffer; - LyXParagraph * simple_cut_clone = tmppar->Clone(); - LyXParagraph * tmppar2 = simple_cut_clone; - if (cursor.par->footnoteflag){ - tmppar->footnoteflag = cursor.par->footnoteflag; - tmppar->footnotekind = cursor.par->footnotekind; - } - while (tmppar->next) { - tmppar = tmppar->next; - tmppar2->next = tmppar->Clone(); - tmppar2->next->previous = tmppar2; - tmppar2 = tmppar2->next; - if (cursor.par->footnoteflag){ - tmppar->footnoteflag = cursor.par->footnoteflag; - tmppar->footnotekind = cursor.par->footnotekind; - } - } - - // make sure there is no class difference - cap.SwitchLayoutsBetweenClasses(simple_cut_buffer_textclass, - buffer->params.textclass, - simple_cut_buffer); - - // make the simple_cut_buffer exactly the same layout than - // the cursor paragraph - simple_cut_buffer->MakeSameLayout(cursor.par); - - // find the end of the buffer - LyXParagraph * lastbuffer = simple_cut_buffer; - while (lastbuffer->Next()) - lastbuffer = lastbuffer->Next(); - - bool paste_the_end = false; - - // open the paragraph for inserting the simple_cut_buffer - // if necessary - if (cursor.par->Last() > cursor.pos || !cursor.par->Next()){ - cursor.par->BreakParagraphConservative(cursor.pos); - paste_the_end = true; - } - - // set the end for redoing later - endpar = cursor.par->ParFromPos(cursor.pos)->next->Next(); - - // paste it! - lastbuffer->ParFromPos(lastbuffer->Last())->next = - cursor.par->ParFromPos(cursor.pos)->next; - cursor.par->ParFromPos(cursor.pos)->next->previous = - lastbuffer->ParFromPos(lastbuffer->Last()); - - cursor.par->ParFromPos(cursor.pos)->next = simple_cut_buffer; - simple_cut_buffer->previous = - cursor.par->ParFromPos(cursor.pos); - - if (cursor.par->ParFromPos(cursor.pos)->Next() == lastbuffer) - lastbuffer = cursor.par; - - cursor.par->ParFromPos(cursor.pos)->PasteParagraph(); - - // store the new cursor position - tmpcursor.par = lastbuffer; - tmpcursor.pos = lastbuffer->Last(); - - // maybe some pasting - if (lastbuffer->Next() && paste_the_end) { - if (lastbuffer->Next()->HasSameLayout(lastbuffer)) { - lastbuffer->ParFromPos(lastbuffer->Last())->PasteParagraph(); - - } else if (!lastbuffer->Next()->Last()) { - lastbuffer->Next()->MakeSameLayout(lastbuffer); - lastbuffer->ParFromPos(lastbuffer->Last())->PasteParagraph(); - - } else if (!lastbuffer->Last()) { - lastbuffer->MakeSameLayout(lastbuffer->next); - lastbuffer->ParFromPos(lastbuffer->Last())->PasteParagraph(); - - } else - lastbuffer->Next()->ClearParagraph(); - } - - // restore the simple cut buffer - simple_cut_buffer = simple_cut_clone; - } - - RedoParagraphs(cursor, endpar); - - SetCursor(cursor.par, cursor.pos); - ClearSelection(); - - sel_cursor = cursor; - SetCursor(tmpcursor.par, tmpcursor.pos); - SetSelection(); - UpdateCounters(cursor.row); -} - -#else //////////////////////////////////////////////////////////////////// - -void LyXText::PasteSelection() -{ - CutAndPaste cap; - - // this does not make sense, if there is nothing to paste - if (!cap.checkPastePossible(cursor.par, cursor.pos)) - return; - - SetUndo(Undo::INSERT, - cursor.par->ParFromPos(cursor.pos)->previous, - cursor.par->ParFromPos(cursor.pos)->next); - - LyXParagraph *endpar; - LyXParagraph *actpar = cursor.par; - int endpos = cursor.pos; - - cap.pasteSelection(&actpar, &endpar, endpos, buffer->params.textclass); - - RedoParagraphs(cursor, endpar); + int pos = cursor.pos(); + CutAndPaste::pasteSelection(&actpar, &endpar, pos, + bview->buffer()->params.textclass); - SetCursor(cursor.par, cursor.pos); - ClearSelection(); + redoParagraphs(bview, cursor, endpar); + + setCursor(bview, cursor.par(), cursor.pos()); + clearSelection(); - sel_cursor = cursor; - SetCursor(actpar, endpos); - SetSelection(); - UpdateCounters(cursor.row); -} -#endif - -// returns a pointer to the very first LyXParagraph -LyXParagraph * LyXText::FirstParagraph() const -{ - return buffer->paragraph; + selection.cursor = cursor; + setCursor(bview, actpar, pos); + setSelection(bview); + updateCounters(bview, cursor.row()); } -// returns true if the specified string is at the specified position -bool LyXText::IsStringInText(LyXParagraph * par, - LyXParagraph::size_type pos, - char const * str) const +// returns a pointer to the very first Paragraph +Paragraph * LyXText::firstParagraph() const { - if (par) { - int i = 0; - while (pos + i < par->Last() && str[i] && - str[i] == par->GetChar(pos + i)) { - ++i; - } - if (!str[i]) - return true; - } - return false; + return ownerParagraph(); } // sets the selection over the number of characters of string, no check!! -void LyXText::SetSelectionOverString(char const * string) +void LyXText::setSelectionOverString(BufferView * bview, string const & str) { - sel_cursor = cursor; - for (int i = 0; string[i]; ++i) - CursorRight(); - SetSelection(); + if (str.empty()) + return; + + selection.cursor = cursor; + for (string::size_type i = 0; i < str.length(); ++i) + cursorRight(bview); + setSelection(bview); } // simple replacing. The font of the first selected character is used -void LyXText::ReplaceSelectionWithString(char const * str) +void LyXText::replaceSelectionWithString(BufferView * bview, + string const & str) { - SetCursorParUndo(); - FreezeUndo(); + setCursorParUndo(bview); + freezeUndo(); - if (!selection) { // create a dummy selection - sel_end_cursor = cursor; - sel_start_cursor = cursor; + if (!selection.set()) { // create a dummy selection + selection.end = cursor; + selection.start = cursor; } // Get font setting before we cut - LyXParagraph::size_type pos = sel_end_cursor.pos; - LyXFont font = sel_start_cursor.par->GetFontSettings(sel_start_cursor.pos); + Paragraph::size_type pos = selection.end.pos(); + LyXFont const font = selection.start.par() + ->getFontSettings(bview->buffer()->params, + selection.start.pos()); // Insert the new string - for (int i = 0; str[i]; ++i) { - sel_end_cursor.par->InsertChar(pos, str[i]); - sel_end_cursor.par->SetFont(pos, font); + for (string::const_iterator cit = str.begin(); cit != str.end(); ++cit) { + selection.end.par()->insertChar(pos, (*cit), font); ++pos; } - + // Cut the selection - CutSelection(); - - UnFreezeUndo(); -} - - -// if the string can be found: return true and set the cursor to -// the new position -bool LyXText::SearchForward(char const * str) const -{ - LyXParagraph * par = cursor.par; - LyXParagraph::size_type pos = cursor.pos; - while (par && !IsStringInText(par, pos, str)) { - if (pos < par->Last() - 1) - ++pos; - else { - pos = 0; - par = par->Next(); - } - } - if (par) { - SetCursor(par, pos); - return true; - } - else - return false; -} - - -bool LyXText::SearchBackward(char const * string) const -{ - LyXParagraph * par = cursor.par; - int pos = cursor.pos; + cutSelection(bview); - do { - if (pos > 0) - --pos; - else { - // We skip empty paragraphs (Asger) - do { - par = par->Previous(); - if (par) - pos = par->Last() - 1; - } while (par && pos < 0); - } - } while (par && !IsStringInText(par, pos, string)); - - if (par) { - SetCursor(par, pos); - return true; - } else - return false; + unFreezeUndo(); } // needed to insert the selection -void LyXText::InsertStringA(string const & str) +void LyXText::insertStringAsLines(BufferView * bview, string const & str) { - LyXParagraph * par = cursor.par; - LyXParagraph::size_type pos = cursor.pos; - LyXParagraph::size_type a = 0; - int cell = 0; - LyXParagraph * endpar = cursor.par->Next(); + Paragraph * par = cursor.par(); + Paragraph::size_type pos = cursor.pos(); + Paragraph * endpar = cursor.par()->next(); - SetCursorParUndo(); + setCursorParUndo(bview); - bool flag = - textclasslist.Style(buffer->params.textclass, - cursor.par->GetLayout()).isEnvironment(); // only to be sure, should not be neccessary - ClearSelection(); + clearSelection(); - // insert the string, don't insert doublespace - string::size_type i = 0; - while (i < str.length()) { - if (str[i] != '\n') { - if (str[i] == ' ' - && i + 1 < str.length() && str[i + 1] != ' ' - && pos && par->GetChar(pos - 1)!= ' ') { - par->InsertChar(pos,' '); - par->SetFont(pos, current_font); - ++pos; - } else if (par->table) { - if (str[i] == '\t') { - while((pos < par->size()) && - (par->GetChar(pos) != LyXParagraph::META_NEWLINE)) - ++pos; - if (pos < par->size()) - ++pos; - else // no more fields to fill skip the rest - break; - } else if ((str[i] != 13) && - ((str[i] & 127) >= ' ')) { - par->InsertChar(pos, str[i]); - par->SetFont(pos, current_font); - ++pos; - } - } else if (str[i] == ' ') { - InsetSpecialChar * new_inset = - new InsetSpecialChar(InsetSpecialChar::PROTECTED_SEPARATOR); - if (par->InsertInsetAllowed(new_inset)) { - par->InsertChar(pos, LyXParagraph::META_INSET); - par->SetFont(pos, current_font); - par->InsertInset(pos, new_inset); - } else { - delete new_inset; - } - ++pos; - } else if (str[i] == '\t') { - for (a = pos; a < (pos / 8 + 1) * 8 ; ++a) { - InsetSpecialChar * new_inset = - new InsetSpecialChar(InsetSpecialChar::PROTECTED_SEPARATOR); - if (par->InsertInsetAllowed(new_inset)) { - par->InsertChar(pos, LyXParagraph::META_INSET); - par->SetFont(pos, current_font); - par->InsertInset(pos, new_inset); - } else { - delete new_inset; - } - } - pos = a; - } else if (str[i] != 13 && - // Ignore unprintables - (str[i] & 127) >= ' ') { - par->InsertChar(pos, str[i]); - par->SetFont(pos, current_font); - ++pos; - } - } else { - if (par->table) { - if (i + 1 >= str.length()) { - ++pos; - break; - } - while((pos < par->size()) && - (par->GetChar(pos) != LyXParagraph::META_NEWLINE)) - ++pos; - ++pos; - cell = NumberOfCell(par, pos); - while((pos < par->size()) && - !(par->table->IsFirstCell(cell))) { - - while((pos < par->size()) && - (par->GetChar(pos) != LyXParagraph::META_NEWLINE)) - ++pos; - ++pos; - cell = NumberOfCell(par, pos); - } - if (pos >= par->size()) - // no more fields to fill skip the rest - break; - } else { - if (!par->size()) { // par is empty - InsetSpecialChar * new_inset = - new InsetSpecialChar(InsetSpecialChar::PROTECTED_SEPARATOR); - if (par->InsertInsetAllowed(new_inset)) { - par->InsertChar(pos, LyXParagraph::META_INSET); - par->SetFont(pos, current_font); - par->InsertInset(pos, new_inset); - } else { - delete new_inset; - } - ++pos; - } - par->BreakParagraph(pos, flag); - par = par->Next(); - pos = 0; - } - } - ++i; - } - - RedoParagraphs(cursor, endpar); - SetCursor(cursor.par, cursor.pos); - sel_cursor = cursor; - SetCursor(par, pos); - SetSelection(); -} - - -/* turns double-CR to single CR, others where converted into one blank and 13s - * that are ignored .Double spaces are also converted into one. Spaces at - * the beginning of a paragraph are forbidden. tabs are converted into one - * space. then InsertStringA is called */ -void LyXText::InsertStringB(string const & s) -{ - string str(s); - LyXParagraph * par = cursor.par; - string::size_type i = 1; - while (i < str.length()) { - if (str[i] == '\t' && !par->table) - str[i] = ' '; - if (str[i] == ' ' && i + 1 < str.length() && str[i + 1] == ' ') - str[i] = 13; - if (str[i] == '\n' && i + 1 < str.length() && !par->table){ - if (str[i + 1] != '\n') { - if (str[i - 1] != ' ') - str[i] = ' '; - else - str[i] = 13; - } - while (i + 1 < str.length() - && (str[i + 1] == ' ' - || str[i + 1] == '\t' - || str[i + 1] == '\n' - || str[i + 1] == 13)) { - str[i + 1] = 13; - ++i; - } - } - ++i; - } - InsertStringA(str); -} - - -bool LyXText::GotoNextError() const -{ - LyXCursor res = cursor; - do { - if (res.pos < res.par->Last() - 1) { - res.pos++; - } - else { - res.par = res.par->Next(); - res.pos = 0; + bview->buffer()->insertStringAsLines(par, pos, current_font, str); + + redoParagraphs(bview, cursor, endpar); + setCursor(bview, cursor.par(), cursor.pos()); + selection.cursor = cursor; + setCursor(bview, par, pos); + setSelection(bview); +} + + +// 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); + bool newline_inserted = false; + for (string::size_type i = 0; i < linestr.length(); ++i) { + if (linestr[i] == '\n') { + if (newline_inserted) { + // we know that \r will be ignored by + // InsertStringA. Of course, it is a dirty + // trick, but it works... + linestr[i - 1] = '\r'; + linestr[i] = '\n'; + } else { + linestr[i] = ' '; + newline_inserted = true; + } + } else if (IsPrintable(linestr[i])) { + newline_inserted = false; } - - } while (res.par && - !(res.par->GetChar(res.pos) == LyXParagraph::META_INSET - && res.par->GetInset(res.pos)->AutoDelete())); - - if (res.par) { - SetCursor(res.par, res.pos); - return true; } - return false; + insertStringAsLines(bview, linestr); } -bool LyXText::GotoNextNote() const +bool LyXText::gotoNextInset(BufferView * bview, + std::vector const & codes, + string const & contents) const { LyXCursor res = cursor; + Inset * inset; do { - if (res.pos < res.par->Last() - 1) { - res.pos++; + if (res.pos() < res.par()->size() - 1) { + res.pos(res.pos() + 1); } else { - res.par = res.par->Next(); - res.pos = 0; + res.par(res.par()->next()); + res.pos(0); } - } while (res.par && - !(res.par->GetChar(res.pos) == LyXParagraph::META_INSET - && res.par->GetInset(res.pos)->LyxCode() == Inset::IGNORE_CODE)); - - if (res.par) { - SetCursor(res.par, res.pos); + } while (res.par() && + !(res.par()->getChar(res.pos()) == Paragraph::META_INSET + && (inset = res.par()->getInset(res.pos())) != 0 + && find(codes.begin(), codes.end(), inset->lyxCode()) + != codes.end() + && (contents.empty() || + static_cast(res.par()->getInset(res.pos()))->getContents() + == contents))); + + if (res.par()) { + setCursor(bview, res.par(), res.pos()); return true; } return false; } -void LyXText::CheckParagraph(LyXParagraph * par, - LyXParagraph::size_type pos) +void LyXText::checkParagraph(BufferView * bview, Paragraph * par, + Paragraph::size_type pos) { LyXCursor tmpcursor; - - /* table stuff -- begin*/ - - if (par->table) { - CheckParagraphInTable(par, pos); - } - else { - /* table stuff -- end*/ - - long y = 0; - LyXParagraph::size_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(row->previous, paperwidth); - if ( z >= row->pos) { - // set the dimensions of the row above - y -= row->previous->height; - refresh_y = y; - refresh_row = row->previous; - status = LyXText::NEED_MORE_REFRESH; - - BreakAgain(row->previous); - - // set the cursor again. Otherwise - // dangling pointers are possible - SetCursor(cursor.par, cursor.pos); - sel_cursor = cursor; - return; - } + int y = 0; + Paragraph::size_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)); + if (z >= row->pos()) { + // set the dimensions of the row above + y -= row->previous()->height(); + 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(), + false, cursor.boundary()); + selection.cursor = cursor; + return; } + } - int tmpheight = row->height; - LyXParagraph::size_type tmplast = RowLast(row); - refresh_y = y; - refresh_row = row; - - BreakAgain(row); - if (row->height == tmpheight && RowLast(row) == tmplast) - status = LyXText::NEED_VERY_LITTLE_REFRESH; - else - status = LyXText::NEED_MORE_REFRESH; - - // check the special right address boxes - if (textclasslist.Style(buffer->params.textclass, - par->GetLayout()).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(tmpcursor); - } - + int const tmpheight = row->height(); + Paragraph::size_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); + + // check the special right address boxes + if (textclasslist.Style(bview->buffer()->params.textclass, + par->getLayout()).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); } // set the cursor again. Otherwise dangling pointers are possible // also set the selection - if (selection) { + if (selection.set()) { tmpcursor = cursor; - SetCursorIntern(sel_cursor.par, sel_cursor.pos); - sel_cursor = cursor; - SetCursorIntern(sel_start_cursor.par, sel_start_cursor.pos); - sel_start_cursor = cursor; - SetCursorIntern(sel_end_cursor.par, sel_end_cursor.pos); - sel_end_cursor = cursor; - SetCursorIntern(last_sel_cursor.par, last_sel_cursor.pos); + setCursorIntern(bview, selection.cursor.par(), selection.cursor.pos(), + false, selection.cursor.boundary()); + selection.cursor = cursor; + setCursorIntern(bview, selection.start.par(), + selection.start.pos(), + false, selection.start.boundary()); + selection.start = cursor; + setCursorIntern(bview, selection.end.par(), + selection.end.pos(), + false, selection.end.boundary()); + selection.end = cursor; + setCursorIntern(bview, last_sel_cursor.par(), + last_sel_cursor.pos(), + false, last_sel_cursor.boundary()); last_sel_cursor = cursor; cursor = tmpcursor; } - SetCursorIntern(cursor.par, cursor.pos); + setCursorIntern(bview, cursor.par(), cursor.pos(), + false, cursor.boundary()); } -// returns 0 if inset wasn't found -int LyXText::UpdateInset(Inset * inset) +// returns false if inset wasn't found +bool LyXText::updateInset(BufferView * bview, Inset * inset) { // first check the current paragraph - int pos = cursor.par->GetPositionOfInset(inset); + int pos = cursor.par()->getPositionOfInset(inset); if (pos != -1){ - CheckParagraph(cursor.par, pos); - return 1; + checkParagraph(bview, cursor.par(), pos); + return true; } // check every paragraph - LyXParagraph * par = FirstParagraph(); + Paragraph * par = firstParagraph(); do { - // make sure the paragraph is open - if (par->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE){ - pos = par->GetPositionOfInset(inset); - if (pos != -1){ - CheckParagraph(par, pos); - return 1; - } + pos = par->getPositionOfInset(inset); + if (pos != -1){ + checkParagraph(bview, par, pos); + return true; } - par = par->Next(); + par = par->next(); } while (par); - return 0; + return false; } -void LyXText::SetCursor(LyXParagraph * par, - LyXParagraph::size_type pos, bool setfont) const +void LyXText::setCursor(BufferView * bview, Paragraph * par, + Paragraph::size_type pos, + bool setfont, bool boundary) const { LyXCursor old_cursor = cursor; - SetCursorIntern(par, pos, setfont); - DeleteEmptyParagraphMechanism(old_cursor); + setCursorIntern(bview, par, pos, setfont, boundary); + deleteEmptyParagraphMechanism(bview, old_cursor); } -void LyXText::SetCursor(LyXCursor & cur, LyXParagraph * par, - LyXParagraph::size_type pos) const +void LyXText::setCursor(BufferView *bview, LyXCursor & cur, Paragraph * par, + Paragraph::size_type pos, bool boundary) const { - // correct the cursor position if impossible - if (pos > par->Last()){ - LyXParagraph * tmppar = par->ParFromPos(pos); - pos = par->PositionInParFromPos(pos); - par = tmppar; - } - if (par->IsDummy() && par->previous && - par->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { - while (par->previous && - ((par->previous->IsDummy() && - (par->previous->previous->footnoteflag == - LyXParagraph::CLOSED_FOOTNOTE)) || - (par->previous->footnoteflag == - LyXParagraph::CLOSED_FOOTNOTE))) { - par = par->previous ; - if (par->IsDummy() && - (par->previous->footnoteflag == - LyXParagraph::CLOSED_FOOTNOTE)) - pos += par->size() + 1; - } - if (par->previous) { - par = par->previous; - } - pos += par->size() + 1; - } - - cur.par = par; - cur.pos = pos; + cur.par(par); + cur.pos(pos); + cur.boundary(boundary); - /* get the cursor y position in text */ - long y = 0; - Row * row = GetRow(par, pos, y); - /* y is now the beginning of the cursor row */ - y += row->baseline; - /* y is now the cursor baseline */ - cur.y = y; + // 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 += row->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, fill_hfill, fill_label_hfill; - PrepareToPrint(row, x, fill_separator, fill_hfill, fill_label_hfill); - LyXParagraph::size_type cursor_vpos; - LyXParagraph::size_type last = RowLastPrintable(row); + float fill_separator; + float fill_hfill; + float fill_label_hfill; + prepareToPrint(bview, row, x, fill_separator, fill_hfill, + fill_label_hfill); + Paragraph::size_type cursor_vpos = 0; + Paragraph::size_type last = rowLastPrintable(row); if (pos > last + 1) // This shouldn't happen. - pos = last+1; - - if (last < row->pos) - cursor_vpos = 0; - else if ((pos > last) || - ((pos - 1 >= row->pos) && - (row->par->IsSeparator(pos) || - (row->par->table && row->par->IsNewline(pos))))) - /// Place cursor after char at (logical) position pos-1 - cursor_vpos = !(bidi_level(pos-1) % 2) - ? log2vis(pos-1) + 1 : log2vis(pos-1); + pos = last + 1; + else if (pos < row->pos()) + pos = row->pos(); + + if (last < row->pos()) + cursor_vpos = row->pos(); + else if (pos > last && !boundary) + cursor_vpos = (row->par()->isRightToLeftPar(bview->buffer()->params)) + ? row->pos() : last + 1; + else if (pos > row->pos() && + (pos > last || boundary)) + /// Place cursor after char at (logical) position pos - 1 + cursor_vpos = (bidi_level(pos - 1) % 2 == 0) + ? log2vis(pos - 1) + 1 : log2vis(pos - 1); else /// Place cursor before char at (logical) position pos - cursor_vpos = !(bidi_level(pos) % 2) + cursor_vpos = (bidi_level(pos) % 2 == 0) ? log2vis(pos) : log2vis(pos) + 1; - - /* table stuff -- begin*/ - if (row->par->table) { - int cell = NumberOfCell(row->par, row->pos); - float x_old = x; - x += row->par->table->GetBeginningOfTextInCell(cell); - for (LyXParagraph::size_type vpos = row->pos; - vpos < cursor_vpos; ++vpos) { - pos = vis2log(vpos); - if (row->par->IsNewline(pos)) { - x = x_old + row->par->table->WidthOfColumn(cell); - x_old = x; - ++cell; - x += row->par->table->GetBeginningOfTextInCell(cell); - } else { - x += SingleWidth(row->par, pos); - } - } - } else { - /* table stuff -- end*/ - LyXParagraph::size_type main_body = - BeginningOfMainBody(row->par); - if ((main_body > 0) && - ((main_body-1 > last) || - !row->par->IsLineSeparator(main_body-1))) - main_body = 0; - - for (LyXParagraph::size_type vpos = row->pos; - vpos < cursor_vpos; ++vpos) { - pos = vis2log(vpos); - if (main_body > 0 && pos == main_body-1) { - x += fill_label_hfill + - lyxfont::width(textclasslist.Style( - buffer->params.textclass, - row->par->GetLayout()) - .labelsep, - GetFont(row->par, -2)); - if (row->par->IsLineSeparator(main_body-1)) - x -= SingleWidth(row->par,main_body-1); - } - if (HfillExpansion(row, pos)) { - x += SingleWidth(row->par, pos); - if (pos >= main_body) - x += fill_hfill; - else - x += fill_label_hfill; - } else if (row->par->IsSeparator(pos)) { - x += SingleWidth(row->par, pos); - if (pos >= main_body) - x += fill_separator; - } else - x += SingleWidth(row->par, pos); - } + + Paragraph::size_type main_body = + beginningOfMainBody(bview->buffer(), row->par()); + if ((main_body > 0) && + ((main_body-1 > last) || + !row->par()->isLineSeparator(main_body-1))) + main_body = 0; + + for (Paragraph::size_type vpos = row->pos(); + vpos < cursor_vpos; ++vpos) { + pos = vis2log(vpos); + if (main_body > 0 && pos == main_body - 1) { + x += fill_label_hfill + + lyxfont::width(textclasslist.Style( + bview->buffer()->params.textclass, + row->par()->getLayout()) + .labelsep, + getFont(bview->buffer(), row->par(), -2)); + 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 + x += fill_label_hfill; + } else if (row->par()->isSeparator(pos)) { + x += singleWidth(bview, row->par(), pos); + if (pos >= main_body) + x += fill_separator; + } else + x += singleWidth(bview, row->par(), pos); } - - cur.x = int(x); - cur.x_fix = cur.x; - cur.row = row; + + cur.x(int(x)); + cur.x_fix(cur.x()); + cur.row(row); } -void LyXText::SetCursorIntern(LyXParagraph * par, - LyXParagraph::size_type pos, bool setfont) const +void LyXText::setCursorIntern(BufferView * bview, Paragraph * par, + Paragraph::size_type pos, + bool setfont, bool boundary) const { - SetCursor(cursor, par, pos); -// #warning Remove this when verified working (Jug 20000413) -#if 0 - // correct the cursor position if impossible - if (pos > par->Last()){ - LyXParagraph * tmppar = par->ParFromPos(pos); - pos = par->PositionInParFromPos(pos); - par = tmppar; - } - if (par->IsDummy() && par->previous && - par->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { - while (par->previous && - ((par->previous->IsDummy() && par->previous->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) || - (par->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE))) { - par = par->previous ; - if (par->IsDummy() && - par->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - pos += par->size() + 1; - } - if (par->previous) { - par = par->previous; - } - pos += par->size() + 1; + InsetText * it = static_cast(par->inInset()); + if (it && (it != inset_owner)) { + it->getLyXText(bview)->setCursorIntern(bview, par, pos, setfont, + boundary); + } else { + setCursor(bview, cursor, par, pos, boundary); + if (setfont) + setCurrentFont(bview); } +} - cursor.par = par; - cursor.pos = pos; - - /* get the cursor y position in text */ - long y = 0; - Row * row = GetRow(par, pos, y); - /* y is now the beginning of the cursor row */ - y += row->baseline; - /* y is now the cursor baseline */ - cursor.y = y; - - /* now get the cursors x position */ - float x; - float fill_separator, fill_hfill, fill_label_hfill; - PrepareToPrint(row, x, fill_separator, fill_hfill, fill_label_hfill); - LyXParagraph::size_type cursor_vpos; - LyXParagraph::size_type last = RowLastPrintable(row); - if (pos > last + 1) // This shouldn't happen. - pos = last+1; - - if (last < row->pos) - cursor_vpos = 0; - else if (pos > last || - (pos - 1 >= row->pos && - (row->par->IsSeparator(pos) || - (row->par->table && row->par->IsNewline(pos)) - ))) - /// Place cursor after char at (logical) position pos-1 - cursor_vpos = (bidi_level(pos-1) % 2 == 0) - ? log2vis(pos-1) + 1 : log2vis(pos-1); - else - /// Place cursor before char at (logical) position pos - cursor_vpos = (bidi_level(pos) % 2 == 0) - ? log2vis(pos) : log2vis(pos) + 1; +void LyXText::setCurrentFont(BufferView * bview) const +{ + Paragraph::size_type pos = cursor.pos(); + if (cursor.boundary() && pos > 0) + --pos; - /* table stuff -- begin*/ - if (row->par->table) { - int cell = NumberOfCell(row->par, row->pos); - float x_old = x; - x += row->par->table->GetBeginningOfTextInCell(cell); - for (LyXParagraph::size_type vpos = row->pos; vpos < cursor_vpos; ++vpos) { - pos = vis2log(vpos); - if (row->par->IsNewline(pos)) { - x = x_old + row->par->table->WidthOfColumn(cell); - x_old = x; - ++cell; - x += row->par->table->GetBeginningOfTextInCell(cell); - } else { - x += SingleWidth(row->par, pos); - } - } - } else { - /* table stuff -- end*/ - LyXParagraph::size_type main_body = - BeginningOfMainBody(row->par); - if (main_body > 0 && - (main_body-1 > last || - !row->par->IsLineSeparator(main_body-1))) - main_body = 0; - - for (LyXParagraph::size_type vpos = row->pos; vpos < cursor_vpos; ++vpos) { - pos = vis2log(vpos); - if (main_body > 0 && pos == main_body-1) { - x += fill_label_hfill + - lyxfont::width(textclasslist - .Style(buffer->params.textclass, - row->par->GetLayout()) - .labelsep, - GetFont(row->par, -2)); - if (row->par->IsLineSeparator(main_body-1)) - x -= SingleWidth(row->par, main_body-1); - } - if (HfillExpansion(row, pos)) { - x += SingleWidth(row->par, pos); - if (pos >= main_body) - x += fill_hfill; - else - x += fill_label_hfill; + if (pos > 0) { + 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; } - else if (row->par->IsSeparator(pos)) { - x += SingleWidth(row->par, pos); - if (pos >= main_body) - x += fill_separator; - } else - x += SingleWidth(row->par, pos); - } } - - cursor.x = int(x); - - cursor.x_fix = cursor.x; - cursor.row = row; -#endif - if (setfont) { - if (cursor.pos && - (cursor.pos == cursor.par->Last() || cursor.par->IsSeparator(cursor.pos) - || (cursor.par->table && cursor.par->IsNewline(cursor.pos)) - )) { - current_font = cursor.par->GetFontSettings(cursor.pos - 1); - real_current_font = GetFont(cursor.par, cursor.pos - 1); - } else { - current_font = cursor.par->GetFontSettings(cursor.pos); - real_current_font = GetFont(cursor.par, cursor.pos); - } + + current_font = + cursor.par()->getFontSettings(bview->buffer()->params, pos); + real_current_font = getFont(bview->buffer(), cursor.par(), pos); + + if (cursor.pos() == cursor.par()->size() && + isBoundary(bview->buffer(), cursor.par(), cursor.pos()) && + !cursor.boundary()) { + Language const * lang = + cursor.par()->getParLanguage(bview->buffer()->params); + current_font.setLanguage(lang); + current_font.setNumber(LyXFont::OFF); + real_current_font.setLanguage(lang); + real_current_font.setNumber(LyXFont::OFF); } } -void LyXText::SetCursorFromCoordinates(int x, long y) const +void LyXText::setCursorFromCoordinates(BufferView * bview, int x, int y) const { LyXCursor old_cursor = cursor; - - /* get the row first */ - - Row * row = GetRowNearY(y); - - cursor.par = row->par; - - int column = GetColumnNearX(row, x); - cursor.pos = row->pos + column; - cursor.x = x; - cursor.y = y + row->baseline; - - cursor.row = row; - - if (cursor.pos && - (cursor.pos == cursor.par->Last() - || cursor.par->IsSeparator(cursor.pos) - || (cursor.pos && cursor.pos == BeginningOfMainBody(cursor.par) - && !cursor.par->IsSeparator(cursor.pos)) - || (cursor.par->table && cursor.par->IsNewline(cursor.pos)) - )) { - current_font = cursor.par->GetFontSettings(cursor.pos - 1); - real_current_font = GetFont(cursor.par, cursor.pos - 1); - } else { - current_font = cursor.par->GetFontSettings(cursor.pos); - real_current_font = GetFont(cursor.par, cursor.pos); - } - DeleteEmptyParagraphMechanism(old_cursor); -} -void LyXText::SetCursorFromCoordinates(LyXCursor & cur, int x, long y) const -{ - /* get the row first */ - - Row * row = GetRowNearY(y); - int column = GetColumnNearX(row, x); +#if 0 + // Get the row first. - cur.par = row->par; - cur.pos = row->pos + column; - cur.x = x; - cur.y = y + row->baseline; - cur.row = row; -} + Row * row = getRowNearY(y); + bool bound = false; + int column = getColumnNearX(bview, row, x, bound); -void LyXText::CursorLeft() const -{ - CursorLeftIntern(); - if (cursor.par->table) { - int cell = NumberOfCell(cursor.par, cursor.pos); - if (cursor.par->table->IsContRow(cell) && - cursor.par->table->CellHasContRow(cursor.par->table->GetCellAbove(cell)) < 0) { - CursorUp(); - } - } + 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); } -void LyXText::CursorLeftIntern() const +void LyXText::setCursorFromCoordinates(BufferView * bview, LyXCursor & cur, + int x, int y) const { - if (cursor.pos > 0) { - SetCursor(cursor.par, cursor.pos - 1); - } - else if (cursor.par->Previous()) { // steps into the above paragraph. - SetCursor(cursor.par->Previous(), cursor.par->Previous()->Last()); - } + // Get the row first. + + Row * row = getRowNearY(y); + bool bound = false; + int const column = getColumnNearX(bview, row, x, bound); + + cur.par(row->par()); + cur.pos(row->pos() + column); + cur.x(x); + cur.y(y + row->baseline()); + cur.row(row); + cur.boundary(bound); } -void LyXText::CursorRight() const +void LyXText::cursorLeft(BufferView * bview, bool internal) const { - CursorRightIntern(); - if (cursor.par->table) { - int cell = NumberOfCell(cursor.par, cursor.pos); - if (cursor.par->table->IsContRow(cell) && - cursor.par->table->CellHasContRow(cursor.par->table->GetCellAbove(cell))<0) { - CursorUp(); - } - } + if (cursor.pos() > 0) { + bool boundary = cursor.boundary(); + setCursor(bview, cursor.par(), cursor.pos() - 1, true, false); + if (!internal && !boundary && + isBoundary(bview->buffer(), cursor.par(), cursor.pos() + 1)) + setCursor(bview, cursor.par(), cursor.pos() + 1, true, true); + } else if (cursor.par()->previous()) { // steps into the above paragraph. + Paragraph * par = cursor.par()->previous(); + setCursor(bview, par, par->size()); + } } -void LyXText::CursorRightIntern() const +void LyXText::cursorRight(BufferView * bview, bool internal) const { - if (cursor.pos < cursor.par->Last()) { - SetCursor(cursor.par, cursor.pos + 1); - } - else if (cursor.par->Next()) { - SetCursor(cursor.par->Next(), 0); - } + if (!internal && cursor.boundary() && + !cursor.par()->isNewline(cursor.pos())) + setCursor(bview, cursor.par(), cursor.pos(), true, false); + else if (cursor.pos() < cursor.par()->size()) { + setCursor(bview, cursor.par(), cursor.pos() + 1, true, false); + if (!internal && + isBoundary(bview->buffer(), cursor.par(), cursor.pos())) + setCursor(bview, cursor.par(), cursor.pos(), true, true); + } else if (cursor.par()->next()) + setCursor(bview, cursor.par()->next(), 0); } -void LyXText::CursorUp() const +void LyXText::cursorUp(BufferView * bview) const { - SetCursorFromCoordinates(cursor.x_fix, - cursor.y - cursor.row->baseline - 1); - if (cursor.par->table) { - int cell = NumberOfCell(cursor.par, cursor.pos); - if (cursor.par->table->IsContRow(cell) && - cursor.par->table->CellHasContRow(cursor.par->table->GetCellAbove(cell))<0) { - CursorUp(); - } - } + setCursorFromCoordinates(bview, cursor.x_fix(), + cursor.y() - cursor.row()->baseline() - 1); } -void LyXText::CursorDown() const +void LyXText::cursorDown(BufferView * bview) const { - if (cursor.par->table && - cursor.par->table->ShouldBeVeryLastRow(NumberOfCell(cursor.par, cursor.pos)) && - !cursor.par->next) - return; - SetCursorFromCoordinates(cursor.x_fix, - cursor.y - cursor.row->baseline - + cursor.row->height + 1); - if (cursor.par->table) { - int cell = NumberOfCell(cursor.par, cursor.pos); - int cell_above = cursor.par->table->GetCellAbove(cell); - while(cursor.par->table && - cursor.par->table->IsContRow(cell) && - (cursor.par->table->CellHasContRow(cell_above)<0)) { - SetCursorFromCoordinates(cursor.x_fix, - cursor.y - cursor.row->baseline - + cursor.row->height + 1); - if (cursor.par->table) { - cell = NumberOfCell(cursor.par, cursor.pos); - cell_above = cursor.par->table->GetCellAbove(cell); - } - } - } + setCursorFromCoordinates(bview, cursor.x_fix(), + cursor.y() - cursor.row()->baseline() + + cursor.row()->height() + 1); } -void LyXText::CursorUpParagraph() const +void LyXText::cursorUpParagraph(BufferView * bview) const { - if (cursor.pos > 0) { - SetCursor(cursor.par, 0); + if (cursor.pos() > 0) { + setCursor(bview, cursor.par(), 0); } - else if (cursor.par->Previous()) { - SetCursor(cursor.par->Previous(), 0); + else if (cursor.par()->previous()) { + setCursor(bview, cursor.par()->previous(), 0); } } -void LyXText::CursorDownParagraph() const +void LyXText::cursorDownParagraph(BufferView * bview) const { - if (cursor.par->Next()) { - SetCursor(cursor.par->Next(), 0); + if (cursor.par()->next()) { + setCursor(bview, cursor.par()->next(), 0); } else { - SetCursor(cursor.par, cursor.par->Last()); + setCursor(bview, cursor.par(), cursor.par()->size()); } } - -void LyXText::DeleteEmptyParagraphMechanism(LyXCursor const & old_cursor) const +void LyXText::deleteEmptyParagraphMechanism(BufferView * bview, + LyXCursor const & old_cursor) const { // Would be wrong to delete anything if we have a selection. - if (selection) return; + if (selection.set()) return; // We allow all kinds of "mumbo-jumbo" when freespacing. - if (textclasslist.Style(buffer->params.textclass, - old_cursor.par->GetLayout()).free_spacing) + if (textclasslist.Style(bview->buffer()->params.textclass, + old_cursor.par()->getLayout()).free_spacing) return; bool deleted = false; @@ -3570,531 +2297,252 @@ void LyXText::DeleteEmptyParagraphMechanism(LyXCursor const & old_cursor) const that I can get some feedback. (Lgb) */ - // If old_cursor.pos == 0 and old_cursor.pos(1) == LineSeparator + // If old_cursor.pos() == 0 and old_cursor.pos()(1) == LineSeparator // delete the LineSeparator. // MISSING - // If old_cursor.pos == 1 and old_cursor.pos(0) == LineSeparator + // If old_cursor.pos() == 1 and old_cursor.pos()(0) == LineSeparator // delete the LineSeparator. // MISSING // If the pos around the old_cursor were spaces, delete one of them. - if (old_cursor.par != cursor.par || old_cursor.pos != cursor.pos) { // Only if the cursor has really moved + if (old_cursor.par() != cursor.par() || old_cursor.pos() != cursor.pos()) { + // Only if the cursor has really moved - if (old_cursor.pos > 0 - && old_cursor.pos < old_cursor.par->Last() - && old_cursor.par->IsLineSeparator(old_cursor.pos) - && old_cursor.par->IsLineSeparator(old_cursor.pos - 1)) { - old_cursor.par->Erase(old_cursor.pos - 1); - RedoParagraphs(old_cursor, old_cursor.par->Next()); + if (old_cursor.pos() > 0 + && old_cursor.pos() < old_cursor.par()->size() + && old_cursor.par()->isLineSeparator(old_cursor.pos()) + && old_cursor.par()->isLineSeparator(old_cursor.pos() - 1)) { + old_cursor.par()->erase(old_cursor.pos() - 1); + redoParagraphs(bview, old_cursor, old_cursor.par()->next()); // correct cursor - if (old_cursor.par == cursor.par && - cursor.pos > old_cursor.pos) { - SetCursorIntern(cursor.par, cursor.pos - 1); + if (old_cursor.par() == cursor.par() && + cursor.pos() > old_cursor.pos()) { + setCursorIntern(bview, cursor.par(), + cursor.pos() - 1); } else - SetCursorIntern(cursor.par, cursor.pos); + setCursorIntern(bview, cursor.par(), + cursor.pos()); return; } } // Do not delete empty paragraphs with keepempty set. - if ((textclasslist.Style(buffer->params.textclass, - old_cursor.par->GetLayout())).keepempty) + if ((textclasslist.Style(bview->buffer()->params.textclass, + old_cursor.par()->getLayout())).keepempty) return; LyXCursor tmpcursor; - if (old_cursor.par != cursor.par) { - if ( (old_cursor.par->Last() == 0 - || (old_cursor.par->Last() == 1 - && old_cursor.par->IsLineSeparator(0))) - && old_cursor.par->FirstPhysicalPar() - == old_cursor.par->LastPhysicalPar()) { + if (old_cursor.par() != cursor.par()) { + if ((old_cursor.par()->size() == 0 + || (old_cursor.par()->size() == 1 + && old_cursor.par()->isLineSeparator(0)))) { // ok, we will delete anything // make sure that you do not delete any environments - if ((old_cursor.par->footnoteflag != LyXParagraph::OPEN_FOOTNOTE && - !(old_cursor.row->previous - && old_cursor.row->previous->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) - && !(old_cursor.row->next - && old_cursor.row->next->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE)) - || (old_cursor.par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE - && ((old_cursor.row->previous - && old_cursor.row->previous->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) - || (old_cursor.row->next - && old_cursor.row->next->par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE)) - )) { - status = 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 - LyXParagraph * endpar = old_cursor.par->next; - if (endpar && endpar->GetDepth()) { - while (endpar && endpar->GetDepth()) { - endpar = endpar->LastPhysicalPar()->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(); } - SetUndo(Undo::DELETE, - old_cursor.par->previous, - endpar); - cursor = tmpcursor; - - // delete old row - RemoveRow(old_cursor.row); - if (buffer->paragraph == old_cursor.par) { - buffer->paragraph = buffer->paragraph->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(refresh_row->next); - UpdateCounters(refresh_row); - } - SetHeightOfRow(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 - LyXParagraph *endpar = old_cursor.par->next; - if (endpar && endpar->GetDepth()) { - while (endpar && endpar->GetDepth()) { - endpar = endpar->LastPhysicalPar()->Next(); - } - } - SetUndo(Undo::DELETE, - old_cursor.par->previous, - endpar); - cursor = tmpcursor; - - // delete old row - RemoveRow(old_cursor.row); - // delete old par - if (buffer->paragraph == old_cursor.par) { - buffer->paragraph = buffer->paragraph->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(); } - delete old_cursor.par; + } + 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(); - /* 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(refresh_row); - UpdateCounters(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(cursor.par, cursor.pos); + setCursorIntern(bview, cursor.par(), cursor.pos()); - if (sel_cursor.par == old_cursor.par - && sel_cursor.pos == sel_cursor.pos) { - // correct selection - sel_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->ClearParagraph()) { - RedoParagraphs(old_cursor, old_cursor.par->Next()); + if (old_cursor.par()->stripLeadingSpaces(bview->buffer()->params.textclass)) { + redoParagraphs(bview, old_cursor, old_cursor.par()->next()); // correct cursor y - SetCursorIntern(cursor.par, cursor.pos); - sel_cursor = cursor; + setCursorIntern(bview, cursor.par(), cursor.pos()); + selection.cursor = cursor; } } } } -LyXParagraph * LyXText::GetParFromID(int id) +void LyXText::toggleAppendix(BufferView * bview) { - LyXParagraph * result = FirstParagraph(); - while (result && result->id() != id) - result = result->next; - return result; -} + Paragraph * par = cursor.par(); + bool start = !par->params().startOfAppendix(); - -// undo functions -bool LyXText::TextUndo() -{ - // returns false if no undo possible - Undo * undo = buffer->undostack.pop(); - if (undo) { - FinishUndo(); - if (!undo_frozen) - buffer->redostack - .push(CreateUndo(undo->kind, - GetParFromID(undo->number_of_before_par), - GetParFromID(undo->number_of_behind_par))); + // ensure that we have only one start_of_appendix in this document + Paragraph * tmp = firstParagraph(); + for (; tmp; tmp = tmp->next()) { + tmp->params().startOfAppendix(false); } - return TextHandleUndo(undo); -} - + + par->params().startOfAppendix(start); -bool LyXText::TextRedo() -{ - // returns false if no redo possible - Undo * undo = buffer->redostack.pop(); - if (undo) { - FinishUndo(); - if (!undo_frozen) - buffer->undostack - .push(CreateUndo(undo->kind, - GetParFromID(undo->number_of_before_par), - GetParFromID(undo->number_of_behind_par))); - } - return TextHandleUndo(undo); + // 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()); } -bool LyXText::TextHandleUndo(Undo * undo) +Paragraph * LyXText::ownerParagraph() const { - // returns false if no undo possible - bool result = false; - if (undo) { - LyXParagraph * before = - GetParFromID(undo->number_of_before_par); - LyXParagraph * behind = - GetParFromID(undo->number_of_behind_par); - LyXParagraph * tmppar; - LyXParagraph * tmppar2; - LyXParagraph * endpar; - LyXParagraph * tmppar5; - - // if there's no before take the beginning - // of the document for redoing - if (!before) - SetCursorIntern(FirstParagraph(), 0); - - // replace the paragraphs with the undo informations - - LyXParagraph * tmppar3 = undo->par; - undo->par = 0; // otherwise the undo destructor would delete the paragraph - LyXParagraph * tmppar4 = tmppar3; - if (tmppar4){ - while (tmppar4->next) - tmppar4 = tmppar4->next; - } // get last undo par - - // now remove the old text if there is any - if (before != behind || (!behind && !before)){ - if (before) - tmppar5 = before->next; - else - tmppar5 = buffer->paragraph; - tmppar2 = tmppar3; - while (tmppar5 && tmppar5 != behind){ - tmppar = tmppar5; - tmppar5 = tmppar5->next; - // a memory optimization for edit: Only layout information - // is stored in the undo. So restore the text informations. - if (undo->kind == Undo::EDIT) { - tmppar2->setContentsFromPar(tmppar); - tmppar->clearContents(); - tmppar2 = tmppar2->next; - } - } - } - - // put the new stuff in the list if there is one - if (tmppar3){ - if (before) - before->next = tmppar3; - else - buffer->paragraph = tmppar3; - tmppar3->previous = before; - } - else { - if (!before) - buffer->paragraph = behind; - } - if (tmppar4) { - tmppar4->next = behind; - if (behind) - behind->previous = tmppar4; - } - - - // Set the cursor for redoing - if (before) { - SetCursorIntern(before->FirstSelfrowPar(), 0); - // check wether before points to a closed float and open it if necessary - if (before && before->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE - && before->next && before->next->footnoteflag != LyXParagraph::NO_FOOTNOTE){ - tmppar4 = before; - while (tmppar4->previous && - tmppar4->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - tmppar4 = tmppar4->previous; - while (tmppar4 && tmppar4->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE){ - tmppar4->footnoteflag = LyXParagraph::OPEN_FOOTNOTE; - tmppar4 = tmppar4->next; - } - } - } - - // open a cosed footnote at the end if necessary - if (behind && behind->previous && - behind->previous->footnoteflag != LyXParagraph::NO_FOOTNOTE && - behind->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE){ - while (behind && behind->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE){ - behind->footnoteflag = LyXParagraph::OPEN_FOOTNOTE; - behind = behind->next; - } - } - - // calculate the endpar for redoing the paragraphs. - if (behind){ - if (behind->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) - endpar = behind->LastPhysicalPar()->Next(); - else - endpar = behind->NextAfterFootnote()->LastPhysicalPar()->Next(); - } - else - endpar = behind; - - tmppar = GetParFromID(undo->number_of_cursor_par); - RedoParagraphs(cursor, endpar); - if (tmppar){ - SetCursorIntern(tmppar, undo->cursor_pos); - UpdateCounters(cursor.row); - } - result = true; - delete undo; + if (inset_owner) { + return inset_owner->paragraph(); } - FinishUndo(); - return result; + return bv_owner->buffer()->paragraph; } -void LyXText::FinishUndo() +Paragraph * LyXText::ownerParagraph(Paragraph * p) const { - // makes sure the next operation will be stored - undo_finished = True; -} - - -void LyXText::FreezeUndo() -{ - // this is dangerous and for internal use only - undo_frozen = True; -} - - -void LyXText::UnFreezeUndo() -{ - // this is dangerous and for internal use only - undo_frozen = false; + if (inset_owner) { + inset_owner->paragraph(p); + } else { + bv_owner->buffer()->paragraph = p; + } + return 0; } - -void LyXText::SetUndo(Undo::undo_kind kind, LyXParagraph const * before, - LyXParagraph const * behind) const +Paragraph * LyXText::ownerParagraph(int id, Paragraph * p) const { - if (!undo_frozen) - buffer->undostack.push(CreateUndo(kind, before, behind)); - buffer->redostack.clear(); + Paragraph * op = bv_owner->buffer()->getParFromID(id); + if (op && op->inInset()) { + static_cast(op->inInset())->paragraph(p); + } else { + if (inset_owner) { + inset_owner->paragraph(p); + } else { + bv_owner->buffer()->paragraph = p; + } + } + return 0; } -void LyXText::SetRedo(Undo::undo_kind kind, LyXParagraph const * before, - LyXParagraph const * behind) +LyXText::text_status LyXText::status() const { - buffer->redostack.push(CreateUndo(kind, before, behind)); + return status_; } -Undo * LyXText::CreateUndo(Undo::undo_kind kind, LyXParagraph const * before, - LyXParagraph const * behind) const +void LyXText::status(BufferView * bview, LyXText::text_status st) const { - int before_number = -1; - int behind_number = -1; - if (before) - before_number = before->id(); - if (behind) - behind_number = behind->id(); - // Undo::EDIT and Undo::FINISH are - // always finished. (no overlapping there) - // overlapping only with insert and delete inside one paragraph: - // Nobody wants all removed character - // appear one by one when undoing. - // EDIT is special since only layout information, not the - // contents of a paragaph are stored. - if (!undo_finished && kind != Undo::EDIT && - kind != Undo::FINISH){ - // check wether storing is needed - if (!buffer->undostack.empty() && - buffer->undostack.top()->kind == kind && - buffer->undostack.top()->number_of_before_par == before_number && - buffer->undostack.top()->number_of_behind_par == behind_number ){ - // no undo needed - return 0; +#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); } } - // create a new Undo - LyXParagraph * undopar; - LyXParagraph * tmppar; - LyXParagraph * tmppar2; - - LyXParagraph * start = 0; - LyXParagraph * end = 0; - - if (before) - start = before->next; - else - start = FirstParagraph(); - if (behind) - end = behind->previous; - else { - end = FirstParagraph(); - while (end->next) - end = end->next; - } - - if (start && end - && start != end->next - && (before != behind || (!before && !behind))) { - tmppar = start; - tmppar2 = tmppar->Clone(); - tmppar2->id(tmppar->id()); - - // a memory optimization: Just store the layout information - // when only edit - if (kind == Undo::EDIT){ - //tmppar2->text.clear(); - tmppar2->clearContents(); - } - - undopar = tmppar2; - - while (tmppar != end && tmppar->next) { - tmppar = tmppar->next; - tmppar2->next = tmppar->Clone(); - tmppar2->next->id(tmppar->id()); - // a memory optimization: Just store the layout - // information when only edit - if (kind == Undo::EDIT){ - //tmppar2->next->text.clear(); - tmppar2->clearContents(); +#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) { + 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(); } - tmppar2->next->previous = tmppar2; - tmppar2 = tmppar2->next; } - tmppar2->next = 0; - } else - undopar = 0; // nothing to replace (undo of delete maybe) - - int cursor_par = cursor.par->ParFromPos(cursor.pos)->id(); - int cursor_pos = cursor.par->PositionInParFromPos(cursor.pos); - - Undo * undo = new Undo(kind, - before_number, behind_number, - cursor_par, cursor_pos, - undopar); - - undo_finished = false; - return undo; -} - - -void LyXText::SetCursorParUndo() -{ - SetUndo(Undo::FINISH, - cursor.par->ParFromPos(cursor.pos)->previous, - cursor.par->ParFromPos(cursor.pos)->next); -} - - -void LyXText::RemoveTableRow(LyXCursor * cur) const -{ - int cell = -1; - int cell_org = 0; - int ocell = 0; - - // move to the previous row - int cell_act = NumberOfCell(cur->par, cur->pos); - if (cell < 0) - cell = cell_act; - while (cur->pos && !cur->par->IsNewline(cur->pos - 1)) - cur->pos--; - while (cur->pos && - !cur->par->table->IsFirstCell(cell_act)) { - cur->pos--; - while (cur->pos && !cur->par->IsNewline(cur->pos - 1)) - cur->pos--; - --cell; - --cell_act; } - // now we have to pay attention if the actual table is the - // main row of TableContRows and if yes to delete all of them - if (!cell_org) - cell_org = cell; - do { - ocell = cell; - // delete up to the next row - while (cur->pos < cur->par->Last() && - (cell_act == ocell - || !cur->par->table->IsFirstCell(cell_act))) { - while (cur->pos < cur->par->Last() && - !cur->par->IsNewline(cur->pos)) - cur->par->Erase(cur->pos); - ++cell; - ++cell_act; - if (cur->pos < cur->par->Last()) - cur->par->Erase(cur->pos); - } - if (cur->pos && cur->pos == cur->par->Last()) { - cur->pos--; - cur->par->Erase(cur->pos); // no newline at very end! - } - } while (((cell + 1) < cur->par->table->GetNumberOfCells()) && - !cur->par->table->IsContRow(cell_org) && - cur->par->table->IsContRow(cell)); - cur->par->table->DeleteRow(cell_org); - return; -} - - -bool LyXText::IsEmptyTableCell() const -{ - LyXParagraph::size_type pos = cursor.pos - 1; - while (pos >= 0 && pos < cursor.par->Last() - && !cursor.par->IsNewline(pos)) - --pos; - return cursor.par->IsNewline(pos + 1); -} - - -void LyXText::toggleAppendix(){ - LyXParagraph * par = cursor.par->FirstPhysicalPar(); - bool start = !par->start_of_appendix; - - // ensure that we have only one start_of_appendix in this document - LyXParagraph * tmp = FirstParagraph(); - for (; tmp; tmp = tmp->next) - tmp->start_of_appendix = 0; - par->start_of_appendix = start; - - // we can set the refreshing parameters now - status = LyXText::NEED_MORE_REFRESH; - refresh_y = 0; - refresh_row = 0; // not needed for full update - UpdateCounters(0); - SetCursor(cursor.par, cursor.pos); +#endif } -