X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsettext.C;h=ffcd351f4f8e458eb705be34d2c2586f050dd729;hb=a8e8e755fc32233e91bf787d5032fd81147d0909;hp=b191f313eadedfba2f6bcbf4d74a39d9493be45e;hpb=6b5c9696b6669b48062bec96707c78d605e1af58;p=lyx.git diff --git a/src/insets/insettext.C b/src/insets/insettext.C index b191f313ea..ffcd351f4f 100644 --- a/src/insets/insettext.C +++ b/src/insets/insettext.C @@ -1,54 +1,60 @@ -/* This file is part of - * ====================================================== +/** + * \file insettext.C + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. * - * LyX, The Document Processor + * \author Jürgen Vigna * - * Copyright 1998-2001 The LyX Team. - * - * ====================================================== + * Full author contact details are available in file CREDITS */ #include -#ifdef __GNUG__ -#pragma implementation -#endif - #include "insettext.h" -#include "paragraph.h" -#include "lyxlex.h" -#include "debug.h" -#include "lyxfont.h" -#include "commandtags.h" + #include "buffer.h" -#include "frontends/LyXView.h" #include "BufferView.h" -#include "LaTeXFeatures.h" -#include "frontends/Painter.h" -#include "lyxtext.h" -#include "lyxcursor.h" #include "CutAndPaste.h" -#include "frontends/font_metrics.h" +#include "debug.h" +#include "dimension.h" +#include "funcrequest.h" +#include "gettext.h" +#include "intl.h" +#include "LaTeXFeatures.h" #include "LColor.h" +#include "Lsstream.h" +#include "lyxfont.h" +#include "lyxcursor.h" +#include "lyxfind.h" +#include "lyxlex.h" #include "lyxrow.h" #include "lyxrc.h" -#include "intl.h" -#include "trans_mgr.h" -#include "frontends/screen.h" -#include "gettext.h" -#include "lyxfunc.h" +#include "lyxtext.h" +#include "paragraph.h" #include "ParagraphParameters.h" +#include "trans_mgr.h" #include "undo_funcs.h" -#include "lyxfind.h" +#include "WordLangTuple.h" +#include "paragraph_funcs.h" +#include "sgml.h" +#include "rowpainter.h" +#include "insetnewline.h" +#include "Lsstream.h" #include "frontends/Alert.h" #include "frontends/Dialogs.h" +#include "frontends/font_metrics.h" +#include "frontends/LyXView.h" +#include "frontends/Painter.h" +#include "frontends/screen.h" #include "support/textutils.h" #include "support/LAssert.h" #include "support/lstrings.h" #include "support/lyxalgo.h" // lyx::count +#include + #include #include #include @@ -62,67 +68,62 @@ using std::max; using std::make_pair; using std::vector; using std::pair; +using std::for_each; using lyx::pos_type; using lyx::textclass_type; -extern unsigned char getCurrentTextClass(Buffer *); -extern bool math_insert_greek(BufferView *, char); -extern int greek_kb_flag; - // These functions should probably go into bufferview_funcs somehow (Jug) void InsetText::saveLyXTextState(LyXText * t) const { // check if my paragraphs are still valid - Paragraph * p = par; - while (p) { - if (p == t->cursor.par()) + ParagraphList::iterator it = paragraphs.begin(); + ParagraphList::iterator end = paragraphs.end(); + for (; it != end; ++it) { + if (&*it == t->cursor.par()) break; - p = p->next(); } - if (p && t->cursor.pos() <= p->size()) { - sstate.lpar = t->cursor.par(); + if (it != end && t->cursor.pos() <= it->size()) { + sstate.lpar = &*t->cursor.par(); sstate.pos = t->cursor.pos(); sstate.boundary = t->cursor.boundary(); - sstate.selstartpar = t->selection.start.par(); + sstate.selstartpar = &*t->selection.start.par(); sstate.selstartpos = t->selection.start.pos(); sstate.selstartboundary = t->selection.start.boundary(); - sstate.selendpar = t->selection.end.par(); + sstate.selendpar = &*t->selection.end.par(); sstate.selendpos = t->selection.end.pos(); sstate.selendboundary = t->selection.end.boundary(); sstate.selection = t->selection.set(); sstate.mark_set = t->selection.mark(); - sstate.refresh = t->refresh_row != 0; } else { sstate.lpar = 0; } } -void InsetText::restoreLyXTextState(BufferView * bv, LyXText * t) const + +void InsetText::restoreLyXTextState(LyXText * t) const { - if (sstate.lpar) { - t->selection.set(true); - /* at this point just to avoid the Delete-Empty-Paragraph - * Mechanism when setting the cursor */ - t->selection.mark(sstate.mark_set); - if (sstate.selection) { - t->setCursor(bv, sstate.selstartpar, sstate.selstartpos, - true, sstate.selstartboundary); - t->selection.cursor = t->cursor; - t->setCursor(bv, sstate.selendpar, sstate.selendpos, - true, sstate.selendboundary); - t->setSelection(bv); - t->setCursor(bv, sstate.lpar, sstate.pos); - } else { - t->setCursor(bv, sstate.lpar, sstate.pos, true, sstate.boundary); - t->selection.cursor = t->cursor; - t->selection.set(false); - } - if (sstate.refresh) { - } + if (!sstate.lpar) + return; + + t->selection.set(true); + /* at this point just to avoid the DEPM when setting the cursor */ + t->selection.mark(sstate.mark_set); + if (sstate.selection) { + t->setCursor(sstate.selstartpar, sstate.selstartpos, + true, sstate.selstartboundary); + t->selection.cursor = t->cursor; + t->setCursor(sstate.selendpar, sstate.selendpos, + true, sstate.selendboundary); + t->setSelection(); + t->setCursor(sstate.lpar, sstate.pos); + } else { + t->setCursor(sstate.lpar, sstate.pos, true, sstate.boundary); + t->selection.cursor = t->cursor; + t->selection.set(false); } } @@ -138,21 +139,30 @@ InsetText::InsetText(BufferParams const & bp) : UpdatableInset(), lt(0), in_update(false), do_resize(0), do_reinit(false) { - par = new Paragraph; - par->layout(bp.getLyXTextClass().defaultLayout()); - init(); + paragraphs.push_back(Paragraph()); + paragraphs.begin()->layout(bp.getLyXTextClass().defaultLayout()); + if (bp.tracking_changes) + paragraphs.begin()->trackChanges(); + init(0); } -InsetText::InsetText(InsetText const & in, bool same_id) - : UpdatableInset(in, same_id), lt(0), in_update(false), do_resize(0), +InsetText::InsetText(InsetText const & in) + : UpdatableInset(in), lt(0), in_update(false), do_resize(0), do_reinit(false) { - par = 0; - init(&in, same_id); + init(&in); } +// InsetText::InsetText(InsetText const & in, bool same_id) +// : UpdatableInset(in, same_id), lt(0), in_update(false), do_resize(0), +// do_reinit(false) +// { +// init(&in, same_id); +// } + + InsetText & InsetText::operator=(InsetText const & it) { init(&it); @@ -160,85 +170,113 @@ InsetText & InsetText::operator=(InsetText const & it) } -void InsetText::init(InsetText const * ins, bool same_id) +void InsetText::init(InsetText const * ins) { if (ins) { - setParagraphData(ins->par, same_id); + setParagraphData(ins->paragraphs); autoBreakRows = ins->autoBreakRows; drawFrame_ = ins->drawFrame_; frame_color = ins->frame_color; - if (same_id) - id_ = ins->id_; } else { - Paragraph * p = par; - while (p) { - p->setInsetOwner(this); - p = p->next(); - } + for_each(paragraphs.begin(), paragraphs.end(), + boost::bind(&Paragraph::setInsetOwner, _1, this)); + the_locking_inset = 0; drawFrame_ = NEVER; frame_color = LColor::insetframe; autoBreakRows = false; } top_y = 0; - insetAscent = 0; - insetDescent = 0; - insetWidth = 0; old_max_width = 0; no_selection = true; need_update = FULL; drawTextXOffset = 0; drawTextYOffset = 0; - xpos = 0.0; locked = false; old_par = 0; last_drawn_width = -1; - frame_is_visible = false; cached_bview = 0; sstate.lpar = 0; in_insetAllowed = false; } -InsetText::~InsetText() -{ - cached_bview = 0; +// void InsetText::init(InsetText const * ins, bool same_id) +// { +// if (ins) { +// setParagraphData(ins->paragraphs, same_id); +// autoBreakRows = ins->autoBreakRows; +// drawFrame_ = ins->drawFrame_; +// frame_color = ins->frame_color; +// if (same_id) +// id_ = ins->id_; +// } else { +// for_each(paragraphs.begin(), paragraphs.end(), +// boost::bind(&Paragraph::setInsetOwner, _1, this)); + +// the_locking_inset = 0; +// drawFrame_ = NEVER; +// frame_color = LColor::insetframe; +// autoBreakRows = false; +// } +// top_y = 0; +// old_max_width = 0; +// no_selection = true; +// need_update = FULL; +// drawTextXOffset = 0; +// drawTextYOffset = 0; +// locked = false; +// old_par = 0; +// last_drawn_width = -1; +// cached_bview = 0; +// sstate.lpar = 0; +// in_insetAllowed = false; +// } - // NOTE - while (par) { - Paragraph * tmp = par->next(); - delete par; - par = tmp; - } +InsetText::~InsetText() +{ + paragraphs.clear(); } -void InsetText::clear() +void InsetText::clear(bool just_mark_erased) { + if (just_mark_erased) { + ParagraphList::iterator it = paragraphs.begin(); + ParagraphList::iterator end = paragraphs.end(); + for (; it != end; ++it) { + it->markErased(); + } + need_update = FULL; + return; + } + // This is a gross hack... - LyXLayout_ptr old_layout = par->layout(); + LyXLayout_ptr old_layout = paragraphs.begin()->layout(); - while (par) { - Paragraph * tmp = par->next(); - delete par; - par = tmp; - } - par = new Paragraph; - par->setInsetOwner(this); - par->layout(old_layout); + paragraphs.clear(); + paragraphs.push_back(Paragraph()); + paragraphs.begin()->setInsetOwner(this); + paragraphs.begin()->layout(old_layout); reinitLyXText(); need_update = INIT; } -Inset * InsetText::clone(Buffer const &, bool same_id) const +Inset * InsetText::clone(Buffer const &) const { - return new InsetText(*this, same_id); + return new InsetText(*this); } +// Inset * InsetText::clone(Buffer const &, bool same_id) const +// { +// return new InsetText(*this, same_id); +// } + + void InsetText::write(Buffer const * buf, ostream & os) const { os << "Text\n"; @@ -248,19 +286,28 @@ void InsetText::write(Buffer const * buf, ostream & os) const void InsetText::writeParagraphData(Buffer const * buf, ostream & os) const { - par->writeFile(buf, os, buf->params, 0); + ParagraphList::iterator it = paragraphs.begin(); + ParagraphList::iterator end = paragraphs.end(); + Paragraph::depth_type dth = 0; + for (; it != end; ++it) { + it->write(buf, os, buf->params, dth); + } } void InsetText::read(Buffer const * buf, LyXLex & lex) { string token; - int pos = 0; - Paragraph * return_par = 0; Paragraph::depth_type depth = 0; - LyXFont font(LyXFont::ALL_INHERIT); - clear(); + clear(false); + + if (buf->params.tracking_changes) + paragraphs.begin()->trackChanges(); + + // delete the initial paragraph + paragraphs.clear(); + ParagraphList::iterator pit = paragraphs.begin(); while (lex.isOK()) { lex.nextToken(); @@ -268,27 +315,22 @@ void InsetText::read(Buffer const * buf, LyXLex & lex) if (token.empty()) continue; if (token == "\\end_inset") { -#ifndef NO_COMPABILITY - const_cast(buf)->insertErtContents(par, pos, false); -#endif break; } - if (const_cast(buf)-> - parseSingleLyXformat2Token(lex, par, return_par, - token, pos, depth, font)) { - // the_end read this should NEVER happen + if (token == "\\the_end") { lex.printError("\\the_end read in inset! Error in document!"); return; } + + // FIXME: ugly. + const_cast(buf)->readParagraph(lex, token, paragraphs, pit, depth); } - if (!return_par) - return_par = par; - par = return_par; - while (return_par) { - return_par->setInsetOwner(this); - return_par = return_par->next(); - } + + pit = paragraphs.begin(); + ParagraphList::iterator const end = paragraphs.end(); + for (; pit != end; ++pit) + pit->setInsetOwner(this); if (token != "\\end_inset") { lex.printError("Missing \\end_inset at this point. " @@ -298,140 +340,81 @@ void InsetText::read(Buffer const * buf, LyXLex & lex) } -int InsetText::ascent(BufferView * bv, LyXFont const &) const +void InsetText::dimension(BufferView * bv, LyXFont const &, + Dimension & dim) const { - insetAscent = getLyXText(bv)->firstRow()->ascent_of_text() + - TEXT_TO_INSET_OFFSET; - return insetAscent; + LyXText * text = getLyXText(bv); + dim.asc = text->rows().begin()->ascent_of_text() + TEXT_TO_INSET_OFFSET; + dim.des = text->height - dim.asc + TEXT_TO_INSET_OFFSET; + dim.wid = max(textWidth(bv), int(text->width)) + 2 * TEXT_TO_INSET_OFFSET; + dim.wid = max(dim.wid, 10); + // cache it + dim_ = dim; } -int InsetText::descent(BufferView * bv, LyXFont const &) const +int InsetText::textWidth(BufferView * bv, bool fordraw) const { - LyXText * llt = getLyXText(bv); - insetDescent = llt->height - llt->firstRow()->ascent_of_text() + - TEXT_TO_INSET_OFFSET; - return insetDescent; -} - + int w = autoBreakRows ? getMaxWidth(bv, this) : -1; -int InsetText::width(BufferView * bv, LyXFont const &) const -{ - insetWidth = max(textWidth(bv), (int)getLyXText(bv)->width) + - (2 * TEXT_TO_INSET_OFFSET); - insetWidth = max(insetWidth, 10); - return insetWidth; -} + if (fordraw) + return max(w - 2 * TEXT_TO_INSET_OFFSET, + (int)getLyXText(bv)->width); + if (w < 0) + return -1; -int InsetText::textWidth(BufferView * bv, bool fordraw) const -{ - int w; - if (!autoBreakRows) { - w = -1; - } else { - w = getMaxWidth(bv, this); - } - if (fordraw) { - return max(w - (2 * TEXT_TO_INSET_OFFSET), - (int)getLyXText(bv)->width); - } else if (w < 0) { - return -1; - } - return w - (2 * TEXT_TO_INSET_OFFSET); + return w - 2 * TEXT_TO_INSET_OFFSET; } void InsetText::draw(BufferView * bv, LyXFont const & f, - int baseline, float & x, bool cleared) const + int baseline, float & x) const { if (nodraw()) return; - Painter & pain = bv->painter(); - - // this is the first thing we have to ask because if the x pos - // changed we have to do a complete rebreak of the text as we - // may have few space to draw in. Well we should check on this too - int old_x = top_x; - if (top_x != int(x)) { + // update our idea of where we are. Clearly, we should + // not have to know this information. + if (top_x != int(x)) top_x = int(x); - topx_set = true; - int nw = getMaxWidth(bv, this); - if (nw > 0 && old_max_width != nw) { - need_update = INIT; - old_max_width = nw; - bv->text->status(bv, LyXText::CHANGED_IN_DRAW); - return; - } - } - // call these methods so that insetWidth, insetAscent and - // insetDescent have the right values. - width(bv, f); - ascent(bv, f); - descent(bv, f); + int const start_x = int(x); + + Painter & pain = bv->painter(); + + // call this method so that dim_ has the right value + dimension(bv, f, dim_); // repaint the background if needed - if (cleared && backgroundColor() != LColor::background) { - clearInset(bv, baseline, cleared); - } + if (backgroundColor() != LColor::background) + clearInset(bv, start_x + TEXT_TO_INSET_OFFSET, baseline); // no draw is necessary !!! - if ((drawFrame_ == LOCKED) && !locked && !par->size()) { + if ((drawFrame_ == LOCKED) && !locked && paragraphs.begin()->empty()) { top_baseline = baseline; x += width(bv, f); - if (need_update & CLEAR_FRAME) - clearFrame(pain, cleared); need_update = NONE; return; } - xpos = x; if (!owner()) x += static_cast(scroll()); - // if top_x differs we did it already - if (!cleared && (old_x == int(x)) - && ((need_update&(INIT|FULL)) || (top_baseline != baseline) - ||(last_drawn_width != insetWidth))) - { - // Condition necessary to eliminate bug 59 attachment 37 - if (baseline > 0) - clearInset(bv, baseline, cleared); - } - - if (cleared) - frame_is_visible = false; - - if (!cleared && (need_update == NONE)) { - if (locked) - drawFrame(pain, cleared); - return; - } - top_baseline = baseline; - top_y = baseline - insetAscent; + top_y = baseline - dim_.asc; - if (last_drawn_width != insetWidth) { - if (!cleared) - clearInset(bv, baseline, cleared); + if (last_drawn_width != dim_.wid) { need_update |= FULL; - last_drawn_width = insetWidth; + last_drawn_width = dim_.wid; } if (the_locking_inset && (cpar(bv) == inset_par) && (cpos(bv) == inset_pos)) { - inset_x = cix(bv) - top_x + drawTextXOffset; + inset_x = cix(bv) - int(x) + drawTextXOffset; inset_y = ciy(bv) + drawTextYOffset; } - if (!cleared && (need_update == CURSOR) - && !getLyXText(bv)->selection.set()) { - drawFrame(pain, cleared); - x += insetWidth; - need_update = NONE; - return; - } + bool clear = false; if (!lt) { lt = getLyXText(bv); @@ -439,85 +422,49 @@ void InsetText::draw(BufferView * bv, LyXFont const & f, } x += TEXT_TO_INSET_OFFSET; - Row * row = lt->firstRow(); - int y_offset = baseline - row->ascent_of_text(); + RowList::iterator rowit = lt->rows().begin(); + RowList::iterator end = lt->rows().end(); + + int y_offset = baseline - rowit->ascent_of_text(); int ph = pain.paperHeight(); int first = 0; int y = y_offset; - while ((row != 0) && ((y+row->height()) <= 0)) { - y += row->height(); - first += row->height(); - row = row->next(); + while ((rowit != end) && ((y + rowit->height()) <= 0)) { + y += rowit->height(); + first += rowit->height(); + ++rowit; } if (y_offset < 0) { - lt->first_y = -y_offset; + lt->top_y(-y_offset); first = y; y_offset = 0; } else { - lt->first_y = first; + lt->top_y(first); first = 0; } - if (cleared || (need_update&(INIT|FULL))) { - int yf = y_offset + first; - y = 0; - while ((row != 0) && (yf < ph)) { - lt->getVisibleRow(bv, y + y_offset + first, int(x), - row, y + lt->first_y, cleared); - if (bv->text->status() == LyXText::CHANGED_IN_DRAW) { - lt->need_break_row = row; - lt->fullRebreak(bv); - lt->setCursor(bv, lt->cursor.par(), - lt->cursor.pos()); - if (lt->selection.set()) { - lt->setCursor(bv, lt->selection.start, - lt->selection.start.par(), - lt->selection.start.pos()); - lt->setCursor(bv, lt->selection.end, - lt->selection.end.par(), - lt->selection.end.pos()); - } - break; - } - y += row->height(); - yf += row->height(); - row = row->next(); - } - } else if (!locked) { - if (need_update & CURSOR) { - bv->screen().toggleSelection(lt, bv, true, y_offset,int(x)); - lt->clearSelection(); - lt->selection.cursor = lt->cursor; - } - bv->screen().update(lt, bv, y_offset, int(x)); - } else { - locked = false; - if (need_update & SELECTION) { - bv->screen().toggleToggle(lt, bv, y_offset, int(x)); - } else if (need_update & CURSOR) { - bv->screen().toggleSelection(lt, bv, true, y_offset,int(x)); - lt->clearSelection(); - lt->selection.cursor = lt->cursor; - } - bv->screen().update(lt, bv, y_offset, int(x)); - locked = true; + + int yf = y_offset + first; + y = 0; + + bv->hideCursor(); + + while ((rowit != end) && (yf < ph)) { + RowPainter rp(*bv, *lt, rowit); + rp.paint(y + y_offset + first, int(x), y + lt->top_y()); + y += rowit->height(); + yf += rowit->height(); + ++rowit; } - lt->refresh_y = 0; - lt->status(bv, LyXText::UNCHANGED); - if ((drawFrame_ == ALWAYS) || - ((cleared || (need_update != CURSOR_PAR)) && - (drawFrame_ == LOCKED) && locked)) - { - drawFrame(pain, cleared); - } else if (need_update & CLEAR_FRAME) { - clearFrame(pain, cleared); + lt->clearPaint(); + + if ((drawFrame_ == ALWAYS) || (drawFrame_ == LOCKED && locked)) { + drawFrame(pain, int(start_x)); } - x += insetWidth - TEXT_TO_INSET_OFFSET; + x += dim_.wid - TEXT_TO_INSET_OFFSET; - if (bv->text->status() == LyXText::CHANGED_IN_DRAW) { - need_update |= FULL; - } else if (need_update != INIT) { + if (need_update != INIT) { need_update = NONE; } if (clear) @@ -525,60 +472,53 @@ void InsetText::draw(BufferView * bv, LyXFont const & f, } -void InsetText::drawFrame(Painter & pain, bool cleared) const +void InsetText::drawFrame(Painter & pain, int x) const { static int const ttoD2 = TEXT_TO_INSET_OFFSET / 2; - if (!frame_is_visible || cleared) { - frame_x = top_x + ttoD2; - frame_y = top_baseline - insetAscent + ttoD2; - frame_w = insetWidth - TEXT_TO_INSET_OFFSET; - frame_h = insetAscent + insetDescent - TEXT_TO_INSET_OFFSET; - pain.rectangle(frame_x, frame_y, frame_w, frame_h, - frame_color); - frame_is_visible = true; - } + frame_x = x + ttoD2; + frame_y = top_baseline - dim_.asc + ttoD2; + frame_w = dim_.wid - TEXT_TO_INSET_OFFSET; + frame_h = dim_.asc + dim_.des - TEXT_TO_INSET_OFFSET; + pain.rectangle(frame_x, frame_y, frame_w, frame_h, + frame_color); } -void InsetText::clearFrame(Painter & pain, bool cleared) const -{ - if (frame_is_visible) { - if (!cleared) { - pain.rectangle(frame_x, frame_y, frame_w, frame_h, - backgroundColor()); - } - frame_is_visible = false; - } -} - - -void InsetText::update(BufferView * bv, LyXFont const & font, bool reinit) +void InsetText::update(BufferView * bv, bool reinit) { if (in_update) { if (reinit && owner()) { reinitLyXText(); - owner()->update(bv, font, true); + owner()->update(bv, true); } return; } in_update = true; + if (reinit || need_update == INIT) { need_update = FULL; // we should put this call where we set need_update to INIT! reinitLyXText(); if (owner()) - owner()->update(bv, font, true); + owner()->update(bv, true); in_update = false; + + int nw = getMaxWidth(bv, this); + if (nw > 0 && old_max_width != nw) { + need_update |= INIT; + old_max_width = nw; + } return; } - if (!autoBreakRows && par->next()) + if (!autoBreakRows && + boost::next(paragraphs.begin()) != paragraphs.end()) collapseParagraphs(bv); if (the_locking_inset) { inset_x = cix(bv) - top_x + drawTextXOffset; inset_y = ciy(bv) + drawTextYOffset; - the_locking_inset->update(bv, font, reinit); + the_locking_inset->update(bv, reinit); } bool clear = false; @@ -586,16 +526,23 @@ void InsetText::update(BufferView * bv, LyXFont const & font, bool reinit) lt = getLyXText(bv); clear = true; } - if ((need_update & CURSOR_PAR) && (lt->status() == LyXText::UNCHANGED) && - the_locking_inset) - { - lt->updateInset(bv, the_locking_inset); + if ((need_update & CURSOR_PAR) && (lt->refreshStatus() == LyXText::REFRESH_NONE) && + the_locking_inset) { + lt->updateInset(the_locking_inset); } - if (lt->status() == LyXText::NEED_MORE_REFRESH) + + if (lt->refreshStatus() == LyXText::REFRESH_AREA) need_update |= FULL; if (clear) lt = 0; + in_update = false; + + int nw = getMaxWidth(bv, this); + if (nw > 0 && old_max_width != nw) { + need_update |= INIT; + old_max_width = nw; + } } @@ -605,14 +552,14 @@ void InsetText::setUpdateStatus(BufferView * bv, int what) const LyXText * llt = getLyXText(bv); need_update |= what; - // we have to redraw us full if our LyXText NEEDS_MORE_REFRES or + // we have to redraw us full if our LyXText REFRESH_AREA or // if we don't break row so that we only have one row to update! - if ((llt->status() == LyXText::NEED_MORE_REFRESH) || + if ((llt->refreshStatus() == LyXText::REFRESH_AREA) || (!autoBreakRows && - (llt->status() == LyXText::NEED_VERY_LITTLE_REFRESH))) + (llt->refreshStatus() == LyXText::REFRESH_ROW))) { need_update |= FULL; - } else if (llt->status() == LyXText::NEED_VERY_LITTLE_REFRESH) { + } else if (llt->refreshStatus() == LyXText::REFRESH_ROW) { need_update |= CURSOR_PAR; } @@ -625,35 +572,39 @@ void InsetText::setUpdateStatus(BufferView * bv, int what) const } -void InsetText::updateLocal(BufferView * bv, int what, bool mark_dirty) const +void InsetText::updateLocal(BufferView * bv, int what, bool mark_dirty) { - if (!autoBreakRows && par->next()) +#if 0 + if (!autoBreakRows && + boost::next(paragraphs.begin()) != paragraphs.end()) + collapseParagraphs(bv); +#else + if (!autoBreakRows && paragraphs.size() > 1) collapseParagraphs(bv); +#endif + bool clear = false; if (!lt) { lt = getLyXText(bv); clear = true; } - lt->fullRebreak(bv); + lt->fullRebreak(); setUpdateStatus(bv, what); bool flag = mark_dirty || (((need_update != CURSOR) && (need_update != NONE)) || - (lt->status() != LyXText::UNCHANGED) || lt->selection.set()); + (lt->refreshStatus() != LyXText::REFRESH_NONE) || lt->selection.set()); if (!lt->selection.set()) lt->selection.cursor = lt->cursor; + + bv->fitCursor(); + + if (flag) { + lt->postPaint(0); + bv->updateInset(const_cast(this)); + } + if (clear) lt = 0; -#if 0 - // IMO this is not anymore needed as we do this in fitInsetCursor! - // and we always get "true" as returnvalue of this function in the - // case of a locking inset (Jug 20020412) - if (locked && (need_update & CURSOR) && bv->fitCursor()) - need_update |= FULL; -#else - bv->fitCursor(); -#endif - if (flag) - bv->updateInset(const_cast(this), mark_dirty); if (need_update == CURSOR) need_update = NONE; @@ -673,108 +624,6 @@ string const InsetText::editMessage() const } -void InsetText::edit(BufferView * bv, int x, int y, mouse_button::state button) -{ - UpdatableInset::edit(bv, x, y, button); - - if (!bv->lockInset(this)) { - lyxerr[Debug::INSETS] << "Cannot lock inset" << endl; - return; - } - locked = true; - the_locking_inset = 0; - inset_pos = inset_x = inset_y = 0; - inset_boundary = false; - inset_par = 0; - old_par = 0; - int tmp_y = (y < 0) ? 0 : y; - bool clear = false; - if (!lt) { - lt = getLyXText(bv); - clear = true; - } - // we put here -1 and not button as now the button in the - // edit call should not be needed we will fix this in 1.3.x - // cycle hopefully (Jug 20020509) - // FIXME: GUII I've changed this to none: probably WRONG - if (!checkAndActivateInset(bv, x, tmp_y, mouse_button::none)) { - lt->setCursorFromCoordinates(bv, x - drawTextXOffset, - y + insetAscent); - lt->cursor.x_fix(lt->cursor.x()); - } - lt->clearSelection(); - finishUndo(); - // If the inset is empty set the language of the current font to the - // language to the surronding text (if different). - if (par->size() == 0 && !par->next() && - bv->getParentLanguage(this) != lt->current_font.language()) - { - LyXFont font(LyXFont::ALL_IGNORE); - font.setLanguage(bv->getParentLanguage(this)); - setFont(bv, font, false); - } - if (clear) - lt = 0; - - int code = CURSOR; - if (drawFrame_ == LOCKED) - code = CURSOR|DRAW_FRAME; - updateLocal(bv, code, false); - showInsetCursor(bv); - - // Tell the paragraph dialog that we've entered an insettext. - bv->owner()->getDialogs()->updateParagraph(); -} - - -void InsetText::edit(BufferView * bv, bool front) -{ - UpdatableInset::edit(bv, front); - - if (!bv->lockInset(this)) { - lyxerr[Debug::INSETS] << "Cannot lock inset" << endl; - return; - } - locked = true; - the_locking_inset = 0; - inset_pos = inset_x = inset_y = 0; - inset_boundary = false; - inset_par = 0; - old_par = 0; - bool clear = false; - if (!lt) { - lt = getLyXText(bv); - clear = true; - } - if (front) - lt->setCursor(bv, par, 0); - else { - Paragraph * p = par; - while (p->next()) - p = p->next(); -// int const pos = (p->size() ? p->size()-1 : p->size()); - lt->setCursor(bv, p, p->size()); - } - lt->clearSelection(); - finishUndo(); - // If the inset is empty set the language of the current font to the - // language to the surronding text (if different). - if (par->size() == 0 && !par->next() && - bv->getParentLanguage(this) != lt->current_font.language()) { - LyXFont font(LyXFont::ALL_IGNORE); - font.setLanguage(bv->getParentLanguage(this)); - setFont(bv, font, false); - } - if (clear) - lt = 0; - int code = CURSOR; - if (drawFrame_ == LOCKED) - code = CURSOR|DRAW_FRAME; - updateLocal(bv, code, false); - showInsetCursor(bv); -} - - void InsetText::insetUnlock(BufferView * bv) { if (the_locking_inset) { @@ -782,20 +631,11 @@ void InsetText::insetUnlock(BufferView * bv) the_locking_inset = 0; updateLocal(bv, CURSOR_PAR, false); } - hideInsetCursor(bv); no_selection = true; locked = false; int code = NONE; -#if 0 - if (drawFrame_ == LOCKED) - code = CURSOR|CLEAR_FRAME; - else - code = CURSOR; -#else - if (drawFrame_ == LOCKED) - code = CLEAR_FRAME; -#endif bool clear = false; + if (!lt) { lt = getLyXText(bv); clear = true; @@ -809,10 +649,10 @@ void InsetText::insetUnlock(BufferView * bv) } else bv->owner()->setLayout(bv->text->cursor.par()->layout()->name()); // hack for deleteEmptyParMech - if (par->size()) { - lt->setCursor(bv, par, 0); - } else if (par->next()) { - lt->setCursor(bv, par->next(), 0); + if (!paragraphs.begin()->empty()) { + lt->setCursor(paragraphs.begin(), 0); + } else if (boost::next(paragraphs.begin()) != paragraphs.end()) { + lt->setCursor(boost::next(paragraphs.begin()), 0); } if (clear) lt = 0; @@ -838,12 +678,13 @@ void InsetText::lockInset(BufferView * bv) lt = getLyXText(bv); clear = true; } - lt->setCursor(bv, par, 0); + lt->setCursor(paragraphs.begin(), 0); lt->clearSelection(); finishUndo(); // If the inset is empty set the language of the current font to the // language to the surronding text (if different). - if (par->size() == 0 && !par->next() && + if (paragraphs.begin()->empty() && + boost::next(paragraphs.begin()) == paragraphs.end() && bv->getParentLanguage(this) != lt->current_font.language()) { LyXFont font(LyXFont::ALL_IGNORE); font.setLanguage(bv->getParentLanguage(this)); @@ -877,26 +718,27 @@ bool InsetText::lockInsetInInset(BufferView * bv, UpdatableInset * inset) if (!inset) return false; if (!the_locking_inset) { - Paragraph * p = par; + ParagraphList::iterator pit = paragraphs.begin(); + ParagraphList::iterator pend = paragraphs.end(); + int const id = inset->id(); - while(p) { - Paragraph::inset_iterator it = - p->inset_iterator_begin(); - Paragraph::inset_iterator const end = - p->inset_iterator_end(); + for (; pit != pend; ++pit) { + InsetList::iterator it = + pit->insetlist.begin(); + InsetList::iterator const end = + pit->insetlist.end(); for (; it != end; ++it) { - if ((*it) == inset) { - getLyXText(bv)->setCursorIntern(bv, p, it.getPos()); + if (it.getInset() == inset) { + getLyXText(bv)->setCursorIntern(pit, it.getPos()); lockInset(bv, inset); return true; } - if ((*it)->getInsetFromID(id)) { - getLyXText(bv)->setCursorIntern(bv, p, it.getPos()); - (*it)->edit(bv); + if (it.getInset()->getInsetFromID(id)) { + getLyXText(bv)->setCursorIntern(pit, it.getPos()); + it.getInset()->localDispatch(FuncRequest(bv, LFUN_INSET_EDIT)); return the_locking_inset->lockInsetInInset(bv, inset); } } - p = p->next(); } return false; } @@ -928,7 +770,7 @@ bool InsetText::unlockInsetInInset(BufferView * bv, UpdatableInset * inset, return false; if (the_locking_inset == inset) { the_locking_inset->insetUnlock(bv); - getLyXText(bv)->updateInset(bv, inset); + getLyXText(bv)->updateInset(inset); the_locking_inset = 0; if (lr) moveRightIntern(bv, true, false); @@ -945,7 +787,8 @@ bool InsetText::unlockInsetInInset(BufferView * bv, UpdatableInset * inset, bool InsetText::updateInsetInInset(BufferView * bv, Inset * inset) { - if (!autoBreakRows && par->next()) + if (!autoBreakRows && + boost::next(paragraphs.begin()) != paragraphs.end()) collapseParagraphs(bv); if (inset == this) return true; @@ -970,14 +813,14 @@ bool InsetText::updateInsetInInset(BufferView * bv, Inset * inset) ustat = FULL; } if (found) - lt->updateInset(bv, tl_inset); + lt->updateInset(tl_inset); if (clear) lt = 0; if (found) setUpdateStatus(bv, ustat); return found; } - bool found = lt->updateInset(bv, inset); + bool found = lt->updateInset(inset); if (clear) lt = 0; if (found) { @@ -993,46 +836,30 @@ bool InsetText::updateInsetInInset(BufferView * bv, Inset * inset) } -void InsetText::insetButtonPress(BufferView * bv, - int x, int y, mouse_button::state button) +void InsetText::lfunMousePress(FuncRequest const & cmd) { no_selection = true; // use this to check mouse motion for selection! - mouse_x = x; - mouse_y = y; + mouse_x = cmd.x; + mouse_y = cmd.y; + BufferView * bv = cmd.view(); + FuncRequest cmd1 = cmd; + cmd1.x -= inset_x; + cmd1.y -= inset_y; if (!locked) lockInset(bv); - int tmp_x = x - drawTextXOffset; - int tmp_y = y + insetAscent - getLyXText(bv)->first_y; - Inset * inset = bv->checkInsetHit(getLyXText(bv), tmp_x, tmp_y); + int tmp_x = cmd.x - drawTextXOffset; + int tmp_y = cmd.y + dim_.asc - getLyXText(bv)->top_y(); + Inset * inset = getLyXText(bv)->checkInsetHit(tmp_x, tmp_y); - hideInsetCursor(bv); if (the_locking_inset) { if (the_locking_inset == inset) { - the_locking_inset->insetButtonPress(bv, - x - inset_x, - y - inset_y, - button); + the_locking_inset->localDispatch(cmd1); return; } -#if 0 - else if (inset) { - // otherwise unlock the_locking_inset and lock the new inset - the_locking_inset->insetUnlock(bv); - inset_x = cix(bv) - top_x + drawTextXOffset; - inset_y = ciy(bv) + drawTextYOffset; - the_locking_inset = 0; - inset->insetButtonPress(bv, x - inset_x, - y - inset_y, button); -// inset->edit(bv, x - inset_x, y - inset_y, button); - if (the_locking_inset) - updateLocal(bv, CURSOR, false); - return; - } -#endif // otherwise only unlock the_locking_inset the_locking_inset->insetUnlock(bv); the_locking_inset = 0; @@ -1048,16 +875,16 @@ void InsetText::insetButtonPress(BufferView * bv, if (!bv->lockInset(uinset)) { lyxerr[Debug::INSETS] << "Cannot lock inset" << endl; } - inset->insetButtonPress(bv, x - inset_x, y - inset_y, button); + inset->localDispatch(cmd1); if (the_locking_inset) updateLocal(bv, CURSOR, false); return; } } - if (!inset) { // && (button == mouse_button::button2)) { + if (!inset) { bool paste_internally = false; - if ((button == mouse_button::button2) && getLyXText(bv)->selection.set()) { - localDispatch(bv, LFUN_COPY, ""); + if (cmd.button() == mouse_button::button2 && getLyXText(bv)->selection.set()) { + localDispatch(FuncRequest(bv, LFUN_COPY)); paste_internally = true; } bool clear = false; @@ -1065,106 +892,117 @@ void InsetText::insetButtonPress(BufferView * bv, lt = getLyXText(bv); clear = true; } - int old_first_y = lt->first_y; + int old_top_y = lt->top_y(); - lt->setCursorFromCoordinates(bv, x - drawTextXOffset, - y + insetAscent); + lt->setCursorFromCoordinates(cmd.x - drawTextXOffset, + cmd.y + dim_.asc); // set the selection cursor! lt->selection.cursor = lt->cursor; lt->cursor.x_fix(lt->cursor.x()); if (lt->selection.set()) { lt->clearSelection(); - if (clear) - lt = 0; updateLocal(bv, FULL, false); } else { lt->clearSelection(); - if (clear) - lt = 0; updateLocal(bv, CURSOR, false); } + if (clear) + lt = 0; + bv->owner()->setLayout(cpar(bv)->layout()->name()); // we moved the view we cannot do mouse selection in this case! - if (getLyXText(bv)->first_y != old_first_y) + if (getLyXText(bv)->top_y() != old_top_y) no_selection = true; old_par = cpar(bv); // Insert primary selection with middle mouse // if there is a local selection in the current buffer, // insert this - if (button == mouse_button::button2) { + if (cmd.button() == mouse_button::button2) { if (paste_internally) - localDispatch(bv, LFUN_PASTE, ""); + localDispatch(FuncRequest(bv, LFUN_PASTE)); else - localDispatch(bv, LFUN_PASTESELECTION, - "paragraph"); + localDispatch(FuncRequest(bv, LFUN_PASTESELECTION, "paragraph")); } } else { getLyXText(bv)->clearSelection(); } - showInsetCursor(bv); } -bool InsetText::insetButtonRelease(BufferView * bv, - int x, int y, mouse_button::state button) +bool InsetText::lfunMouseRelease(FuncRequest const & cmd) { + BufferView * bv = cmd.view(); + FuncRequest cmd1 = cmd; + cmd1.x -= inset_x; + cmd1.y -= inset_y; + no_selection = true; - if (the_locking_inset) { - return the_locking_inset->insetButtonRelease(bv, - x - inset_x, y - inset_y, - button); - } - int tmp_x = x - drawTextXOffset; - int tmp_y = y + insetAscent - getLyXText(bv)->first_y; - Inset * inset = bv->checkInsetHit(getLyXText(bv), tmp_x, tmp_y); + if (the_locking_inset) + return the_locking_inset->localDispatch(cmd1); + + int tmp_x = cmd.x - drawTextXOffset; + int tmp_y = cmd.y + dim_.asc - getLyXText(bv)->top_y(); + Inset * inset = getLyXText(bv)->checkInsetHit(tmp_x, tmp_y); bool ret = false; if (inset) { - if (isHighlyEditableInset(inset)) { - ret = inset->insetButtonRelease(bv, x - inset_x, - y - inset_y, button); - } else { +// This code should probably be removed now. Simple insets +// (!highlyEditable) can actually take the localDispatch, +// and turn it into edit() if necessary. But we still +// need to deal properly with the whole relative vs. +// absolute mouse co-ords thing in a realiable, sensible way +#if 0 + if (isHighlyEditableInset(inset)) + ret = inset->localDispatch(cmd1); + else { inset_x = cix(bv) - top_x + drawTextXOffset; inset_y = ciy(bv) + drawTextYOffset; - ret = inset->insetButtonRelease(bv, x - inset_x, - y - inset_y, button); - inset->edit(bv, x - inset_x, - y - inset_y, button); + cmd1.x = cmd.x - inset_x; + cmd1.y = cmd.x - inset_y; + inset->edit(bv, cmd1.x, cmd1.y, cmd.button()); + ret = true; } +#endif + ret = inset->localDispatch(cmd1); updateLocal(bv, CURSOR_PAR, false); + } return ret; } -void InsetText::insetMotionNotify(BufferView * bv, int x, int y, mouse_button::state state) +void InsetText::lfunMouseMotion(FuncRequest const & cmd) { + FuncRequest cmd1 = cmd; + cmd1.x -= inset_x; + cmd1.y -= inset_y; + if (the_locking_inset) { - the_locking_inset->insetMotionNotify(bv, x - inset_x, - y - inset_y,state); + the_locking_inset->localDispatch(cmd1); return; } - if (no_selection || ((mouse_x == x) && (mouse_y == y))) + if (no_selection || (mouse_x == cmd.x && mouse_y == cmd.y)) return; + BufferView * bv = cmd.view(); bool clear = false; if (!lt) { lt = getLyXText(bv); clear = true; } - hideInsetCursor(bv); LyXCursor cur = lt->cursor; - lt->setCursorFromCoordinates(bv, x - drawTextXOffset, y + insetAscent); + lt->setCursorFromCoordinates + (cmd.x - drawTextXOffset, cmd.y + dim_.asc); lt->cursor.x_fix(lt->cursor.x()); if (cur == lt->cursor) { if (clear) lt = 0; return; } - lt->setSelection(bv); + lt->setSelection(); bool flag = (lt->toggle_cursor.par() != lt->toggle_end_cursor.par() || lt->toggle_cursor.pos() != lt->toggle_end_cursor.pos()); if (clear) @@ -1172,28 +1010,111 @@ void InsetText::insetMotionNotify(BufferView * bv, int x, int y, mouse_button::s if (flag) { updateLocal(bv, SELECTION, false); } - showInsetCursor(bv); } -UpdatableInset::RESULT -InsetText::localDispatch(BufferView * bv, - kb_action action, string const & arg) +Inset::RESULT InsetText::localDispatch(FuncRequest const & cmd) { - bool was_empty = par->size() == 0 && !par->next(); - no_selection = false; - UpdatableInset::RESULT - result= UpdatableInset::localDispatch(bv, action, arg); - if (result != UNDISPATCHED) { + BufferView * bv = cmd.view(); + + if (cmd.action == LFUN_INSET_EDIT) { + UpdatableInset::localDispatch(cmd); + + if (!bv->lockInset(this)) { + lyxerr[Debug::INSETS] << "Cannot lock inset" << endl; + return DISPATCHED; + } + + locked = true; + the_locking_inset = 0; + inset_pos = inset_x = inset_y = 0; + inset_boundary = false; + inset_par = 0; + old_par = 0; + + bool clear = false; + if (!lt) { + lt = getLyXText(bv); + clear = true; + } + + if (cmd.argument.size()) { + if (cmd.argument == "left") + lt->setCursor(paragraphs.begin(), 0); + else { + ParagraphList::iterator it = paragraphs.begin(); + ParagraphList::iterator end = paragraphs.end(); + while (boost::next(it) != end) + ++it; + // int const pos = (p->size() ? p->size()-1 : p->size()); + lt->setCursor(it, it->size()); + } + } else { + int tmp_y = (cmd.y < 0) ? 0 : cmd.y; + // we put here -1 and not button as now the button in the + // edit call should not be needed we will fix this in 1.3.x + // cycle hopefully (Jug 20020509) + // FIXME: GUII I've changed this to none: probably WRONG + if (!checkAndActivateInset(bv, cmd.x, tmp_y, mouse_button::none)) { + lt->setCursorFromCoordinates(cmd.x - drawTextXOffset, + cmd.y + dim_.asc); + lt->cursor.x_fix(lt->cursor.x()); + } + } + + lt->clearSelection(); + finishUndo(); + + // If the inset is empty set the language of the current font to the + // language to the surronding text (if different). + if (paragraphs.begin()->empty() && + boost::next(paragraphs.begin()) == paragraphs.end()&& + bv->getParentLanguage(this) != lt->current_font.language()) + { + LyXFont font(LyXFont::ALL_IGNORE); + font.setLanguage(bv->getParentLanguage(this)); + setFont(bv, font, false); + } + + if (clear) + lt = 0; + int code = CURSOR; + if (drawFrame_ == LOCKED) + code = CURSOR | DRAW_FRAME; + + updateLocal(bv, code, false); + // Tell the paragraph dialog that we've entered an insettext. + bv->dispatch(FuncRequest(LFUN_PARAGRAPH_UPDATE)); return DISPATCHED; } + + switch (cmd.action) { + case LFUN_MOUSE_PRESS: + lfunMousePress(cmd); + return DISPATCHED; + case LFUN_MOUSE_MOTION: + lfunMouseMotion(cmd); + return DISPATCHED; + case LFUN_MOUSE_RELEASE: + return lfunMouseRelease(cmd) ? DISPATCHED : UNDISPATCHED; + default: + break; + } + + bool was_empty = (paragraphs.begin()->empty() && + boost::next(paragraphs.begin()) == paragraphs.end()); + no_selection = false; + RESULT result = UpdatableInset::localDispatch(cmd); + if (result != UNDISPATCHED) + return DISPATCHED; + result = DISPATCHED; - if ((action < 0) && arg.empty()) + if (cmd.action < 0 && cmd.argument.empty()) return FINISHED; if (the_locking_inset) { - result = the_locking_inset->localDispatch(bv, action, arg); + result = the_locking_inset->localDispatch(cmd); if (result == DISPATCHED_NOUPDATE) return result; else if (result == DISPATCHED) { @@ -1212,20 +1133,10 @@ InsetText::localDispatch(BufferView * bv, } break; case FINISHED_DOWN: - { - LyXText *lt = getLyXText(bv); - if (lt->cursor.irow()->next()) { - lt->setCursorFromCoordinates( - bv, lt->cursor.ix() + inset_x, - lt->cursor.iy() - - lt->cursor.irow()->baseline() + - lt->cursor.irow()->height() + 1); - lt->cursor.x_fix(lt->cursor.x()); + if ((result = moveDown(bv)) >= FINISHED) { updateLocal(bv, CURSOR, false); - } else { bv->unlockInset(this); } - } break; default: result = DISPATCHED; @@ -1233,10 +1144,11 @@ InsetText::localDispatch(BufferView * bv, } the_locking_inset = 0; updateLocal(bv, CURSOR, false); + // make sure status gets reset immediately + bv->owner()->clearMessage(); return result; } } - hideInsetCursor(bv); bool clear = false; if (!lt) { lt = getLyXText(bv); @@ -1244,32 +1156,41 @@ InsetText::localDispatch(BufferView * bv, } int updwhat = 0; int updflag = false; - switch (action) { + + // what type of update to do on a cursor movement + int cursor_update = CURSOR; + + if (lt->selection.set()) + cursor_update = SELECTION; + + switch (cmd.action) { + // Normal chars case LFUN_SELFINSERT: if (bv->buffer()->isReadonly()) { // setErrorMessage(N_("Document is read only")); break; } - if (!arg.empty()) { + if (!cmd.argument.empty()) { /* Automatically delete the currently selected * text and replace it with what is being * typed in now. Depends on lyxrc settings * "auto_region_delete", which defaults to * true (on). */ - - setUndo(bv, Undo::INSERT, - lt->cursor.par(), lt->cursor.par()->next()); +#if 0 + // This should not be needed here and is also WRONG! + setUndo(bv, Undo::INSERT, lt->cursor.par()); +#endif bv->switchKeyMap(); if (lyxrc.auto_region_delete) { if (lt->selection.set()) { - lt->cutSelection(bv, false); + lt->cutSelection(false, false); } } lt->clearSelection(); - for (string::size_type i = 0; i < arg.length(); ++i) { - bv->owner()->getIntl()->getTransManager(). - TranslateAndInsert(arg[i], lt); + for (string::size_type i = 0; i < cmd.argument.length(); ++i) { + bv->owner()->getIntl().getTransManager(). + TranslateAndInsert(cmd.argument[i], lt); } } lt->selection.cursor = lt->cursor; @@ -1277,109 +1198,96 @@ InsetText::localDispatch(BufferView * bv, updflag = true; result = DISPATCHED_NOUPDATE; break; - // --- Cursor Movements ----------------------------------- - case LFUN_RIGHTSEL: - finishUndo(); - moveRight(bv, false, true); - lt->setSelection(bv); - updwhat = SELECTION; - break; + + // cursor movements that need special handling + case LFUN_RIGHT: result = moveRight(bv); finishUndo(); - updwhat = CURSOR; - break; - case LFUN_LEFTSEL: - finishUndo(); - moveLeft(bv, false, true); - lt->setSelection(bv); - updwhat = SELECTION; + updwhat = cursor_update; break; case LFUN_LEFT: finishUndo(); result = moveLeft(bv); - updwhat = CURSOR; - break; - case LFUN_DOWNSEL: - finishUndo(); - moveDown(bv); - lt->setSelection(bv); - updwhat = SELECTION; + updwhat = cursor_update; break; case LFUN_DOWN: finishUndo(); result = moveDown(bv); - updwhat = CURSOR; - break; - case LFUN_UPSEL: - finishUndo(); - moveUp(bv); - lt->setSelection(bv); - updwhat = SELECTION; + updwhat = cursor_update; break; case LFUN_UP: finishUndo(); result = moveUp(bv); - updwhat = CURSOR; + updwhat = cursor_update; break; - case LFUN_HOME: - finishUndo(); - lt->cursorHome(bv); - updwhat = CURSOR; + + case LFUN_PRIOR: + if (crow(bv) == lt->rows().begin()) + result = FINISHED_UP; + else { + lt->cursorPrevious(); + lt->clearSelection(); + result = DISPATCHED_NOUPDATE; + } + updwhat = cursor_update; break; - case LFUN_END: - lt->cursorEnd(bv); - updwhat = CURSOR; + + case LFUN_NEXT: + if (boost::next(crow(bv)) == lt->rows().end()) + result = FINISHED_DOWN; + else { + lt->cursorNext(); + lt->clearSelection(); + result = DISPATCHED_NOUPDATE; + } + updwhat = cursor_update; break; + case LFUN_BACKSPACE: { - setUndo(bv, Undo::DELETE, - lt->cursor.par(), lt->cursor.par()->next()); if (lt->selection.set()) - lt->cutSelection(bv); + lt->cutSelection(true, false); else - lt->backspace(bv); + lt->backspace(); updwhat = CURSOR_PAR; updflag = true; + break; } - break; case LFUN_DELETE: { - setUndo(bv, Undo::DELETE, - lt->cursor.par(), lt->cursor.par()->next()); if (lt->selection.set()) { - lt->cutSelection(bv); + lt->cutSelection(true, false); } else { - lt->Delete(bv); + lt->Delete(); } updwhat = CURSOR_PAR; updflag = true; + break; } - break; case LFUN_CUT: { - setUndo(bv, Undo::DELETE, - lt->cursor.par(), lt->cursor.par()->next()); lt->cutSelection(bv); updwhat = CURSOR_PAR; updflag = true; + break; } - break; case LFUN_COPY: finishUndo(); - lt->copySelection(bv); + lt->copySelection(); updwhat = CURSOR_PAR; break; + case LFUN_PASTESELECTION: { string const clip(bv->getClipboard()); if (clip.empty()) break; - if (arg == "paragraph") { - lt->insertStringAsParagraphs(bv, clip); + if (cmd.argument == "paragraph") { + lt->insertStringAsParagraphs(clip); } else { - lt->insertStringAsLines(bv, clip); + lt->insertStringAsLines(clip); } // bug 393 lt->clearSelection(); @@ -1388,41 +1296,42 @@ InsetText::localDispatch(BufferView * bv, updflag = true; break; } + case LFUN_PASTE: { if (!autoBreakRows) { - if (CutAndPaste::nrOfParagraphs() > 1) { - Alert::alert(_("Impossible operation"), - _("Cannot include more than one paragraph!"), - _("Sorry.")); +#ifdef WITH_WARNINGS +#warning FIXME horrendously bad UI +#endif + Alert::error(_("Paste failed"), _("Cannot include more than one paragraph.")); break; } } - setUndo(bv, Undo::INSERT, - lt->cursor.par(), lt->cursor.par()->next()); - lt->pasteSelection(bv); + + lt->pasteSelection(); // bug 393 lt->clearSelection(); updwhat = CURSOR_PAR; updflag = true; + break; } - break; case LFUN_BREAKPARAGRAPH: if (!autoBreakRows) { result = DISPATCHED; break; } - lt->breakParagraph(bv, 0); + lt->breakParagraph(paragraphs, 0); updwhat = CURSOR | FULL; updflag = true; break; + case LFUN_BREAKPARAGRAPHKEEPLAYOUT: if (!autoBreakRows) { result = DISPATCHED; break; } - lt->breakParagraph(bv, 1); + lt->breakParagraph(paragraphs, 1); updwhat = CURSOR | FULL; updflag = true; break; @@ -1432,13 +1341,12 @@ InsetText::localDispatch(BufferView * bv, result = DISPATCHED; break; } - setUndo(bv, Undo::INSERT, - lt->cursor.par(), lt->cursor.par()->next()); - lt->insertChar(bv, Paragraph::META_NEWLINE); + + lt->insertInset(new InsetNewline); updwhat = CURSOR | CURSOR_PAR; updflag = true; + break; } - break; case LFUN_LAYOUT: // do not set layouts on non breakable textinsets @@ -1449,7 +1357,7 @@ InsetText::localDispatch(BufferView * bv, // and current buffer's textclass (number). */ LyXTextClass const & tclass = bv->buffer()->params.getLyXTextClass(); - string layout = arg; + string layout = cmd.argument; bool hasLayout = tclass.hasLayout(layout); // If the entry is obsolete, use the new one instead. @@ -1462,14 +1370,14 @@ InsetText::localDispatch(BufferView * bv, // see if we found the layout number: if (!hasLayout) { - string const msg = string(N_("Layout ")) + arg + N_(" not known"); - bv->owner()->getLyXFunc()->dispatch(LFUN_MESSAGE, msg); + FuncRequest lf(LFUN_MESSAGE, N_("Layout ") + cmd.argument + N_(" not known")); + bv->owner()->dispatch(lf); break; } if (cur_layout != layout) { cur_layout = layout; - lt->setLayout(bv, layout); + lt->setLayout(layout); bv->owner()->setLayout(cpar(bv)->layout()->name()); updwhat = CURSOR_PAR; updflag = true; @@ -1483,15 +1391,16 @@ InsetText::localDispatch(BufferView * bv, // This one is absolutely not working. When fiddling with this // it also seems to me that the paragraphs inside the insettext // inherit bufferparams/paragraphparams in a strange way. (Lgb) + // FIXME: how old is this comment ? ... { - Paragraph * par = lt->cursor.par(); - Spacing::Space cur_spacing = par->params().spacing().getSpace(); + ParagraphList::iterator pit = lt->cursor.par(); + Spacing::Space cur_spacing = pit->params().spacing().getSpace(); float cur_value = 1.0; if (cur_spacing == Spacing::Other) { - cur_value = par->params().spacing().getValue(); + cur_value = pit->params().spacing().getValue(); } - istringstream istr(arg.c_str()); + istringstream istr(STRCONV(cmd.argument)); string tmp; istr >> tmp; Spacing::Space new_spacing = cur_spacing; @@ -1516,18 +1425,46 @@ InsetText::localDispatch(BufferView * bv, new_spacing = Spacing::Default; } else { lyxerr << _("Unknown spacing argument: ") - << arg << endl; + << cmd.argument << endl; } if (cur_spacing != new_spacing || cur_value != new_value) { - par->params().spacing(Spacing(new_spacing, new_value)); + pit->params().spacing(Spacing(new_spacing, new_value)); updwhat = CURSOR_PAR; updflag = true; } } break; + // These need to do repaints but don't require + // special handling otherwise. A *lot* of the + // above could probably be done similarly ... + + case LFUN_HOME: + case LFUN_END: + case LFUN_WORDLEFT: + case LFUN_WORDRIGHT: + // these two are really unhandled ... + case LFUN_ENDBUF: + case LFUN_BEGINNINGBUF: + updwhat = cursor_update; + if (!bv->dispatch(cmd)) + result = UNDISPATCHED; + break; + + case LFUN_RIGHTSEL: + case LFUN_UPSEL: + case LFUN_DOWNSEL: + case LFUN_LEFTSEL: + case LFUN_HOMESEL: + case LFUN_ENDSEL: + case LFUN_WORDLEFTSEL: + case LFUN_WORDRIGHTSEL: + updwhat = SELECTION; + + // fallthrough + default: - if (!bv->dispatch(action, arg)) + if (!bv->dispatch(cmd)) result = UNDISPATCHED; break; } @@ -1538,7 +1475,8 @@ InsetText::localDispatch(BufferView * bv, updateLocal(bv, updwhat, updflag); /// If the action has deleted all text in the inset, we need to change the // language to the language of the surronding text. - if (!was_empty && par->size() == 0 && !par->next()) { + if (!was_empty && paragraphs.begin()->empty() && + boost::next(paragraphs.begin()) == paragraphs.end()) { LyXFont font(LyXFont::ALL_IGNORE); font.setLanguage(bv->getParentLanguage(this)); setFont(bv, font, false); @@ -1553,24 +1491,26 @@ InsetText::localDispatch(BufferView * bv, } -int InsetText::latex(Buffer const * buf, ostream & os, bool moving_arg, bool) const +int InsetText::latex(Buffer const * buf, ostream & os, + LatexRunParams const & runparams) const { TexRow texrow; - buf->latexParagraphs(os, par, 0, texrow, moving_arg); + latexParagraphs(buf, paragraphs, os, texrow, runparams); return texrow.rows(); } int InsetText::ascii(Buffer const * buf, ostream & os, int linelen) const { - Paragraph * p = par; unsigned int lines = 0; - while (p) { - string const tmp = buf->asciiParagraph(p, linelen, p->previous()==0); + ParagraphList::iterator beg = paragraphs.begin(); + ParagraphList::iterator end = paragraphs.end(); + ParagraphList::iterator it = beg; + for (; it != end; ++it) { + string const tmp = buf->asciiParagraph(*it, linelen, it == beg); lines += lyx::count(tmp.begin(), tmp.end(), '\n'); os << tmp; - p = p->next(); } return lines; } @@ -1578,7 +1518,6 @@ int InsetText::ascii(Buffer const * buf, ostream & os, int linelen) const int InsetText::docbook(Buffer const * buf, ostream & os, bool mixcont) const { - Paragraph * p = par; unsigned int lines = 0; vector environment_stack(10); @@ -1589,36 +1528,39 @@ int InsetText::docbook(Buffer const * buf, ostream & os, bool mixcont) const Paragraph::depth_type depth = 0; // paragraph depth - while (p) { + ParagraphList::iterator pit = paragraphs.begin(); + ParagraphList::iterator pend = paragraphs.end(); + + for (; pit != pend; ++pit) { string sgmlparam; int desc_on = 0; // description mode - LyXLayout_ptr const & style = p->layout(); + LyXLayout_ptr const & style = pit->layout(); // environment tag closing - for (; depth > p->params().depth(); --depth) { + for (; depth > pit->params().depth(); --depth) { if (environment_inner[depth] != "!-- --") { item_name = "listitem"; - lines += buf->sgmlCloseTag(os, command_depth + depth, mixcont, item_name); + lines += sgml::closeTag(os, command_depth + depth, mixcont, item_name); if (environment_inner[depth] == "varlistentry") - lines += buf->sgmlCloseTag(os, depth+command_depth, mixcont, environment_inner[depth]); + lines += sgml::closeTag(os, depth+command_depth, mixcont, environment_inner[depth]); } - lines += buf->sgmlCloseTag(os, depth + command_depth, mixcont, environment_stack[depth]); + lines += sgml::closeTag(os, depth + command_depth, mixcont, environment_stack[depth]); environment_stack[depth].erase(); environment_inner[depth].erase(); } - if (depth == p->params().depth() + if (depth == pit->params().depth() && environment_stack[depth] != style->latexname() && !environment_stack[depth].empty()) { if (environment_inner[depth] != "!-- --") { item_name= "listitem"; - lines += buf->sgmlCloseTag(os, command_depth+depth, mixcont, item_name); + lines += sgml::closeTag(os, command_depth+depth, mixcont, item_name); if (environment_inner[depth] == "varlistentry") - lines += buf->sgmlCloseTag(os, depth + command_depth, mixcont, environment_inner[depth]); + lines += sgml::closeTag(os, depth + command_depth, mixcont, environment_inner[depth]); } - lines += buf->sgmlCloseTag(os, depth + command_depth, mixcont, environment_stack[depth]); + lines += sgml::closeTag(os, depth + command_depth, mixcont, environment_stack[depth]); environment_stack[depth].erase(); environment_inner[depth].erase(); @@ -1627,18 +1569,18 @@ int InsetText::docbook(Buffer const * buf, ostream & os, bool mixcont) const // Write opening SGML tags. switch (style->latextype) { case LATEX_PARAGRAPH: - lines += buf->sgmlOpenTag(os, depth + command_depth, mixcont, style->latexname()); + lines += sgml::openTag(os, depth + command_depth, mixcont, style->latexname()); break; case LATEX_COMMAND: - buf->sgmlError(p, 0, _("Error : LatexType Command not allowed here.\n")); + buf->sgmlError(pit, 0, _("Error: LatexType Command not allowed here.\n")); return -1; break; case LATEX_ENVIRONMENT: case LATEX_ITEM_ENVIRONMENT: - if (depth < p->params().depth()) { - depth = p->params().depth(); + if (depth < pit->params().depth()) { + depth = pit->params().depth(); environment_stack[depth].erase(); } @@ -1649,13 +1591,13 @@ int InsetText::docbook(Buffer const * buf, ostream & os, bool mixcont) const } environment_stack[depth] = style->latexname(); environment_inner[depth] = "!-- --"; - lines += buf->sgmlOpenTag(os, depth + command_depth, mixcont, environment_stack[depth]); + lines += sgml::openTag(os, depth + command_depth, mixcont, environment_stack[depth]); } else { if (environment_inner[depth] != "!-- --") { item_name= "listitem"; - lines += buf->sgmlCloseTag(os, command_depth + depth, mixcont, item_name); + lines += sgml::closeTag(os, command_depth + depth, mixcont, item_name); if (environment_inner[depth] == "varlistentry") - lines += buf->sgmlCloseTag(os, depth + command_depth, mixcont, environment_inner[depth]); + lines += sgml::closeTag(os, depth + command_depth, mixcont, environment_inner[depth]); } } @@ -1664,27 +1606,26 @@ int InsetText::docbook(Buffer const * buf, ostream & os, bool mixcont) const if (style->latexparam() == "CDATA") os << "sgmlOpenTag(os, depth + command_depth, mixcont, style->latexparam()); + lines += sgml::openTag(os, depth + command_depth, mixcont, style->latexparam()); } break; } desc_on = (style->labeltype == LABEL_MANUAL); - environment_inner[depth] = desc_on?"varlistentry":"listitem"; - lines += buf->sgmlOpenTag(os, depth + 1 + command_depth, mixcont, environment_inner[depth]); + environment_inner[depth] = desc_on ? "varlistentry" : "listitem"; + lines += sgml::openTag(os, depth + 1 + command_depth, mixcont, environment_inner[depth]); - item_name = desc_on?"term":"para"; - lines += buf->sgmlOpenTag(os, depth + 1 + command_depth, mixcont, item_name); + item_name = desc_on ? "term" : "para"; + lines += sgml::openTag(os, depth + 1 + command_depth, mixcont, item_name); break; default: - lines += buf->sgmlOpenTag(os, depth + command_depth, mixcont, style->latexname()); + lines += sgml::openTag(os, depth + command_depth, mixcont, style->latexname()); break; } - buf->simpleDocBookOnePar(os, p, desc_on, depth + 1 + command_depth); - p = p->next(); + buf->simpleDocBookOnePar(os, pit, desc_on, depth + 1 + command_depth); string end_tag; // write closing SGML tags @@ -1694,19 +1635,19 @@ int InsetText::docbook(Buffer const * buf, ostream & os, bool mixcont) const if (style->latexparam() == "CDATA") os << "]]>"; else - lines += buf->sgmlCloseTag(os, depth + command_depth, mixcont, style->latexparam()); + lines += sgml::closeTag(os, depth + command_depth, mixcont, style->latexparam()); } break; case LATEX_ITEM_ENVIRONMENT: if (desc_on == 1) break; end_tag= "para"; - lines += buf->sgmlCloseTag(os, depth + 1 + command_depth, mixcont, end_tag); + lines += sgml::closeTag(os, depth + 1 + command_depth, mixcont, end_tag); break; case LATEX_PARAGRAPH: - lines += buf->sgmlCloseTag(os, depth + command_depth, mixcont, style->latexname()); + lines += sgml::closeTag(os, depth + command_depth, mixcont, style->latexname()); break; default: - lines += buf->sgmlCloseTag(os, depth + command_depth, mixcont, style->latexname()); + lines += sgml::closeTag(os, depth + command_depth, mixcont, style->latexname()); break; } } @@ -1716,12 +1657,12 @@ int InsetText::docbook(Buffer const * buf, ostream & os, bool mixcont) const if (!environment_stack[depth].empty()) { if (environment_inner[depth] != "!-- --") { item_name = "listitem"; - lines += buf->sgmlCloseTag(os, command_depth + depth, mixcont, item_name); + lines += sgml::closeTag(os, command_depth + depth, mixcont, item_name); if (environment_inner[depth] == "varlistentry") - lines += buf->sgmlCloseTag(os, depth + command_depth, mixcont, environment_inner[depth]); + lines += sgml::closeTag(os, depth + command_depth, mixcont, environment_inner[depth]); } - lines += buf->sgmlCloseTag(os, depth + command_depth, mixcont, environment_stack[depth]); + lines += sgml::closeTag(os, depth + command_depth, mixcont, environment_stack[depth]); } } @@ -1731,20 +1672,19 @@ int InsetText::docbook(Buffer const * buf, ostream & os, bool mixcont) const void InsetText::validate(LaTeXFeatures & features) const { - Paragraph * p = par; - while (p) { - p->validate(features); - p = p->next(); - } + for_each(paragraphs.begin(), paragraphs.end(), + boost::bind(&Paragraph::validate, _1, boost::ref(features))); } -int InsetText::beginningOfMainBody(Paragraph * p) const +void InsetText::getCursor(BufferView & bv, int & x, int & y) const { - if (p->layout()->labeltype != LABEL_MANUAL) - return 0; - else - return p->beginningOfMainBody(); + if (the_locking_inset) { + the_locking_inset->getCursor(bv, x, y); + return; + } + x = cx(&bv); + y = cy(&bv) + InsetText::y(); } @@ -1768,58 +1708,6 @@ int InsetText::insetInInsetY() const } -void InsetText::toggleInsetCursor(BufferView * bv) -{ - if (the_locking_inset) { - the_locking_inset->toggleInsetCursor(bv); - return; - } - - LyXFont const font(getLyXText(bv)->getFont(bv->buffer(), cpar(bv), cpos(bv))); - - int const asc = font_metrics::maxAscent(font); - int const desc = font_metrics::maxDescent(font); - - if (isCursorVisible()) - bv->hideLockedInsetCursor(); - else - bv->showLockedInsetCursor(cx(bv), cy(bv), asc, desc); - toggleCursorVisible(); -} - - -void InsetText::showInsetCursor(BufferView * bv, bool show) -{ - if (the_locking_inset) { - the_locking_inset->showInsetCursor(bv, show); - return; - } - if (!isCursorVisible()) { - LyXFont const font = - getLyXText(bv)->getFont(bv->buffer(), cpar(bv), cpos(bv)); - - int const asc = font_metrics::maxAscent(font); - int const desc = font_metrics::maxDescent(font); - - bv->fitLockedInsetCursor(cx(bv), cy(bv), asc, desc); - if (show) - bv->showLockedInsetCursor(cx(bv), cy(bv), asc, desc); - setCursorVisible(true); - } -} - - -void InsetText::hideInsetCursor(BufferView * bv) -{ - if (isCursorVisible()) { - bv->hideLockedInsetCursor(); - setCursorVisible(false); - } - if (the_locking_inset) - the_locking_inset->hideInsetCursor(bv); -} - - void InsetText::fitInsetCursor(BufferView * bv) const { if (the_locking_inset) { @@ -1837,7 +1725,7 @@ void InsetText::fitInsetCursor(BufferView * bv) const } -UpdatableInset::RESULT +Inset::RESULT InsetText::moveRight(BufferView * bv, bool activate_inset, bool selecting) { if (getLyXText(bv)->cursor.par()->isRightToLeftPar(bv->buffer()->params)) @@ -1847,7 +1735,7 @@ InsetText::moveRight(BufferView * bv, bool activate_inset, bool selecting) } -UpdatableInset::RESULT +Inset::RESULT InsetText::moveLeft(BufferView * bv, bool activate_inset, bool selecting) { if (getLyXText(bv)->cursor.par()->isRightToLeftPar(bv->buffer()->params)) @@ -1857,52 +1745,59 @@ InsetText::moveLeft(BufferView * bv, bool activate_inset, bool selecting) } -UpdatableInset::RESULT +Inset::RESULT InsetText::moveRightIntern(BufferView * bv, bool front, bool activate_inset, bool selecting) { - if (!cpar(bv)->next() && (cpos(bv) >= cpar(bv)->size())) + LyXText * text = getLyXText(bv); + + ParagraphList::iterator c_par = cpar(bv); + + if (boost::next(c_par) == paragraphs.end() && + (cpos(bv) >= c_par->size())) return FINISHED_RIGHT; if (activate_inset && checkAndActivateInset(bv, front)) return DISPATCHED; - getLyXText(bv)->cursorRight(bv); + text->cursorRight(bv); if (!selecting) - getLyXText(bv)->selection.cursor = getLyXText(bv)->cursor; + text->clearSelection(); return DISPATCHED_NOUPDATE; } -UpdatableInset::RESULT +Inset::RESULT InsetText::moveLeftIntern(BufferView * bv, bool front, bool activate_inset, bool selecting) { - if (!cpar(bv)->previous() && (cpos(bv) <= 0)) + LyXText * text = getLyXText(bv); + + if (cpar(bv) == paragraphs.begin() && (cpos(bv) <= 0)) return FINISHED; - getLyXText(bv)->cursorLeft(bv); + text->cursorLeft(bv); if (!selecting) - getLyXText(bv)->selection.cursor = getLyXText(bv)->cursor; + text->clearSelection(); if (activate_inset && checkAndActivateInset(bv, front)) return DISPATCHED; return DISPATCHED_NOUPDATE; } -UpdatableInset::RESULT -InsetText::moveUp(BufferView * bv) +Inset::RESULT InsetText::moveUp(BufferView * bv) { - if (!crow(bv)->previous()) + if (crow(bv) == getLyXText(bv)->rows().begin()) return FINISHED_UP; getLyXText(bv)->cursorUp(bv); + getLyXText(bv)->clearSelection(); return DISPATCHED_NOUPDATE; } -UpdatableInset::RESULT -InsetText::moveDown(BufferView * bv) +Inset::RESULT InsetText::moveDown(BufferView * bv) { - if (!crow(bv)->next()) + if (boost::next(crow(bv)) == getLyXText(bv)->rows().end()) return FINISHED_DOWN; getLyXText(bv)->cursorDown(bv); + getLyXText(bv)->clearSelection(); return DISPATCHED_NOUPDATE; } @@ -1915,8 +1810,7 @@ bool InsetText::insertInset(BufferView * bv, Inset * inset) return false; } inset->setOwner(this); - hideInsetCursor(bv); - getLyXText(bv)->insertInset(bv, inset); + getLyXText(bv)->insertInset(inset); bv->fitCursor(); updateLocal(bv, CURSOR_PAR|CURSOR, true); return true; @@ -1971,15 +1865,15 @@ vector const InsetText::getLabelList() const { vector label_list; - Paragraph * tpar = par; - while (tpar) { - Paragraph::inset_iterator beg = tpar->inset_iterator_begin(); - Paragraph::inset_iterator end = tpar->inset_iterator_end(); + ParagraphList::iterator pit = paragraphs.begin(); + ParagraphList::iterator pend = paragraphs.end(); + for (; pit != pend; ++pit) { + InsetList::iterator beg = pit->insetlist.begin(); + InsetList::iterator end = pit->insetlist.end(); for (; beg != end; ++beg) { - vector const l = (*beg)->getLabelList(); + vector const l = beg.getInset()->getLabelList(); label_list.insert(label_list.end(), l.begin(), l.end()); } - tpar = tpar->next(); } return label_list; } @@ -1992,8 +1886,9 @@ void InsetText::setFont(BufferView * bv, LyXFont const & font, bool toggleall, the_locking_inset->setFont(bv, font, toggleall, selectall); return; } - if ((!par->next() && !par->size()) || !cpar(bv)->size()) { - getLyXText(bv)->setFont(bv, font, toggleall); + if ((boost::next(paragraphs.begin()) == paragraphs.end() && + paragraphs.begin()->empty()) || cpar(bv)->empty()) { + getLyXText(bv)->setFont(font, toggleall); return; } bool clear = false; @@ -2002,11 +1897,11 @@ void InsetText::setFont(BufferView * bv, LyXFont const & font, bool toggleall, clear = true; } if (lt->selection.set()) { - setUndo(bv, Undo::EDIT, lt->cursor.par(), lt->cursor.par()->next()); + setUndo(bv, Undo::EDIT, lt->cursor.par()); } if (selectall) selectAll(bv); - lt->toggleFree(bv, font, toggleall); + lt->toggleFree(font, toggleall); if (selectall) lt->clearSelection(); bv->fitCursor(); @@ -2027,7 +1922,8 @@ bool InsetText::checkAndActivateInset(BufferView * bv, bool front) static_cast(cpar(bv)->getInset(cpos(bv))); if (!isHighlyEditableInset(inset)) return false; - inset->edit(bv, front); + FuncRequest cmd(bv, LFUN_INSET_EDIT, front ? "left" : "right"); + inset->localDispatch(cmd); if (!the_locking_inset) return false; updateLocal(bv, CURSOR, false); @@ -2042,8 +1938,8 @@ bool InsetText::checkAndActivateInset(BufferView * bv, int x, int y, { x -= drawTextXOffset; int dummyx = x; - int dummyy = y + insetAscent; - Inset * inset = bv->checkInsetHit(getLyXText(bv), dummyx, dummyy); + int dummyy = y + dim_.asc; + Inset * inset = getLyXText(bv)->checkInsetHit(dummyx, dummyy); // we only do the edit() call if the inset was hit by the mouse // or if it is a highly editable inset. So we should call this // function from our own edit with button < 0. @@ -2054,12 +1950,13 @@ bool InsetText::checkAndActivateInset(BufferView * bv, int x, int y, if (inset) { if (x < 0) - x = insetWidth; + x = dim_.wid; if (y < 0) - y = insetDescent; + y = dim_.des; inset_x = cix(bv) - top_x + drawTextXOffset; inset_y = ciy(bv) + drawTextYOffset; - inset->edit(bv, x - inset_x, y - inset_y, button); + FuncRequest cmd(bv, LFUN_INSET_EDIT, x - inset_x, y - inset_y, button); + inset->localDispatch(cmd); if (!the_locking_inset) return false; updateLocal(bv, CURSOR, false); @@ -2088,36 +1985,89 @@ int InsetText::getMaxWidth(BufferView * bv, UpdatableInset const * inset) const } -void InsetText::setParagraphData(Paragraph * p, bool same_id) +void InsetText::setParagraphData(ParagraphList const & plist) { // we have to unlock any locked inset otherwise we're in troubles the_locking_inset = 0; - while (par) { - Paragraph * tmp = par->next(); - delete par; - par = tmp; - } - - par = new Paragraph(*p, same_id); - par->setInsetOwner(this); - Paragraph * np = par; - while (p->next()) { - p = p->next(); - np->next(new Paragraph(*p, same_id)); - np->next()->previous(np); - np = np->next(); - np->setInsetOwner(this); + + // But it it makes no difference that is a lot better. +#warning FIXME. + // See if this can be simplified when std::list is in effect. + paragraphs.clear(); + + ParagraphList::iterator it = plist.begin(); + ParagraphList::iterator end = plist.end(); + for (; it != end; ++it) { + paragraphs.push_back(*it); + Paragraph & tmp = paragraphs.back(); + tmp.setInsetOwner(this); } + reinitLyXText(); need_update = INIT; } +// void InsetText::setParagraphData(ParagraphList const & plist, bool same_id) +// { +// // we have to unlock any locked inset otherwise we're in troubles +// the_locking_inset = 0; + +// #warning CHECK not adhering to same_id here might wreck havoc (Lgb) +// // But it it makes no difference that is a lot better. +// if (same_id) { +// lyxerr << "Same_id called with 'true'" << endl; +// lyxerr << "Please report this to the list." << endl; + +// paragraphs.clear(); +// ParagraphList::iterator it = plist.begin(); +// ParagraphList::iterator end = plist.end(); +// for (; it != end; ++it) { +// int const id = it->id(); +// paragraphs.push_back(*it); +// Paragraph & tmp = paragraphs.back(); +// tmp.setInsetOwner(this); +// tmp.id(id); +// } +// } else { +// #warning FIXME. +// // See if this can be simplified when std::list is in effect. +// paragraphs.clear(); + +// ParagraphList::iterator it = plist.begin(); +// ParagraphList::iterator end = plist.end(); +// for (; it != end; ++it) { +// paragraphs.push_back(*it); +// Paragraph & tmp = paragraphs.back(); +// tmp.setInsetOwner(this); +// } +// } + +// reinitLyXText(); +// need_update = INIT; +// } + + +void InsetText::markNew(bool track_changes) +{ + ParagraphList::iterator pit = paragraphs.begin(); + ParagraphList::iterator pend = paragraphs.end(); + for (; pit != pend; ++pit) { + if (track_changes) { + pit->trackChanges(); + } else { + // no-op when not tracking + pit->cleanChanges(); + } + } +} + + void InsetText::setText(string const & data, LyXFont const & font) { - clear(); - for (unsigned int i=0; i < data.length(); ++i) - par->insertChar(i, data[i], font); + clear(false); + for (unsigned int i = 0; i < data.length(); ++i) + paragraphs.begin()->insertChar(i, data[i], font); reinitLyXText(); } @@ -2203,7 +2153,7 @@ pos_type InsetText::cpos(BufferView * bv) const } -Paragraph * InsetText::cpar(BufferView * bv) const +ParagraphList::iterator InsetText::cpar(BufferView * bv) const { return getLyXText(bv)->cursor.par(); } @@ -2215,7 +2165,7 @@ bool InsetText::cboundary(BufferView * bv) const } -Row * InsetText::crow(BufferView * bv) const +RowList::iterator InsetText::crow(BufferView * bv) const { return getLyXText(bv)->cursor.row(); } @@ -2228,7 +2178,7 @@ LyXText * InsetText::getLyXText(BufferView const * lbv, if (recursive && the_locking_inset) return the_locking_inset->getLyXText(lbv, true); LyXText * lt = cached_text.get(); - lyx::Assert(lt && lt->firstRow()->par() == par); + lyx::Assert(lt && lt->rows().begin()->par() == paragraphs.begin()); return lt; } // Super UGLY! (Lgb) @@ -2261,7 +2211,7 @@ LyXText * InsetText::getLyXText(BufferView const * lbv, // when we have to reinit the existing LyXText! // it->second.text->init(bv); - restoreLyXTextState(bv, it->second.text.get()); + restoreLyXTextState(it->second.text.get()); it->second.remove = false; } cached_text = it->second.text; @@ -2273,9 +2223,9 @@ LyXText * InsetText::getLyXText(BufferView const * lbv, /// // we are here only if we don't have a BufferView * in the cache!!! /// - cached_text.reset(new LyXText(const_cast(this))); + cached_text.reset(new LyXText(bv, const_cast(this))); cached_text->init(bv); - restoreLyXTextState(bv, cached_text.get()); + restoreLyXTextState(cached_text.get()); cache.insert(make_pair(bv, cached_text)); @@ -2301,10 +2251,8 @@ void InsetText::deleteLyXText(BufferView * bv, bool recursive) const it->second.remove = true; if (recursive) { /// then remove all LyXText in text-insets - Paragraph * p = par; - for (; p; p = p->next()) { - p->deleteInsetsLyXText(bv); - } + for_each(paragraphs.begin(), paragraphs.end(), + boost::bind(&Paragraph::deleteInsetsLyXText, _1, bv)); } } @@ -2318,13 +2266,13 @@ void InsetText::resizeLyXText(BufferView * bv, bool force) const return; } do_resize = 0; -// lyxerr << "InsetText::resizeLyXText\n"; - if (!par->next() && !par->size()) { // no data, resize not neccessary! + if (boost::next(paragraphs.begin()) == paragraphs.end() && + paragraphs.begin()->empty()) { // no data, resize not neccessary! // we have to do this as a fixed width may have changed! LyXText * t = getLyXText(bv); saveLyXTextState(t); t->init(bv, true); - restoreLyXTextState(bv, t); + restoreLyXTextState(t); return; } // one endless line, resize normally not necessary @@ -2339,19 +2287,20 @@ void InsetText::resizeLyXText(BufferView * bv, bool force) const LyXText * t = it->second.text.get(); saveLyXTextState(t); - for (Paragraph * p = par; p; p = p->next()) { - p->resizeInsetsLyXText(bv); - } + + for_each(paragraphs.begin(), paragraphs.end(), + boost::bind(&Paragraph::resizeInsetsLyXText, _1, bv)); + t->init(bv, true); - restoreLyXTextState(bv, t); + restoreLyXTextState(t); if (the_locking_inset) { inset_x = cix(bv) - top_x + drawTextXOffset; inset_y = ciy(bv) + drawTextYOffset; } - t->first_y = bv->screen().topCursorVisible(t->cursor, t->first_y); + t->top_y(bv->screen().topCursorVisible(t->cursor, t->top_y())); if (!owner()) { - updateLocal(bv, FULL, false); + const_cast(this)->updateLocal(bv, FULL, false); // this will scroll the screen such that the cursor becomes visible bv->updateScrollbar(); } else { @@ -2370,26 +2319,26 @@ void InsetText::reinitLyXText() const } do_reinit = false; do_resize = 0; -// lyxerr << "InsetText::reinitLyXText\n"; - for(Cache::iterator it = cache.begin(); it != cache.end(); ++it) { + for (Cache::iterator it = cache.begin(); it != cache.end(); ++it) { lyx::Assert(it->second.text.get()); LyXText * t = it->second.text.get(); BufferView * bv = it->first; saveLyXTextState(t); - for (Paragraph * p = par; p; p = p->next()) { - p->resizeInsetsLyXText(bv); - } + + for_each(paragraphs.begin(), paragraphs.end(), + boost::bind(&Paragraph::resizeInsetsLyXText, _1, bv)); + t->init(bv, true); - restoreLyXTextState(bv, t); + restoreLyXTextState(t); if (the_locking_inset) { inset_x = cix(bv) - top_x + drawTextXOffset; inset_y = ciy(bv) + drawTextYOffset; } - t->first_y = bv->screen().topCursorVisible(t->cursor, t->first_y); + t->top_y(bv->screen().topCursorVisible(t->cursor, t->top_y())); if (!owner()) { - updateLocal(bv, FULL, false); + const_cast(this)->updateLocal(bv, FULL, false); // this will scroll the screen such that the cursor becomes visible bv->updateScrollbar(); } else { @@ -2403,11 +2352,13 @@ void InsetText::removeNewlines() { bool changed = false; - for (Paragraph * p = par; p; p = p->next()) { - for (int i = 0; i < p->size(); ++i) { - if (p->getChar(i) == Paragraph::META_NEWLINE) { + ParagraphList::iterator it = paragraphs.begin(); + ParagraphList::iterator end = paragraphs.end(); + for (; it != end; ++it) { + for (int i = 0; i < it->size(); ++i) { + if (it->isNewline(i)) { changed = true; - p->erase(i); + it->erase(i); } } } @@ -2435,18 +2386,12 @@ int InsetText::scroll(bool recursive) const } -bool InsetText::doClearArea() const -{ - return !locked || (need_update & (FULL|INIT)); -} - - void InsetText::selectAll(BufferView * bv) { - getLyXText(bv)->cursorTop(bv); + getLyXText(bv)->cursorTop(); getLyXText(bv)->selection.cursor = getLyXText(bv)->cursor; - getLyXText(bv)->cursorBottom(bv); - getLyXText(bv)->setSelection(bv); + getLyXText(bv)->cursorBottom(); + getLyXText(bv)->setSelection(); } @@ -2456,12 +2401,12 @@ void InsetText::clearSelection(BufferView * bv) } -void InsetText::clearInset(BufferView * bv, int baseline, bool & cleared) const +void InsetText::clearInset(BufferView * bv, int start_x, int baseline) const { Painter & pain = bv->painter(); - int w = insetWidth; - int h = insetAscent + insetDescent; - int ty = baseline - insetAscent; + int w = dim_.wid; + int h = dim_.asc + dim_.des; + int ty = baseline - dim_.asc; if (ty < 0) { h += ty; @@ -2471,89 +2416,22 @@ void InsetText::clearInset(BufferView * bv, int baseline, bool & cleared) const h = pain.paperHeight(); if ((top_x + drawTextXOffset + w) > pain.paperWidth()) w = pain.paperWidth(); -// w -= TEXT_TO_INSET_OFFSET; - pain.fillRectangle(top_x + 1, ty + 1, w - 1, h - 1, backgroundColor()); - cleared = true; + pain.fillRectangle(start_x + 1, ty + 1, w - 3, h - 1, backgroundColor()); need_update = FULL; - frame_is_visible = false; -} - - -Paragraph * InsetText::getParFromID(int id) const -{ -#if 0 - Paragraph * result = par; - Paragraph * ires = 0; - while (result && result->id() != id) { - if ((ires = result->getParFromID(id))) - return ires; - result = result->next(); - } - return result; -#else - Paragraph * tmp = par; - while (tmp) { - if (tmp->id() == id) { - return tmp; - } - Paragraph * tmp2 = tmp->getParFromID(id); - if (tmp2 != 0) { - return tmp2; - } - tmp = tmp->next(); - } - return 0; -#endif -} - - -Paragraph * InsetText::firstParagraph() const -{ - Paragraph * result; - if (the_locking_inset) - if ((result = the_locking_inset->firstParagraph())) - return result; - return par; } -Paragraph * InsetText::getFirstParagraph(int i) const +ParagraphList * InsetText::getParagraphs(int i) const { - return (i == 0) ? par : 0; + return (i == 0) ? const_cast(¶graphs) : 0; } LyXCursor const & InsetText::cursor(BufferView * bv) const { - if (the_locking_inset) - return the_locking_inset->cursor(bv); - return getLyXText(bv)->cursor; -} - - -Paragraph * InsetText::paragraph() const -{ - return par; -} - - -void InsetText::paragraph(Paragraph * p) -{ - // GENERAL COMMENT: We don't have to free the old paragraphs as the - // caller of this function has to take care of it. This IS important - // as we could have to insert a paragraph before this one and just - // link the actual to a new ones next and set it with this function - // and are done! - par = p; - // set ourself as owner for all the paragraphs inserted! - Paragraph * np = par; - while (np) { - np->setInsetOwner(this); - np = np->next(); - } - reinitLyXText(); - // redraw myself when asked for - need_update = INIT; + if (the_locking_inset) + return the_locking_inset->cursor(bv); + return getLyXText(bv)->cursor; } @@ -2562,26 +2440,26 @@ Inset * InsetText::getInsetFromID(int id_arg) const if (id_arg == id()) return const_cast(this); - Paragraph * lp = par; - - while (lp) { - for (Paragraph::inset_iterator it = lp->inset_iterator_begin(), - en = lp->inset_iterator_end(); - it != en; ++it) - { - if ((*it)->id() == id_arg) - return *it; - Inset * in = (*it)->getInsetFromID(id_arg); + ParagraphList::iterator pit = paragraphs.begin(); + ParagraphList::iterator pend = paragraphs.end(); + for (; pit != pend; ++pit) { + InsetList::iterator it = pit->insetlist.begin(); + InsetList::iterator end = pit->insetlist.end(); + for (; it != end; ++it) { + if (it.getInset()->id() == id_arg) + return it.getInset(); + Inset * in = it.getInset()->getInsetFromID(id_arg); if (in) return in; } - lp = lp->next(); } return 0; } -WordLangTuple InsetText::selectNextWordToSpellcheck(BufferView * bv, float & value) const +WordLangTuple const +InsetText::selectNextWordToSpellcheck(BufferView * bv, + float & value) const { bool clear = false; WordLangTuple word; @@ -2601,7 +2479,7 @@ WordLangTuple InsetText::selectNextWordToSpellcheck(BufferView * bv, float & val // we have to go on checking so move cursor to the next char lt->cursor.pos(lt->cursor.pos() + 1); } - word = lt->selectNextWordToSpellcheck(bv, value); + word = lt->selectNextWordToSpellcheck(value); if (word.word().empty()) bv->unlockInset(const_cast(this)); else @@ -2618,7 +2496,7 @@ void InsetText::selectSelectedWord(BufferView * bv) the_locking_inset->selectSelectedWord(bv); return; } - getLyXText(bv)->selectSelectedWord(bv); + getLyXText(bv)->selectSelectedWord(); updateLocal(bv, SELECTION, false); } @@ -2636,12 +2514,13 @@ void InsetText::toggleSelection(BufferView * bv, bool kill_selection) int x = top_x + TEXT_TO_INSET_OFFSET; - Row * row = lt->firstRow(); - int y_offset = top_baseline - row->ascent_of_text(); + RowList::iterator rowit = lt->rows().begin(); + RowList::iterator end = lt->rows().end(); + int y_offset = top_baseline - rowit->ascent_of_text(); int y = y_offset; - while ((row != 0) && ((y+row->height()) <= 0)) { - y += row->height(); - row = row->next(); + while ((rowit != end) && ((y + rowit->height()) <= 0)) { + y += rowit->height(); + ++rowit; } if (y_offset < 0) y_offset = y; @@ -2654,6 +2533,36 @@ void InsetText::toggleSelection(BufferView * bv, bool kill_selection) } +bool InsetText::nextChange(BufferView * bv, lyx::pos_type & length) +{ + bool clear = false; + if (!lt) { + lt = getLyXText(bv); + clear = true; + } + if (the_locking_inset) { + if (the_locking_inset->nextChange(bv, length)) + return true; + lt->cursorRight(true); + } + lyxfind::SearchResult result = + lyxfind::findNextChange(bv, lt, length); + + if (result == lyxfind::SR_FOUND) { + LyXCursor cur = lt->cursor; + bv->unlockInset(bv->theLockingInset()); + if (bv->lockInset(this)) + locked = true; + lt->cursor = cur; + lt->setSelectionRange(length); + updateLocal(bv, SELECTION, false); + } + if (clear) + lt = 0; + return result != lyxfind::SR_NOT_FOUND; +} + + bool InsetText::searchForward(BufferView * bv, string const & str, bool cs, bool mw) { @@ -2665,7 +2574,7 @@ bool InsetText::searchForward(BufferView * bv, string const & str, if (the_locking_inset) { if (the_locking_inset->searchForward(bv, str, cs, mw)) return true; - lt->cursorRight(bv, true); + lt->cursorRight(true); } lyxfind::SearchResult result = lyxfind::LyXFind(bv, lt, str, true, cs, mw); @@ -2676,7 +2585,7 @@ bool InsetText::searchForward(BufferView * bv, string const & str, if (bv->lockInset(this)) locked = true; lt->cursor = cur; - lt->setSelectionOverString(bv, str); + lt->setSelectionRange(str.length()); updateLocal(bv, SELECTION, false); } if (clear) @@ -2697,10 +2606,13 @@ bool InsetText::searchBackward(BufferView * bv, string const & str, clear = true; } if (!locked) { - Paragraph * p = par; - while (p->next()) - p = p->next(); - lt->setCursor(bv, p, p->size()); + ParagraphList::iterator pit = paragraphs.begin(); + ParagraphList::iterator pend = paragraphs.end(); + + while (boost::next(pit) != pend) + ++pit; + + lt->setCursor(pit, pit->size()); } lyxfind::SearchResult result = lyxfind::LyXFind(bv, lt, str, false, cs, mw); @@ -2711,7 +2623,7 @@ bool InsetText::searchBackward(BufferView * bv, string const & str, if (bv->lockInset(this)) locked = true; lt->cursor = cur; - lt->setSelectionOverString(bv, str); + lt->setSelectionRange(str.length()); updateLocal(bv, SELECTION, false); } if (clear) @@ -2728,30 +2640,30 @@ bool InsetText::checkInsertChar(LyXFont & font) } -void InsetText::collapseParagraphs(BufferView * bv) const +void InsetText::collapseParagraphs(BufferView * bv) { - BufferParams const & bparams = bv->buffer()->params; LyXText * llt = getLyXText(bv); - while(par->next()) { - if (par->size() && par->next()->size() && - !par->isSeparator(par->size()-1)) + while (boost::next(paragraphs.begin()) != paragraphs.end()) { + if (!paragraphs.begin()->empty() && + !boost::next(paragraphs.begin())->empty() && + !paragraphs.begin()->isSeparator(paragraphs.begin()->size() - 1)) { - par->insertChar(par->size(), ' '); + paragraphs.begin()->insertChar(paragraphs.begin()->size(), ' '); } if (llt->selection.set()) { - if (llt->selection.start.par() == par->next()) { - llt->selection.start.par(par); + if (llt->selection.start.par() == boost::next(paragraphs.begin())) { + llt->selection.start.par(paragraphs.begin()); llt->selection.start.pos( - llt->selection.start.pos() + par->size()); + llt->selection.start.pos() + paragraphs.begin()->size()); } - if (llt->selection.end.par() == par->next()) { - llt->selection.end.par(par); + if (llt->selection.end.par() == boost::next(paragraphs.begin())) { + llt->selection.end.par(paragraphs.begin()); llt->selection.end.pos( - llt->selection.end.pos() + par->size()); + llt->selection.end.pos() + paragraphs.begin()->size()); } } - par->pasteParagraph(bparams); + mergeParagraph(bv->buffer()->params, paragraphs, paragraphs.begin()); } reinitLyXText(); } @@ -2765,24 +2677,33 @@ void InsetText::getDrawFont(LyXFont & font) const } -void InsetText::appendParagraphs(BufferParams const & bparams, - Paragraph * newpar) +void InsetText::appendParagraphs(Buffer * buffer, ParagraphList & plist) { +#warning FIXME Check if Changes stuff needs changing here. (Lgb) +// And it probably does. You have to take a look at this John. (Lgb) +#warning John, have a look here. (Lgb) +#if 0 + BufferParams const & bparams = buffer->params; Paragraph * buf; Paragraph * tmpbuf = newpar; Paragraph * lastbuffer = buf = new Paragraph(*tmpbuf, false); + if (bparams.tracking_changes) + buf->cleanChanges(); while (tmpbuf->next()) { tmpbuf = tmpbuf->next(); lastbuffer->next(new Paragraph(*tmpbuf, false)); lastbuffer->next()->previous(lastbuffer); lastbuffer = lastbuffer->next(); + if (bparams.tracking_changes) + lastbuffer->cleanChanges(); } - lastbuffer = par; + + lastbuffer = &*(paragraphs.begin()); while (lastbuffer->next()) lastbuffer = lastbuffer->next(); - if (newpar->size() && lastbuffer->size() && - !lastbuffer->isSeparator(lastbuffer->size()-1)) + if (!newpar->empty() && !lastbuffer->empty() && + !lastbuffer->isSeparator(lastbuffer->size() - 1)) { lastbuffer->insertChar(lastbuffer->size(), ' '); } @@ -2793,7 +2714,19 @@ void InsetText::appendParagraphs(BufferParams const & bparams, // paste it! lastbuffer->next(buf); buf->previous(lastbuffer); - lastbuffer->pasteParagraph(bparams); + mergeParagraph(buffer->params, paragraphs, lastbuffer); +#else + ParagraphList::iterator pit = plist.begin(); + ParagraphList::iterator ins = paragraphs.insert(paragraphs.end(), *pit); + ++pit; + mergeParagraph(buffer->params, paragraphs, boost::prior(ins)); + + ParagraphList::iterator pend = plist.end(); + for (; pit != pend; ++pit) { + paragraphs.push_back(*pit); + } + +#endif reinitLyXText(); } @@ -2801,14 +2734,14 @@ void InsetText::appendParagraphs(BufferParams const & bparams, void InsetText::addPreview(grfx::PreviewLoader & loader) const { - Paragraph * par = getFirstParagraph(0); - while (par) { - Paragraph::inset_iterator it = par->inset_iterator_begin(); - Paragraph::inset_iterator end = par->inset_iterator_end(); + ParagraphList::iterator pit = paragraphs.begin(); + ParagraphList::iterator pend = paragraphs.end(); + + for (; pit != pend; ++pit) { + InsetList::iterator it = pit->insetlist.begin(); + InsetList::iterator end = pit->insetlist.end(); for (; it != end; ++it) { - it->addPreview(loader); + it.getInset()->addPreview(loader); } - - par = par->next(); } }