#ifdef WIN32
#include "windows.h"
#include "windowsx.h"
#endif
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

// max vertices in polygon
#define MAX_VERTICES 100

#define WINDOW_WIDTH 512
#define WINDOW_HEIGHT 384
#define WINDOW_ORIG_X 256
#define WINDOW_ORIG_Y 192

// point structure definition
typedef struct
{
   GLint x;
   GLint y;
} GLintPoint;

// globals
GLboolean g_bDragging;
GLboolean g_bPolyComplete;
GLintPoint g_aVertices[MAX_VERTICES];
GLint g_nVertices = 0;
GLintPoint g_LastLine[2];

// function prototypes
int main(int argc, char** argv);
void Init(void);
void OnDisplay(void);
void OnReshape(int w, int h);
void OnMouseClick(int button, int state, int x, int y);
void OnMouseMove(int x, int y);

int main(int argc, char** argv)
{
   // initialize the display
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
   glutInitWindowSize (WINDOW_WIDTH, WINDOW_HEIGHT); 
   glutInitWindowPosition (WINDOW_ORIG_X, WINDOW_ORIG_Y);
   glutCreateWindow (argv[0]);

   // user-specific initialization
   Init();

   // register callbacks
   glutDisplayFunc(OnDisplay); 
   glutReshapeFunc(OnReshape); 
   glutMouseFunc(OnMouseClick);
   glutMotionFunc(OnMouseMove);

   // start the main event loop
   glutMainLoop();

   return 0;
}

// Init().  User-specific initialization.
void Init(void)
{
   glClearColor (1.0, 1.0, 1.0, 1.0);
   glPointSize(5.0);
   glLogicOp(GL_XOR);
   g_nVertices = 0;
   g_bDragging = false;
   g_bPolyComplete = true;
}

// The OnDisplay() callback is invoked in response to an expose or a resize event.
void OnDisplay(void)
{
   glClear(GL_COLOR_BUFFER_BIT);

   // redraw the polygon if necessary //////////////////////////////////////////
   if (g_nVertices != 0)
   {  
      int i;

      // draw the polygon vertices in black
      glColor3f(0.0, 0.0, 0.0);
      glBegin(GL_POINTS);
         for (i=0; i<g_nVertices; i++)
         {
            glVertex2i(g_aVertices[i].x, g_aVertices[i].y);
         }
      glEnd();

      if (g_bPolyComplete)
      {
         // draw the polygon sides in black
         glBegin(GL_LINE_LOOP);
         for (i=0; i<g_nVertices; i++)
         {
            glVertex2i(g_aVertices[i].x, g_aVertices[i].y);
         }
         glEnd();

         // draw the filled polygon in red
         glColor3f(1.0, 0.0, 0.0);
         glBegin(GL_POLYGON);
         for (i=0; i<g_nVertices; i++)
         {
            glVertex2i(g_aVertices[i].x, g_aVertices[i].y);
         }
         glEnd();
      }
      else
      {
         // draw the polygon sides in black
         glBegin(GL_LINE_STRIP);
         for (i=0; i<g_nVertices; i++)
         {
            glVertex2i(g_aVertices[i].x, g_aVertices[i].y);
         }
         glEnd();
      }
   }
   // end of polygon redraw ////////////////////////////////////////////////////
   
   glFlush();
}   

// The OnReshape() callback is invoked when the user changes the window size.
void OnReshape(int w, int h)
{
   // update the projection information
   glViewport (0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   glOrtho(0, WINDOW_WIDTH, 0, WINDOW_HEIGHT, -1.0, 1.0);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();

   // redraw (a redisplay will be posted automatically, but calling
   // OnDisplay() directly gives is smoother in single buffer mode)
   glutPostRedisplay();
}

// The OnMouseClick() callback is invoked when one of the mouse buttons is clicked.
void OnMouseClick(int button, int state, int mouse_x, int mouse_y)
{
   int x = mouse_x;
   int y = WINDOW_HEIGHT - mouse_y;

   switch (button)
   {
      case GLUT_LEFT_BUTTON:
         if (state == GLUT_DOWN)
         {
            if (g_bPolyComplete)
            {
               // this block of code is reached if there is either no polygon
               // or a complete polygon on the screen
               g_bPolyComplete = false;
               g_nVertices = 0;
               glClear(GL_COLOR_BUFFER_BIT);

               // update the vertex array
               g_aVertices[g_nVertices].x = x;
               g_aVertices[g_nVertices].y = y;
               g_nVertices++;

               // draw the current point
               glColor3f(0.0, 0.0, 0.0);
               glBegin(GL_POINTS);
                  glVertex2i(x, y);
               glEnd();
               glFlush();
            }

            // draw the current line
            glColor3f(0.0, 0.0, 0.0);
            glBegin(GL_LINES);
               glVertex2i(g_aVertices[g_nVertices - 1].x, g_aVertices[g_nVertices - 1].y);
               glVertex2i(x, y);
            glEnd();
            glFlush();

            // store the last line
            g_LastLine[0].x = g_aVertices[g_nVertices - 1].x;
            g_LastLine[0].y = g_aVertices[g_nVertices - 1].y;
            g_LastLine[1].x = x;
            g_LastLine[1].y = y;

            g_bDragging = true;
         }
         else
         {
            // update the vertex array
            g_aVertices[g_nVertices].x = x;
            g_aVertices[g_nVertices].y = y;
            g_nVertices++;

            // draw the current point
            glColor3f(0.0, 0.0, 0.0);
            glBegin(GL_POINTS);
               glVertex2i(x, y);
            glEnd();
            glFlush();

            g_bDragging = false;
         }

         break;
      case GLUT_MIDDLE_BUTTON:
      case GLUT_RIGHT_BUTTON:
         if (state == GLUT_DOWN && g_nVertices > 2)
         {
            // connect the last and first vertices of the polygon
            glColor3f(0.0, 0.0, 0.0);
            glBegin(GL_LINES);
               glVertex2i(g_aVertices[g_nVertices - 1].x, g_aVertices[g_nVertices - 1].y);
               glVertex2i(g_aVertices[0].x, g_aVertices[0].y);
            glEnd();
            glFlush();

            // draw the complete polygon in red
            glColor3f(1.0, 0.0, 0.0);
            glBegin(GL_POLYGON);
               for (int i=0; i<g_nVertices; i++)
               {
                  glVertex2i(g_aVertices[i].x, g_aVertices[i].y);
               }
            glEnd();
            glFlush();

            g_bPolyComplete = true;
         }
         break;
      default:
         break;
   }
}

// The OnMouseMove() callback is invoked when the mouse is moved while
// one of the buttons depressed.
void OnMouseMove(int mouse_x, int mouse_y)
{
   if (g_bDragging)
   {
      int x = mouse_x;
      int y = WINDOW_HEIGHT - mouse_y;

      glColor3f(1.0, 1.0, 1.0);
      glEnable(GL_COLOR_LOGIC_OP);
      glBegin(GL_LINES);
         // redraw to erase the old line
         glVertex2i(g_LastLine[0].x, g_LastLine[0].y);
         glVertex2i(g_LastLine[1].x, g_LastLine[1].y);
         // draw the new line
         glVertex2i(g_LastLine[0].x, g_LastLine[0].y);
         glVertex2i(x, y);
      glEnd();
      glFlush();
      glDisable(GL_COLOR_LOGIC_OP);
   
      // update the last line
      g_LastLine[1].x = x;
      g_LastLine[1].y = y;
   }
}