fix typo that put too many include paths for most people

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

diff --git a/src/insets/insetcommand.C b/src/insets/insetcommand.C
index 4beaec279c5a8948413e279660cdd4a374b1748f..8c64fd76e5dd211c4f859bc9e4bc4506b0147fa4 100644 (file)
--- a/src/insets/insetcommand.C
+++ b/src/insets/insetcommand.C
@@ -1,10 +1,10 @@
 /* This file is part of
  * ======================================================
- * 
+ *
  *           LyX, The Document Processor
- *      
+ *
  *         Copyright 1995 Matthias Ettrich
- *          Copyright 1995-2000 The LyX Team.
+ *          Copyright 1995-2001 The LyX Team.
  *
  * ====================================================== */
 
@@ -17,6 +17,7 @@
 #include "insetcommand.h"
 #include "debug.h"
 #include "Painter.h"
+#include "lyxlex.h"
 
 using std::ostream;
 using std::endl;
@@ -26,78 +27,64 @@ InsetCommandParams::InsetCommandParams()
 {}
 
 
-InsetCommandParams::InsetCommandParams( string const & n,
+InsetCommandParams::InsetCommandParams(string const & n,
                                        string const & c,
-                                       string const & o )
+                                       string const & o)
        : cmdname(n), contents(c), options(o)
 {}
 
 
-string InsetCommandParams::getAsString() const
+string const InsetCommandParams::getAsString() const
 {
-       string b(cmdname);
-       b += "|++|" + options + "|++|" + contents;
-       return b;
+       return cmdname + "|++|" + contents + "|++|" + options;
 }
 
 
-void InsetCommandParams::setFromString( string const & b )
+void InsetCommandParams::setFromString(string const & b)
 {
        string::size_type idx = b.find("|++|");
-       if( idx == string::npos ) return;
+       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 ) {
-               options = tmp;
+       if (idx == string::npos) {
+               contents = tmp;
+               options = "";
        } else {
-               options  = tmp.substr(0, idx);
-               contents = tmp.substr(idx+4);
+               contents  = tmp.substr(0, idx);
+               options = tmp.substr(idx+4);
        }
 }
 
 
-InsetCommand::InsetCommand()
-{}
-
-
-InsetCommand::InsetCommand( string const & n,
-                           string const & c, 
-                           string const & o )
-       : p_(n, c, o)
-{}
-
-
-InsetCommand::InsetCommand( InsetCommandParams const & p )
-       : p_( p.getCmdName(), p.getContents(), p.getOptions() )
-{}
-
-
-void InsetCommand::setParams(InsetCommandParams const & p )
+bool InsetCommandParams::operator==(InsetCommandParams const & o) const
 {
-       p_.setCmdName( p.getCmdName() );
-       p_.setContents( p.getContents() );
-       p_.setOptions( p.getOptions() );
+       return cmdname == o.cmdname && contents == o.contents
+               && options == o.options;
 }
 
 
-// In lyxf3 this will be just LaTeX
-void InsetCommand::Write(Buffer const *, ostream & os) const
+bool InsetCommandParams::operator!=(InsetCommandParams const & o) const
 {
-       os << "LatexCommand " << getCommand() << "\n";
+       return !(*this == o);
 }
 
 
-void InsetCommand::scanCommand(string const & cmd)
+void InsetCommandParams::scanCommand(string const & cmd)
 {
        string tcmdname, toptions, tcontents;
 
        if (cmd.empty()) return;
 
        enum { WS, CMDNAME, OPTION, CONTENT } state = WS;
-       
+
        // Used to handle things like \command[foo[bar]]{foo{bar}}
        int nestdepth = 0;
 
@@ -118,11 +105,11 @@ void InsetCommand::scanCommand(string const & cmd)
                }
                if ((state == OPTION  && c == '[') ||
                    (state == CONTENT && c == '{')) {
-                       ++nestdepth;
+                       ++nestdepth;
                }
                switch (state) {
                case CMDNAME:   tcmdname += c; break;
-               case OPTION:    toptions += c; break;
+               case OPTION:    toptions += c; break;
                case CONTENT:   tcontents += c; break;
                case WS:
                        if (c == '\\') {
@@ -139,9 +126,9 @@ void InsetCommand::scanCommand(string const & cmd)
        }
 
        // Don't mess with this.
-       if (!tcmdname.empty())  setCmdName( tcmdname );
-       if (!toptions.empty())  setOptions( toptions );
-       if (!tcontents.empty()) setContents( tcontents ); 
+       if (!tcmdname.empty())  setCmdName(tcmdname);
+       if (!toptions.empty())  setOptions(toptions);
+       if (!tcontents.empty()) setContents(tcontents);
 
        if (lyxerr.debugging(Debug::PARSER))
                lyxerr << "Command <" <<  cmd
@@ -153,18 +140,20 @@ void InsetCommand::scanCommand(string const & cmd)
 
 
 // This function will not be necessary when lyx3
-void InsetCommand::Read(Buffer const *, LyXLex & lex)
-{    
+void InsetCommandParams::read(LyXLex & lex)
+{
        string token;
 
-       if (lex.EatLine()) {
-               token = lex.GetString();
+       if (lex.eatLine()) {
+               token = lex.getString();
                scanCommand(token);
-       } else
+       } else {
                lex.printError("InsetCommand: Parse error: `$$Token'");
-       while (lex.IsOK()) {
+       }
+
+       while (lex.isOK()) {
                lex.nextToken();
-               token = lex.GetString();
+               token = lex.getString();
                if (token == "\\end_inset")
                        break;
        }
@@ -175,43 +164,56 @@ void InsetCommand::Read(Buffer const *, LyXLex & lex)
 }
 
 
-int InsetCommand::Latex(Buffer const *, ostream & os,
-                       bool /*fragile*/, bool/*fs*/) const
+void InsetCommandParams::write(ostream & os) const
 {
-       os << getCommand();
-       return 0;
+       os << "LatexCommand " << getCommand() << "\n";
 }
 
 
-int InsetCommand::Ascii(Buffer const *, ostream &) const
+string const InsetCommandParams::getCommand() const
 {
-       return 0;
+       string s;
+       if (!getCmdName().empty()) s += "\\"+getCmdName();
+       if (!getOptions().empty()) s += "["+getOptions()+']';
+       s += "{"+getContents()+'}';
+       return s;
+}
+
+
+InsetCommand::InsetCommand(InsetCommandParams const & p, bool)
+       : p_(p.getCmdName(), p.getContents(), p.getOptions())
+{}
+
+
+void InsetCommand::setParams(InsetCommandParams const & p)
+{
+       p_.setCmdName(p.getCmdName());
+       p_.setContents(p.getContents());
+       p_.setOptions(p.getOptions());
 }
 
 
-int InsetCommand::Linuxdoc(Buffer const *, ostream &) const
+int InsetCommand::latex(Buffer const *, ostream & os,
+                       bool /*fragile*/, bool/*fs*/) const
 {
+       os << getCommand();
        return 0;
 }
 
 
-int InsetCommand::DocBook(Buffer const *, ostream &) const
+int InsetCommand::ascii(Buffer const *, ostream &, int) const
 {
        return 0;
 }
 
 
-Inset * InsetCommand::Clone() const
+int InsetCommand::linuxdoc(Buffer const *, ostream &) const
 {
-       return new InsetCommand(getCmdName(), getContents(), getOptions());
+       return 0;
 }
 
 
-string InsetCommand::getCommand() const
-{      
-       string s;
-       if (!getCmdName().empty()) s += "\\"+getCmdName();
-       if (!getOptions().empty()) s += "["+getOptions()+']';
-       s += "{"+getContents()+'}';
-       return s;
+int InsetCommand::docbook(Buffer const *, ostream &) const
+{
+       return 0;
 }