Ayuda con mi programa

resulta q hice un programa en codeblocks ...esta fucional todo ..pero por mas q trato no puedo hacerlo con listas de visualizacion (glnewlist)
por fa ayuda
acxa les dejo el codigo



#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#include <iostream>
#endif
#include<conio.h>
#include<stdio.h>
#include<math.h>
#include<iostream>
#include <stdlib.h>
#define NUM_PUNTOS 200
#define NUM_EXTREMOS 200
#include <GL/glut.h>
#include <iostream>
#include<math.h>
#include<stdio.h>
#include <stdlib.h>
#define max 70000000


using namespace std;


int comparar(int x, int y);

void dda(float x0,float y0,float x1,float y1);
void init(void);
void hermite(void);
void dibujar_puntos(void);
void dibujar_rectas(void);
int dim=600;


float P_Control[NUM_PUNTOS][2];
float P_Extremo[NUM_EXTREMOS][2];

int num_punto=0,inc=50;



int activ_add_point=0;
int activ_ver_recta=0;
int activ_mov_point=0;
int activ_curve=0;


int MOVENAME =-1;
int MOVEPOINT =-1;


void init(void)
{
     glutCreateWindow("Labo_1");
     glClearColor(1.0, 1.0, 1.0, 0.0);
     glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
     gluOrtho2D(0.0, dim, 0.0, dim);

}

static void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3d(1,0,0);

glPushMatrix();

        dibujar_puntos();
        dibujar_rectas();

        if(activ_curve==1){
            hermite();
        }

glPopMatrix();

glutSwapBuffers();
}



void ControlRaton( int button, int state, int x, int y ){

     if(activ_add_point==1 && num_punto != 2){

            if (button==GLUT_LEFT_BUTTON && state==GLUT_DOWN ){


                P_Control[num_punto][0]=x;
                P_Control[num_punto][1]=dim-y;
                P_Extremo[num_punto][0]=x+inc;
                P_Extremo[num_punto][1]=dim-y+inc;

                cout<<x<<"     "<<dim-y<<endl;

                num_punto++;
            }


     }
     else{
         if(activ_mov_point==1){
            if (button==GLUT_LEFT_BUTTON && state==GLUT_DOWN ){

                int newX=x;
                int newY=dim-y;

                int choiceFound = 0;


                for (int i = 0; i < num_punto && !choiceFound; i++){

                    if ((abs(P_Control[i][0] - newX) <= 20) &&
                        (abs(P_Control[i][1] - newY) <= 20)){

                        MOVEPOINT = i;
                        choiceFound = 1;

                    }
                }

            }

            if (button == GLUT_LEFT_BUTTON && state == GLUT_UP) {

                MOVEPOINT = -1;
            }


         }
         else{
                if (button==GLUT_LEFT_BUTTON && state==GLUT_DOWN ){
                int newX=x;
                int newY=dim-y;

                int choiceFound = 0;


                for (int i = 0; i < num_punto && !choiceFound; i++){

                    if ((abs(P_Extremo[i][0] - newX) <= 50) &&
                        (abs(P_Extremo[i][1] - newY) <= 50)){

                        MOVENAME = i;
                        choiceFound = 1;

                    }
                }

            }

            if (button == GLUT_LEFT_BUTTON && state == GLUT_UP) {

                MOVENAME = -1;
            }
        }
     }
    glutPostRedisplay();

}


void myMouseMove(int x, int y)
{
if (MOVENAME > -1 && activ_ver_recta==1)
{
int newX = x;
int newY = dim- y;

P_Extremo[MOVENAME][0] = newX;
P_Extremo[MOVENAME][1] = newY;

glutPostRedisplay();
}

if (MOVEPOINT > -1 && activ_mov_point==1)
{
int newX = x;
int newY = dim- y;

P_Control[MOVEPOINT][0] = newX;
P_Control[MOVEPOINT][1] = newY;

glutPostRedisplay();
}
}



void dibujar_puntos(void){

glColor3d(1,0,0);

        for(int i=0;i<num_punto;i++){

           glPointSize(10);
           glBegin(GL_POINTS);

                glVertex2f(P_Control[i][0],P_Control[i][1]);

           glEnd();

      }

}

void dibujar_rectas(void){

     if(activ_ver_recta==1){
        for(int i=0;i<num_punto;i++){

            dda(P_Control[i][0],P_Control[i][1],P_Extremo[i][0],P_Extremo[i][1]);
        }
     }
}

void hermite()
{


glLineWidth(4.0);

glColor3f(1,1,0);

float fu[4];

glBegin(GL_LINE_STRIP);

for (float uInt = 0; uInt <= 1; uInt+=0.01)
{
float u = uInt;
float u2 = u*u;
float u3 = u2*u;


fu[0] = 2.0*u3 - 3.0*u2 + 1.0;
fu[1] = -2.0*u3 + 3.0*u2;
fu[2] = u3 - 2.0*u2 + u;
fu[3] = u3 - u2;

float x = 0.0;
float y = 0.0;

// p0 = P_Control[0]
x += fu[0]*P_Control[0][0];
y += fu[0]*P_Control[0][1];

// p1 = P_Control[1]
x += fu[1]*P_Control[1][0];
y += fu[1]*P_Control[1][1];

   //  tangent at p0 = ctrlPoints[1]-ctrlPoints[0]
x += fu[2]*(P_Extremo[0][0]-P_Control[0][0]);
y += fu[2]*(P_Extremo[0][1]-P_Control[0][1]);

//  tangent at p1 = ctrlPoints[3]-ctrlPoints[2]
x += fu[3]*(P_Extremo[1][0]-P_Control[1][0]);
y += fu[3]*(P_Extremo[1][1]-P_Control[1][1]);

glVertex2i(x,y);
}

glEnd();
    glFlush();
}

void dda(float x0,float y0,float x1,float y1){

    glColor3d(1,0,0);
    glBegin(GL_LINES);

        glVertex2f(x0,y0);
        glVertex2f(x1,y1);

    glEnd();

}




static void idle(void)
{
    glutPostRedisplay();
}

void menu_principal(int opcion){

   switch(opcion){

        case 4:
             exit(-1);
             break;
   }
}
void menu_puntos(int opcion){

   switch(opcion){
   }
}

void menu_mod_puntos(int opcion){

   switch(opcion){

     case 1:
          activ_mov_point=1;
          activ_add_point=0;
          break;
     case 2:
          activ_mov_point=0;
          break;
   }
}

void menu_add_puntos(int opcion){

     switch(opcion){
         case 1:
              if(num_punto!=2){
                 activ_add_point=1;
              }

              break;

         case 2:
              activ_add_point=0;
              break;
     }
}

void menu_recta(int opcion){

     switch(opcion){
         case 1:
              activ_ver_recta=1;
              activ_mov_point=0;
              break;

         case 2:
              activ_ver_recta=0;
              break;
     }

}
void menu_curva(int opcion){

     switch(opcion){
         case 1:
              if(num_punto==2){
                activ_curve=1;
              }
              break;

         case 2:
              activ_curve=0;
              break;
     }
}
int main(int argc, char *argv[])
{
    glutInit(&argc, argv);
    glutInitWindowSize(dim,dim);
    glutInitWindowPosition(100,100);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);


    init();
    int submenu_curva = glutCreateMenu(menu_curva);
        glutAddMenuEntry("Activar",1);
        glutAddMenuEntry("Desactivar",2);
    int submenu_rectas = glutCreateMenu(menu_recta);
        glutAddMenuEntry("Activar",1);
        glutAddMenuEntry("Desactivar",2);

    int submenu_add = glutCreateMenu(menu_add_puntos);
        glutAddMenuEntry("Activar",1);
        glutAddMenuEntry("Desactivar",2);
    int submenu_mod = glutCreateMenu(menu_mod_puntos);
        glutAddMenuEntry("Activar",1);
        glutAddMenuEntry("Desactivar",2);
    int submenu_puntos = glutCreateMenu(menu_puntos);
        glutAddSubMenu("Ingreso de puntos ",submenu_add);
        glutAddSubMenu("Modificar posicion",submenu_mod);
    int menu = glutCreateMenu(menu_principal);
        glutAddSubMenu("Puntos de control",submenu_puntos);
        glutAddSubMenu("Rectas tangentes ",submenu_rectas);
        glutAddSubMenu("Curva de Hermite ",submenu_curva);
        glutAddMenuEntry("salir",4);


    glutAttachMenu(GLUT_RIGHT_BUTTON);


    glutDisplayFunc(display);
    glutIdleFunc(idle);
    glClearColor(1,1,1,1);
    glutMouseFunc(ControlRaton);
    glutMotionFunc(myMouseMove);

    glutMainLoop();

    return 0;
}