prevent crash when inserting minipage in table cell,

[lyx.git] / src / insets / insetcollapsable.C

diff --git a/src/insets/insetcollapsable.C b/src/insets/insetcollapsable.C
index 7f24b59882c4a8eaafd3d5338f6255a6dca48947..4a5002bf199fc9e1f96f1c568393b1ae618b161a 100644 (file)
--- a/src/insets/insetcollapsable.C
+++ b/src/insets/insetcollapsable.C
@@ -35,18 +35,17 @@
 #include "support/LOstream.h"
 
 using namespace lyx::support;
+using namespace lyx::graphics;
 
 using std::vector;
 using std::ostream;
 using std::endl;
 using std::max;
 
-namespace grfx = lyx::graphics;
 
 InsetCollapsable::InsetCollapsable(BufferParams const & bp, bool collapsed)
        : UpdatableInset(), collapsed_(collapsed), inset(bp),
-         button_length(0), button_top_y(0), button_bottom_y(0),
-         label("Label"),
+         button_dim(0, 0, 0, 0), label("Label"),
 #if 0
        autocollapse(false),
 #endif
@@ -63,8 +62,7 @@ InsetCollapsable::InsetCollapsable(BufferParams const & bp, bool collapsed)
 InsetCollapsable::InsetCollapsable(InsetCollapsable const & in)
        : UpdatableInset(in), collapsed_(in.collapsed_),
          framecolor(in.framecolor), labelfont(in.labelfont), inset(in.inset),
-         button_length(0), button_top_y(0), button_bottom_y(0),
-         label(in.label),
+         button_dim(0, 0, 0, 0), label(in.label),
 #if 0
          autocollapse(in.autocollapse),
 #endif
@@ -75,7 +73,7 @@ InsetCollapsable::InsetCollapsable(InsetCollapsable const & in)
 }
 
 
-bool InsetCollapsable::insertInset(BufferView * bv, Inset * in)
+bool InsetCollapsable::insertInset(BufferView * bv, InsetOld * in)
 {
        if (!insetAllowed(in->lyxCode())) {
                lyxerr << "InsetCollapsable::InsertInset: "
@@ -115,7 +113,6 @@ void InsetCollapsable::read(Buffer const * buf, LyXLex & lex)
 void InsetCollapsable::dimension_collapsed(Dimension & dim) const
 {
        font_metrics::buttonText(label, labelfont, dim.wid, dim.asc, dim.des);
-       dim.wid += 2 * TEXT_TO_INSET_OFFSET;
 }
 
 
@@ -129,19 +126,21 @@ int InsetCollapsable::height_collapsed() const
 
 void InsetCollapsable::metrics(MetricsInfo & mi, Dimension & dim) const
 {
+       //lyxerr << "InsetCollapsable::metrics:  width: " << mi.base.textwidth << "\n";
        dimension_collapsed(dim);
-       if (collapsed_)
-               return;
-       Dimension insetdim;
-       inset.metrics(mi, insetdim);
-       dim.des += insetdim.height() + TEXT_TO_BOTTOM_OFFSET;
-       dim.wid = max(dim.wid, insetdim.wid);
+       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;
 }
 
 
 void InsetCollapsable::draw_collapsed(PainterInfo & pi, int x, int y) const
 {
-       pi.pain.buttonText(x + TEXT_TO_INSET_OFFSET, y, label, labelfont);
+       pi.pain.buttonText(x, y, label, labelfont);
 }
 
 
@@ -156,10 +155,11 @@ void InsetCollapsable::draw(PainterInfo & pi, int x, int y, bool inlined) const
        Dimension dim_collapsed;
        dimension_collapsed(dim_collapsed);
 
-       int const aa    = ascent(pi.base.bv, pi.base.font);
-       button_length   = dim_collapsed.width();
-       button_top_y    = -aa;
-       button_bottom_y = -aa + dim_collapsed.height();
+       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(pi, x, y);
@@ -180,9 +180,7 @@ void InsetCollapsable::draw(PainterInfo & pi, int x, int y, bool inlined) const
                inset.draw(pi, x, y);
        } else {
                draw_collapsed(pi, old_x, bl);
-               int const yy = bl + dim_collapsed.descent()
-                       + inset.ascent(pi.base.bv, pi.base.font);
-               inset.draw(pi, x, yy);
+               inset.draw(pi, x, bl + dim_collapsed.descent() + inset.ascent());
        }
 }
 
@@ -194,7 +192,7 @@ void InsetCollapsable::draw(PainterInfo & pi, int x, int y) const
 }
 
 
-Inset::EDITABLE InsetCollapsable::editable() const
+InsetOld::EDITABLE InsetCollapsable::editable() const
 {
        return collapsed_ ? IS_EDITABLE : HIGHLY_EDITABLE;
 }
@@ -221,10 +219,8 @@ void InsetCollapsable::insetUnlock(BufferView * bv)
 
 FuncRequest InsetCollapsable::adjustCommand(FuncRequest const & cmd)
 {
-       LyXFont font(LyXFont::ALL_SANE);
        FuncRequest cmd1 = cmd;
-       cmd1.y = ascent(cmd.view(), font) + cmd.y -
-           (height_collapsed() + inset.ascent(cmd.view(), font));
+       cmd1.y = ascent() + cmd.y - (height_collapsed() + inset.ascent());
        return cmd1;
 }
 
@@ -242,8 +238,7 @@ void InsetCollapsable::lfunMouseRelease(FuncRequest const & cmd)
                return;
        }
 
-       if ((cmd.button() != mouse_button::button3) && (cmd.x < button_length) &&
-           (cmd.y >= button_top_y) && (cmd.y <= button_bottom_y))
+       if (cmd.button() != mouse_button::button3 && hitButton(cmd))
        {
                if (collapsed_) {
                        collapsed_ = false;
@@ -256,7 +251,7 @@ void InsetCollapsable::lfunMouseRelease(FuncRequest const & cmd)
                        bv->updateInset(this);
                        bv->buffer()->markDirty();
                }
-       } else if (!collapsed_ && (cmd.y > button_bottom_y)) {
+       } else if (!collapsed_ && (cmd.y > button_dim.y2)) {
                ret = (inset.localDispatch(adjustCommand(cmd)) == DISPATCHED);
        }
        if (cmd.button() == mouse_button::button3 && !ret)
@@ -289,32 +284,23 @@ int InsetCollapsable::docbook(Buffer const * buf, ostream & os, bool mixcont) co
 }
 
 
-void InsetCollapsable::update(BufferView * bv, bool reinit)
+bool InsetCollapsable::hitButton(FuncRequest const & cmd) const
 {
-       if (in_update) {
-               if (reinit && owner()) {
-                       owner()->update(bv, true);
-               }
-               return;
-       }
-       in_update = true;
-       inset.update(bv, reinit);
-       if (reinit && owner()) {
-               owner()->update(bv, true);
-       }
-       in_update = false;
+       return button_dim.contained(cmd.x, cmd.y);
 }
 
 
-Inset::RESULT InsetCollapsable::localDispatch(FuncRequest const & cmd)
+InsetOld::RESULT InsetCollapsable::localDispatch(FuncRequest const & cmd)
 {
-       //lyxerr << "InsetCollapsable::localDispatch: " << cmd.action << "\n";
+       lyxerr << "InsetCollapsable::localDispatch: "
+               << cmd.action << " '" << cmd.argument << "'\n";
        BufferView * bv = cmd.view();
        switch (cmd.action) {
                case LFUN_INSET_EDIT: {
                        if (!cmd.argument.empty()) {
                                UpdatableInset::localDispatch(cmd);
                                if (collapsed_) {
+                                       lyxerr << "branch collapsed_\n";
                                        collapsed_ = false;
                                        if (bv->lockInset(this)) {
                                                inset.setUpdateStatus(InsetText::FULL);
@@ -324,6 +310,7 @@ Inset::RESULT InsetCollapsable::localDispatch(FuncRequest const & cmd)
                                                first_after_edit = true;
                                        }
                                } else {
+                                       lyxerr << "branch not collapsed_\n";
                                        if (bv->lockInset(this))
                                                inset.localDispatch(cmd);
                                }
@@ -352,12 +339,10 @@ Inset::RESULT InsetCollapsable::localDispatch(FuncRequest const & cmd)
                                FuncRequest cmd1 = cmd;
                                if (!bv->lockInset(this))
                                        return DISPATCHED;
-                               if (cmd.y <= button_bottom_y) {
+                               if (cmd.y <= button_dim.y2) {
                                        cmd1.y = 0;
                                } else {
-                                       LyXFont font(LyXFont::ALL_SANE);
-                                       cmd1.y = ascent(bv, font) + cmd.y -
-                                               (height_collapsed() + inset.ascent(bv, font));
+                                       cmd1.y = ascent() + cmd.y - (height_collapsed() + inset.ascent());
                                }
                                inset.localDispatch(cmd);
                        }
@@ -365,12 +350,12 @@ Inset::RESULT InsetCollapsable::localDispatch(FuncRequest const & cmd)
                }
 
                case LFUN_MOUSE_PRESS:
-                       if (!collapsed_ && cmd.y > button_bottom_y)
+                       if (!collapsed_ && cmd.y > button_dim.y2)
                                inset.localDispatch(adjustCommand(cmd));
                        return DISPATCHED;
 
                case LFUN_MOUSE_MOTION:
-                       if (!collapsed_ && cmd.y > button_bottom_y)
+                       if (!collapsed_ && cmd.y > button_dim.y2)
                                inset.localDispatch(adjustCommand(cmd));
                        return DISPATCHED;
 
@@ -407,7 +392,7 @@ bool InsetCollapsable::unlockInsetInInset(BufferView * bv, UpdatableInset * in,
 }
 
 
-bool InsetCollapsable::updateInsetInInset(BufferView * bv, Inset *in)
+bool InsetCollapsable::updateInsetInInset(BufferView * bv, InsetOld *in)
 {
        if (in == this)
                return true;
@@ -442,13 +427,13 @@ void InsetCollapsable::getCursorPos(BufferView * bv, int & x, int & y) const
 UpdatableInset * InsetCollapsable::getLockingInset() const
 {
        UpdatableInset * in = inset.getLockingInset();
-       if (const_cast<InsetText *>(&inset) == in)
+       if (&inset == in)
                return const_cast<InsetCollapsable *>(this);
        return in;
 }
 
 
-UpdatableInset * InsetCollapsable::getFirstLockingInsetOfType(Inset::Code c)
+UpdatableInset * InsetCollapsable::getFirstLockingInsetOfType(InsetOld::Code c)
 {
        if (c == lyxCode())
                return this;
@@ -479,8 +464,7 @@ void InsetCollapsable::deleteLyXText(BufferView * bv, bool recursive) const
 void InsetCollapsable::resizeLyXText(BufferView * bv, bool force) const
 {
        inset.resizeLyXText(bv, force);
-       LyXFont font(LyXFont::ALL_SANE);
-       oldWidth = width(bv, font);
+       oldWidth = width();
 }
 
 
@@ -519,7 +503,7 @@ LyXCursor const & InsetCollapsable::cursor(BufferView * bv) const
 }
 
 
-Inset * InsetCollapsable::getInsetFromID(int id_arg) const
+InsetOld * InsetCollapsable::getInsetFromID(int id_arg) const
 {
        if (id_arg == id())
                return const_cast<InsetCollapsable *>(this);
@@ -605,7 +589,7 @@ InsetCollapsable::selectNextWordToSpellcheck(BufferView * bv, float & value) con
 }
 
 
-void InsetCollapsable::addPreview(grfx::PreviewLoader & loader) const
+void InsetCollapsable::addPreview(PreviewLoader & loader) const
 {
        inset.addPreview(loader);
 }