X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsettext.C;h=ffcd351f4f8e458eb705be34d2c2586f050dd729;hb=a8e8e755fc32233e91bf787d5032fd81147d0909;hp=7a8111fe2f60d87460e55851bee7032b211a07d5;hpb=52ef85f57f61967d70f4d710351ffb62fad82454;p=lyx.git diff --git a/src/insets/insettext.C b/src/insets/insettext.C index 7a8111fe2f..ffcd351f4f 100644 --- a/src/insets/insettext.C +++ b/src/insets/insettext.C @@ -1,30 +1,28 @@ -/* 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 "buffer.h" #include "BufferView.h" #include "CutAndPaste.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" @@ -38,6 +36,10 @@ #include "undo_funcs.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" @@ -71,10 +73,6 @@ 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) @@ -89,45 +87,43 @@ void InsetText::saveLyXTextState(LyXText * t) const } if (it != end && t->cursor.pos() <= it->size()) { - sstate.lpar = t->cursor.par(); + 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); } } @@ -143,20 +139,30 @@ InsetText::InsetText(BufferParams const & bp) : UpdatableInset(), lt(0), in_update(false), do_resize(0), do_reinit(false) { - paragraphs.set(new Paragraph); + paragraphs.push_back(Paragraph()); paragraphs.begin()->layout(bp.getLyXTextClass().defaultLayout()); - init(); + 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) { - 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); @@ -164,15 +170,13 @@ 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->paragraphs.begin()), same_id); + setParagraphData(ins->paragraphs); 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)); @@ -183,9 +187,6 @@ void InsetText::init(InsetText const * ins, bool same_id) autoBreakRows = false; } top_y = 0; - insetAscent = 0; - insetDescent = 0; - insetWidth = 0; old_max_width = 0; no_selection = true; need_update = FULL; @@ -194,26 +195,68 @@ void InsetText::init(InsetText const * ins, bool same_id) locked = false; old_par = 0; last_drawn_width = -1; - frame_is_visible = false; cached_bview = 0; sstate.lpar = 0; in_insetAllowed = false; } +// 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; +// } + + 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 = paragraphs.begin()->layout(); paragraphs.clear(); - paragraphs.set(new Paragraph); + paragraphs.push_back(Paragraph()); paragraphs.begin()->setInsetOwner(this); paragraphs.begin()->layout(old_layout); @@ -222,12 +265,18 @@ void InsetText::clear() } -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"; @@ -249,12 +298,16 @@ void InsetText::writeParagraphData(Buffer const * buf, ostream & os) const 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(); @@ -265,25 +318,20 @@ void InsetText::read(Buffer const * buf, LyXLex & lex) break; } - Paragraph * tmp = &*(paragraphs.begin()); - - if (const_cast(buf)-> - parseSingleLyXformat2Token(lex, tmp, 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; } - paragraphs.set(tmp); - } - if (!return_par) - return_par = &*(paragraphs.begin()); - paragraphs.set(return_par); - while (return_par) { - return_par->setInsetOwner(this); - return_par = return_par->next(); + + // FIXME: ugly. + const_cast(buf)->readParagraph(lex, token, paragraphs, pit, depth); } + 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. " "Read: `$$Token'"); @@ -292,91 +340,60 @@ 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; + if (fordraw) + return max(w - 2 * TEXT_TO_INSET_OFFSET, + (int)getLyXText(bv)->width); -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 (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 && paragraphs.begin()->empty()) { top_baseline = baseline; x += width(bv, f); - if (need_update & CLEAR_FRAME) - clearFrame(pain, cleared); need_update = NONE; return; } @@ -384,47 +401,20 @@ void InsetText::draw(BufferView * bv, LyXFont const & f, 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); @@ -432,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) @@ -518,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; - } -} - - -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; - } + 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::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 && paragraphs.begin()->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; @@ -579,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; + } } @@ -598,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; } @@ -618,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 && paragraphs.begin()->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; @@ -666,109 +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 (paragraphs.begin()->empty() && !paragraphs.begin()->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, &*(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(bv, &*it, it->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 (paragraphs.begin()->empty() && !paragraphs.begin()->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) { @@ -776,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; @@ -804,9 +650,9 @@ void InsetText::insetUnlock(BufferView * bv) bv->owner()->setLayout(bv->text->cursor.par()->layout()->name()); // hack for deleteEmptyParMech if (!paragraphs.begin()->empty()) { - lt->setCursor(bv, &*(paragraphs.begin()), 0); - } else if (paragraphs.begin()->next()) { - lt->setCursor(bv, paragraphs.begin()->next(), 0); + lt->setCursor(paragraphs.begin(), 0); + } else if (boost::next(paragraphs.begin()) != paragraphs.end()) { + lt->setCursor(boost::next(paragraphs.begin()), 0); } if (clear) lt = 0; @@ -832,12 +678,13 @@ void InsetText::lockInset(BufferView * bv) lt = getLyXText(bv); clear = true; } - lt->setCursor(bv, &*(paragraphs.begin()), 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 (paragraphs.begin()->empty() && !paragraphs.begin()->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)); @@ -871,26 +718,27 @@ bool InsetText::lockInsetInInset(BufferView * bv, UpdatableInset * inset) if (!inset) return false; if (!the_locking_inset) { - Paragraph * p = &*(paragraphs.begin()); + ParagraphList::iterator pit = paragraphs.begin(); + ParagraphList::iterator pend = paragraphs.end(); + int const id = inset->id(); - while(p) { + for (; pit != pend; ++pit) { InsetList::iterator it = - p->insetlist.begin(); + pit->insetlist.begin(); InsetList::iterator const end = - p->insetlist.end(); + pit->insetlist.end(); for (; it != end; ++it) { if (it.getInset() == inset) { - getLyXText(bv)->setCursorIntern(bv, p, it.getPos()); + getLyXText(bv)->setCursorIntern(pit, it.getPos()); lockInset(bv, inset); return true; } if (it.getInset()->getInsetFromID(id)) { - getLyXText(bv)->setCursorIntern(bv, p, it.getPos()); - it.getInset()->edit(bv); + 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; } @@ -922,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); @@ -939,7 +787,8 @@ bool InsetText::unlockInsetInInset(BufferView * bv, UpdatableInset * inset, bool InsetText::updateInsetInInset(BufferView * bv, Inset * inset) { - if (!autoBreakRows && paragraphs.begin()->next()) + if (!autoBreakRows && + boost::next(paragraphs.begin()) != paragraphs.end()) collapseParagraphs(bv); if (inset == this) return true; @@ -964,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) { @@ -1003,29 +852,14 @@ void InsetText::lfunMousePress(FuncRequest const & cmd) lockInset(bv); int tmp_x = cmd.x - drawTextXOffset; - int tmp_y = cmd.y + insetAscent - getLyXText(bv)->first_y; - Inset * inset = bv->checkInsetHit(getLyXText(bv), tmp_x, tmp_y); + 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->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->localDispatch(cmd1); -// 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; @@ -1047,7 +881,7 @@ void InsetText::lfunMousePress(FuncRequest const & cmd) return; } } - if (!inset) { // && (button == mouse_button::button2)) { + if (!inset) { bool paste_internally = false; if (cmd.button() == mouse_button::button2 && getLyXText(bv)->selection.set()) { localDispatch(FuncRequest(bv, LFUN_COPY)); @@ -1058,30 +892,29 @@ void InsetText::lfunMousePress(FuncRequest const & cmd) lt = getLyXText(bv); clear = true; } - int old_first_y = lt->first_y; + int old_top_y = lt->top_y(); - lt->setCursorFromCoordinates(bv, cmd.x - drawTextXOffset, - cmd.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 @@ -1096,7 +929,6 @@ void InsetText::lfunMousePress(FuncRequest const & cmd) } else { getLyXText(bv)->clearSelection(); } - showInsetCursor(bv); } @@ -1112,10 +944,16 @@ bool InsetText::lfunMouseRelease(FuncRequest const & cmd) return the_locking_inset->localDispatch(cmd1); int tmp_x = cmd.x - drawTextXOffset; - int tmp_y = cmd.y + insetAscent - getLyXText(bv)->first_y; - Inset * inset = bv->checkInsetHit(getLyXText(bv), tmp_x, tmp_y); + 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) { +// 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 { @@ -1123,10 +961,13 @@ bool InsetText::lfunMouseRelease(FuncRequest const & cmd) inset_y = ciy(bv) + drawTextYOffset; cmd1.x = cmd.x - inset_x; cmd1.y = cmd.x - inset_y; - ret = inset->localDispatch(cmd1); inset->edit(bv, cmd1.x, cmd1.y, cmd.button()); + ret = true; } +#endif + ret = inset->localDispatch(cmd1); updateLocal(bv, CURSOR_PAR, false); + } return ret; } @@ -1152,17 +993,16 @@ void InsetText::lfunMouseMotion(FuncRequest const & cmd) lt = getLyXText(bv); clear = true; } - hideInsetCursor(bv); LyXCursor cur = lt->cursor; lt->setCursorFromCoordinates - (bv, cmd.x - drawTextXOffset, cmd.y + insetAscent); + (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) @@ -1170,25 +1010,111 @@ void InsetText::lfunMouseMotion(FuncRequest const & cmd) if (flag) { updateLocal(bv, SELECTION, false); } - showInsetCursor(bv); } -Inset::RESULT InsetText::localDispatch(FuncRequest const & ev) +Inset::RESULT InsetText::localDispatch(FuncRequest const & cmd) { - BufferView * bv = ev.view(); - bool was_empty = (paragraphs.begin()->empty() && !paragraphs.begin()->next()); + 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(ev); + RESULT result = UpdatableInset::localDispatch(cmd); if (result != UNDISPATCHED) return DISPATCHED; result = DISPATCHED; - if (ev.action < 0 && ev.argument.empty()) + if (cmd.action < 0 && cmd.argument.empty()) return FINISHED; if (the_locking_inset) { - result = the_locking_inset->localDispatch(ev); + result = the_locking_inset->localDispatch(cmd); if (result == DISPATCHED_NOUPDATE) return result; else if (result == DISPATCHED) { @@ -1207,20 +1133,10 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev) } 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; @@ -1228,10 +1144,11 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev) } 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); @@ -1239,44 +1156,41 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev) } int updwhat = 0; int updflag = false; - switch (ev.action) { - case LFUN_MOUSE_PRESS: - lfunMousePress(ev); - return DISPATCHED; - - case LFUN_MOUSE_MOTION: - lfunMouseMotion(ev); - return DISPATCHED; - - case LFUN_MOUSE_RELEASE: - return lfunMouseRelease(ev) ? DISPATCHED : UNDISPATCHED; - + // 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 (!ev.argument.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, false); + lt->cutSelection(false, false); } } lt->clearSelection(); - for (string::size_type i = 0; i < ev.argument.length(); ++i) { + for (string::size_type i = 0; i < cmd.argument.length(); ++i) { bv->owner()->getIntl().getTransManager(). - TranslateAndInsert(ev.argument[i], lt); + TranslateAndInsert(cmd.argument[i], lt); } } lt->selection.cursor = lt->cursor; @@ -1284,109 +1198,96 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev) 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, true, false); + 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, true, false); + 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 (ev.argument == "paragraph") { - lt->insertStringAsParagraphs(bv, clip); + if (cmd.argument == "paragraph") { + lt->insertStringAsParagraphs(clip); } else { - lt->insertStringAsLines(bv, clip); + lt->insertStringAsLines(clip); } // bug 393 lt->clearSelection(); @@ -1395,41 +1296,42 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev) 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; @@ -1439,13 +1341,12 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev) 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 @@ -1456,7 +1357,7 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev) // and current buffer's textclass (number). */ LyXTextClass const & tclass = bv->buffer()->params.getLyXTextClass(); - string layout = ev.argument; + string layout = cmd.argument; bool hasLayout = tclass.hasLayout(layout); // If the entry is obsolete, use the new one instead. @@ -1469,14 +1370,14 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev) // see if we found the layout number: if (!hasLayout) { - FuncRequest lf(LFUN_MESSAGE, N_("Layout ") + ev.argument + N_(" not known")); + 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; @@ -1490,15 +1391,16 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev) // 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(ev.argument.c_str()); + istringstream istr(STRCONV(cmd.argument)); string tmp; istr >> tmp; Spacing::Space new_spacing = cur_spacing; @@ -1523,18 +1425,46 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev) new_spacing = Spacing::Default; } else { lyxerr << _("Unknown spacing argument: ") - << ev.argument << 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(ev)) + if (!bv->dispatch(cmd)) result = UNDISPATCHED; break; } @@ -1545,7 +1475,8 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev) 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 && paragraphs.begin()->empty() && !paragraphs.begin()->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); @@ -1561,11 +1492,10 @@ Inset::RESULT InsetText::localDispatch(FuncRequest const & ev) int InsetText::latex(Buffer const * buf, ostream & os, - bool moving_arg, bool) const + LatexRunParams const & runparams) const { TexRow texrow; - buf->latexParagraphs(os, &*(paragraphs.begin()), 0, - texrow, moving_arg); + latexParagraphs(buf, paragraphs, os, texrow, runparams); return texrow.rows(); } @@ -1588,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 = &*(paragraphs.begin()); unsigned int lines = 0; vector environment_stack(10); @@ -1599,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(); @@ -1637,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(); } @@ -1659,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]); } } @@ -1674,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 @@ -1704,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; } } @@ -1726,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]); } } @@ -1746,12 +1677,14 @@ void InsetText::validate(LaTeXFeatures & features) const } -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(); } @@ -1775,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) { @@ -1868,13 +1749,18 @@ 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; } @@ -1883,33 +1769,35 @@ 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; } -Inset::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; } -Inset::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; } @@ -1922,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; @@ -1999,8 +1886,9 @@ void InsetText::setFont(BufferView * bv, LyXFont const & font, bool toggleall, the_locking_inset->setFont(bv, font, toggleall, selectall); return; } - if ((!paragraphs.begin()->next() && paragraphs.begin()->empty()) || cpar(bv)->empty()) { - 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; @@ -2009,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(); @@ -2034,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); @@ -2049,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. @@ -2061,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); @@ -2095,30 +1985,87 @@ 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; + // 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(); - paragraphs.set(new Paragraph(*p, same_id)); - paragraphs.begin()->setInsetOwner(this); - Paragraph * np = &*(paragraphs.begin()); - while (p->next()) { - p = p->next(); - np->next(new Paragraph(*p, same_id)); - np->next()->previous(np); - np = np->next(); - np->setInsetOwner(this); + + 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(); + clear(false); for (unsigned int i = 0; i < data.length(); ++i) paragraphs.begin()->insertChar(i, data[i], font); reinitLyXText(); @@ -2206,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(); } @@ -2218,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(); } @@ -2231,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() == &*(paragraphs.begin())); + lyx::Assert(lt && lt->rows().begin()->par() == paragraphs.begin()); return lt; } // Super UGLY! (Lgb) @@ -2264,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; @@ -2276,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)); @@ -2319,13 +2266,13 @@ void InsetText::resizeLyXText(BufferView * bv, bool force) const return; } do_resize = 0; -// lyxerr << "InsetText::resizeLyXText\n"; - if (!paragraphs.begin()->next() && paragraphs.begin()->empty()) { // 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 @@ -2345,15 +2292,15 @@ void InsetText::resizeLyXText(BufferView * bv, bool force) const 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 { @@ -2372,7 +2319,6 @@ void InsetText::reinitLyXText() const } do_reinit = false; do_resize = 0; -// lyxerr << "InsetText::reinitLyXText\n"; for (Cache::iterator it = cache.begin(); it != cache.end(); ++it) { lyx::Assert(it->second.text.get()); @@ -2385,14 +2331,14 @@ void InsetText::reinitLyXText() const 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 { @@ -2410,7 +2356,7 @@ void InsetText::removeNewlines() ParagraphList::iterator end = paragraphs.end(); for (; it != end; ++it) { for (int i = 0; i < it->size(); ++i) { - if (it->getChar(i) == Paragraph::META_NEWLINE) { + if (it->isNewline(i)) { changed = true; it->erase(i); } @@ -2440,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(); } @@ -2461,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; @@ -2476,76 +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 -{ - ParagraphList::iterator it = paragraphs.begin(); - ParagraphList::iterator end = paragraphs.end(); - for (; it != end; ++it) { - if (it->id() == id) { - return &*(it); - } - Paragraph * tmp2 = it->getParFromID(id); - if (tmp2 != 0) { - return tmp2; - } - } - return 0; -} - - -Paragraph * InsetText::firstParagraph() const -{ - Paragraph * result; - if (the_locking_inset) - if ((result = the_locking_inset->firstParagraph())) - return result; - return &*(paragraphs.begin()); } -Paragraph * InsetText::getFirstParagraph(int i) const +ParagraphList * InsetText::getParagraphs(int i) const { - return (i == 0) ? &*(paragraphs.begin()) : 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 &*(paragraphs.begin()); -} - - -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! - paragraphs.set(p); - // set ourself as owner for all the paragraphs inserted! - for_each(paragraphs.begin(), paragraphs.end(), - boost::bind(&Paragraph::setInsetOwner, _1, this)); - - reinitLyXText(); - // redraw myself when asked for - need_update = INIT; + if (the_locking_inset) + return the_locking_inset->cursor(bv); + return getLyXText(bv)->cursor; } @@ -2593,7 +2479,7 @@ InsetText::selectNextWordToSpellcheck(BufferView * bv, // 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 @@ -2610,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); } @@ -2628,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; @@ -2646,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) { @@ -2657,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); @@ -2668,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) @@ -2689,10 +2606,13 @@ bool InsetText::searchBackward(BufferView * bv, string const & str, clear = true; } if (!locked) { - Paragraph * p = &*(paragraphs.begin()); - 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); @@ -2703,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) @@ -2720,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 (paragraphs.begin()->next()) { - if (!paragraphs.begin()->empty() && !paragraphs.begin()->next()->empty() && + while (boost::next(paragraphs.begin()) != paragraphs.end()) { + if (!paragraphs.begin()->empty() && + !boost::next(paragraphs.begin())->empty() && !paragraphs.begin()->isSeparator(paragraphs.begin()->size() - 1)) { paragraphs.begin()->insertChar(paragraphs.begin()->size(), ' '); } if (llt->selection.set()) { - if (llt->selection.start.par() == paragraphs.begin()->next()) { - llt->selection.start.par(&*(paragraphs.begin())); + if (llt->selection.start.par() == boost::next(paragraphs.begin())) { + llt->selection.start.par(paragraphs.begin()); llt->selection.start.pos( llt->selection.start.pos() + paragraphs.begin()->size()); } - if (llt->selection.end.par() == paragraphs.begin()->next()) { - llt->selection.end.par(&*(paragraphs.begin())); + if (llt->selection.end.par() == boost::next(paragraphs.begin())) { + llt->selection.end.par(paragraphs.begin()); llt->selection.end.pos( llt->selection.end.pos() + paragraphs.begin()->size()); } } - pasteParagraph(bparams, &*paragraphs.begin()); + mergeParagraph(bv->buffer()->params, paragraphs, paragraphs.begin()); } reinitLyXText(); } @@ -2757,19 +2677,28 @@ 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 = &*(paragraphs.begin()); while (lastbuffer->next()) lastbuffer = lastbuffer->next(); @@ -2785,7 +2714,19 @@ void InsetText::appendParagraphs(BufferParams const & bparams, // paste it! lastbuffer->next(buf); buf->previous(lastbuffer); - pasteParagraph(bparams, lastbuffer); + 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(); } @@ -2793,14 +2734,14 @@ void InsetText::appendParagraphs(BufferParams const & bparams, void InsetText::addPreview(grfx::PreviewLoader & loader) const { - Paragraph * par = getFirstParagraph(0); - while (par) { - InsetList::iterator it = par->insetlist.begin(); - InsetList::iterator end = par->insetlist.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.getInset()->addPreview(loader); } - - par = par->next(); } }