]> git.lyx.org Git - lyx.git/blobdiff - src/text2.C
Fix working of the spellchecker dialog with ispell when there are no
[lyx.git] / src / text2.C
index caaa887447852a72d031f4f13dbad8c409ff93f3..dab824fb143f6faae5da6f9ff077ffa4f3b2ab3d 100644 (file)
@@ -2195,7 +2195,7 @@ void LyXText::setCursorIntern(BufferView * bview, Paragraph * par,
                if (it != inset_owner) {
                        lyxerr << "InsetText   is " << it << endl;
                        lyxerr << "inset_owner is " << inset_owner << endl;
-#warning I belive this code is wrong. (Lgb)
+#warning I believe this code is wrong. (Lgb)
 #warning Jürgen, have a look at this. (Lgb)
 #warning Hmmm, I guess you are right but we
 #warning should verify when this is needed
@@ -2349,6 +2349,26 @@ void LyXText::cursorDownParagraph(BufferView * bview) const
        }
 }
 
+// fix the cursor `cur' after a characters has been deleted at `where'
+// position. Called by deleteEmptyParagraphMechanism
+void LyXText::fixCursorAfterDelete(BufferView * bview,
+                                  LyXCursor & cur,
+                                  LyXCursor const & where) const
+{
+       // if cursor is not in the paragraph where the delete occured,
+       // do nothing
+       if (cur.par() != where.par())
+               return;
+
+       // if cursor position is after the place where the delete occured,
+       // update it
+       if (cur.pos() > where.pos())
+               cur.pos(cur.pos()-1);
+
+       // recompute row et al. for this cursor
+       setCursor(bview, cur, cur.par(), cur.pos(), cur.boundary());
+}
+
 
 void LyXText::deleteEmptyParagraphMechanism(BufferView * bview,
                                            LyXCursor const & old_cursor) const
@@ -2396,14 +2416,25 @@ void LyXText::deleteEmptyParagraphMechanism(BufferView * bview,
                    && old_cursor.par()->isLineSeparator(old_cursor.pos() - 1)) {
                        old_cursor.par()->erase(old_cursor.pos() - 1);
                        redoParagraphs(bview, old_cursor, old_cursor.par()->next());
-                       // correct cursor
-                       if (old_cursor.par() == cursor.par() &&
-                           cursor.pos() > old_cursor.pos()) {
-                               setCursorIntern(bview, cursor.par(),
-                                               cursor.pos() - 1);
-                       } else
-                               setCursorIntern(bview, cursor.par(),
-                                               cursor.pos());
+
+#ifdef WITH_WARNINGS
+#warning This will not work anymore when we have multiple views of the same buffer
+// In this case, we will have to correct also the cursors held by
+// other bufferviews. It will probably be easier to do that in a more
+// automated way in LyXCursor code. (JMarc 26/09/2001)
+#endif
+                       // correct all cursors held by the LyXText
+                       fixCursorAfterDelete(bview, cursor, old_cursor);
+                       fixCursorAfterDelete(bview, selection.cursor,
+                                            old_cursor);
+                       fixCursorAfterDelete(bview, selection.start,
+                                            old_cursor);
+                       fixCursorAfterDelete(bview, selection.end, old_cursor);
+                       fixCursorAfterDelete(bview, last_sel_cursor,
+                                            old_cursor);
+                       fixCursorAfterDelete(bview, toggle_cursor, old_cursor);
+                       fixCursorAfterDelete(bview, toggle_end_cursor,
+                                            old_cursor);
                        return;
                }
        }
@@ -2413,107 +2444,101 @@ void LyXText::deleteEmptyParagraphMechanism(BufferView * bview,
                                 old_cursor.par()->getLayout())).keepempty)
                return;
 
-       LyXCursor tmpcursor;
-
-       if (old_cursor.par() != cursor.par()) {
-               if ((old_cursor.par()->size() == 0
-                    || (old_cursor.par()->size() == 1
-                        && old_cursor.par()->isLineSeparator(0)))) {
-                       // ok, we will delete anything
-                       
-                       // make sure that you do not delete any environments
-                       status(bview, LyXText::NEED_MORE_REFRESH);
-                       deleted = true;
+       // only do our magic if we changed paragraph
+       if (old_cursor.par() == cursor.par()) 
+               return;
+       
+       if ((old_cursor.par()->size() == 0
+            || (old_cursor.par()->size() == 1
+                && old_cursor.par()->isLineSeparator(0)))) {
+               // ok, we will delete anything
+               LyXCursor tmpcursor;
+               
+               // make sure that you do not delete any environments
+               status(bview, LyXText::NEED_MORE_REFRESH);
+               deleted = true;
                                
-                       if (old_cursor.row()->previous()) {
-                               refresh_row = old_cursor.row()->previous();
-                               refresh_y = old_cursor.y() - old_cursor.row()->baseline() - refresh_row->height();
-                               tmpcursor = cursor;
-                               cursor = old_cursor; // that undo can restore the right cursor position
-                               Paragraph * endpar = old_cursor.par()->next();
-                               if (endpar && endpar->getDepth()) {
-                                       while (endpar && endpar->getDepth()) {
-                                               endpar = endpar->next();
-                                       }
+               if (old_cursor.row()->previous()) {
+                       refresh_row = old_cursor.row()->previous();
+                       refresh_y = old_cursor.y() - old_cursor.row()->baseline() - refresh_row->height();
+                       tmpcursor = cursor;
+                       cursor = old_cursor; // that undo can restore the right cursor position
+                       Paragraph * endpar = old_cursor.par()->next();
+                       if (endpar && endpar->getDepth()) {
+                               while (endpar && endpar->getDepth()) {
+                                       endpar = endpar->next();
                                }
-                               setUndo(bview, Undo::DELETE,
-                                       old_cursor.par(),
-                                       endpar);
-                               cursor = tmpcursor;
+                       }
+                       setUndo(bview, Undo::DELETE, old_cursor.par(), endpar);
+                       cursor = tmpcursor;
 
                                // delete old row
-                               removeRow(old_cursor.row());
-                               if (ownerParagraph() == old_cursor.par()) {
-                                       ownerParagraph(ownerParagraph()->next());
-                               }
+                       removeRow(old_cursor.row());
+                       if (ownerParagraph() == old_cursor.par()) {
+                               ownerParagraph(ownerParagraph()->next());
+                       }
                                // delete old par
-                               delete old_cursor.par();
+                       delete old_cursor.par();
                                        
-                               /* Breakagain the next par. Needed
-                                * because of the parindent that
-                                * can occur or dissappear. The
-                                * next row can change its height,
-                                * if there is another layout before */
-                               if (refresh_row->next()) {
-                                       breakAgain(bview, refresh_row->next());
-                                       updateCounters(bview, refresh_row);
-                               }
-                               setHeightOfRow(bview, refresh_row);
-                       } else {
-                               refresh_row = old_cursor.row()->next();
-                               refresh_y = old_cursor.y() - old_cursor.row()->baseline();
+                       /* Breakagain the next par. Needed because of
+                        * the parindent that can occur or dissappear.
+                        * The next row can change its height, if
+                        * there is another layout before */
+                       if (refresh_row->next()) {
+                               breakAgain(bview, refresh_row->next());
+                               updateCounters(bview, refresh_row);
+                       }
+                       setHeightOfRow(bview, refresh_row);
+               } else {
+                       refresh_row = old_cursor.row()->next();
+                       refresh_y = old_cursor.y() - old_cursor.row()->baseline();
                                        
-                               tmpcursor = cursor;
-                               cursor = old_cursor; // that undo can restore the right cursor position
-                               Paragraph * endpar = old_cursor.par()->next();
-                               if (endpar && endpar->getDepth()) {
-                                       while (endpar && endpar->getDepth()) {
-                                               endpar = endpar->next();
-                                       }
-                               }
-                               setUndo(bview, Undo::DELETE,
-                                       old_cursor.par(),
-                                       endpar);
-                               cursor = tmpcursor;
-
-                               // delete old row
-                               removeRow(old_cursor.row());
-                               // delete old par
-                               if (ownerParagraph() == old_cursor.par()) {
-                                       ownerParagraph(ownerParagraph()->next());
+                       tmpcursor = cursor;
+                       cursor = old_cursor; // that undo can restore the right cursor position
+                       Paragraph * endpar = old_cursor.par()->next();
+                       if (endpar && endpar->getDepth()) {
+                               while (endpar && endpar->getDepth()) {
+                                       endpar = endpar->next();
                                }
+                       }
+                       setUndo(bview, Undo::DELETE, old_cursor.par(), endpar);
+                       cursor = tmpcursor;
+
+                       // delete old row
+                       removeRow(old_cursor.row());
+                       // delete old par
+                       if (ownerParagraph() == old_cursor.par()) {
+                               ownerParagraph(ownerParagraph()->next());
+                       }
 
-                               delete old_cursor.par();
+                       delete old_cursor.par();
                                        
-                               /* Breakagain the next par. Needed
-                                  because of the parindent that can
-                                  occur or dissappear.
-                                  The next row can change its height,
-                                  if there is another layout before
-                               */ 
-                               if (refresh_row) {
-                                       breakAgain(bview, refresh_row);
-                                       updateCounters(bview, refresh_row->previous());
-                               }
+                       /* Breakagain the next par. Needed because of
+                          the parindent that can occur or dissappear.
+                          The next row can change its height, if
+                          there is another layout before */
+                       if (refresh_row) {
+                               breakAgain(bview, refresh_row);
+                               updateCounters(bview, refresh_row->previous());
                        }
+               }
                                
-                               // correct cursor y
-
-                       setCursorIntern(bview, cursor.par(), cursor.pos());
+               // correct cursor y
+               setCursorIntern(bview, cursor.par(), cursor.pos());
 
-                       if (selection.cursor.par()  == old_cursor.par()
-                           && selection.cursor.pos() == selection.cursor.pos()) {
-                               // correct selection
-                               selection.cursor = cursor;
-                       }
+               if (selection.cursor.par()  == old_cursor.par()
+                   && selection.cursor.pos() == selection.cursor.pos()) {
+                       // correct selection
+                       selection.cursor = cursor;
                }
-               if (!deleted) {
-                       if (old_cursor.par()->stripLeadingSpaces(bview->buffer()->params.textclass)) {
-                               redoParagraphs(bview, old_cursor, old_cursor.par()->next());
-                               // correct cursor y
-                               setCursorIntern(bview, cursor.par(), cursor.pos());
-                               selection.cursor = cursor;
-                       }
+       }
+       if (!deleted) {
+               if (old_cursor.par()->stripLeadingSpaces(bview->buffer()->params.textclass)) {
+                       redoParagraphs(bview, old_cursor,
+                                      old_cursor.par()->next());
+                       // correct cursor y
+                       setCursorIntern(bview, cursor.par(), cursor.pos());
+                       selection.cursor = cursor;
                }
        }
 }