]> git.lyx.org Git - lyx.git/blobdiff - src/insets/insetcollapsable.C
fix #832
[lyx.git] / src / insets / insetcollapsable.C
index 9c8d1ac4465a5d7df65695855c47d695bd2913c0..ea684568d03b06aedd2680d111fe71c68e19649f 100644 (file)
@@ -12,7 +12,6 @@
 
 #include <config.h>
 
-
 #include "insetcollapsable.h"
 #include "insettext.h"
 
@@ -32,7 +31,6 @@
 
 #include "support/LAssert.h"
 #include "support/LOstream.h"
-#include "support/lstrings.h"
 
 using std::vector;
 using std::ostream;
@@ -40,9 +38,6 @@ using std::endl;
 using std::max;
 
 
-class LyXText;
-
-
 InsetCollapsable::InsetCollapsable(BufferParams const & bp, bool collapsed)
        : UpdatableInset(), collapsed_(collapsed), inset(bp),
          button_length(0), button_top_y(0), button_bottom_y(0),
@@ -88,7 +83,7 @@ bool InsetCollapsable::insertInset(BufferView * bv, Inset * in)
 
 void InsetCollapsable::write(Buffer const * buf, ostream & os) const
 {
-       os << "collapsed " << tostr(collapsed_) << "\n";
+       os << "collapsed " << (collapsed_ ? "true" : "false") << "\n";
        inset.writeParagraphData(buf, os);
 }
 
@@ -234,70 +229,9 @@ void InsetCollapsable::draw(BufferView * bv, LyXFont const & f,
 }
 
 
-void InsetCollapsable::edit(BufferView * bv, int xp, int yp,
-                           mouse_button::state button)
-{
-#ifdef WITH_WARNINGS
-#warning Fix this properly in BufferView_pimpl::workAreaButtonRelease
-#endif
-       if (button == mouse_button::button3)
-               return;
-
-       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);
-               bv->buffer()->markDirty();
-               inset.edit(bv);
-       } 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);
-               }
-       }
-}
-
-
-void InsetCollapsable::edit(BufferView * bv, bool front)
-{
-       UpdatableInset::edit(bv, front);
-
-       if (collapsed_) {
-               collapsed_ = false;
-               if (!bv->lockInset(this))
-                       return;
-               inset.setUpdateStatus(bv, InsetText::FULL);
-               bv->updateInset(this);
-               bv->buffer()->markDirty();
-               inset.edit(bv, front);
-               first_after_edit = true;
-       } else {
-               if (!bv->lockInset(this))
-                       return;
-               inset.edit(bv, front);
-       }
-}
-
-
 Inset::EDITABLE InsetCollapsable::editable() const
 {
-       if (collapsed_)
-               return IS_EDITABLE;
-       return HIGHLY_EDITABLE;
+       return collapsed_ ? IS_EDITABLE : HIGHLY_EDITABLE;
 }
 
 
@@ -320,31 +254,36 @@ void InsetCollapsable::insetUnlock(BufferView * bv)
 }
 
 
-void InsetCollapsable::lfunMousePress(FuncRequest const & cmd)
+FuncRequest InsetCollapsable::adjustCommand(FuncRequest const & cmd)
 {
-       if (!collapsed_ && (cmd.y > button_bottom_y)) {
-               LyXFont font(LyXFont::ALL_SANE);
-               FuncRequest cmd1 = cmd;
-               cmd1.y = ascent(cmd.view(), font) + cmd.y -
-                   (ascent_collapsed() +
-                    descent_collapsed() +
-                    inset.ascent(cmd.view(), font));
-               inset.localDispatch(cmd1);
-       }
+       LyXFont font(LyXFont::ALL_SANE);
+       FuncRequest cmd1 = cmd;
+       cmd1.y = ascent(cmd.view(), font) + cmd.y -
+           (ascent_collapsed() +
+            descent_collapsed() +
+            inset.ascent(cmd.view(), font));
+       return cmd1;
 }
 
 
-bool InsetCollapsable::lfunMouseRelease(FuncRequest const & cmd)
+void InsetCollapsable::lfunMouseRelease(FuncRequest const & cmd)
 {
        bool ret = false;
        BufferView * bv = cmd.view();
+
+       if (collapsed_ && cmd.button() != mouse_button::button3) {
+               collapsed_ = false;
+               inset.setUpdateStatus(bv, InsetText::FULL);
+               bv->updateInset(this);
+               bv->buffer()->markDirty();
+               return;
+       }
+
        if ((cmd.button() != mouse_button::button3) && (cmd.x < button_length) &&
            (cmd.y >= button_top_y) && (cmd.y <= button_bottom_y))
        {
                if (collapsed_) {
                        collapsed_ = false;
-// should not be called on inset open!
-//                     inset.insetButtonRelease(bv, 0, 0, button);
                        inset.setUpdateStatus(bv, InsetText::FULL);
                        bv->updateInset(this);
                        bv->buffer()->markDirty();
@@ -355,31 +294,10 @@ bool InsetCollapsable::lfunMouseRelease(FuncRequest const & cmd)
                        bv->buffer()->markDirty();
                }
        } else if (!collapsed_ && (cmd.y > button_bottom_y)) {
-               LyXFont font(LyXFont::ALL_SANE);
-               FuncRequest cmd1 = cmd;
-               cmd1.y = ascent(cmd.view(), font) + cmd.y -
-                   (ascent_collapsed() +
-                    descent_collapsed() +
-                    inset.ascent(cmd.view(), font));
-               ret = (inset.localDispatch(cmd1) == DISPATCHED);
+               ret = (inset.localDispatch(adjustCommand(cmd)) == DISPATCHED);
        }
        if (cmd.button() == mouse_button::button3 && !ret)
-               return showInsetDialog(bv);
-       return ret;
-}
-
-
-void InsetCollapsable::lfunMouseMotion(FuncRequest const & cmd)
-{
-       if (cmd.y > button_bottom_y) {
-               LyXFont font(LyXFont::ALL_SANE);
-               FuncRequest cmd1 = cmd;
-               cmd1.y = ascent(cmd.view(), font) + cmd.y -
-                   (ascent_collapsed() +
-                    descent_collapsed() +
-                    inset.ascent(cmd.view(), font));
-               inset.localDispatch(cmd1);
-       }
+               showInsetDialog(bv);
 }
 
 
@@ -427,14 +345,72 @@ void InsetCollapsable::update(BufferView * bv, bool reinit)
 
 Inset::RESULT InsetCollapsable::localDispatch(FuncRequest const & cmd)
 {
+       //lyxerr << "InsetCollapsable::localDispatch: " << cmd.action << "\n";
+       BufferView * bv = cmd.view();
        switch (cmd.action) {
+               case LFUN_INSET_EDIT: {
+                       if (!cmd.argument.empty()) {
+                               UpdatableInset::localDispatch(cmd);
+                               if (collapsed_) {
+                                       collapsed_ = false;
+                                       if (bv->lockInset(this)) {
+                                               inset.setUpdateStatus(bv, InsetText::FULL);
+                                               bv->updateInset(this);
+                                               bv->buffer()->markDirty();
+                                               inset.localDispatch(cmd);
+                                               first_after_edit = true;
+                                       }
+                               } else {
+                                       if (bv->lockInset(this))
+                                               inset.localDispatch(cmd);
+                               }
+                               return DISPATCHED;
+                       }
+
+#ifdef WITH_WARNINGS
+#warning Fix this properly in BufferView_pimpl::workAreaButtonRelease
+#endif
+                       if (cmd.button() == mouse_button::button3)
+                               return DISPATCHED;
+
+                       UpdatableInset::localDispatch(cmd);
+
+                       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 DISPATCHED;
+                               bv->updateInset(this);
+                               bv->buffer()->markDirty();
+                               inset.localDispatch(cmd);
+                       } else {
+                               FuncRequest cmd1 = cmd;
+                               if (!bv->lockInset(this))
+                                       return DISPATCHED;
+                               if (cmd.y <= button_bottom_y) {
+                                       cmd1.y = 0;
+                               } else {
+                                       LyXFont font(LyXFont::ALL_SANE);
+                                       cmd1.y = ascent(bv, font) + cmd.y -
+                                               (ascent_collapsed() +
+                                               descent_collapsed() +
+                                               inset.ascent(bv, font));
+                               }
+                               inset.localDispatch(cmd);
+                       }
+                       return DISPATCHED;
+               }
 
                case LFUN_MOUSE_PRESS:
-                       lfunMousePress(cmd);
+                       if (!collapsed_ && cmd.y > button_bottom_y)
+                               inset.localDispatch(adjustCommand(cmd));
                        return DISPATCHED;
 
                case LFUN_MOUSE_MOTION:
-                       lfunMouseMotion(cmd);
+                       if (!collapsed_ && cmd.y > button_bottom_y)
+                               inset.localDispatch(adjustCommand(cmd));
                        return DISPATCHED;
 
                case LFUN_MOUSE_RELEASE:
@@ -444,11 +420,10 @@ Inset::RESULT InsetCollapsable::localDispatch(FuncRequest const & cmd)
                default:
                        UpdatableInset::RESULT result = inset.localDispatch(cmd);
                        if (result >= FINISHED)
-                               cmd.view()->unlockInset(this);
+                               bv->unlockInset(this);
                        first_after_edit = false;
                        return result;
        }
-       return UNDISPATCHED;
 }
 
 
@@ -571,9 +546,9 @@ int InsetCollapsable::scroll(bool recursive) const
 }
 
 
-Paragraph * InsetCollapsable::getFirstParagraph(int i) const
+ParagraphList * InsetCollapsable::getParagraphs(int i) const
 {
-       return inset.getFirstParagraph(i);
+       return inset.getParagraphs(i);
 }