* InsetListings.cpp:

[lyx.git] / src / Text.cpp

diff --git a/src/Text.cpp b/src/Text.cpp
index 80357393904089d726e42b5d8e93f63143d5d1d2..c0aa9a26dfbd8e4b6ab4653a0234da1aecb3dfb9 100644 (file)
--- a/src/Text.cpp
+++ b/src/Text.cpp
@@ -56,7 +56,7 @@
 #include "insets/InsetLine.h"
 #include "insets/InsetNewline.h"
 #include "insets/InsetNewpage.h"
-#include "insets/InsetOptArg.h"
+#include "insets/InsetArgument.h"
 #include "insets/InsetSpace.h"
 #include "insets/InsetSpecialChar.h"
 #include "insets/InsetTabular.h"
@@ -259,37 +259,59 @@ Font const Text::outerFont(pit_type par_offset) const
 }
 
 
-void acceptChanges(ParagraphList & pars, BufferParams const & bparams)
+static void acceptOrRejectChanges(ParagraphList & pars,
+       BufferParams const & bparams, Text::ChangeOp op)
 {
        pit_type pars_size = static_cast<pit_type>(pars.size());
 
-       // first, accept changes within each individual paragraph
-       // (do not consider end-of-par)
+       // first, accept or reject changes within each individual
+       // paragraph (do not consider end-of-par)
        for (pit_type pit = 0; pit < pars_size; ++pit) {
-               if (!pars[pit].empty())   // prevent assertion failure
-                       pars[pit].acceptChanges(0, pars[pit].size());
+               // prevent assertion failure
+               if (!pars[pit].empty()) {
+                       if (op == Text::ACCEPT)
+                               pars[pit].acceptChanges(0, pars[pit].size());
+                       else
+                               pars[pit].rejectChanges(0, pars[pit].size());
+               }
        }
 
-       // next, accept imaginary end-of-par characters
+       // next, accept or reject imaginary end-of-par characters
        for (pit_type pit = 0; pit < pars_size; ++pit) {
                pos_type pos = pars[pit].size();
-
-               if (pars[pit].isInserted(pos)) {
-                       pars[pit].setChange(pos, Change(Change::UNCHANGED));
-               } else if (pars[pit].isDeleted(pos)) {
-                       if (pit == pars_size - 1) {
-                               // we cannot remove a par break at the end of the last
-                               // paragraph; instead, we mark it unchanged
+               if (pars[pit].isChanged(pos)) {
+                       // keep the end-of-par char if it is inserted and accepted
+                       // or when it is deleted and rejected.
+                       if (pars[pit].isInserted(pos) == (op == Text::ACCEPT)) {
                                pars[pit].setChange(pos, Change(Change::UNCHANGED));
                        } else {
-                               mergeParagraph(bparams, pars, pit);
-                               --pit;
-                               --pars_size;
+                               if (pit == pars_size - 1) {
+                                       // we cannot remove a par break at the end of the last
+                                       // paragraph; instead, we mark it unchanged
+                                       pars[pit].setChange(pos, Change(Change::UNCHANGED));
+                               } else {
+                                       mergeParagraph(bparams, pars, pit);
+                                       --pit;
+                                       --pars_size;
+                               }
                        }
                }
        }
 }
 
+
+void acceptChanges(ParagraphList & pars, BufferParams const & bparams)
+{
+       acceptOrRejectChanges(pars, bparams, Text::ACCEPT);
+}
+
+
+void rejectChanges(ParagraphList & pars, BufferParams const & bparams)
+{
+       acceptOrRejectChanges(pars, bparams, Text::REJECT);
+}
+
+
 InsetText const & Text::inset() const
 {
        return *owner_;
@@ -1834,10 +1856,11 @@ docstring Text::getPossibleLabel(Cursor const & cur) const
 
        docstring text;
        docstring par_text = pars_[pit].asString();
-       string piece;
-       // the return string of math matrices might contain linebreaks
+
+       // The return string of math matrices might contain linebreaks
        par_text = subst(par_text, '\n', '-');
-       for (int i = 0; i < lyxrc.label_init_length; ++i) {
+       int const numwords = 3;
+       for (int i = 0; i < numwords; ++i) {
                if (par_text.empty())
                        break;
                docstring head;
@@ -1847,12 +1870,13 @@ docstring Text::getPossibleLabel(Cursor const & cur) const
                        text += '-';
                text += head;
        }
+       
+       // Make sure it isn't too long
+       unsigned int const max_label_length = 32;
+       if (text.size() > max_label_length)
+               text.resize(max_label_length);
 
-       // No need for a prefix if the user said so.
-       if (lyxrc.label_init_length <= 0)
-               return text;
-
-       // Will contain the label type.
+       // Will contain the label prefix.
        docstring name;
 
        // For section, subsection, etc...
@@ -1866,7 +1890,7 @@ docstring Text::getPossibleLabel(Cursor const & cur) const
        if (layout->latextype != LATEX_PARAGRAPH)
                name = layout->refprefix;
 
-       // for captions, we just take the caption type
+       // For captions, we just take the caption type
        Inset * caption_inset = cur.innerInsetOfType(CAPTION_CODE);
        if (caption_inset) {
                string const & ftype = static_cast<InsetCaption *>(caption_inset)->type();
@@ -1886,9 +1910,8 @@ docstring Text::getPossibleLabel(Cursor const & cur) const
        }
 
        if (!name.empty())
-               // FIXME
-               // we should allow customization of the separator or else change it
-               // once we have refstyle
+               // FIXME refstyle
+               // We should allow customization of the separator or else change it
                text = name + ':' + text;
 
        return text;
@@ -2019,8 +2042,8 @@ bool Text::insertCompletion(Cursor & cur, docstring const & s, bool /*finished*/
        LASSERT(cur.bv().cursor() == cur, /**/);
        cur.insert(s);
        cur.bv().cursor() = cur;
-       if (!(cur.disp_.update() & Update::Force))
-               cur.updateFlags(cur.disp_.update() | Update::SinglePar);
+       if (!(cur.result().update() & Update::Force))
+               cur.updateFlags(cur.result().update() | Update::SinglePar);
        return true;
 }