X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsetcollapsable.C;h=aec1bf69ec0fdc5901a2008e87fd99723f979d08;hb=e28331ed63062dea10d0a21b9ec12034b4b17b9a;hp=7f0cfe151f79b45aef82c63e0bb310e567fb554c;hpb=0ca871014add94c501cb423d8dc65c1405f4d141;p=lyx.git diff --git a/src/insets/insetcollapsable.C b/src/insets/insetcollapsable.C index 7f0cfe151f..aec1bf69ec 100644 --- a/src/insets/insetcollapsable.C +++ b/src/insets/insetcollapsable.C @@ -15,242 +15,256 @@ #include "insetcollapsable.h" #include "buffer.h" +#include "bufferparams.h" #include "BufferView.h" #include "cursor.h" #include "debug.h" #include "dispatchresult.h" +#include "FloatList.h" +#include "FuncStatus.h" +#include "gettext.h" #include "LColor.h" #include "lyxlex.h" #include "funcrequest.h" #include "metricsinfo.h" #include "paragraph.h" -#include "frontends/font_metrics.h" +#include "frontends/FontMetrics.h" #include "frontends/Painter.h" -#include "frontends/LyXView.h" -using lyx::graphics::PreviewLoader; +namespace lyx { + +using graphics::PreviewLoader; using std::endl; using std::string; using std::max; +using std::min; using std::ostream; -InsetCollapsable::InsetCollapsable(BufferParams const & bp, bool collapsed) - : UpdatableInset(), inset(bp), collapsed_(collapsed), label("Label") -#if 0 - ,autocollapse(false) -#endif +InsetCollapsable::CollapseStatus InsetCollapsable::status() const { - inset.setOwner(this); - inset.setAutoBreakRows(true); - inset.setDrawFrame(InsetText::ALWAYS); - inset.setFrameColor(LColor::collapsableframe); - setInsetName("Collapsable"); + return (autoOpen_ && status_ != Inlined) ? Open : status_; } -InsetCollapsable::InsetCollapsable(InsetCollapsable const & in) - : UpdatableInset(in), inset(in.inset), collapsed_(in.collapsed_), - labelfont_(in.labelfont_), label(in.label) -#if 0 - ,autocollapse(in.autocollapse) -#endif +InsetCollapsable::InsetCollapsable + (BufferParams const & bp, CollapseStatus status) + : InsetText(bp), label(from_ascii("Label")), status_(status), + openinlined_(false), autoOpen_(false), mouse_hover_(false) { - inset.setOwner(this); + setAutoBreakRows(true); + setDrawFrame(true); + setFrameColor(LColor::collapsableframe); + setInsetName(from_ascii("Collapsable")); + setButtonLabel(); } -bool InsetCollapsable::insertInset(BufferView * bv, InsetOld * in) +InsetCollapsable::InsetCollapsable(InsetCollapsable const & rhs): + InsetText(rhs), + labelfont_(rhs.labelfont_), + button_dim(rhs.button_dim), + topx(rhs.topx), + topbaseline(rhs.topbaseline), + label(rhs.label), + status_(rhs.status_), + openinlined_(rhs.openinlined_), + autoOpen_(rhs.autoOpen_), + textdim_(rhs.textdim_), + // the sole purpose of this copy constructor + mouse_hover_(false) { - if (!insetAllowed(in->lyxCode())) { - lyxerr << "InsetCollapsable::InsertInset: " - "Unable to insert inset." << endl; - return false; - } - return inset.insertInset(bv, in); } void InsetCollapsable::write(Buffer const & buf, ostream & os) const { - os << "collapsed " << (collapsed_ ? "true" : "false") << "\n"; - inset.writeParagraphData(buf, os); + os << "status "; + switch (status_) { + case Open: + os << "open"; + break; + case Collapsed: + os << "collapsed"; + break; + case Inlined: + os << "inlined"; + break; + } + os << "\n"; + text_.write(buf, os); } void InsetCollapsable::read(Buffer const & buf, LyXLex & lex) { + bool token_found = false; if (lex.isOK()) { lex.next(); string const token = lex.getString(); - if (token == "collapsed") { + if (token == "status") { lex.next(); - collapsed_ = lex.getBool(); + string const tmp_token = lex.getString(); + + if (tmp_token == "inlined") { + status_ = Inlined; + token_found = true; + } else if (tmp_token == "collapsed") { + status_ = Collapsed; + token_found = true; + } else if (tmp_token == "open") { + status_ = Open; + token_found = true; + } else { + lyxerr << "InsetCollapsable::read: Missing status!" + << endl; + // Take countermeasures + lex.pushToken(token); + } } else { - lyxerr << "InsetCollapsable::Read: Missing collapsed!" - << endl; - // Take countermeasures + lyxerr << "InsetCollapsable::read: Missing 'status'-tag!" + << endl; + // take countermeasures lex.pushToken(token); } } - inset.read(buf, lex); -} + InsetText::read(buf, lex); + if (!token_found) + status_ = isOpen() ? Open : Collapsed; -void InsetCollapsable::dimension_collapsed(Dimension & dim) const -{ - font_metrics::buttonText(label, labelfont_, dim.wid, dim.asc, dim.des); + setButtonLabel(); } -int InsetCollapsable::height_collapsed() const +Dimension InsetCollapsable::dimensionCollapsed() const { Dimension dim; - font_metrics::buttonText(label, labelfont_, dim.wid, dim.asc, dim.des); - return dim.asc + dim.des; + theFontMetrics(labelfont_).buttonText( + label, dim.wid, dim.asc, dim.des); + return dim; } -void InsetCollapsable::metrics(MetricsInfo & mi, Dimension & dim) const +bool InsetCollapsable::metrics(MetricsInfo & mi, Dimension & dim) const { - //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); + autoOpen_ = mi.base.bv->cursor().isInside(this); + mi.base.textwidth -= 2 * TEXT_TO_INSET_OFFSET; + + if (status() == Inlined) { + InsetText::metrics(mi, dim); + } else { + dim = dimensionCollapsed(); + if (status() == Open) { + InsetText::metrics(mi, textdim_); + // This expression should not contain mi.base.texwidth + openinlined_ = !hasFixedWidth() + && textdim_.wid < 0.5 * mi.base.bv->workWidth(); + if (openinlined_) { + // Correct for button width, and re-fit + mi.base.textwidth -= dim.wid; + InsetText::metrics(mi, textdim_); + dim.wid += textdim_.wid; + dim.des = max(dim.des - textdim_.asc + dim.asc, textdim_.des); + dim.asc = textdim_.asc; + } else { + dim.des += textdim_.height() + TEXT_TO_BOTTOM_OFFSET; + dim.wid = max(dim.wid, textdim_.wid); + } + } } + dim.asc += TEXT_TO_INSET_OFFSET; + dim.des += TEXT_TO_INSET_OFFSET; + dim.wid += 2 * TEXT_TO_INSET_OFFSET; + mi.base.textwidth += 2 * TEXT_TO_INSET_OFFSET; + bool const changed = dim_ != dim; dim_ = dim; - //lyxerr << "InsetCollapsable::metrics: dim.wid: " << dim.wid << endl; + return changed; } -void InsetCollapsable::draw_collapsed(PainterInfo & pi, int x, int y) const +bool InsetCollapsable::setMouseHover(bool mouse_hover) { - pi.pain.buttonText(x, y, label, labelfont_); + mouse_hover_ = mouse_hover; + return true; } -void InsetCollapsable::draw(PainterInfo & pi, int x, int y, bool inlined) const +void InsetCollapsable::draw(PainterInfo & pi, int x, int y) const { - Dimension dim_collapsed; - dimension_collapsed(dim_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(); - - xo_ = x; - yo_ = y; - - if (!isOpen()) { - draw_collapsed(pi, x, y); - return; - } - - int old_x = x; - - if (!owner()) - x += scroll(); - - if (inlined) { - inset.draw(pi, x, y); + const int xx = x + TEXT_TO_INSET_OFFSET; + if (status() == Inlined) { + InsetText::draw(pi, xx, y); } else { - int const bl = y - aa + dim_collapsed.ascent(); - draw_collapsed(pi, old_x, bl); - inset.draw(pi, x, bl + dim_collapsed.descent() + inset.ascent()); + Dimension dimc = dimensionCollapsed(); + int const top = y - ascent() + TEXT_TO_INSET_OFFSET; + button_dim.x1 = xx + 0; + button_dim.x2 = xx + dimc.width(); + button_dim.y1 = top; + button_dim.y2 = top + dimc.height(); + + pi.pain.buttonText(xx, top + dimc.asc, label, labelfont_, mouse_hover_); + + if (status() == Open) { + int textx, texty; + if (openinlined_) { + textx = xx + dimc.width(); + texty = top + textdim_.asc; + } else { + textx = xx; + texty = top + dimc.height() + textdim_.asc; + } + InsetText::draw(pi, textx, texty); + } } + setPosCache(pi, x, y); } -void InsetCollapsable::draw(PainterInfo & pi, int x, int y) const -{ - // by default, we are not inlined-drawing - draw(pi, x, y, false); -} - - -InsetOld::EDITABLE InsetCollapsable::editable() const -{ - return collapsed_ ? IS_EDITABLE : HIGHLY_EDITABLE; -} - - -FuncRequest InsetCollapsable::adjustCommand(FuncRequest const & cmd) -{ - FuncRequest cmd1 = cmd; - cmd1.y += ascent() - height_collapsed(); - return cmd1; -} - - -DispatchResult InsetCollapsable::lfunMouseRelease(FuncRequest const & cmd) +void InsetCollapsable::drawSelection(PainterInfo & pi, int x, int y) const { - BufferView * bv = cmd.view(); - - if (cmd.button() == mouse_button::button3) { - lyxerr << "InsetCollapsable::lfunMouseRelease 0" << endl; - if (hitButton(cmd)) - showInsetDialog(bv); - return DispatchResult(true, true); - } - - if (collapsed_) { - lyxerr << "InsetCollapsable::lfunMouseRelease 1" << endl; - collapsed_ = false; - edit(bv, true); - return DispatchResult(true, true); - } - - if (hitButton(cmd)) { - if (!collapsed_) { - collapsed_ = true; - lyxerr << "InsetCollapsable::lfunMouseRelease 2" << endl; - return DispatchResult(false, FINISHED_RIGHT); - } - collapsed_ = false; - lyxerr << "InsetCollapsable::lfunMouseRelease 3" << endl; - } else if (!collapsed_ && cmd.y > button_dim.y2) { - lyxerr << "InsetCollapsable::lfunMouseRelease 4" << endl; - return inset.dispatch(adjustCommand(cmd)); + x += TEXT_TO_INSET_OFFSET; + if (status() == Open) { + if (openinlined_) + x += dimensionCollapsed().wid; + else + y += dimensionCollapsed().des + textdim_.asc; } - - lyxerr << "InsetCollapsable::lfunMouseRelease 5" << endl; - return DispatchResult(true, true); + if (status() != Collapsed) + InsetText::drawSelection(pi, x, y); } -int InsetCollapsable::latex(Buffer const & buf, ostream & os, - OutputParams const & runparams) const +void InsetCollapsable::cursorPos(BufferView const & bv, + CursorSlice const & sl, bool boundary, int & x, int & y) const { - return inset.latex(buf, os, runparams); -} + BOOST_ASSERT(status() != Collapsed); + InsetText::cursorPos(bv, sl, boundary, x, y); -int InsetCollapsable::plaintext(Buffer const & buf, ostream & os, - OutputParams const & runparams) const -{ - return inset.plaintext(buf, os, runparams); + if (status() == Open) { + if (openinlined_) + x += dimensionCollapsed().wid; + else + y += dimensionCollapsed().height() - ascent() + + TEXT_TO_INSET_OFFSET + textdim_.asc; + } + x += TEXT_TO_INSET_OFFSET; } -int InsetCollapsable::linuxdoc(Buffer const & buf, ostream & os, - OutputParams const & runparams) const +InsetBase::EDITABLE InsetCollapsable::editable() const { - return inset.linuxdoc(buf, os, runparams); + return status() != Collapsed ? HIGHLY_EDITABLE : IS_EDITABLE; } -int InsetCollapsable::docbook(Buffer const & buf, ostream & os, - OutputParams const & runparams) const +bool InsetCollapsable::descendable() const { - return inset.docbook(buf, os, runparams); + return status() != Collapsed; } @@ -260,199 +274,188 @@ bool InsetCollapsable::hitButton(FuncRequest const & cmd) const } -void InsetCollapsable::edit(BufferView * bv, bool left) +docstring const InsetCollapsable::getNewLabel(docstring const & l) const { - lyxerr << "InsetCollapsable: edit left/right" << endl; - inset.edit(bv, left); - open(); - bv->cursor().push(this); -} - - -void InsetCollapsable::edit(BufferView * bv, int x, int y) -{ - lyxerr << "InsetCollapsable: edit xy" << endl; - if (collapsed_) { - collapsed_ = false; - // set this only here as it should be recollapsed only if - // it was already collapsed! - 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()); + docstring label; + pos_type const max_length = 15; + pos_type const p_siz = paragraphs().begin()->size(); + pos_type const n = min(max_length, p_siz); + pos_type i = 0; + pos_type j = 0; + for (; i < n && j < p_siz; ++j) { + if (paragraphs().begin()->isInset(j)) + continue; + label += paragraphs().begin()->getChar(j); + ++i; } - - bv->cursor().push(this); -} - - -DispatchResult -InsetCollapsable::priv_dispatch(FuncRequest const & cmd, idx_type &, pos_type &) -{ - 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_) - inset.dispatch(adjustCommand(cmd)); - return DispatchResult(true, true); - - case LFUN_MOUSE_RELEASE: - if (!collapsed_ && cmd.y > button_dim.y2) - inset.dispatch(adjustCommand(cmd)); - else - return lfunMouseRelease(cmd); - return DispatchResult(true, true); - - default: - return inset.dispatch(adjustCommand(cmd)); + if (paragraphs().size() > 1 || (i > 0 && j < p_siz)) { + label += "..."; } - lyxerr << "InsetCollapsable::priv_dispatch (end)" << endl; -} - - -int InsetCollapsable::insetInInsetY() const -{ - return inset.y() - yo_ + inset.insetInInsetY(); -} - - -void InsetCollapsable::validate(LaTeXFeatures & features) const -{ - inset.validate(features); + return label.empty() ? l : label; } -void InsetCollapsable::getCursorPos(int & x, int & y) const +void InsetCollapsable::edit(LCursor & cur, bool left) { - inset.getCursorPos(x , y); - y += - ascent() + height_collapsed() + inset.ascent(); + //lyxerr << "InsetCollapsable: edit left/right" << endl; + cur.push(*this); + InsetText::edit(cur, left); } -void InsetCollapsable::getLabelList(Buffer const & buffer, - std::vector & list) const +InsetBase * InsetCollapsable::editXY(LCursor & cur, int x, int y) { - inset.getLabelList(buffer, list); + //lyxerr << "InsetCollapsable: edit xy" << endl; + if (status() == Collapsed || (button_dim.contains(x, y) && status() != Inlined)) + return this; + cur.push(*this); + return InsetText::editXY(cur, x, y); } -int InsetCollapsable::scroll(bool recursive) const +void InsetCollapsable::doDispatch(LCursor & cur, FuncRequest & cmd) { - int sx = UpdatableInset::scroll(false); - - if (recursive) - sx += inset.scroll(false); - - return sx; -} - - -ParagraphList * InsetCollapsable::getParagraphs(int i) const -{ - return inset.getParagraphs(i); -} + //lyxerr << "InsetCollapsable::doDispatch (begin): cmd: " << cmd + // << " cur: " << cur << " bvcur: " << cur.bv().cursor() << endl; + switch (cmd.action) { + case LFUN_MOUSE_PRESS: + if (cmd.button() == mouse_button::button1 && hitButton(cmd) && status() != Inlined) { + // reset selection if necessary (see bug 3060) + if (cur.selection()) + cur.bv().cursor().clearSelection(); + else + cur.noUpdate(); + cur.dispatched(); + break; + } + if (status() == Inlined) + InsetText::doDispatch(cur, cmd); + else if (status() == Open && !hitButton(cmd)) + InsetText::doDispatch(cur, cmd); + else + cur.undispatched(); + break; + + case LFUN_MOUSE_MOTION: + case LFUN_MOUSE_DOUBLE: + case LFUN_MOUSE_TRIPLE: + if (status_ == Inlined) + InsetText::doDispatch(cur, cmd); + else if (status() && !hitButton(cmd)) + InsetText::doDispatch(cur, cmd); + else + cur.undispatched(); + break; + + case LFUN_MOUSE_RELEASE: + if (cmd.button() == mouse_button::button3) { + // Open the Inset configuration dialog + showInsetDialog(&cur.bv()); + break; + } -int InsetCollapsable::numParagraphs() const -{ - return inset.numParagraphs(); -} + if (status() == Inlined) { + // The mouse click has to be within the inset! + InsetText::doDispatch(cur, cmd); + break; + } + if (cmd.button() == mouse_button::button1 && hitButton(cmd)) { + // if we are selecting, we do not want to + // toggle the inset. + if (cur.selection()) + break; + // Left button is clicked, the user asks to + // toggle the inset visual state. + cur.dispatched(); + cur.updateFlags(Update::Force | Update::FitCursor); + if (status() == Collapsed) { + setStatus(cur, Open); + edit(cur, true); + } + else { + setStatus(cur, Collapsed); + } + cur.bv().cursor() = cur; + break; + } -LyXText * InsetCollapsable::getText(int i) const -{ - return inset.getText(i); + // The mouse click is within the opened inset. + if (status() == Open) + InsetText::doDispatch(cur, cmd); + break; + + case LFUN_INSET_TOGGLE: + if (cmd.argument() == "open") + setStatus(cur, Open); + else if (cmd.argument() == "close") + setStatus(cur, Collapsed); + else if (cmd.argument() == "toggle" || cmd.argument().empty()) + if (isOpen()) { + setStatus(cur, Collapsed); + cur.forwardPosNoDescend(); + } + else + setStatus(cur, Open); + else // if assign or anything else + cur.undispatched(); + cur.dispatched(); + break; + + default: + InsetText::doDispatch(cur, cmd); + break; + } } -void InsetCollapsable::open() +bool InsetCollapsable::getStatus(LCursor & cur, FuncRequest const & cmd, + FuncStatus & flag) const { - if (!collapsed_) - return; - - collapsed_ = false; -} - + switch (cmd.action) { -void InsetCollapsable::close() const -{ - if (collapsed_) - return; + case LFUN_INSET_TOGGLE: + if (cmd.argument() == "open" || cmd.argument() == "close" || + cmd.argument() == "toggle") + flag.enabled(true); + else + flag.enabled(false); + return true; - collapsed_ = true; + default: + return InsetText::getStatus(cur, cmd, flag); + } } -void InsetCollapsable::setLabel(string const & l) const +void InsetCollapsable::setLabel(docstring const & l) { label = l; } -void InsetCollapsable::setCollapsed(bool c) const -{ - collapsed_ = c; -} - - -void InsetCollapsable::markErased() -{ - inset.markErased(); -} - - -void InsetCollapsable::addPreview(PreviewLoader & loader) const -{ - inset.addPreview(loader); -} - - -bool InsetCollapsable::insetAllowed(InsetOld::Code code) const +void InsetCollapsable::setStatus(LCursor & cur, CollapseStatus status) { - return inset.insetAllowed(code); + status_ = status; + setButtonLabel(); + if (status_ == Collapsed) + cur.leaveInset(*this); } -void InsetCollapsable::setLabelFont(LyXFont & f) +void InsetCollapsable::setLabelFont(LyXFont & font) { - labelfont_ = f; + labelfont_ = font; } -#if 0 -void InsetCollapsable::setAutoCollapse(bool f) +docstring InsetCollapsable::floatName(string const & type, BufferParams const & bp) { - autocollapse = f; + FloatList const & floats = bp.getLyXTextClass().floats(); + FloatList::const_iterator it = floats[type]; + // FIXME UNICODE + return (it == floats.end()) ? from_ascii(type) : _(it->second.name()); } -#endif -void InsetCollapsable::scroll(BufferView *bv, float sx) const -{ - UpdatableInset::scroll(bv, sx); -} - - -void InsetCollapsable::scroll(BufferView *bv, int offset) const -{ - UpdatableInset::scroll(bv, offset); -} - - -bool InsetCollapsable::isOpen() const -{ - return !collapsed_; -} - - -Box const & InsetCollapsable::buttonDim() const -{ - return button_dim; -} +} // namespace lyx