Make the float interface for XHTML consistent with the others.

[lyx.git] / src / BufferView.cpp

diff --git a/src/BufferView.cpp b/src/BufferView.cpp
index 5bac1e182853def008c3a51fba510c19b38bd1c6..5107eb192472758f1fb26078970f8c050a451a07 100644 (file)
--- a/src/BufferView.cpp
+++ b/src/BufferView.cpp
@@ -939,35 +939,6 @@ static Change::Type lookupChangeType(DocIterator const & dit, bool outer = false
 }
 
 
-static bool getLocalStatus(Cursor cursor, FuncRequest const & cmd, FuncStatus & status)
-{
-       // Try to fix cursor in case it is broken.
-       cursor.fixIfBroken();
-
-       // This is, of course, a mess. Better create a new doc iterator and use
-       // this in Inset::getStatus. This might require an additional
-       // BufferView * arg, though (which should be avoided)
-       //Cursor safe = *this;
-       bool res = false;
-       for ( ; cursor.depth(); cursor.pop()) {
-               //lyxerr << "\nCursor::getStatus: cmd: " << cmd << endl << *this << endl;
-               LASSERT(cursor.idx() <= cursor.lastidx(), /**/);
-               LASSERT(cursor.pit() <= cursor.lastpit(), /**/);
-               LASSERT(cursor.pos() <= cursor.lastpos(), /**/);
-
-               // The inset's getStatus() will return 'true' if it made
-               // a definitive decision on whether it want to handle the
-               // request or not. The result of this decision is put into
-               // the 'status' parameter.
-               if (cursor.inset().getStatus(cursor, cmd, status)) {
-                       res = true;
-                       break;
-               }
-       }
-       return res;
-}
-
-
 bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 {
        // Can we use a readonly buffer?
@@ -989,13 +960,7 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 
        Cursor & cur = d->cursor_;
 
-       // Is this a function that acts on inset at point?
-       Inset * inset = cur.nextInset();
-       if (lyxaction.funcHasFlag(cmd.action, LyXAction::AtPoint)
-           && inset && inset->getStatus(cur, cmd, flag))
-               return true;
-
-       if (getLocalStatus(cur, cmd, flag))
+       if (cur.getStatus(cmd, flag))
                return true;
 
        switch (cmd.action) {
@@ -1125,6 +1090,7 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
        case LFUN_SCROLL:
        case LFUN_SCREEN_UP_SELECT:
        case LFUN_SCREEN_DOWN_SELECT:
+       case LFUN_INSET_FORALL:
                flag.setEnabled(true);
                break;
 
@@ -1211,7 +1177,8 @@ bool BufferView::dispatch(FuncRequest const & cmd)
        Cursor & cur = d->cursor_;
 
        // Don't dispatch function that does not apply to internal buffers.
-       if (buffer_.isInternal() && lyxaction.funcHasFlag(cmd.action, LyXAction::NoInternal))
+       if (buffer_.isInternal() 
+           && lyxaction.funcHasFlag(cmd.action, LyXAction::NoInternal))
                return false;
 
        // We'll set this back to false if need be.
@@ -1537,9 +1504,16 @@ bool BufferView::dispatch(FuncRequest const & cmd)
                break;
        }
 
-       case LFUN_WORD_FINDADV:
-               findAdv(this, cmd);
+       case LFUN_WORD_FINDADV: {
+               FindAndReplaceOptions opt;
+               istringstream iss(to_utf8(cmd.argument()));
+               iss >> opt;
+               if (findAdv(this, opt))
+                       cur.dispatched();
+               else
+                       cur.undispatched();
                break;
+       }
 
        case LFUN_MARK_OFF:
                cur.clearSelection();
@@ -1763,6 +1737,53 @@ bool BufferView::dispatch(FuncRequest const & cmd)
                break;
        }
 
+
+       // This would be in Buffer class if only Cursor did not
+       // require a bufferview
+       case LFUN_INSET_FORALL: {
+               docstring const name = from_utf8(cmd.getArg(0));
+               string const commandstr = cmd.getLongArg(1);
+               FuncRequest const fr = lyxaction.lookupFunc(commandstr);
+
+               // an arbitrary number to limit number of iterations
+               const int max_iter = 1000;
+               int iterations = 0;
+               Cursor & cur = d->cursor_;
+               cur.reset();
+               if (!cur.nextInset())
+                       cur.forwardInset();
+               cur.beginUndoGroup();
+               while(cur && iterations < max_iter) {
+                       Inset * ins = cur.nextInset();
+                       if (!ins)
+                               break;
+                       docstring insname = ins->name();
+                       while (!insname.empty()) {
+                               if (insname == name || name == from_utf8("*")) {
+                                       cur.recordUndo();
+                                       lyx::dispatch(fr);
+                                       ++iterations;
+                                       break;
+                               }
+                               size_t const i = insname.rfind(':');
+                               if (i == string::npos)
+                                       break;
+                               insname = insname.substr(0, i);
+                       }
+                       cur.forwardInset();
+               }
+               cur.endUndoGroup();
+               cur.reset();
+               processUpdateFlags(Update::Force);
+
+               if (iterations >= max_iter)
+                       cur.errorMessage(bformat(_("`inset-forall' interrupted because number of actions is larger than %1$d"), max_iter));
+               else
+                       cur.message(bformat(_("Applied \"%1$s\" to %2$d insets"), from_utf8(commandstr), iterations));
+               break;
+       }
+
+
        case LFUN_ALL_INSETS_TOGGLE: {
                string action;
                string const name = split(to_utf8(cmd.argument()), action, ' ');
@@ -2295,7 +2316,8 @@ bool BufferView::mouseSetCursor(Cursor & cur, bool select)
        if (!do_selection && d->cursor_.inTexted())
                update |= checkDepm(cur, d->cursor_);
 
-       d->cursor_.resetAnchor();
+       if (!do_selection)
+               d->cursor_.resetAnchor();
        d->cursor_.setCursor(cur);
        d->cursor_.boundary(cur.boundary());
        if (do_selection)