X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsetcollapsable.C;h=9194111ad793dac1a399467dfcdfb0f4995efa67;hb=b0cffd9fc0288a639a7271837ae8efb319d704be;hp=00b3e869ec6c3ce989ecb5b63d41ecf05bcfa110;hpb=97ef9131ba95f605a48d09595bd2ace0f993a55b;p=lyx.git diff --git a/src/insets/insetcollapsable.C b/src/insets/insetcollapsable.C index 00b3e869ec..9194111ad7 100644 --- a/src/insets/insetcollapsable.C +++ b/src/insets/insetcollapsable.C @@ -1,76 +1,69 @@ -/* This file is part of - * ====================================================== +/** + * \file insetcollapsable.C + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. * - * LyX, The Document Processor + * \author Alejandro Aguilar Sierra + * \author Jürgen Vigna + * \author Lars Gullik Bjønnes * - * Copyright 1998-2001 The LyX Team. - * - * ====================================================== + * Full author contact details are available in file CREDITS. */ #include -#ifdef __GNUG__ -#pragma implementation -#endif - #include "insetcollapsable.h" -#include "gettext.h" -#include "lyxfont.h" + +#include "buffer.h" #include "BufferView.h" -#include "frontends/Painter.h" +#include "cursor.h" #include "debug.h" -#include "lyxtext.h" -#include "frontends/font_metrics.h" +#include "dispatchresult.h" +#include "LColor.h" #include "lyxlex.h" +#include "funcrequest.h" +#include "metricsinfo.h" +#include "paragraph.h" -#include "insets/insettext.h" +#include "frontends/font_metrics.h" +#include "frontends/Painter.h" +#include "frontends/LyXView.h" -#include "support/LOstream.h" -#include "support/lstrings.h" -using std::vector; -using std::ostream; +using lyx::graphics::PreviewLoader; + using std::endl; +using std::string; using std::max; - - -class LyXText; +using std::ostream; InsetCollapsable::InsetCollapsable(BufferParams const & bp, bool collapsed) - : UpdatableInset(), collapsed_(collapsed), inset(bp), - button_length(0), button_top_y(0), button_bottom_y(0), - need_update(NONE), label("Label"), + : UpdatableInset(), inset(bp), collapsed_(collapsed), label("Label") #if 0 - autocollapse(false), + ,autocollapse(false) #endif - oldWidth(0), in_update(false), first_after_edit(false) { inset.setOwner(this); inset.setAutoBreakRows(true); - inset.setDrawFrame(0, InsetText::ALWAYS); - inset.setFrameColor(0, LColor::collapsableframe); + inset.setDrawFrame(InsetText::ALWAYS); + inset.setFrameColor(LColor::collapsableframe); setInsetName("Collapsable"); } -InsetCollapsable::InsetCollapsable(InsetCollapsable const & in, bool same_id) - : UpdatableInset(in, same_id), collapsed_(in.collapsed_), - framecolor(in.framecolor), labelfont(in.labelfont), inset(in.inset), - button_length(0), button_top_y(0), button_bottom_y(0), - need_update(NONE), label(in.label), +InsetCollapsable::InsetCollapsable(InsetCollapsable const & in) + : UpdatableInset(in), inset(in.inset), collapsed_(in.collapsed_), + labelfont_(in.labelfont_), label(in.label) #if 0 - autocollapse(in.autocollapse), + ,autocollapse(in.autocollapse) #endif - oldWidth(0), in_update(false), first_after_edit(false) { - inset.init(&(in.inset), same_id); inset.setOwner(this); } -bool InsetCollapsable::insertInset(BufferView * bv, Inset * in) +bool InsetCollapsable::insertInset(BufferView * bv, InsetOld * in) { if (!insetAllowed(in->lyxCode())) { lyxerr << "InsetCollapsable::InsertInset: " @@ -81,15 +74,14 @@ bool InsetCollapsable::insertInset(BufferView * bv, Inset * in) } -void InsetCollapsable::write(Buffer const * buf, ostream & os) const +void InsetCollapsable::write(Buffer const & buf, ostream & os) const { - os << "collapsed " << tostr(collapsed_) << "\n"; + os << "collapsed " << (collapsed_ ? "true" : "false") << "\n"; inset.writeParagraphData(buf, os); } - -void InsetCollapsable::read(Buffer const * buf, LyXLex & lex) +void InsetCollapsable::read(Buffer const & buf, LyXLex & lex) { if (lex.isOK()) { lex.next(); @@ -108,376 +100,234 @@ void InsetCollapsable::read(Buffer const * buf, LyXLex & lex) } -int InsetCollapsable::ascent_collapsed() const -{ - int width = 0; - int ascent = 0; - int descent = 0; - font_metrics::buttonText(label, labelfont, width, ascent, descent); - return ascent; -} - - -int InsetCollapsable::descent_collapsed() const -{ - int width = 0; - int ascent = 0; - int descent = 0; - font_metrics::buttonText(label, labelfont, width, ascent, descent); - return descent; -} - - -//int InsetCollapsable::width_collapsed(Painter & pain) const -int InsetCollapsable::width_collapsed() const -{ - int width; - int ascent; - int descent; - font_metrics::buttonText(label, labelfont, width, ascent, descent); - return width + (2*TEXT_TO_INSET_OFFSET); -} - - -int InsetCollapsable::ascent(BufferView * /*bv*/, LyXFont const &) const +void InsetCollapsable::dimension_collapsed(Dimension & dim) const { - return ascent_collapsed(); + font_metrics::buttonText(label, labelfont_, dim.wid, dim.asc, dim.des); } -int InsetCollapsable::descent(BufferView * bv, LyXFont const & font) const +int InsetCollapsable::height_collapsed() const { - if (collapsed_) - return descent_collapsed(); - - return descent_collapsed() - + inset.descent(bv, font) - + inset.ascent(bv, font) - + TEXT_TO_BOTTOM_OFFSET; + Dimension dim; + font_metrics::buttonText(label, labelfont_, dim.wid, dim.asc, dim.des); + return dim.asc + dim.des; } -int InsetCollapsable::width(BufferView * bv, LyXFont const & font) const +void InsetCollapsable::metrics(MetricsInfo & mi, Dimension & dim) const { - if (collapsed_) - return width_collapsed(); - - int widthCollapsed = width_collapsed(); - - return (inset.width(bv, font) > widthCollapsed) ? - inset.width(bv, font) : widthCollapsed; + //lyxerr << "InsetCollapsable::metrics: width: " << mi.base.textwidth << endl; + dimension_collapsed(dim); + if (!collapsed_) { + Dimension insetdim; + inset.metrics(mi, insetdim); + dim.des += insetdim.height() + TEXT_TO_BOTTOM_OFFSET; + dim.wid = max(dim.wid, insetdim.wid); + } + dim_ = dim; + //lyxerr << "InsetCollapsable::metrics: dim.wid: " << dim.wid << endl; } -void InsetCollapsable::draw_collapsed(Painter & pain, - int baseline, float & x) const +void InsetCollapsable::draw_collapsed(PainterInfo & pi, int x, int y) const { - pain.buttonText(int(x) + TEXT_TO_INSET_OFFSET, - baseline, label, labelfont); - x += width_collapsed(); + pi.pain.buttonText(x, y, label, labelfont_); } -void InsetCollapsable::draw(BufferView * bv, LyXFont const & f, - int baseline, float & x, bool cleared) const +void InsetCollapsable::draw(PainterInfo & pi, int x, int y, bool inlined) const { - if (need_update != NONE) { - const_cast(&inset)->update(bv, f, true); - bv->text->status(bv, LyXText::CHANGED_IN_DRAW); - need_update = NONE; - return; - } - if (nodraw()) - return; - - Painter & pain = bv->painter(); + Dimension dim_collapsed; + dimension_collapsed(dim_collapsed); - button_length = width_collapsed(); - button_top_y = -ascent(bv, f); - button_bottom_y = -ascent(bv, f) + ascent_collapsed() + - descent_collapsed(); + int const aa = ascent(); + button_dim.x1 = 0; + button_dim.x2 = dim_collapsed.width(); + button_dim.y1 = -aa; + button_dim.y2 = -aa + dim_collapsed.height(); if (!isOpen()) { - draw_collapsed(pain, baseline, x); + draw_collapsed(pi, x, y); return; } - float old_x = x; + int old_x = x; if (!owner()) - x += static_cast(scroll()); - - if (!cleared && (inset.need_update == InsetText::FULL || - inset.need_update == InsetText::INIT || - top_x != int(x) || - top_baseline != baseline)) - { - // we don't need anymore to clear here we just have to tell - // the underlying LyXText that it should do the RowClear! - inset.setUpdateStatus(bv, InsetText::FULL); - bv->text->status(bv, LyXText::CHANGED_IN_DRAW); - return; - } + x += scroll(); - top_x = int(x); - topx_set = true; - top_baseline = baseline; + top_x = x; + top_baseline = y; - int const bl = baseline - ascent(bv, f) + ascent_collapsed(); - - draw_collapsed(pain, bl, old_x); - inset.draw(bv, f, - bl + descent_collapsed() + inset.ascent(bv, f), - x, cleared); - if (x < (top_x + button_length + TEXT_TO_INSET_OFFSET)) - x = top_x + button_length + TEXT_TO_INSET_OFFSET; -} - - -void InsetCollapsable::edit(BufferView * bv, int xp, int yp, - mouse_button::state button) -{ - UpdatableInset::edit(bv, xp, yp, button); - - if (collapsed_) { - collapsed_ = false; - // set this only here as it should be recollapsed only if - // it was already collapsed! - first_after_edit = true; - if (!bv->lockInset(this)) - return; - bv->updateInset(this, false); - inset.edit(bv); + if (inlined) { + inset.draw(pi, x, y); } else { - if (!bv->lockInset(this)) - return; - if (yp <= button_bottom_y) { - inset.edit(bv, xp, 0, button); - } else { - LyXFont font(LyXFont::ALL_SANE); - int yy = ascent(bv, font) + yp - - (ascent_collapsed() + - descent_collapsed() + - inset.ascent(bv, font)); - inset.edit(bv, xp, yy, button); - } + int const bl = y - aa + dim_collapsed.ascent(); + draw_collapsed(pi, old_x, bl); + inset.draw(pi, x, bl + dim_collapsed.descent() + inset.ascent()); } } -void InsetCollapsable::edit(BufferView * bv, bool front) +void InsetCollapsable::draw(PainterInfo & pi, int x, int y) const { - UpdatableInset::edit(bv, front); - - if (collapsed_) { - collapsed_ = false; - if (!bv->lockInset(this)) - return; - inset.setUpdateStatus(bv, InsetText::FULL); - bv->updateInset(this, false); - inset.edit(bv, front); - first_after_edit = true; - } else { - if (!bv->lockInset(this)) - return; - inset.edit(bv, front); - } + // by default, we are not inlined-drawing + draw(pi, x, y, false); } -Inset::EDITABLE InsetCollapsable::editable() const +InsetOld::EDITABLE InsetCollapsable::editable() const { - if (collapsed_) - return IS_EDITABLE; - return HIGHLY_EDITABLE; + return collapsed_ ? IS_EDITABLE : HIGHLY_EDITABLE; } -void InsetCollapsable::insetUnlock(BufferView * bv) +FuncRequest InsetCollapsable::adjustCommand(FuncRequest const & cmd) { -#if 0 - if (autocollapse) { - if (change_label_with_text) { - draw_label = get_new_label(); - } else { - draw_label = label; - } - collapsed_ = true; - } -#endif - inset.insetUnlock(bv); - if (scroll()) - scroll(bv, 0.0F); - bv->updateInset(this, false); + FuncRequest cmd1 = cmd; + cmd1.y = ascent() + cmd.y - height_collapsed() - inset.ascent(); + return cmd1; } -void InsetCollapsable::insetButtonPress(BufferView * bv, - int x, int y, mouse_button::state button) +DispatchResult InsetCollapsable::lfunMouseRelease(FuncRequest const & cmd) { - if (!collapsed_ && (y > button_bottom_y)) { - LyXFont font(LyXFont::ALL_SANE); - int yy = ascent(bv, font) + y - - (ascent_collapsed() + - descent_collapsed() + - inset.ascent(bv, font)); - inset.insetButtonPress(bv, x, yy, button); - } -} - + DispatchResult result(true, true); + BufferView * bv = cmd.view(); -bool InsetCollapsable::insetButtonRelease(BufferView * bv, - int x, int y, mouse_button::state button) -{ - bool ret = false; - if ((button != mouse_button::button3) && (x < button_length) && - (y >= button_top_y) && (y <= button_bottom_y)) - { + if (cmd.button() == mouse_button::button3) { + lyxerr << "InsetCollapsable::lfunMouseRelease 0" << endl; + if (hitButton(cmd)) + showInsetDialog(bv); + } else { if (collapsed_) { + lyxerr << "InsetCollapsable::lfunMouseRelease 1" << endl; collapsed_ = false; -// should not be called on inset open! -// inset.insetButtonRelease(bv, 0, 0, button); - inset.setUpdateStatus(bv, InsetText::FULL); - bv->updateInset(this, false); - } else { - collapsed_ = true; - bv->unlockInset(this); - bv->updateInset(this, false); + bv->updateInset(this); + bv->buffer()->markDirty(); + return result; + } + + if (hitButton(cmd)) { + if (collapsed_) { + lyxerr << "InsetCollapsable::lfunMouseRelease 2" << endl; + collapsed_ = false; + } else { + collapsed_ = true; + result.update(true); + result.val(FINISHED_RIGHT); + return result; + } + result.update(true); + bv->updateInset(this); + bv->buffer()->markDirty(); + } else if (!collapsed_ && cmd.y > button_dim.y2) { + lyxerr << "InsetCollapsable::lfunMouseRelease 3" << endl; + result = inset.dispatch(adjustCommand(cmd)); } - } else if (!collapsed_ && (y > button_bottom_y)) { - LyXFont font(LyXFont::ALL_SANE); - int yy = ascent(bv, font) + y - - (ascent_collapsed() + - descent_collapsed() + - inset.ascent(bv, font)); - ret = inset.insetButtonRelease(bv, x, yy, button); - } - if ((button == mouse_button::button3) && !ret) { - return showInsetDialog(bv); } - return ret; + lyxerr << "InsetCollapsable::lfunMouseRelease 4" << endl; + return result; } -void InsetCollapsable::insetMotionNotify(BufferView * bv, - int x, int y, mouse_button::state state) +int InsetCollapsable::latex(Buffer const & buf, ostream & os, + OutputParams const & runparams) const { - if (y > button_bottom_y) { - LyXFont font(LyXFont::ALL_SANE); - int yy = ascent(bv, font) + y - - (ascent_collapsed() + - descent_collapsed() + - inset.ascent(bv, font)); - inset.insetMotionNotify(bv, x, yy, state); - } + return inset.latex(buf, os, runparams); } -int InsetCollapsable::latex(Buffer const * buf, ostream & os, - bool fragile, bool free_spc) const +int InsetCollapsable::plaintext(Buffer const & buf, ostream & os, + OutputParams const & runparams) const { - return inset.latex(buf, os, fragile, free_spc); + return inset.plaintext(buf, os, runparams); } -int InsetCollapsable::ascii(Buffer const * buf, ostream & os, int ll) const +int InsetCollapsable::linuxdoc(Buffer const & buf, ostream & os, + OutputParams const & runparams) const { - return inset.ascii(buf, os, ll); + return inset.linuxdoc(buf, os, runparams); } -int InsetCollapsable::linuxdoc(Buffer const * buf, ostream & os) const +int InsetCollapsable::docbook(Buffer const & buf, ostream & os, + OutputParams const & runparams) const { - return inset.linuxdoc(buf, os); + return inset.docbook(buf, os, runparams); } -int InsetCollapsable::docbook(Buffer const * buf, ostream & os) const +bool InsetCollapsable::hitButton(FuncRequest const & cmd) const { - return inset.docbook(buf, os); + return button_dim.contains(cmd.x, cmd.y); } -#if 0 -int InsetCollapsable::getMaxWidth(BufferView * bv, - UpdatableInset const * in) const -{ -#if 0 - int const w = UpdatableInset::getMaxWidth(bv, in); - if (w < 0) { - // What does a negative max width signify? (Lgb) - // Use the max width of the draw-area (Jug) - return w; - } - // should be at least 30 pixels !!! - return max(30, w - width_collapsed()); -#else - return UpdatableInset::getMaxWidth(bv, in); -#endif +void InsetCollapsable::edit(BufferView * bv, bool left) +{ + lyxerr << "InsetCollapsable: edit left/right" << endl; + bv->cursor().push(this); + inset.edit(bv, left); + open(bv); } -#endif -void InsetCollapsable::update(BufferView * bv, LyXFont const & font, - bool reinit) +void InsetCollapsable::edit(BufferView * bv, int x, int y) { - if (in_update) { - if (reinit && owner()) { - owner()->update(bv, font, true); - } - return; - } - in_update = true; - inset.update(bv, font, reinit); - if (reinit && owner()) { - owner()->update(bv, font, true); + lyxerr << "InsetCollapsable: edit xy" << endl; + if (collapsed_) { + collapsed_ = false; + // set this only here as it should be recollapsed only if + // it was already collapsed! + bv->updateInset(this); + bv->buffer()->markDirty(); + inset.edit(bv, x, y); + } else { + if (y <= button_dim.y2) + inset.edit(bv, x, 0); + else + inset.edit(bv, x, + ascent() + y - height_collapsed() + inset.ascent()); } - in_update = false; + bv->cursor().push(this); } -UpdatableInset::RESULT -InsetCollapsable::localDispatch(BufferView * bv, kb_action action, - string const & arg) +DispatchResult +InsetCollapsable::priv_dispatch(FuncRequest const & cmd, idx_type &, pos_type &) { - UpdatableInset::RESULT result = inset.localDispatch(bv, action, arg); - if (result >= FINISHED) - bv->unlockInset(this); - first_after_edit = false; - return result; -} + lyxerr << "\nInsetCollapsable::priv_dispatch (begin): cmd: " << cmd + << " button y: " << button_dim.y2 << endl; + switch (cmd.action) { + case LFUN_MOUSE_PRESS: + if (!collapsed_ && cmd.y > button_dim.y2) + inset.dispatch(adjustCommand(cmd)); + return DispatchResult(true, true); + case LFUN_MOUSE_MOTION: + if (!collapsed_ && cmd.y > button_dim.y2) + inset.dispatch(adjustCommand(cmd)); + return DispatchResult(true, true); -bool InsetCollapsable::lockInsetInInset(BufferView * bv, UpdatableInset * in) -{ - if (&inset == in) - return true; - return inset.lockInsetInInset(bv, in); -} + case LFUN_MOUSE_RELEASE: + if (!collapsed_ && cmd.y > button_dim.y2) + inset.dispatch(adjustCommand(cmd)); + else + return lfunMouseRelease(cmd); + return DispatchResult(true, true); - -bool InsetCollapsable::unlockInsetInInset(BufferView * bv, UpdatableInset * in, - bool lr) -{ - if (&inset == in) { - bv->unlockInset(this); - return true; + default: + return inset.dispatch(cmd); } - return inset.unlockInsetInInset(bv, in, lr); -} - - -bool InsetCollapsable::updateInsetInInset(BufferView * bv, Inset *in) -{ - if (in == this) - return true; - return inset.updateInsetInInset(bv, in); + lyxerr << "InsetCollapsable::priv_dispatch (end)" << endl; } int InsetCollapsable::insetInInsetY() const { - return inset.insetInInsetY() - (top_baseline - inset.y()); + return inset.y() - top_baseline + inset.insetInInsetY(); } @@ -490,187 +340,147 @@ void InsetCollapsable::validate(LaTeXFeatures & features) const void InsetCollapsable::getCursorPos(BufferView * bv, int & x, int & y) const { inset.getCursorPos(bv, x , y); + y += - ascent() + height_collapsed() + inset.ascent(); } -void InsetCollapsable::toggleInsetCursor(BufferView * bv) +void InsetCollapsable::setFont(BufferView * bv, LyXFont const & font, + bool toggleall, bool selectall) { - inset.toggleInsetCursor(bv); + inset.setFont(bv, font, toggleall, selectall); } -void InsetCollapsable::showInsetCursor(BufferView * bv, bool show) +void InsetCollapsable::deleteLyXText(BufferView * bv, bool recursive) const { - inset.showInsetCursor(bv, show); + inset.deleteLyXText(bv, recursive); } -void InsetCollapsable::hideInsetCursor(BufferView * bv) +void InsetCollapsable::getLabelList(Buffer const & buffer, + std::vector & list) const { - inset.hideInsetCursor(bv); + inset.getLabelList(buffer, list); } -UpdatableInset * InsetCollapsable::getLockingInset() const +int InsetCollapsable::scroll(bool recursive) const { - UpdatableInset * in = inset.getLockingInset(); - if (const_cast(&inset) == in) - return const_cast(this); - return in; -} + int sx = UpdatableInset::scroll(false); + if (recursive) + sx += inset.scroll(recursive); -UpdatableInset * InsetCollapsable::getFirstLockingInsetOfType(Inset::Code c) -{ - if (c == lyxCode()) - return this; - return inset.getFirstLockingInsetOfType(c); + return sx; } -void InsetCollapsable::setFont(BufferView * bv, LyXFont const & font, - bool toggleall, bool selectall) +ParagraphList * InsetCollapsable::getParagraphs(int i) const { - inset.setFont(bv, font, toggleall, selectall); + return inset.getParagraphs(i); } -bool InsetCollapsable::doClearArea() const +int InsetCollapsable::numParagraphs() const { - return inset.doClearArea(); + return inset.numParagraphs(); } -LyXText * InsetCollapsable::getLyXText(BufferView const * bv, - bool const recursive) const +LyXText * InsetCollapsable::getText(int i) const { - return inset.getLyXText(bv, recursive); + return inset.getText(i); } -void InsetCollapsable::deleteLyXText(BufferView * bv, bool recursive) const +void InsetCollapsable::open(BufferView * bv) { - inset.deleteLyXText(bv, recursive); -} - + if (!collapsed_) + return; -void InsetCollapsable::resizeLyXText(BufferView * bv, bool force) const -{ - inset.resizeLyXText(bv, force); - LyXFont font(LyXFont::ALL_SANE); - oldWidth = width(bv, font); + collapsed_ = false; + bv->updateInset(this); } -vector const InsetCollapsable::getLabelList() const +void InsetCollapsable::close(BufferView * bv) const { - return inset.getLabelList(); -} - + if (collapsed_) + return; -bool InsetCollapsable::nodraw() const -{ - return inset.nodraw(); + collapsed_ = true; + bv->updateInset(this); } -int InsetCollapsable::scroll(bool recursive) const +void InsetCollapsable::setLabel(string const & l) const { - int sx = UpdatableInset::scroll(false); - - if (recursive) - sx += inset.scroll(recursive); - - return sx; + label = l; } -Paragraph * InsetCollapsable::getParFromID(int id) const +void InsetCollapsable::setCollapsed(bool c) const { - lyxerr[Debug::INFO] << "Looking for paragraph " << id << endl; - return inset.getParFromID(id); + collapsed_ = c; } -Paragraph * InsetCollapsable::firstParagraph() const +void InsetCollapsable::markErased() { - return inset.firstParagraph(); + inset.markErased(); } -Paragraph * InsetCollapsable::getFirstParagraph(int i) const +void InsetCollapsable::addPreview(PreviewLoader & loader) const { - return inset.getFirstParagraph(i); + inset.addPreview(loader); } -LyXCursor const & InsetCollapsable::cursor(BufferView * bv) const +bool InsetCollapsable::insetAllowed(InsetOld::Code code) const { - return inset.cursor(bv); + return inset.insetAllowed(code); } -Inset * InsetCollapsable::getInsetFromID(int id_arg) const +void InsetCollapsable::fitInsetCursor(BufferView * bv) const { - if (id_arg == id()) - return const_cast(this); - return inset.getInsetFromID(id_arg); + inset.fitInsetCursor(bv); } -void InsetCollapsable::open(BufferView * bv) +void InsetCollapsable::setLabelFont(LyXFont & f) { - if (!collapsed_) return; - - collapsed_ = false; - bv->updateInset(this, false); + labelfont_ = f; } - -void InsetCollapsable::close(BufferView * bv) const +#if 0 +void InsetCollapsable::setAutoCollapse(bool f) { - if (collapsed_) - return; - - collapsed_ = true; - bv->updateInset(const_cast(this), false); + autocollapse = f; } +#endif - -void InsetCollapsable::setLabel(string const & l) const +void InsetCollapsable::scroll(BufferView *bv, float sx) const { - label = l; + UpdatableInset::scroll(bv, sx); } -bool InsetCollapsable::searchForward(BufferView * bv, string const & str, - bool cs, bool mw) +void InsetCollapsable::scroll(BufferView *bv, int offset) const { - bool found = inset.searchForward(bv, str, cs, mw); - if (first_after_edit && !found) - close(bv); - first_after_edit = false; - return found; + UpdatableInset::scroll(bv, offset); } -bool InsetCollapsable::searchBackward(BufferView * bv, string const & str, - bool cs, bool mw) +bool InsetCollapsable::isOpen() const { - bool found = inset.searchBackward(bv, str, cs, mw); - if (first_after_edit && !found) - close(bv); - first_after_edit = false; - return found; + return !collapsed_; } -string const InsetCollapsable::selectNextWordToSpellcheck(BufferView * bv, - float & value) const +Box const & InsetCollapsable::buttonDim() const { - string const str = inset.selectNextWordToSpellcheck(bv, value); - if (first_after_edit && str.empty()) - close(bv); - first_after_edit = false; - return str; + return button_dim; } +