//plotter.cpp, 5/25/1998
//modified from 
//graph.cpp
//Oguz Yetkin, 5/20/1998
//
//opengl graphics kludge for physics neural network project

#ifdef WIN

#include<iostream.h>
#include<stdio.h>
#include<assert.h>
#include<process.h>

#include "plotter.h"

static Plotter* pl;



void Launch(void* Me){

		int dummyargc=1;
	char** dummyargv=new char*[1];
	dummyargv[0]=new char[20];
	strcpy(dummyargv[0], "application");
	
	
	printf("\nMe: %x pl: %x",Me, pl);
	assert(Me==pl);
	((Plotter*)Me)->MyMain(dummyargc, dummyargv); ///will invoke glutMainLoop() which never returns
	//********!!!! all subsequent communication 
	//********!!!! with outside work happens via display_mutex
	//********!!!! controlled variables 
	

	//point of no return
}

void Display(){

	int count;
	static int firstrun=1;
	if(firstrun){
		glClear(GL_COLOR_BUFFER_BIT); /*clear the window*/
		firstrun=0;
	
	}
	//acquire the mutex
	//cout<<"\ndisplay waiting for run mutex!"<<endl;
	//WaitForSingleObject(pl->run_mutex, INFINITE);
	//cout<<"\ndisplay acquired run mutex!"<<endl;

 while(1){	//crude
	//cout<<"\ndisplay waiting for display mutex!"<<endl;
	WaitForSingleObject(pl->display_mutex, INFINITE);
	//WaitForSingleObject(pl->display_mutex, INFINITE);
	//cout<<"\ndisplay now has display mutex!"<<endl;	//am I inviting deadlock?
	
	//if(!pl->displayed){
	

	//long random();	/*standard random number gen */
	/* point2 p={75.0,50.0}; */	/* random point */
		
		//we only want to do this once!  It's commented out!
		//glClear(GL_COLOR_BUFFER_BIT); /*clear the window*/



		// plot point 
	

	
		if(!pl->displayed){
		
			glBegin(GL_POINTS);
			//glBegin(GL_POLYGON);
		
		
			glVertex2f(pl->x_location, pl->y_location);
		
			glEnd();
		
			pl->displayed=1;
	
		
			printf("\ndisplayed: %f %f",pl->x_location, pl->y_location);


		
			glFlush();
			//glutPostRedisplay();
		}
	
	
	
	
		ReleaseMutex(pl->run_mutex);
		ReleaseMutex(pl->display_mutex);
		Sleep(0);//give up thread time!
		
 }//end while


}

//encapsulate former main into Plotter class,
//add public variables 
//int displayed, 
//float x_location, y_location,
//HANDLE display_mutex

	
//	void myinit(void);
//void display(void);



Plotter::Plotter(int _maxx, int _maxy){
	maxx=_maxx;
	maxy=_maxy;
	maxz=500;	//for now
	displayed=1;	//initially we have nothing to display
	//clear mutex
	//display_mutex=CreateMutex(NULL, FALSE, NULL);	//clear
	//displayed_mutex=CreateMutex(NULL, TRUE, NULL); //set

	display_mutex=CreateMutex(NULL, FALSE, NULL);	//cleared
	run_mutex=CreateMutex(NULL, TRUE, NULL);	//set
	::pl=this;	//this is the kludgiest thing I've ever done, I hope it works
	thread_num=_beginthread(Launch, 0, (void*)this);
	//cout<<"\n***THREAD LAUNCHED"<<endl;
}




Plotter::~Plotter(){



}






//this will invoke glutMainLoop() through MyMain, and
//will constitute the body of main itself.  The 
//display() callback given to glut will be playing with
//display_mutex and plotting whatever needs to be plotted
/* 
void __cdecl Plotter::Launch(void* args){

		int dummyargc=1;
	char** dummyargv=new char*[1];
	dummyargv[0]=new char[20];
	strcpy(dummyargv[0], "application");
	
	MyMain(dummyargc, dummyargv); ///will invoke glutMainLoop() which never returns
	//********!!!! all subsequent communication 
	//********!!!! with outside work happens via display_mutex
	//********!!!! controlled variables 
	
	//point of no return
}
*/
const int WIDTH=500;
//used to be main
int Plotter::MyMain(int argc, char** argv){

		//void myinit(), display();

		glutInit(&argc, argv);
		glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
		glutInitWindowSize(maxx,maxy);
		//glutInitWindowSize(WIDTH, (int)WIDTH*(maxy/(float)WIDTH));
		glutInitWindowPosition(0,0);
		glutCreateWindow("Plotter Window");
		glutDisplayFunc(Display);
		myinit();
		glutMainLoop();


		return 0;	//will never happen

}


void Plotter::myinit(void){

	/* attributes */
	glClearColor(0.0, 0.0, 1.0, 0-.0);	/* white bkg */
	glColor3f(1.0, 0.0, 0.0);	/* draw in red */
	//glClearColor(0,0,0,0);//black bkg
	//glColor3f(0.0, 1.0, 1.0);	//draw in yellow

	/* set up viewing */
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	/* gluOrtho2D(0.0, 500.0, 0.0, 500.0); */
	//glOrtho(-500.0,500.0,-500.0,500.0,-500.0,500.0);
	//glOrtho(-(float)maxx,(float)maxx,-(float)maxy,(float)maxy,-(float)maxz,(float)maxz);
	gluOrtho2D(-(float)maxx, (float)maxx, -float(maxy), (float)maxy);
	glMatrixMode(GL_MODELVIEW);


}

//updates necessary variables so that display can 
//update the display when it gets the chance
void Plotter::plotpixel(float x, float y){
	//get a hold of the mutex
	//cout<<"\nplotpixel waiting for run mutex..."<<endl;

	//WaitForSingleObject(run_mutex, INFINITE);
	//cout<<"\nplotpixel has run mutex!"<<endl;
	Sleep(0);
	//cout<<"\nplotpixel waiting for display mutex..."<<endl;
	WaitForSingleObject(display_mutex, INFINITE);
begin:
	//cout<<"\nplotpixel has display mutex!"<<endl;
	
	//cout<<"\nsanity check, reacquiring mutex!"<<endl;
	//WaitForSingleObject(display_mutex, INFINITE);
	//cout<<"\n**********WE SHOULD NEVER SEE THIS!!"<<endl;

	//displayed=0;	//probably not releveant
	if(displayed==1){
		x_location=x;
		y_location=y;
		displayed=0;
	}else{
		
		
		//WaitForSingleObject(display_mutex, INFINITE);
		//ReleaseMutex(display_mutex);
		//glutPostRedisplay();	
		Sleep(0);	//give up thread time
		//goto begin;	//Display has to get called somewhere along the way
	}
	//now display() can do whatever it wants
	//ReleaseMutex(run_mutex);	//allow display function to run
	//cout<<"\nplotpixel released the run mutex!"<<endl;
	//SignalObjectAndWait(run_mutex, display_mutex, INFINITE, FALSE);
	Sleep(0);
	//ReleaseMutex(run_mutex);	//yea!  The ProducerConsumer problem in action!!!
	//display_mutex will be released AFTER a display
	//cout<<"\nplotpixel released the run mutex!"<<endl;
	ReleaseMutex(display_mutex);
	//glutPostRedisplay();
	WaitForSingleObject(run_mutex, INFINITE);
	//WaitForSingleObject(display_mutex, INFINITE);
	//WaitForSingleObject(run_mutex, INFINITE);

}

//will eventually play with the mutex display_mutex
void Plotter::display(void){
	cout<<"\ndon't call this function! call global version instead!"<<endl;
}


#endif