extension.h

Go to the documentation of this file.

/*
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
    as published by the Free Software Foundation; either version 2
    of the License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA  02110-1301, USA.

    ---
    Copyright (C) 2009 Alexander Rieder <alexanderrieder@gmail.com>
 */

#ifndef _EXTENSION_H
#define _EXTENSION_H

#include <QObject>
#include <QPair>
#include <QVector>
#include <kdebug.h>
#include <QWidget>
#include "cantor_export.h"

namespace Cantor
{
class CANTOR_EXPORT Extension : public QObject
{
  public:
    Extension( const QString& name, QObject* parent );
    ~Extension();

};

//Some basic interfaces for extensions

class CANTOR_EXPORT HistoryExtension : public Extension
{
  public:
    HistoryExtension(QObject* parent);
    ~HistoryExtension();
  public slots:
    virtual QString lastResult() = 0;
};

class CANTOR_EXPORT ScriptExtension : public Extension
{
  public:
    ScriptExtension(QObject* parent);
    ~ScriptExtension();
  public slots:
    virtual QString runExternalScript(const QString& path) = 0;
    virtual QString scriptFileFilter() = 0;

    virtual QString commandSeparator();
    virtual QString commentStartingSequence();
    virtual QString commentEndingSequence();
};

class CANTOR_EXPORT CASExtension : public Extension
{
  public:
    CASExtension(QObject* parent);
    ~CASExtension();

  public slots:
    virtual QString solve(const QStringList& equations, const QStringList& variables) = 0;
    virtual QString simplify(const QString& expression) = 0;
    virtual QString expand(const QString& expression) = 0;
};

class CANTOR_EXPORT CalculusExtension : public Extension
{
  public:
    CalculusExtension(QObject* parent);
    ~CalculusExtension();

  public slots:
    virtual QString limit(const QString& expression, const QString& variable, const QString& limit) = 0;
    virtual QString differentiate(const QString& function,const QString& variable, int times) = 0;
    virtual QString integrate(const QString& function, const QString& variable) = 0;
    virtual QString integrate(const QString& function,const QString& variable, const QString& left, const QString& right) = 0;
};

class CANTOR_EXPORT PlotExtension : public Extension
{
  public:
    typedef QPair<QString,QString> Interval;
    typedef QPair<QString, Interval> VariableParameter;

    PlotExtension(QObject* parent);
    ~PlotExtension();

  public slots:
    virtual QString plotFunction2d(const QString& function, const QString& variable, const QString& left, const QString& right) = 0;
    virtual QString plotFunction3d(const QString& function, VariableParameter var1, VariableParameter var2) = 0;
};

#define PLOT_DIRECTIVE_DISPATCHING(x) QString dispatch(const Cantor::AdvancedPlotExtension::AcceptorBase& acc) const \
 { \
    const Cantor::AdvancedPlotExtension::DirectiveAcceptor<x>* adaptor= \
        dynamic_cast<const Cantor::AdvancedPlotExtension::DirectiveAcceptor<x>*>(&acc); \
    if (adaptor==NULL) { kDebug()<<"Backend incapable of processing directives of type "#x;  return ""; } \
    else \
        return adaptor->accept(*this); \
 }

class CANTOR_EXPORT AdvancedPlotExtension : public Extension
{
  public:
    AdvancedPlotExtension(QObject* parent);
    ~AdvancedPlotExtension();

    // TODO comment

    class PlotDirective;

    // TODO move the hell out of here
    class CANTOR_EXPORT DirectiveProducer : public QWidget
    {
        public:
            DirectiveProducer(QWidget* parent);
            virtual PlotDirective* produceDirective() const=0;
    };

    template <class UI> class DirectiveControl : protected UI, public DirectiveProducer
    {
        public:
            DirectiveControl(QWidget* parent) : DirectiveProducer(parent) { UI::setupUi(this); }
        protected:
            typedef DirectiveControl<UI> AbstractParent;
    };

    class CANTOR_EXPORT AcceptorBase
    {
        public:
            typedef DirectiveProducer * (*widgetProc)(QWidget*);

            const QVector<widgetProc>& widgets() const;

        protected:
            AcceptorBase();
            virtual ~AcceptorBase();

            QVector<widgetProc> m_widgets;
    };

    template <class Directive> class DirectiveAcceptor : virtual public AcceptorBase
    {

        public:
            virtual QString accept(const Directive& directive) const=0;

        protected:
            DirectiveAcceptor();
    };

    class CANTOR_EXPORT PlotDirective
    {
        public:
            virtual ~PlotDirective();

            static QWidget* widget(QWidget* parent);

            virtual PLOT_DIRECTIVE_DISPATCHING(PlotDirective);
            // TODO: find a workaround not to put class names manually

        protected:
            PlotDirective();
    };

  public slots:
    QString plotFunction2d(const QString& expression, const QVector<PlotDirective*> directives) const;

    QString dispatchDirective(const PlotDirective& directive) const;

  protected:
    virtual QString plotCommand() const=0;
    virtual QString separatorSymbol() const;
};

template <class Directive> AdvancedPlotExtension::DirectiveAcceptor<Directive>::DirectiveAcceptor()
{
    m_widgets.push_back(&Directive::widget);
}

class CANTOR_EXPORT LinearAlgebraExtension : public Extension
{
  public:
    enum VectorType { ColumnVector, RowVector };
    typedef QList<QStringList> Matrix;

    LinearAlgebraExtension(QObject* parent);
    ~LinearAlgebraExtension();

  public slots:
    //Commands to create Vectors/Matrices
    virtual QString createVector(const QStringList& entries, VectorType type) = 0;
    virtual QString nullVector(int size, VectorType type);
    virtual QString createMatrix(const Matrix& matrix) = 0;
    virtual QString identityMatrix(int size);
    virtual QString nullMatrix(int rows,int columns);

    //basic functions
    virtual QString rank(const QString& matrix) = 0;
    virtual QString invertMatrix(const QString& matrix) = 0;
    virtual QString charPoly(const QString& matrix) = 0;
    virtual QString eigenVectors(const QString& matrix) = 0;
    virtual QString eigenValues(const QString& matrix) = 0;

};

class CANTOR_EXPORT VariableManagementExtension : public Extension
{
  public:
    VariableManagementExtension( QObject* parent );
    ~VariableManagementExtension();

  public slots:
    virtual QString addVariable(const QString& name, const QString& value) = 0;
    virtual QString setValue(const QString& name,const QString& value) = 0;
    virtual QString removeVariable(const QString& name) = 0;

    virtual QString saveVariables(const QString& fileName) = 0;
    virtual QString loadVariables(const QString& fileName) = 0;
    virtual QString clearVariables() = 0;
};

class CANTOR_EXPORT PackagingExtension : public Extension
{
  public:
    PackagingExtension(QObject* parent);
    ~PackagingExtension();

  public slots:
    virtual QString importPackage(const QString& package) = 0;
};

}
#endif /* _EXTENSION_H */