The speed patch: redraw only rows that have changed

[lyx.git] / src / insets / insetcommandparams.C

diff --git a/src/insets/insetcommandparams.C b/src/insets/insetcommandparams.C
index 93a3070d49c27a759653c2464fec2b97881d789b..ddb78faef0b7f9cd438ca2136a3dd4b64c2d4771 100644 (file)
--- a/src/insets/insetcommandparams.C
+++ b/src/insets/insetcommandparams.C
@@ -1,20 +1,24 @@
-/* This file is part of
- * ======================================================
+/**
+ * \file insetcommandparams.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
  *
- *           LyX, The Document Processor
+ * \author Angus Leeming
  *
- *          Copyright 2002-2002 The LyX Team.
- *
- * ====================================================== */
-
+ * Full author contact details are available in file CREDITS.
+ */
 
-#ifdef __GNUG__
-#pragma implementation
-#endif
+#include <config.h>
 
 #include "insetcommandparams.h"
-#include "lyxlex.h"
+
 #include "debug.h"
+#include "lyxlex.h"
+
+
+using std::string;
+using std::endl;
+using std::ostream;
 
 
 InsetCommandParams::InsetCommandParams()
@@ -23,73 +27,33 @@ InsetCommandParams::InsetCommandParams()
 
 InsetCommandParams::InsetCommandParams(string const & n,
                                        string const & c,
-                                       string const & o)
-       : cmdname(n), contents(c), options(o)
+                                       string const & o,
+                                       string const & s)
+       : cmdname(n), contents(c), options(o), sec_options(s),
+       preview_(false)
 {}
 
 
-string const InsetCommandParams::getAsString() const
-{
-       return cmdname + "|++|" + contents + "|++|" + options;
-}
-
-
-void InsetCommandParams::setFromString(string const & b)
-{
-       string::size_type idx = b.find("|++|");
-       if (idx == string::npos) {
-               cmdname = b;
-               contents = "";
-               options = "";
-               return;
-       }
-
-       cmdname = b.substr(0, idx);
-       string tmp = b.substr(idx+4);
-
-       idx = tmp.find("|++|");
-       if (idx == string::npos) {
-               contents = tmp;
-               options = "";
-       } else {
-               contents  = tmp.substr(0, idx);
-               options = tmp.substr(idx+4);
-       }
-}
-
-
-bool InsetCommandParams::operator==(InsetCommandParams const & o) const
-{
-       return cmdname == o.cmdname && contents == o.contents
-               && options == o.options;
-}
-
-
-bool InsetCommandParams::operator!=(InsetCommandParams const & o) const
-{
-       return !(*this == o);
-}
-
-
 void InsetCommandParams::scanCommand(string const & cmd)
 {
-       string tcmdname, toptions, tcontents;
+       string tcmdname, toptions, tsecoptions, tcontents;
 
        if (cmd.empty()) return;
 
-       enum { WS, CMDNAME, OPTION, CONTENT } state = WS;
+       enum { WS, CMDNAME, OPTION, SECOPTION, CONTENT } state = WS;
 
        // Used to handle things like \command[foo[bar]]{foo{bar}}
        int nestdepth = 0;
 
        for (string::size_type i = 0; i < cmd.length(); ++i) {
-               char c = cmd[i];
+               char const c = cmd[i];
                if ((state == CMDNAME && c == ' ') ||
                    (state == CMDNAME && c == '[') ||
                    (state == CMDNAME && c == '{')) {
                        state = WS;
                }
                if ((state == OPTION  && c == ']') ||
+                   (state == SECOPTION  && c == ']') ||
                    (state == CONTENT && c == '}')) {
                        if (nestdepth == 0) {
                                state = WS;
@@ -98,30 +62,38 @@ void InsetCommandParams::scanCommand(string const & cmd)
                        }
                }
                if ((state == OPTION  && c == '[') ||
+                   (state == SECOPTION  && c == '[') ||
                    (state == CONTENT && c == '{')) {
                        ++nestdepth;
                }
                switch (state) {
                case CMDNAME:   tcmdname += c; break;
                case OPTION:    toptions += c; break;
+               case SECOPTION: tsecoptions += c; break;
                case CONTENT:   tcontents += c; break;
-               case WS:
+               case WS: {
+                       char const b = i? cmd[i-1]: 0;
                        if (c == '\\') {
                                state = CMDNAME;
-                       } else if (c == '[') {
+                       } else if (c == '[' && b != ']') {
                                state = OPTION;
                                nestdepth = 0; // Just to be sure
+                       } else if (c == '[' && b == ']') {
+                               state = SECOPTION;
+                               nestdepth = 0; // Just to be sure
                        } else if (c == '{') {
                                state = CONTENT;
                                nestdepth = 0; // Just to be sure
                        }
                        break;
                }
+               }
        }
 
        // Don't mess with this.
        if (!tcmdname.empty())  setCmdName(tcmdname);
        if (!toptions.empty())  setOptions(toptions);
+       if (!tsecoptions.empty())  setSecOptions(tsecoptions);
        if (!tcontents.empty()) setContents(tcontents);
 
        if (lyxerr.debugging(Debug::PARSER))
@@ -129,7 +101,8 @@ void InsetCommandParams::scanCommand(string const & cmd)
                       << "> == <" << getCommand()
                       << "> == <" << getCmdName()
                       << '|' << getContents()
-                      << '|' << getOptions() << '>' << endl;
+                      << '|' << getOptions()
+                      << '|' << getSecOptions() << '>' << endl;
 }
 
 
@@ -145,10 +118,14 @@ void InsetCommandParams::read(LyXLex & lex)
        }
 
        while (lex.isOK()) {
-               lex.nextToken();
+               lex.next();
                token = lex.getString();
                if (token == "\\end_inset")
                        break;
+               if (token == "preview") {
+                       lex.next();
+                       preview_ = lex.getBool();
+               }
        }
        if (token != "\\end_inset") {
                lex.printError("Missing \\end_inset at this point. "
@@ -166,9 +143,31 @@ void InsetCommandParams::write(ostream & os) const
 string const InsetCommandParams::getCommand() const
 {
        string s;
-       if (!getCmdName().empty()) s += "\\"+getCmdName();
-       if (!getOptions().empty()) s += "["+getOptions()+']';
-       s += "{"+getContents()+'}';
+       if (!getCmdName().empty()) s += '\\' + getCmdName();
+       if (!getOptions().empty()) s += '[' + getOptions() + ']';
+       if (!getSecOptions().empty()) {
+               // for cases like \command[][sec_option]{arg}
+               if (getOptions().empty()) s += "[]";
+       s += '[' + getSecOptions() + ']';
+       }
+       s += '{' + getContents() + '}';
        return s;
 }
 
+
+bool operator==(InsetCommandParams const & o1,
+               InsetCommandParams const & o2)
+{
+       return o1.getCmdName() == o2.getCmdName()
+               && o1.getContents() == o2.getContents()
+               && o1.getOptions() == o2.getOptions()
+               && o1.getSecOptions() == o2.getSecOptions()
+               && o1.preview() == o2.preview();
+}
+
+
+bool operator!=(InsetCommandParams const & o1,
+               InsetCommandParams const & o2)
+{
+       return !(o1 == o2);
+}