John's Layout Tabular UI improvements and Martins fixes to clearing the

[lyx.git] / src / BufferView2.C

diff --git a/src/BufferView2.C b/src/BufferView2.C
index 2fad793b7bab3817cda0e9e9499d4b671c6bcb04..7bdda14a64331c48a76ad5896b6e4f6514771b29 100644 (file)
--- a/src/BufferView2.C
+++ b/src/BufferView2.C
@@ -33,12 +33,15 @@
 #include "support/FileInfo.h"
 #include "support/filetools.h"
 #include "support/lyxfunctional.h" //equal_1st_in_pair
+#include "support/types.h"
 
 #include <fstream>
 #include <algorithm>
 
 extern BufferList bufferlist;
 
+using lyx::pos_type;
+
 using std::pair;
 using std::endl;
 using std::ifstream;
@@ -106,34 +109,42 @@ bool BufferView::insertLyXFile(string const & filen)
 bool BufferView::removeAutoInsets()
 {
        LyXCursor tmpcursor = text->cursor;
-       LyXCursor cursor;
+       Paragraph * cur_par = tmpcursor.par();
+       pos_type cur_pos = tmpcursor.pos();
+       
        bool found = false;
 
+       ParIterator it = buffer()->par_iterator_begin();
        ParIterator end = buffer()->par_iterator_end();
-       for (ParIterator it = buffer()->par_iterator_begin();
-            it != end; ++it) {
+       for (; it != end; ++it) {
                Paragraph * par = *it;
-               // this has to be done before the delete
-               if (par->autoDeleteInsets()) {
-                       found = true;
-#ifdef WITH_WARNINGS
-#warning FIXME
-#endif
-                       // The test it.size()==1 was needed to prevent crashes.
-                       if (it.size() == 1) {
-                               text->setCursor(this, cursor, par, 0);
-                               text->redoParagraphs(this, cursor,
-                                                    cursor.par()->next());
-                               text->fullRebreak(this);
+               bool removed = false;
+
+               text->setCursor(this, par, 0);
+               
+               Paragraph::inset_iterator pit = par->inset_iterator_begin();
+               Paragraph::inset_iterator pend = par->inset_iterator_end();
+               while (pit != pend) {
+                       if (pit->autoDelete()) {
+                               removed = true;
+                               pos_type const pos = pit.getPos();
+                               
+                               par->erase(pos);
+                               if (cur_par == par) {
+                                       if (cur_pos > pos)
+                                               --cur_pos;
+                               }
+                       } else {
+                               ++pit;
                        }
                }
+               if (removed) {
+                       found = true;
+                       text->redoParagraph(this);
+               }
        }
 
-       // avoid forbidden cursor positions caused by error removing
-       if (tmpcursor.pos() > tmpcursor.par()->size())
-               tmpcursor.pos(tmpcursor.par()->size());
-
-       text->setCursorIntern(this, tmpcursor.par(), tmpcursor.pos());
+       text->setCursorIntern(this, cur_par, cur_pos);
 
        return found;
 }
@@ -144,9 +155,9 @@ void BufferView::insertErrors(TeXErrors & terr)
        // Save the cursor position
        LyXCursor cursor = text->cursor;
 
-       for (TeXErrors::Errors::const_iterator cit = terr.begin();
-            cit != terr.end();
-            ++cit) {
+       TeXErrors::Errors::const_iterator cit = terr.begin();
+       TeXErrors::Errors::const_iterator end = terr.end();
+       for (; cit != end; ++cit) {
                string const desctext(cit->error_desc);
                string const errortext(cit->error_text);
                string const msgtxt = desctext + '\n' + errortext;
@@ -249,10 +260,12 @@ void BufferView::menuUndo()
 
 void BufferView::menuRedo()
 {
+#if 0 // this should not be here (Jug 20011206)
        if (theLockingInset()) {
                owner()->message(_("Redo not yet supported in math mode"));
                return;
-       }    
+       }
+#endif
    
        if (available()) {
                owner()->message(_("Redo"));
@@ -398,22 +411,53 @@ void BufferView::replaceWord(string const & replacestring)
 
 bool BufferView::lockInset(UpdatableInset * inset)
 {
+       if (!inset)
+               return false;
        // don't relock if we're already locked
        if (theLockingInset() == inset)
                return true;
-       if (!theLockingInset() && inset) {
-               theLockingInset(inset);
-               return true;
-       } else if (inset) {
-           return theLockingInset()->lockInsetInInset(this, inset);
+       if (!theLockingInset()) {
+               // first check if it's the inset under the cursor we want lock
+               // should be most of the time
+               char const c = text->cursor.par()->getChar(text->cursor.pos());
+               if (c == Paragraph::META_INSET) {
+                       Inset * in = text->cursor.par()->getInset(text->cursor.pos());
+                       if (inset == in) {
+                               theLockingInset(inset);
+                               return true;
+                       }
+               }
+               // Then do a deep look of the inset and lock the right one
+               Paragraph * par = buffer()->paragraph;
+               int const id = inset->id();
+               while(par) {
+                       Paragraph::inset_iterator it =
+                               par->inset_iterator_begin();
+                       Paragraph::inset_iterator const end =
+                               par->inset_iterator_end();
+                       for (; it != end; ++it) {
+                               if ((*it) == inset) {
+                                       text->setCursorIntern(this, par, it.getPos());
+                                       theLockingInset(inset);
+                                       return true;
+                               }
+                               if ((*it)->getInsetFromID(id)) {
+                                       text->setCursorIntern(this, par, it.getPos());
+                                       theLockingInset(static_cast<UpdatableInset *>(*it));
+                                       return theLockingInset()->lockInsetInInset(this, inset);
+                               }
+                       }
+                       par = par->next();
+               }
+               return false;
        }
-       return false;
+       return theLockingInset()->lockInsetInInset(this, inset);
 }
 
 
 void BufferView::showLockedInsetCursor(int x, int y, int asc, int desc)
 {
-       if (available() && theLockingInset()) {
+       if (available() && theLockingInset() && !theLockingInset()->nodraw()) {
                LyXCursor cursor = text->cursor;
                Inset * locking_inset = theLockingInset()->getLockingInset();
 
@@ -461,6 +505,8 @@ void BufferView::fitLockedInsetCursor(int x, int y, int asc, int desc)
 
 int BufferView::unlockInset(UpdatableInset * inset)
 {
+       if (!inset)
+               return 0;
        if (inset && theLockingInset() == inset) {
                inset->insetUnlock(this);
                theLockingInset(0);