milo.h

Go to the documentation of this file.

#ifndef __MILO_H
#define __MILO_H

/* Copyright (C) 2017 - James Terman
 *
 * milo is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * milo 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <string>
#include <memory>
#include <complex>
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <ctime>
#include <algorithm>
#include <typeindex>

#include "util.h"
#include "xml.h"
#include "smart.h"

// Forward class declerations
namespace UI { class Graphics; }
class Node;
class Term;
class Expression;
class Input;
class Equation;

// Hidden class declerations for pointers and reference
class Parser;
class EqnXMLParser;

using Complex = std::complex<double>;     
using NodePtr = SmartPtr<Node>;           
using NodeVector = SmartVector<Node>;     
using NodeIter = NodeVector::iterator;    
using TermPtr = SmartPtr<Term>;           
using TermVector = SmartVector<Term>;     
using ExpressionPtr = SmartPtr<Expression>; 
using EqnPtr = std::shared_ptr<Equation>; 


class Node : public std::enable_shared_from_this<Node>
{
public:
    enum Select { NONE, START, END, ALL };

    static const std::vector<std::string> select_tags;

    struct Frame { Box box; int base; };

    Node(Node* parent = nullptr, bool fNeg = false, Select s = NONE ) : 
        m_parent(parent), m_sign(!fNeg), m_select(s) {}

    Node(EqnXMLParser& in, Node* parent);
    
    virtual ~Node() {} 


    virtual std::string toString() const=0;

    virtual bool isLeaf() const { return true; }

    virtual bool isFactor() const { return true; }

    virtual Node* findNode(int x, int y);

    virtual Node* findNode(const Box& b);

    virtual int numFactors() const { return 1; }

    virtual void normalize() {}

    virtual bool simplify() { return false; }

    virtual bool less(NodePtr b) const { return this->toString() < b->toString(); }

    virtual const std::string& getName() const=0;

    virtual std::type_index getType() const=0;

    void calculateSize(UI::Graphics& gc);

    void out(XML::Stream& xml);

    void calculateOrigin(UI::Graphics& gc, int x, int y);

    void setUpDraw(UI::Graphics& gc);

    void draw(UI::Graphics& gc) const;

    void setSelect(Select s) { m_select = s; }

    Select getSelect() const { return m_select; }

    void setDrawParenthesis(bool fDrawPar) { m_fDrawParenthesis = fDrawPar; }

    bool getDrawParenthesis() const { return m_fDrawParenthesis; }

    const Frame& getFrame() const { return m_frame; }

    Node* first();

    Node* last();

    Node* getNextLeft();

    Node* getNextRight();

    void setParent(Node* parent) { m_parent = parent; }

    Node* getParent() const { return m_parent; }

    int getDepth() const { return getDepth(0); }
    int getNth() const { return m_nth; }

    void addNth(int n) { m_nth += n; }

    void multNth(int n) { m_nth *= n; }

    void setNth(int n) { m_nth = n; }

    void negative() { m_sign = !m_sign; }

    bool getSign() const { return m_sign; }

    Complex getValue() const;

    static bool createNodeByName(std::string name, Equation& eqn);

    std::shared_ptr<Node> getSharedPtr()
    {
        std::shared_ptr<Node> sp;
        try {
            sp = this->shared_from_this();
        }
        catch (std::exception& ex) {
            sp = std::shared_ptr<Node>(this);
        }
        return sp;
    }
    
private:
    virtual Node* downLeft() { return nullptr; }

    virtual Node* downRight() { return nullptr; }

    virtual Node* getLeftSibling(Node*) { return nullptr; }

    virtual Node* getRightSibling(Node*) { return nullptr; }

    virtual Frame calcSize(UI::Graphics& gc)=0;

    virtual void calcOrig(UI::Graphics& gc, int x, int y)=0;

    virtual void drawNode(UI::Graphics& gc) const=0;

    virtual Complex getNodeValue() const=0;

    virtual void xml_out(XML::Stream& xml) const=0;

    int getDepth(int depth) const {
        return (!m_parent) ? depth : m_parent->getDepth(++depth);
    }

    Node* m_parent;    
    bool m_sign;       
    Select m_select;   
    Frame m_frame;     
    Box m_parenthesis; 
    int m_nth = 1;     
    bool m_fDrawParenthesis = false; 
};

class Term : public Node
{
public:
    Term(Parser& p, Expression* parent = nullptr) : Node((Node*) parent) { while(add(p)); }

    Term(EqnXMLParser& in, Node* parent = nullptr);

    Term(NodeVector& f, Expression* parent) : Node((Node*) parent) { factors.swap(f); }
    
     Term(Node* node, Expression* parent = nullptr, bool fNeg = false) : 
        Node((Node*) parent, fNeg), factors(node) 
    {
        node->setParent(this);
    }

    ~Term() {}
    
    static Node* parse(Parser& p, Node* parent = nullptr);

    std::string toString() const;

    bool isLeaf() const { return false; }

    bool isFactor() const { return false; }

    Node* findNode(int x, int y);

    Node* findNode(const Box& b);

    int numFactors() const;

    void normalize();

    bool simplify();

    const std::string& getName() const { return name; }

    std::type_index getType() const { return type; }
    
    static const std::string name;     
    static const std::type_index type; 

    void simplify(NodePtr ref, TermPtr new_term);

    static bool simplify(TermVector& terms, TermVector::iterator a, TermVector::iterator b);

    static void insertAfterMe(Node* me, NodePtr node);

    void setParent() { for ( auto f : factors ) f->setParent(this); }

    void setParent(Expression* parent) { Node::setParent((Node*) parent); }

    NodeIter begin() { return factors.begin(); }

    NodeIter end()   { return factors.end(); }

    static NodeIter pos(Node* me);

    void multiply(double n);

    void multiply(TermPtr old_term);

    std::shared_ptr<Term> getSharedPtr()
    {
        return std::dynamic_pointer_cast<Term>(this->Node::getSharedPtr());
    }

    friend class FactorIterator;
private:
    NodeVector factors; 
    Box m_internal;     

    Node* downLeft()  { return factors.front(); }

    Node* downRight() { return factors.back(); }

    Node* getLeftSibling(Node* node);

    Node* getRightSibling(Node* node);

    Complex getNodeValue() const;

    void xml_out(XML::Stream& xml) const;
    
    Frame calcSize(UI::Graphics& gc);

    void calcOrig(UI::Graphics& gc, int x, int y);

    void drawNode(UI::Graphics& gc) const;
    
    bool add(Parser& p);
};

class Expression : public Node
{
public:
    Expression(EqnXMLParser& in, Node* parent = nullptr);

    Expression(Parser& p, Node* parent = nullptr) : Node(parent)
    {
        while(add(p));
        setDrawParenthesis(true);
    }

    Expression(Term* term, Node* parent = nullptr) : Node(parent), terms(term)
    { 
        term->setParent(this); setDrawParenthesis(true);
    }

    Expression(Node* factor, Node* parent = nullptr) : 
        Node(parent), terms(new Term(factor, this))
    { 
        factor->setParent(terms[0]); setDrawParenthesis(true);
    }

    ~Expression() {}
    
    std::string toString() const;

    bool isLeaf() const { return false; }

    Node* findNode(int x, int y);

    Node* findNode(const Box& b);

    int numFactors() const;

    void normalize();

    bool simplify();

    const std::string& getName() const { return name; }

    std::type_index getType() const { return type; }
    
    static const std::string name;     
    static const std::type_index type; 

    int numTerms() const { return terms.size(); }

    void setParent() { for ( auto t : terms ) t->setParent(this); }

    TermVector::iterator begin() { return terms.begin(); }

    TermVector::iterator end()   { return terms.end(); }

    static Term* getTerm(Equation& eqn, const std::string& text, Expression* parent = nullptr);

    static Term* getTerm(Parser& p, Expression* parent);

    static Node* parse(Parser& p, Node* parent);

    void add(double n);

    void add(ExpressionPtr old_expr);

    friend class FactorIterator;
private:
    TermVector terms; 
    Box m_internal;   

    Node* downLeft()  { return terms.front(); } 

    Node* downRight() { return terms.back(); }

    Node* getLeftSibling(Node* node);

    Node* getRightSibling(Node* node);
    void xml_out(XML::Stream& xml) const;
    
    Frame calcSize(UI::Graphics& gc);

    void calcOrig(UI::Graphics& gc, int x, int y);

    void drawNode(UI::Graphics& gc) const;

    Complex getNodeValue() const;
    
    bool add(Parser& p);
};

class NodeIterator : public std::iterator< std::bidirectional_iterator_tag, Node* >
{
private:
    Node* m_node; 

    void next();  
    void prev();  

public:
    NodeIterator(Node* node) : m_node(node) {}

    Node*& operator*() { return m_node; }

    Node*& operator->() { return m_node; }

    bool operator==(const NodeIterator& rhs) { return m_node == rhs.m_node; }

    bool operator!=(const NodeIterator& rhs) { return m_node != rhs.m_node; }

    NodeIterator& operator++()   { next(); return *this; }

    NodeIterator operator++(int) { NodeIterator tmp(*this); next(); return tmp; }

    NodeIterator& operator--()   { prev(); return *this; }

    NodeIterator operator--(int) { NodeIterator tmp(*this); prev(); return tmp; }
};

class FactorIterator : public std::iterator< std::bidirectional_iterator_tag, Node* >
{
 private:
    Node* m_node;                  
    Term* m_pTerm;                 
    Expression* m_gpExpr;          
    unsigned int m_factor_index;   
    unsigned int m_term_index;     

    void next();                   
    void prev();                   

public:
    FactorIterator(Node* node);

    FactorIterator(NodeIterator n) : FactorIterator(*n) {}

    FactorIterator(Expression* expr);
    
    Node*& operator*() { return m_node; }

    Node*& operator->() { return m_node; }

    bool operator==(const FactorIterator& rhs) { return m_node == rhs.m_node; }

    bool operator!=(const FactorIterator& rhs) { return m_node != rhs.m_node; }

    bool operator>(const FactorIterator& rhs);

    bool operator>=(const FactorIterator& rhs);

    bool operator<(const FactorIterator& rhs);

    bool operator<=(const FactorIterator& rhs);
    
    FactorIterator& operator++()   { next(); return *this; }

    FactorIterator operator++(int) { FactorIterator tmp(*this); next(); return tmp; }

    FactorIterator& operator--()   { prev(); return *this; }

    FactorIterator operator--(int) { FactorIterator tmp(*this); prev(); return tmp; }

    void erase();

    void erase(const FactorIterator& end);

    void mergeNextTerm();

    Term* splitTerm(bool fNeg = false);
    
    void replace(Term* term);
    
    void replace(Node* node);

    void insert(Node* node);

    void insertAfter(Node* node);

    void insert(Term* node, bool sign = true);

    void insertAfter(Term* term, bool sign = true);

    bool isBegin() { return m_factor_index == 0 && m_term_index == 0; }

    bool isEnd()   { return !m_node; }

    bool isBeginTerm() { return m_factor_index == 0; }

    bool isEndTerm();

    void setNode(int factor, int term);

    FactorIterator getBegin() { FactorIterator tmp(*this); tmp.setNode(0, 0); return tmp; }

    FactorIterator getLast() { FactorIterator tmp(*this); tmp.setNode(-1, -1); return tmp; }

    static void swap(FactorIterator& a, FactorIterator& b);
};

class Equation
{
public:
    Equation(const std::string& eq);

    Equation(std::istream& is);

    Equation(const Equation& eqn) { *this = eqn; }

    ~Equation() {}
    
    Equation& operator=(const Equation& eqn);

    Equation(Equation&& eqn)=delete;            
    Equation& operator=(Equation&& eqn)=delete; 

    
    std::string toString() const { return m_root->toString(); }

    void xml_out(std::ostream& os) const;

    void xml_out(std::string& str) const;

    void draw(UI::Graphics& gc, bool fRefresh = false);

    Equation* clone();

    bool blink() { return m_input_index >= 0; }

    void getCursorOrig(int& x, int& y);

    void setCurrentInput(int in_sn);

    void addInput(Input* in) { m_inputs.push_back(in); }

    void removeInput(Input* in);

    Input* getCurrentInput() { 
        if (m_inputs.empty() || m_input_index < 0)
            return nullptr;
        else
            return m_inputs[m_input_index];
    }

    void nextInput(bool fShift);

    FactorIterator disableCurrentInput();

    void setSelectStart(Node* start) { m_selectStart = start; }

    void setSelectEnd(Node* end)   { m_selectEnd = end; }

    void clearSelect(); 

    void setSelect(Node* start, Node* end = nullptr);

    void selectNodeOrInput(Node* node);
    
    void setSelectFromNode(Node* node);

    Node* findNode(UI::Graphics& gc, int x, int y);

    Node* findNode(UI::Graphics& gc, Box b);

    void selectBox(UI::Graphics& gc, Node* start, Box b);

    void eraseSelection(Node* node);

    bool simplify() { m_root->normalize(); return m_root->simplify(); }

    void normalize() { m_root->normalize(); }

    NodeIterator begin() { return NodeIterator(m_root->first()); }

    NodeIterator end()   { return NodeIterator(nullptr); }

    NodeIterator last()  { return NodeIterator(m_root->last()); }

    void insert(FactorIterator& it, const std::string& text);

    Node* getRoot() { return m_root; }

    Node* getSelectStart() { return m_selectStart; }

    Node* getSelectEnd() { return m_selectEnd; }
private:
    NodePtr m_root;                
    std::vector<Input*> m_inputs;  
    int m_input_index = -1;        
    Node* m_selectStart = nullptr; 
    Node* m_selectEnd = nullptr;   

    void setSelect(UI::Graphics& gc);

    void factor(std::string text, NodeVector& factors, Node* parent);

    void xml_out(XML::Stream& xml) const;

    void xml_in(EqnXMLParser& in);
};

class Input : public Node
{
public:
    Input(Parser& p, Node* parent = nullptr);

    Input(Equation& eqn, std::string txt = std::string(), bool current = true, Node* parent = nullptr,
          bool neg = false, Node::Select s = Node::Select::NONE);

    Input(EqnXMLParser& in, Node* parent);
    
    ~Input() {} 

    
    std::string toString() const;

    int numFactors() const { return m_typed.size(); }

    const std::string& getName() const { return name; }

    std::type_index getType() const { return type; }

    bool empty() const { return m_typed.empty(); }

    void add(char ch) { m_typed += std::string(1, ch); }

    void add(const std::string& s) { m_typed += s; }
    
    void remove() { m_typed.erase(m_typed.end() - 1); }

    void clear() { m_typed.clear(); }
    
    const std::string& getBuffer() { return m_typed; }

    bool checkSN(int sn) { return m_sn == sn; }
    bool getCurrent() { return m_current; }

    void setCurrent(bool current) { m_current = current; }

    void makeCurrent() { m_eqn.setCurrentInput(m_sn); }

    FactorIterator emptyBuffer();

    bool unremovable() { return getParent()->numFactors() == 0; }
    
    static Input* parse(Parser& p, Node* parent = nullptr);

    static const std::string name;     
    static const std::type_index type; 
private:
    int m_sn;            
    std::string m_typed; 
    bool m_current;      
    Equation& m_eqn;     
    Box m_internal;      
    
    Frame calcSize(UI::Graphics& gc);

    void calcOrig(UI::Graphics& gc, int x, int y);

    void drawNode(UI::Graphics& gc) const;

    Complex getNodeValue() const;
    
    void xml_out(XML::Stream& xml) const;

    static int input_sn; 
};

class EqnUndoList
{
public:
    EqnUndoList() {}

    void save(EqnPtr eqn);

    EqnPtr undo();

    EqnPtr top();

private:
    std::vector<std::string> m_eqns; 
};
#endif // __MILO_H