script.cpp

#ifdef FOR_WINDOWS
#include <windows.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <gl.h>
#include <glu.h>
#include <GL/freeglut.h>
#include <vector>
#include <iostream>
#include <algorithm>
#include <regex>
#include <string>
#include <map>
#include "function.h"
#include "complex.h"
#include "primitive.h"
#include "line.h"
#include "curve.h"
#include "ellipse.h"
#include "text.h"
#include <chrono>
#endif

#ifndef FOR_WINDOWS
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <GL/glut.h>
#include <GL/freeglut.h>
#include <vector>
#include <iostream>
#include <algorithm>
#include <regex>
#include <string>
#include <map>
#include "function.h"
#include "complex.h"
#include "primitive.h"
#include "line.h"
#include "curve.h"
#include "ellipse.h"
#include "text.h"
#include <chrono>
#endif

// @todo: get rid of glVertex in the entire project, make use of glDrawArray (it will speed up the drawing process)

/*

Int MODE defines a type of primitive which you can paint with your mouse..
There are several modes: curve, straight line and ellipse.
Modes are switched by pressing 1, 2 or 3 on the keyboard.

*/

#define MODE_CURVE 1
#define MODE_LINE 2
#define MODE_ELLIPSE 3
int MODE = MODE_CURVE;

/*

Donw there goes every stuff concerned with layout. Everything is measured in pixels.

In the program 3 different canvas are drawn.
1. Canvas: this is a canvas with PRE image, on which you can draw curves, lines etc.
2. ImageCanvas: this is a canvas with IMAGE, on which an IMAGE of the curves and lines is painted
3. MenuCanvas: this is a canvas with textboxes, it currently consist of two distinct textboxes: one for displaying text and another one for entering text

Span is the distance from any canvas to the nearest edge of window.

*/

int windowWidth=700;
int windowHeight=300;

int xCanvas;
int wCanvas;
int hCanvas;
int yCanvas;

int xImageCanvas;
int wImageCanvas;
int hImageCanvas;
int yImageCanvas;

int xMenuCanvas;
int wMenuCanvas;
int hMenuCanvas;
int yMenuCanvas;

int span=20;

/*

You can move contents of canvas using spacebar+mouse. Moreover, you can zoom it using mousewheel.

dx, dy: amount of pixels on which contents of the 1 and 2 canvas are moved
scale: measure of zoom

prevX, prevY: it stores previous position of the mouse; it changes every time you move your mouse
begin: it is set to the coordinates of the point where you pressed Left Mouse Button; it is set to 0 every time you release Left Mouse Button
f: our function which coverts the pre-images into the images. For example, it converts:
    - preimage => image
    - _precurve => _curve
    - hlines, vlines => hlinesMap, vlinesMap
    - haxe, vaxe => haxeMap, vaxeMap

*/

double dx=0;
double dy=0;

double RESOLUTION = 200;
double scale=1;

bool spacePressed = false;
bool shift = false;

int prevX = 0;
int prevY = 0;
complex * begin = 0;
function * f = new function();

/*

preimage: a vector of original primitives
_precurve: temporary vector used to store a primitive which is not finished
image: a vector of mapped primitives, or curves
_curve: temporary vector used to store a mapped primitive which is not finished
hlines, vlines: vector of horizontal and vertical lines of the graph
haxe, vaxe: axes of the graph
hlinesMap, vlinesMap: vector of maps of horizontal and vertical lines of the graph
haxeMap, vaxeMap: map of axes

*/

std::vector<primitive*> preimage;
primitive* _precurve;
std::vector<curve*> image;
curve* _curve;
std::vector<std::vector<complex>> hlines;
std::vector<std::vector<complex>> vlines;
std::vector<complex> haxe;
std::vector<complex> vaxe;
std::vector<std::vector<complex>> hlinesMap;
std::vector<std::vector<complex>> vlinesMap;
std::vector<complex> haxeMap;
std::vector<complex> vaxeMap;

/*

textOnCanvas: it is a text box used to display information
textEditOnCanvas: it is a text box used to edit text

*/

text textOnCanvas(wMenuCanvas,hMenuCanvas/2,xMenuCanvas,yMenuCanvas,"Please enter your function below:");
text textEditOnCanvas(wMenuCanvas,hMenuCanvas/2,xMenuCanvas,yMenuCanvas+hMenuCanvas/2,"");

/*

priority: dictionary which stores the priorty of every arithmetical operation, for example, "*" has more priority than "+" (2 > 1)
equals: dictionary which substitutes synonymous functions with abbreviation, for example, "ln" and "log" are synonymous and replaced with "l"

*/

std::map<char, int> priority = {
    {'^',3},
    {'*',2},
    {'/',2},
    {'+',1},
    {'-',1}
};

std::map<std::string, char> equals = {
    {"ln", 'l'},
    {"log", 'l'},
    {"l", 'l'},
    {"exp", 'e'},
    {"sin", 's'},
    {"cos", 'c'}
};

/*

Following block of functions is used to parse a string and covert it into function object

*/

bool isargument(std::string s) {
    return !s.compare("x");
}

bool iscomplex(std::string s) {
    int signcounter = 0;
    for (int i = 0; i < s.size(); i++) {
        if (s[i]=='+' || s[i]=='-') {
            signcounter++;
            if (signcounter > 2) return false;
        }
        else if (!(std::isdigit(s[i]) || s[i]=='i')) return false;
    }
    return true;
}

function * parser(std::string s) {
    std::vector<std::string> operands;
    std::vector<int> isfunction;
    std::vector<char> operators;
    int lastOperatorPos = -1;
    int lOpenCounter = 0;
    int lPos = -1;
    function * ret = nullptr;
    std::cout << 111 << std::endl;
    for (int i = 0; i < s.length(); i++) {
        std::cout << 112 << std::endl;
        int value = priority[s[i]];
        if (value) {
            if (!lOpenCounter) {
                operators.push_back(s[i]);
                if (lastOperatorPos+1 != lPos) {
                    isfunction.push_back(lPos-lastOperatorPos-1);
                    operands.push_back(s.substr(lastOperatorPos+1, i-lastOperatorPos-1));
                }
                else {
                    isfunction.push_back(false);
                    operands.push_back(s.substr(lastOperatorPos+2, i-lastOperatorPos-3));
                }
                lastOperatorPos = i;
            }
        }
        else if (s[i]=='(') {
            if (!lOpenCounter) lPos = i;
            lOpenCounter++;
        }
        else if (s[i]==')') {
            lOpenCounter--;
            if (lOpenCounter<0) throw "Syntax error: excess closing bracket";
        }
        std::cout << 113 << std::endl;
    }

    std::cout << 114 << std::endl;
    if (!lOpenCounter) {
        if (lastOperatorPos+1 != lPos) {
            isfunction.push_back(lPos-lastOperatorPos-1);
            operands.push_back(s.substr(lastOperatorPos+1, s.length()-lastOperatorPos-1));
        }
        else {
            isfunction.push_back(false);
            operands.push_back(s.substr(lastOperatorPos+2, s.length()-lastOperatorPos-3));
        }
    }
    //else throw "Syntax error: no closing bracket found";

    std::cout << 115 << std::endl;

    std::cout << 116 << std::endl;
    std::vector<function*> foos(operands.size(), nullptr);
    for (int i = 0; i < operands.size(); i++) {
        std::cout << operands[i] << std::endl;
        function * f;
        if (isargument(operands[i])) {
            std::cout << 116.1 << std::endl;
            f = new function();
        }
        else if (iscomplex(operands[i])) {
            std::cout << 116.2 << std::endl;
            if (operands[i].length()==1 && operands[i][0]!='i' && !std::isdigit(operands[i][0])) {
                throw "Unknown operand";
            }
            complex constant(operands[i]);
            f = new function(constant);
        }
        else if (isfunction[i]) {
            std::cout << 116.3 << std::endl;
            if (operands[i].length()==1 && !std::isdigit(operands[i][0])) {
                throw "Unknown operand";
            }
            std::cout << 116.4 << " " << isfunction[i] << " " << operands[i].length()-isfunction[i] << std::endl;
            std::string subst = operands[i].substr(isfunction[i], operands[i].length()-isfunction[i]); // @todo: handle cases when isfunction[i] < 0
            std::cout << 116.41 << subst << std::endl;

            function * arg = parser(subst);
            std::string subst2 = operands[i].substr(0,isfunction[i]);
            std::cout << 116.5 << std::endl;
            f = new function(equals[subst2], arg); // @todo: what if there is no match in the "equals"?
            std::cout << 116.6 << std::endl;
        }
        else {
            std::cout << 116.4 << std::endl;
            f = parser(operands[i]);
        }

        foos[i] = f;
    }
    std::cout << 117 << std::endl;

    if (operands.size() == 0) throw "there are no operands";
    int i = 0;
    while (operators.size() > 0) {
        std::cout << 118 << std::endl;
        bool greaterThanLeft = false;
        bool greaterThanRight = false;
        if ((i>0 && priority[operators[i]]>=priority[operators[i-1]]) || (i == 0)) greaterThanLeft = true;
        if ((i<operators.size()-1 && priority[operators[i]]>=priority[operators[i+1]]) || (i == operators.size()-1)) greaterThanRight = true;
        if (greaterThanRight && greaterThanLeft) {
            function * foo = new function(operators[i], foos[i], foos[i+1]);
            foos.erase(foos.begin() + i);
            operators.erase(operators.begin() + i);
            foos[i] = foo;
        }

        i++;
        if (i>=operators.size()) i = 0;
    }
    std::cout << "117.1" << std::endl;
    foos[0]->out("");
    ret = foos[0];
    std::cout << "117.2" << std::endl;
    return ret;
}

/*

Following function is just a wrap of the "f"; @todo: remove func from the code

*/

complex func(complex const& z) {
    complex z1(z.re, z.im);
    complex z2(1,0);
    z1=f->calc(z);
    z1.r=z.r;
    z1.g=z.g;
    z1.b=z.b;
    return z1;
}

void draw()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glViewport(xCanvas, yCanvas, wCanvas, hCanvas);
    glMatrixMode(GL_MODELVIEW);

    glLoadIdentity();
    glBegin(GL_LINE_STRIP);
    glColor3d(1,0,0);
    glVertex3d(-1,-1,0);
    glVertex3d(-1,1,0);
    glVertex3d(1,1,0);
    glVertex3d(1,-1,0);
    glVertex3d(-1,-1,0);
    glEnd();

    glLoadIdentity();
    glScalef(scale,scale,1);
    glTranslatef(dx,dy,0);

    GLfloat quadVertices[] = { -1.0f, 1.0f, 0.0f,
        1.0f, 1.0f, 0.0f,
        1.0f,-1.0f, 0.0f,
        -1.0f,-1.0f, 0.0f
    };

    glVertexPointer(3, GL_FLOAT, 0, quadVertices);
    glDrawArrays(GL_QUADS, 0, 4);

    std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
    glBegin(GL_LINE_STRIP);
    for (int i = 0; i < haxe.size(); i++) {
        glColor3d(haxe[i].r,haxe[i].g,haxe[i].b);
        glVertex3d(haxe[i].re,haxe[i].im,0);
    }
    glEnd();
    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();

    glBegin(GL_LINE_STRIP);
    for (int i = 0; i < vaxe.size(); i++) {
        glColor3d(vaxe[i].r,vaxe[i].g,vaxe[i].b);
        glVertex3d(vaxe[i].re,vaxe[i].im,0);
    }
    glEnd();

    for (int i = 0; i < preimage.size(); i++) {
        preimage[i]->draw();
    }

    if (_precurve != nullptr) _precurve->draw();

    for (int i = 0; i < hlines.size(); i++) {
        glBegin(GL_LINE_STRIP);
        for (int k = 0; k < hlines[i].size(); k++) {
            glColor3d(0.7,0.7,0.7);
            glVertex3d(hlines[i][k].re,hlines[i][k].im, 0);
        }
        glEnd();
    }
    for (int i = 0; i < vlines.size(); i++) {
        glBegin(GL_LINE_STRIP);
        for (int k = 0; k < vlines[i].size(); k++) {
            glColor3d(0.7,0.7,0.7);
            glVertex3d(vlines[i][k].re,vlines[i][k].im, 0);
        }
        glEnd();
    }

    glBegin(GL_POLYGON);
    glColor3f(1,1,1);
    glVertex3d(-1,-1,0);
    glVertex3d(-1,1,0);
    glVertex3d(1,1,0);
    glVertex3d(1,-1,0);
    glEnd();



    //glMatrixMode(GL_PROJECTION);
    glViewport(xImageCanvas, yImageCanvas, wImageCanvas, hImageCanvas);
    glMatrixMode(GL_MODELVIEW);

    glLoadIdentity();
    glBegin(GL_LINE_STRIP);
    glColor3d(1,0,0);
    glVertex3d(-1,-1,0);
    glVertex3d(-1,1,0);
    glVertex3d(1,1,0);
    glVertex3d(1,-1,0);
    glVertex3d(-1,-1,0);
    glEnd();

    glLoadIdentity();
    glScalef(scale,scale,1);
    glTranslatef(dx, dy, 0.0);
    glBegin(GL_LINE_STRIP);
    for (int i = 0; i < haxeMap.size(); i++) {
        glColor3d(haxeMap[i].r,haxeMap[i].g,haxeMap[i].b);
        glVertex3d(haxeMap[i].re,haxeMap[i].im,0);
    }
    glEnd();
    glBegin(GL_LINE_STRIP);
    for (int i = 0; i < vaxeMap.size(); i++) {
        glColor3d(vaxeMap[i].r,vaxeMap[i].g,vaxeMap[i].b);
        glVertex3d(vaxeMap[i].re,vaxeMap[i].im,0);
    }
    glEnd();

    for (int i = 0; i < image.size(); i++) {
        image[i]->draw();
    }
    if (_curve != nullptr) _curve->draw();


    for (int i = 0; i < hlinesMap.size(); i++) {
        glBegin(GL_LINE_STRIP);
        for (int k = 0; k < hlinesMap[i].size(); k++) {
            glColor3d(0.7,0.7,0.7);
            glVertex3d(hlinesMap[i][k].re,hlinesMap[i][k].im, 0);
        }
        glEnd();
    }
    for (int i = 0; i < vlinesMap.size(); i++) {
        glBegin(GL_LINE_STRIP);
        for (int k = 0; k < vlinesMap[i].size(); k++) {
            glColor3d(0.7,0.7,0.7);
            glVertex3d(vlinesMap[i][k].re,vlinesMap[i][k].im, 0);
        }
        glEnd();
    }

    glBegin(GL_POLYGON);
    glColor3f(1,1,1);
    glVertex3d(-10,-10,0);
    glVertex3d(-10,10,0);
    glVertex3d(10,10,0);
    glVertex3d(10,-10,0);
    glEnd();



    textOnCanvas.draw();
    textEditOnCanvas.draw();
    glFlush();
    glutSwapBuffers();
    std::cout << "Time difference = " << std::chrono::duration_cast<std::chrono::microseconds> (end - begin).count() << "[ns]" << std::endl;
}

void update(int value)
{
        glutPostRedisplay();
        glutTimerFunc(0.1, update, 0);
}

void initRendering()
{
        glEnable(GL_DEPTH_TEST);
        glEnable(GL_COLOR_MATERIAL);

        glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
        glEnable(GL_NORMALIZE);
}

void handleResize(int w, int h)
{
        glViewport(0, 0, w, h);
        windowWidth=w;
        windowHeight=h;

        int wPanel = (windowWidth-4*span)/3;
        int hPanel = windowHeight-2*span;

        int t = 0;
        if (wPanel<hPanel) {
            wCanvas=wPanel;
            hCanvas=wPanel;
            xCanvas=span;
            yCanvas=(windowHeight-hCanvas)/2;

            wImageCanvas=wPanel;
            hImageCanvas=wPanel;
            xImageCanvas=2*span+wCanvas;
            yImageCanvas=(windowHeight-hCanvas)/2;

            wMenuCanvas=wPanel;
            hMenuCanvas=wPanel;
            xMenuCanvas=3*span+wCanvas+wImageCanvas;
            yMenuCanvas=(windowHeight-hCanvas)/2;
        }
        else {
            int t = (windowWidth-4*span-3*hPanel)/6;
            wCanvas=hPanel;
            hCanvas=hPanel;
            xCanvas=span+t;
            yCanvas=span;

            wImageCanvas=hPanel;
            hImageCanvas=hPanel;
            xImageCanvas=2*span+wCanvas+3*t;
            yImageCanvas=span;

            wMenuCanvas=hPanel;
            hMenuCanvas=hPanel;
            xMenuCanvas=3*span+wCanvas+wImageCanvas+5*t;
            yMenuCanvas=span;
        }

        textOnCanvas.resize(wMenuCanvas, hMenuCanvas/2, xMenuCanvas, yMenuCanvas);
        textEditOnCanvas.resize(wMenuCanvas, hMenuCanvas/2, xMenuCanvas, yMenuCanvas+hMenuCanvas/2);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
}

/*

Now we create event handlers, for example, to handle mouse clicks, interaction with keyboard etc.

*/

void mouse(int button, int state, int x, int y)
{
    switch (button)
    {
        case GLUT_LEFT_BUTTON:
            {
                if(state == GLUT_UP)
                {
                    if (_precurve != nullptr && _curve != nullptr) {
                        preimage.push_back(_precurve);
                        image.push_back(_curve);
                        _precurve = nullptr;
                        _curve = nullptr;
                        if (begin)  {
                            delete begin;
                            begin = 0;
                        }
                    }
                }
                else
                {
                    textEditOnCanvas.inside(x,y);
                }
            break;
        }

        case GLUT_RIGHT_BUTTON:
            {
                if(state == GLUT_UP) {
                }
                else {
                }
            break;
        }

        case 3: // SCROLLING DOWN
            {
                if(state == GLUT_UP) {
                    if (MODE == MODE_ELLIPSE && _precurve != nullptr) {
                        _precurve->resize(1.2);
                    }
                    else {
                        scale=scale*1.2;
                    }
                }
            break;
        }

        case 4: // SCROLLING UP
            {
                if(state == GLUT_UP) {
                    if (MODE == MODE_ELLIPSE && _precurve != nullptr) {
                        _precurve->resize(1/(1.2));
                    }
                    else {
                        scale=scale/1.2;
                    }
                }
            break;
        }
    }
}

void init() {
    hlines.clear();
    vlines.clear();
    haxe.clear();
    vaxe.clear();
    hlinesMap.clear();
    vlinesMap.clear();
    haxeMap.clear();
    vaxeMap.clear();
    /*
        The code below fills with contents the following variables:

        hlines
        vlines
        haxe
        vaxe
        haxeMap
        vaxeMap

        Amount of points in every line of the graph depends on the RESOLUTION
    */

    for (int r = 0; r <= RESOLUTION; r++) {
        std::vector<complex> temph;
        std::vector<complex> tempv;
        for (int c = 0; c <= RESOLUTION; c++) {
            temph.push_back(complex(((double)r/(double)RESOLUTION-0.5)*2, ((double)c/(double)RESOLUTION-0.5)*2));
        }
        for (int c = 0; c <= RESOLUTION; c++) {
            tempv.push_back(complex(((double)c/(double)RESOLUTION-0.5)*2, ((double)r/(double)RESOLUTION-0.5)*2));
        }
        hlines.push_back(temph);
        vlines.push_back(tempv);

        haxe.push_back(complex(((double)r/(double)RESOLUTION-0.5)*2, 0, 1-(double)r/(double)RESOLUTION, (double)r/(double)RESOLUTION, 0));
        vaxe.push_back(complex(0, ((double)r/(double)RESOLUTION-0.5)*2, (double)r/(double)RESOLUTION-0.2, (double)r/(double)RESOLUTION-0.2, 1-(double)r/(double)RESOLUTION));

        haxeMap.push_back(func(haxe[haxe.size()-1]));
        vaxeMap.push_back(func(vaxe[vaxe.size()-1]));
    }

    /*
        hlinesMap
        vlinesMap
    */

    for (int i = 0; i < hlines.size(); i++) {
        std::vector<complex> temp;
        for (int k = 0; k < hlines[i].size(); k++) {
            temp.push_back(func(hlines[i][k]));
        }
        hlinesMap.push_back(temp);
    }

    for (int i = 0; i < vlines.size(); i++) {
        std::vector<complex> temp;
        for (int k = 0; k < vlines[i].size(); k++) {
            temp.push_back(func(vlines[i][k]));
        }
        vlinesMap.push_back(temp);
    }

    /*

    Re-filling the vector with mapped curves

    */

    image.clear();
    for (int i = 0; i < preimage.size(); i++) {
        curve * tc = new curve();
        (*tc) = (*f)(*(preimage[i]));
        image.push_back(tc);
    }
}

void keyboard(unsigned char key, int x, int y) {
    if (textEditOnCanvas.issetcursor()) {
        textEditOnCanvas.keyboard(key);
        function * tf = nullptr;
        try {
            tf = parser(textEditOnCanvas.gettext());
        }
        catch (const char * e) {
            std::cout << "Error: " << e << std::endl;
        }
        catch (const std::out_of_range& e) {
            //std::cout << "Error: " << e << std::endl;
        }
        catch (const std::invalid_argument& e) {
            //std::cout << "Error: " << e << std::endl;
        }
        if (tf == nullptr) std::cout << "No function has been generated." << std::endl;
        else {
            f = tf;
            init();
        }
    }
    if (glutGetModifiers() == GLUT_ACTIVE_SHIFT) {
        shift = true;
    }
    else {
        shift = false;
    }
    if ((glutGetModifiers() == GLUT_ACTIVE_CTRL) && (key+96 == 'z')) {
        if ((_precurve == nullptr) && !(preimage.empty())) {
            preimage.pop_back();
            image.pop_back();
        }
        else {
            delete _precurve;
            _precurve = nullptr;

            delete _curve;
            _curve = nullptr;
        }
    }
    if (key == ' ') {
        spacePressed=true;
    }                       // REFACTOR TO SWITCH
    else if (key <= '9' && key >= '0') {
        MODE = key-'0';
    }
}


void special(int key, int x, int y) {
    textEditOnCanvas.special(key);
    if (key == 112 || key == 113) {
        shift = true;
    }
    else {
        shift = false;
    }
}


void mouseMoving(int x, int y) {
    double _x = (double)x;
    double _y = windowHeight-(double)y;
    double re;
    double im;

    re = (double)(x-(xCanvas+dx*scale*wCanvas/2+wCanvas/2))/(double)(scale*wCanvas/2);
    im = (double)(_y-(yCanvas+dy*scale*hCanvas/2+hCanvas/2))/(double)(scale*hCanvas/2);
    complex c(re, im);
    complex temp = func(c);
    if (_precurve!=nullptr || begin != 0) {
        if (shift) {
            _precurve->resize(c);
            _curve->resize(_precurve->getVertices(),func);
        }
        
        else {
            _precurve->resize(c);
            _curve->resize(_precurve->getVertices(),func);
        }
    }
    else {
        switch (MODE) {
            case MODE_CURVE : {
                _precurve = new curve(c);
                _curve = new curve(temp);
                break;
            }
            case MODE_LINE : {
                _precurve = new line(c);
                _curve = new curve(temp);
                break;
            }
            case MODE_ELLIPSE : {
                _precurve = new ellipse(c);
                _curve = new curve(temp);
                break;
            }
            default: {
                break;
            }
        }
    }
}

void mousePassive(int x, int y) {
    if (spacePressed) {
        dx+=(double)(x-prevX)*2/(scale*wCanvas);
        dy+=(double)(prevY-y)*2/(scale*hCanvas);
    }
    prevX = x;
    prevY = y;
}

void keyboardUp(unsigned char key, int x, int y) {
    if (key == ' ') {
        spacePressed=false;
        prevX = x;
        prevY = y;
    }
}

void specialUp(int key, int x, int y) {
        if (key == 112 || key == 113) {
            shift = false;
        }
}



int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(windowWidth, windowHeight);
    glutInitWindowPosition(200, 200);
    glutCreateWindow("Complex Maps");
    initRendering();

    glutDisplayFunc(draw);
    glutReshapeFunc(handleResize);
    glutSpecialFunc(special);
    glutTimerFunc(25, update, 0);
    glutMouseFunc(mouse);
    glutKeyboardFunc(keyboard);
    glutKeyboardUpFunc(keyboardUp);
    glutSpecialUpFunc(specialUp);
    glutMotionFunc(mouseMoving);
    glutPassiveMotionFunc(mousePassive);

    std::string expression = "exp(x)";
    if (argc>1) {
        expression=argv[1];
    }
    try {
        f = parser(expression);
    }
    catch (const char * e) {
        std::cout << "Error: " << e << std::endl;
    }
    catch (const std::out_of_range& e) {
        //std::cout << "Error: " << e << std::endl;
    }
    catch (const std::invalid_argument& e) {
        //std::cout << "Error: " << e << std::endl;
    }
    f->out("");
    init();

    glutMainLoop();
    return 0;
}