diff --git a/src/libkstmath/dataobjectscriptinterface.cpp b/src/libkstmath/dataobjectscriptinterface.cpp
@@ -12,99 +12,234 @@
 
 #include "dataobjectscriptinterface.h"
 
+#include "objectstore.h"
+
 #include <QStringBuilder>
 
 namespace Kst {
 
-DataObjectSI::DataObjectSI(DataObjectPtr plugin) {
+
+/***************************/
+/* dataobject commands     */
+/***************************/
+QString DataObjectSI::setInputVector(QString& command) {
+  QStringList vars = getArgs(command);
+
+  QString key = vars.at(0);
+  QString vec_name = vars.at(1);
+
+  VectorPtr v = kst_cast<Vector>(_dataObject->store()->retrieveObject(vec_name));
+  if (v) {
+    _dataObject->setInputVector(key, v);
+    return "Done";
+  } else {
+    return QString("Vector %1 not found").arg(vec_name);
+  }
+}
+
+
+QString DataObjectSI::setInputScalar(QString& command) {
+  QStringList vars = getArgs(command);
+
+  QString key = vars.at(0);
+  QString x_name = vars.at(1);
+
+  ScalarPtr x = kst_cast<Scalar>(_dataObject->store()->retrieveObject(x_name));
+  if (x) {
+    _dataObject->setInputScalar(key, x);
+    return "Done";
+  } else {
+    return QString("Scalar %1 not found").arg(x_name);
+  }
+}
+
+
+QString DataObjectSI::outputVector(QString& command) {
+  QString key = getArg(command);
+
+  VectorPtr vout = _dataObject->outputVector(key);
+  if (vout) {
+    return vout->shortName();
+  } else {
+    return "Invalid";
+  }
+
+}
+
+
+QString DataObjectSI::outputScalar(QString& command) {
+  QString key = getArg(command);
+
+  ScalarPtr xout = _dataObject->outputScalar(key);
+  if (xout) {
+    return xout->shortName();
+  } else {
+    return "Invalid";
+  }
+
+}
+
+/***************************/
+/* PluginSI                */
+/***************************/
+PluginSI::PluginSI(BasicPluginPtr plugin) {
   if (plugin) {
     _plugin = plugin;
+    _dataObject = plugin;
   } else {
     _plugin = 0;
+    _dataObject = 0;
   }
+
+  _fnMap.insert("setInputVector",&PluginSI::setInputVector);
+  _fnMap.insert("setInputScalar",&PluginSI::setInputScalar);
+  _fnMap.insert("outputVector",&PluginSI::outputVector);
+  _fnMap.insert("outputScalar",&PluginSI::outputScalar);
+
 }
 
-bool DataObjectSI::isValid() {
+bool PluginSI::isValid() {
   return _plugin;
 }
 
-QByteArray DataObjectSI::endEditUpdate() {
+QByteArray PluginSI::endEditUpdate() {
   if (_plugin) {
     _plugin->registerChange();
     UpdateManager::self()->doUpdates(true);
     UpdateServer::self()->requestUpdateSignal();
 
     return ("Finished editing "%_plugin->Name()).toLatin1();
   } else {
-    return ("Finished editing invalid plugin");
+    return ("Finished editing invalid data object");
   }
 }
 
-QString DataObjectSI::doCommand(QString x) {
+QString PluginSI::doCommand(QString command_in) {
 
   if (isValid()) {
 
-    QString v=doNamedObjectCommand(x, _plugin);
+    QString command = command_in.left(command_in.indexOf('('));
+
+    PluginInterfaceMemberFn fn=_fnMap.value(command,&PluginSI::noSuchFn);
+
+    if(fn!=&PluginSI::noSuchFn) {
+      return CALL_MEMBER_FN(*this,fn)(command_in);
+    }
+
+
+    QString v=doNamedObjectCommand(command_in, _plugin);
     if (!v.isEmpty()) {
       return v;
     }
-    QStringList params;
-    if (x.startsWith("setInputVector(")) {
-      x.remove("setInputVector(");
-      x.remove(x.lastIndexOf(")"),1);
-      params = x.split(',');
-      if (params.size()==2) {
-        VectorPtr V = kst_cast<Vector>(_plugin->store()->retrieveObject(params[1]));
-        if (V) {
-          _plugin->setInputVector(params[0], V);
-        }
-      }
-    } else if (x.startsWith("setInputScalar(")) {
-      x.remove("setInputScalar(");
-      x.remove(x.lastIndexOf(")"),1);
-      params = x.split(',');
-      if (params.size()==2) {
-        ScalarPtr S = kst_cast<Scalar>(_plugin->store()->retrieveObject(params[1]));
-        if (S) {
-          _plugin->setInputScalar(params[0], S);
-        }
-      }
-    } else if (x.startsWith("outputVector(")) {
-      x.remove("outputVector(");
-      x.remove(x.lastIndexOf(")"),1);
-      VectorPtr vout = _plugin->outputVector(x);
-      if (vout) {
-        return vout->shortName();
-      } else {
-        return "Invalid";
-      }
-    } else if (x.startsWith("outputScalar(")) {
-      x.remove("outputScalar(");
-      x.remove(x.lastIndexOf(")"),1);
-      ScalarPtr xout = _plugin->outputScalar(x);
-      if (xout) {
-        return xout->shortName();
-      } else {
-        return "Invalid";
-      }
-    }
-    return "Done";
+
+    return "No such command";
   } else {
     return "Invalid";
   }
 
 }
 
-ScriptInterface* DataObjectSI::newPlugin(ObjectStore *store, QByteArray pluginName) {
+ScriptInterface* PluginSI::newPlugin(ObjectStore *store, QByteArray pluginName) {
   DataObjectConfigWidget* configWidget = DataObject::pluginWidget(pluginName);
 
   if (configWidget) {
       BasicPluginPtr plugin = kst_cast<BasicPlugin>(DataObject::createPlugin(pluginName, store, configWidget));
-      return new DataObjectSI(kst_cast<DataObject>(plugin));
+      return new PluginSI(kst_cast<BasicPlugin>(plugin));
   }
 
   return 0L;
 }
 
+/***************************/
+/* EquationSI              */
+/***************************/
+EquationSI::EquationSI(EquationPtr equation) {
+  if (equation) {
+    _equation = equation;
+    _dataObject = equation;
+  } else {
+    _equation = 0;
+    _dataObject = 0;
+  }
+
+  _fnMap.insert("setEquation",&EquationSI::setEquation);
+  _fnMap.insert("equation",&EquationSI::equation);
+
+  _fnMap.insert("setInputVector",&EquationSI::setInputVector);
+  _fnMap.insert("setInputScalar",&EquationSI::setInputScalar);
+  _fnMap.insert("outputVector",&EquationSI::outputVector);
+  _fnMap.insert("outputScalar",&EquationSI::outputScalar);
+
+}
+
+bool EquationSI::isValid() {
+  return _equation;
+}
+
+QByteArray EquationSI::endEditUpdate() {
+  if (_equation) {
+    _equation->registerChange();
+    UpdateManager::self()->doUpdates(true);
+    UpdateServer::self()->requestUpdateSignal();
+
+    return ("Finished editing "%_equation->Name()).toLatin1();
+  } else {
+    return ("Finished editing invalid equation");
+  }
+}
+
+QString EquationSI::doCommand(QString command_in) {
+qDebug() << "equation do command" << command_in;
+  if (isValid()) {
+
+    QString command = command_in.left(command_in.indexOf('('));
+
+    EquationInterfaceMemberFn fn=_fnMap.value(command,&EquationSI::noSuchFn);
+
+    if(fn!=&EquationSI::noSuchFn) {
+      return CALL_MEMBER_FN(*this,fn)(command_in);
+    }
+
+
+    QString v=doNamedObjectCommand(command_in, _equation);
+    if (!v.isEmpty()) {
+      return v;
+    }
+
+    return "No such command";
+  } else {
+    return "Invalid";
+  }
+
+}
+
+ScriptInterface* EquationSI::newEquation(ObjectStore *store) {
+  EquationPtr equation = store->createObject<Equation>();
+
+  return new EquationSI(equation);
+}
+
+
+QString EquationSI::equation(QString&) {
+  if (_equation) {
+    return _equation->equation();
+  } else {
+    return "Invalid";
+  }
+}
+
+
+QString EquationSI::setEquation(QString& command) {
+  if (_equation) {
+    QString eq = getArg(command);
+
+    _equation->setEquation(eq);
+    return "done";
+  } else {
+    return "Invalid";
+  }
+}
+
+
 
 }
diff --git a/src/libkstmath/dataobjectscriptinterface.h b/src/libkstmath/dataobjectscriptinterface.h
@@ -17,29 +17,85 @@
 
 #include "scriptinterface.h"
 #include "basicplugin.h"
+#include "equation.h"
 #include "objectstore.h"
 #include "updatemanager.h"
 #include "updateserver.h"
 
-#ifndef PLUGINSCRIPTINTERFACE_H
-#define PLUGINSCRIPTINTERFACE_H
+#ifndef DATAOBJECTSCRIPTINTERFACE_H
+#define DATAOBJECTSCRIPTINTERFACE_H
 
 namespace Kst {
 
 class KSTMATH_EXPORT DataObjectSI : public ScriptInterface
+{
+    Q_OBJECT
+
+  public:
+    QString setInputVector(QString& command);
+    QString setInputScalar(QString& command);
+
+    QString outputVector(QString& command);
+    QString outputScalar(QString& command);
+
+  protected:
+    DataObjectPtr _dataObject;
+
+};
+
+
+class PluginSI;
+typedef QString (PluginSI::*PluginInterfaceMemberFn)(QString& command);
+
+class KSTMATH_EXPORT PluginSI : public DataObjectSI
 {    
     Q_OBJECT
 public:
-    explicit DataObjectSI(DataObjectPtr plugin);
+    explicit PluginSI(BasicPluginPtr plugin);
     QString doCommand(QString);
     bool isValid();
     QByteArray endEditUpdate();
 
     static ScriptInterface* newPlugin(ObjectStore *store, QByteArray pluginName);
+
+  protected:
+    QString noSuchFn(QString&) {return ""; }
+
   private:
-    DataObjectPtr _plugin;
+    BasicPluginPtr _plugin;
+
+    QMap<QString,PluginInterfaceMemberFn> _fnMap;
+
+
+};
+
+
+class EquationSI;
+typedef QString (EquationSI::*EquationInterfaceMemberFn)(QString& command);
+
+class KSTMATH_EXPORT EquationSI : public DataObjectSI
+{
+    Q_OBJECT
+public:
+    explicit EquationSI(EquationPtr equation);
+    QString doCommand(QString);
+    bool isValid();
+    QByteArray endEditUpdate();
+
+    static ScriptInterface* newEquation(ObjectStore *store);
+
+  protected:
+    QString noSuchFn(QString&) {return ""; }
+
+  private:
+    EquationPtr _equation;
+
+    QMap<QString,EquationInterfaceMemberFn> _fnMap;
+
+    QString equation(QString &);
+    QString setEquation(QString &eq);
 };
 
 
 }
-#endif // PLUGINSCRIPTINTERFACE_H
+#endif // DATAOBJECTSCRIPTINTERFACE_H
diff --git a/src/libkstmath/equation.cpp b/src/libkstmath/equation.cpp
@@ -37,6 +37,8 @@
 #include "generatedvector.h"
 #include "objectstore.h"
 
+#include "dataobjectscriptinterface.h"
+
 /*extern "C"*/ int yyparse(Kst::ObjectStore *store);
 extern void *ParsedEquation;
 /*extern "C"*/ struct yy_buffer_state *yy_scan_string(const char*);
@@ -93,6 +95,11 @@ void Equation::_initializeShortName() {
 }
 
 
+ScriptInterface* Equation::createScriptInterface() {
+  return new EquationSI(this);
+}
+
+
 void Equation::attach() {
 }
 
@@ -118,6 +125,7 @@ void Equation::internalUpdate() {
 
   writeLockInputsAndOutputs();
 
+  //_xInVector =
   Equations::Context ctx;
   ctx.sampleCount = _ns;
   ctx.xVector = _xInVector;

diff --git a/src/libkstmath/equation.h b/src/libkstmath/equation.h
@@ -80,6 +80,8 @@ class KSTMATH_EXPORT Equation : public DataObject {
     virtual PrimitiveList inputPrimitives() const;
     virtual void replaceInput(PrimitivePtr p, PrimitivePtr new_p);
 
+    virtual ScriptInterface* createScriptInterface();
+
   protected:
     Equation(ObjectStore *store);
     ~Equation();