#include "main.h"

unsigned int EventI = 0;

void Loading()
{
	char Buffer[1024];

	switch(mLoading_I)
	{	
		

	case 0:{ 				
			printf("\n");
			printf("######################################################################\n");
			printf("#                 http://projects.hepforge.org/frog/                 #\n");
			printf("#   Please have a look at the website for latest versions and news   #\n");
			printf("# Also register to the Frog mailing list if you are not a member yet #\n");			
			printf("######################################################################\n");
#ifndef FROG_LIGHTING
			printf("# FROG_LIGHTING is not defined --> Lighting effects will not be used #\n");			
			printf("# Modify the MakeFile to define it in order to have nicer pictures   #\n");			
			printf("######################################################################\n");
#endif
			printf("\n");

			start      = time ( NULL );

			
			// TURN Vertical Synchronisation (VSYNC) OFF
			// This allow the system to have more than 60 or 75FPS.
/*			
			#ifdef windows
				if(WGL_EXT_swap_control){wglSwapIntervalEXT(0);}else{printf("WGL_EXT_swap_control is NOT OK\n");}				
			#else
				if(GLX_SGI_swap_control){glXSwapIntervalSGI(0);}else{printf("GLX_SGI_swap_control is NOT OK\n");}				
			#endif	
*/			
			

			// Init the random number generator
			srand (time(NULL));
						
			Fonts      = new FROG_Fonts();			
			ViewScreen = new FROG_View_Screen("Screen");
			ViewScreen->Reshape(WINDOW_WIDTH,WINDOW_HEIGHT);
			sprintf(Buffer,"Reading %s",inputConfig.c_str());
			ViewScreen->LoadingInProgress(0.0f,Buffer,Fonts,LogoTexture);
		

			LoadCard(inputConfig.c_str());
			if(!Card->IsTagPresent("InputGeom") && !Card->IsTagPresent("InputVisFile")){
			   printf("There is no .geom file neither than .vis file in the Config card\n");
			   printf("FROG will stop.  Please update the Config card (%s)\n",inputConfig.c_str());
			   exit(0);
			}			
			
		   }break;				

		case 1:
			ViewScreen->LoadingInProgress(1.0f,"Downloading Geometry\n(if necessary)",Fonts,LogoTexture);
			
			if(Card->IsTagPresent("InputGeom")){
			   inputGeom = Card->GetStringVector("InputGeom");	   
			   for(unsigned int g=0;g<inputGeom.size();g++){
				   inputGeom[g] = string((char*)DownLoadFile( (char*)inputGeom[g].c_str(), AbsolutePath.c_str() ) );
			   }
			}						
			break;

		case 2:
			/*
			ViewScreen->LoadingInProgress(10.0f,"Downloading Events\n(if necessary)",Fonts,LogoTexture);			

			if(inputVisFileFromCard.length()<3 && Card->IsTagPresent("InputVisFile")){
				inputVisFileFromCard = Card->GetString("InputVisFile");			   	
			}
			inputVisFile = string((char*)DownLoadFile( (char*)inputVisFileFromCard.c_str(), AbsolutePath.c_str() ) );
			*/
			break;

		case 3:{
			ViewScreen->LoadingInProgress(20.0f,"Loading Geometry",Fonts,LogoTexture);
			if(geom)delete geom;
			geom = new FROG_Geometry();	
			if(inputGeom.size()<=0){printf("Error : No Input Geometry File\n");exit(0);}

			while(inputGeom.size()>0){
				ViewScreen->LoadingInProgress(20.f+30.f/inputGeom.size(),(char*)inputGeom[inputGeom.size()-1].c_str(),Fonts,LogoTexture);			
				geom->Load((char*)inputGeom[inputGeom.size()-1].c_str());
				inputGeom.pop_back();
			}			
			frogObjects_ = new FROG_Objects_Extended(geom,NULL,Card, Fonts);

			
			}break;

		case 4:{
			ViewScreen->LoadingInProgress(80.0f,"Loading .vis Files",Fonts,LogoTexture);

			if(events)delete events;
			events = new FROG_Events(frogObjects_);						
			events->Load(inputVisFileFromCommand);				
			events->readEventToDisplay(Card);
			if(SCREENSAVER)eventNumber = rand()%((int)events->NumberOfEvents());			
			event = events->GoToEvent(eventNumber);	
			}break;

		case 5:{			
			ViewScreen->LoadingInProgress(95.0f,"Views Initialisation",Fonts,LogoTexture);

			ViewScreen->displayFunc_ = displaytext;
			std::vector<string> ViewsName = Card->GetStringVector("ActiveViews");
			ViewMain = ViewScreen;						
			for(unsigned int i=0;i<ViewsName.size();i++){								
				char* tmp = new char[ViewsName[i].size()+1];				
				strcpy(tmp,ViewsName[i].c_str());				
				ActiveViews.push_back(FROG_VIEW::Create(tmp,frogObjects_));												
			}							
			ViewScreen->Reshape(WINDOW_WIDTH,WINDOW_HEIGHT);
			
			for(unsigned int j=0;j<ActiveViews.size();j++){
				if(ViewMain==ViewScreen && ActiveViews[j]->IsSwapPossible()){ViewMain = ActiveViews[j];}
				ActiveViews[j]->Reshape(WINDOW_WIDTH,WINDOW_HEIGHT);
				ActiveViews[j]->displayFunc_ = &display2;
			}				
			ViewMain->IsActive = true;			
			geom->updateGeomToDisplay((void*)frogObjects_);

			ViewMenu = new FROG_View_Menu("ViewMenu2",frogObjects_);
			ViewMenu->Reshape(WINDOW_WIDTH,WINDOW_HEIGHT);						
			}break;


		case 20:
			ViewScreen->LoadingInProgress(99.0f,"Preparation for Display",Fonts,LogoTexture);

			glEnable (GL_DEPTH_TEST);

			glFrontFace(GL_CCW);
			glEnable(GL_CULL_FACE);

			glEnable(GL_POINT_SMOOTH);
			glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
			//glHint(GL_POINT_SMOOTH_HINT, GL_FASTEST);

			glEnable(GL_LINE_SMOOTH);
			glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
			//glHint(GL_LINE_SMOOTH_HINT, GL_FASTEST);

			//glEnable(GL_POLYGON_SMOOTH);
			//glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);			

			glEnable(GL_BLEND) ;
			glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) ;		


			mLoading   = false;
			end = time ( NULL );
			printf("Loading Time = %isec\n",(int)(end-start));				

			glutDisplayFunc (display);
			glutIdleFunc    (display);

			glutKeyboardFunc (processNormalKeys);
			glutSpecialFunc  (processSpecialKeys);
		 
			glutMouseFunc(processMouse);
			glutMotionFunc(processMotion);
			if(SCREENSAVER){
				eventTime = 20;
				glutPassiveMotionFunc(processPassiveMotion);		
				glutFullScreen();
			}


			if(SHOOTER){
				mAutomaticShooter_LastEvent = events->Current_Event;
				do{
					frogObjects_->selectedObject_ = NULL;//mCLicked_DetId = (unsigned int) -1;				
					for(unsigned int j=0;j<ActiveViews.size();j++){ActiveViews[j]->MarkForUpdate();}		
					for(unsigned int i=0;i<4;i++)display();
					char temp[255]; sprintf(temp,"AutomaticShooter_%04i.%s",SCREENSHOT,SCREENSHOT_FORMAT);		
					SaveScreenshot(temp,WINDOW_WIDTH,WINDOW_HEIGHT, display);		
					SCREENSHOT++;
					event = events->NextEvent();
				}while(events->Current_Event!=mAutomaticShooter_LastEvent);
				exit(0);
			}

			return;
			break;

		default:
			break;
	}        

	mLoading_I++;
}

void reshape (int w, int h)
{
	if (h == 0)   h = 1;

	WINDOW_WIDTH  = w;
	WINDOW_HEIGHT = h;

	if(ViewScreen)ViewScreen->Reshape(WINDOW_WIDTH,WINDOW_HEIGHT);
	for(unsigned int j=0;j<ActiveViews.size();j++){
		ActiveViews[j]->Reshape(WINDOW_WIDTH,WINDOW_HEIGHT);
	}		
	if(ViewMenu)ViewMenu->Reshape(WINDOW_WIDTH,WINDOW_HEIGHT);
 
	glutPostRedisplay ();
}

void displaytext()
{	
	glColor4fv (Txt_Color);	
	Fonts->Font_Fixed_9_by_15->glPrint(WINDOW_WIDTH-126,WINDOW_HEIGHT - 30,"% 10i FPS", ViewScreen->FPS);
	if(mHelpScreen){		
		if(events) Fonts->Font_Fixed_9_by_15->glPrint(0,WINDOW_HEIGHT - 14,"CurrentFile = ...%s",events->CurrentFile());

		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 45	,"F1     = Open this Screen for Help");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 60	,"F2     = Open the Display Menu");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 75	,"F3     = use only for debug");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 90	,"F4     = Automatic ScreenShooter (Warning)");

		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 125	,"F5     = SimTrack       : ON/OFF");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 140	,"F6     = SimVertex      : ON/OFF");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 155	,"F7     = PSimHits       : ON/OFF");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 170	,"F8     = RecoTrack      : ON/OFF");

		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 205	,"F9     = SiStripCluster : ON/OFF");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 220	,"F10    = EcalHits       : ON/OFF");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 235	,"F11    = HcalHits       : ON/OFF");		
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 250	,"F12    = MuonHit/Seg    : ON/OFF");

		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 285	,"0      = Geometry to Display : NONE");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 300	,"9      = Geometry to Display : FULL");

		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 335	,"LEFT   = Previous Event");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 350	,"RIGHT  = Next     Event");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 375	,"UP     = Increase Rotation");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 390	,"DOWN   = Decrease Rotation");

		Fonts->Font_Fixed_9_by_15->glPrint(500,WINDOW_HEIGHT - 375	,"PAGE UP   = Previous VisFile");
		Fonts->Font_Fixed_9_by_15->glPrint(500,WINDOW_HEIGHT - 390	,"PAGE DOWN = Next     VisFile");

		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 425	,"p      = Zoom In");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 440	,"m      = Zoom Out");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 455	,"f      = Maximize the active view");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 470	,"s      = SlideShow      : ON/OFF");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 485	,"t      = TreeMenu       : ON/OFF");

		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 515   ,"ENTER  = Screenshot");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 530   ,"SPACE  = Rotation       : ON/OFF");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 545   ,"ESCAPE = Exit");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 560   ,"q      = Exit");
		Fonts->Font_Fixed_9_by_15->glPrint(150,WINDOW_HEIGHT - 575   ,"a      = Full Screen");
		
		Fonts->Font_Fixed_9_by_15->glPrint(120,3,"This program has been created by Loic Quertenmont, loic.quertenmont@cern.ch");		
	}else{
		Fonts->Font_Fixed_9_by_15->glPrint(WINDOW_WIDTH-153,WINDOW_HEIGHT - 14,"Press F1 for Help");				
		if(event) Fonts->Font_Fixed_9_by_15->glPrint(0,WINDOW_HEIGHT - 14,"#Run %i  #Event %i (%02i/%02i)",event->NRun_, event->NEvent_, events->Current_Event, (int)events->NumberOfEvents()-1);
		if(event) Fonts->Font_Fixed_9_by_15->glPrint(0,WINDOW_HEIGHT - 29,"%s", event->EventDate_);

		
		char temp[255];
		if(frogObjects_->selectedObject_){
			frogObjects_->selectedObject_->printInfos(temp);
			if(frogObjects_->IsSelected_Geometry())sprintf(temp,"%s : Press '1' or '2' or ... to Display the parent object",temp);
			Fonts->Font_Helvetica_10->glPrint(120,3,temp);
		}

	}

	ViewScreen->DrawLogo(0,0,120,80,LogoTxtTexture, Fonts);	
}

void displayForScreenShot()
{
	display2();	
	ViewMain->DisplayBkgGeom();
}

void display2()
{
	// Display the FrameWork
	if(ZAxis_Color[3]>0){
		glColor4fv (ZAxis_Color);
		glLineWidth(ZAxis_Thickness);
		glBegin (GL_LINES); 		
			glNormal3f(0,1,0);
			glVertex3f (0,0,-300); 
			glVertex3f (0,0,300); 
		glEnd(); 
		glLineWidth(1);
	}

	// Display the 3D Geometry (only if in a 3D View)	
	if(geom!=NULL){// && ViewMain->Type_==VIEW3D){		
		if(Geometry_WireFrame){
			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
		}else{
			glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
		}
		geom->display();		
	}	

	// Display the Event
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);	
	if(event!=NULL)	event->display();		
}

 
void display()
{   
	//-------- update event file if required ------------
    //updateEventsFile();

	glClearColor(BackGround_Color[0],BackGround_Color[1],BackGround_Color[2],1.0);
	glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	// Reset le buffer de couleur et de profondeur
	
	if(ViewMenu->AlphaFx<1){
		ViewMain->Display();
		if(!ViewMain->screen_flag){
			for(unsigned int j=0;j<ActiveViews.size();j++){
				if(ActiveViews[j]!=ViewMain && ActiveViews[j]->Type_!=VIEWMENU) ActiveViews[j]->Display();		
			}		
		}
		if(ViewScreen)	ViewScreen->Display();
	}	
	for(int j=ActiveViews.size()-1;j>=0;j--){		
		if(ActiveViews[j]->Type_==VIEWMENU){ActiveViews[j]->Display();}
	}
	ViewMenu->Display();
			
	glutSwapBuffers();

	SelectedObject_Counter++;
	if(SelectedObject_Counter>25){
		SelectedObject_Counter = 0;
		frogObjects_->selectedObject_DisplayFlag = !frogObjects_->selectedObject_DisplayFlag;
	}

	fflush(stdout);
}

void updateEventsFile() {
// this function lauch a threat to download the input event file
// if required by the variable updateVisFileTime

/*
#ifdef windows        
	if( updateVisFileTime>0 && !Thread_Run) {
		char* argtosend = (char*)inputVisFileFromCard.c_str();
		
		Thread_H = CreateThread( NULL, 0, WinDownLoadFile, (void*)argtosend, 0, &Thread_Id);
		if (Thread_H == NULL){
			printf("Unable to create thread\n");
			exit(1);
		}			   
		Thread_Run = true;
	}

	static time_t upstart = time (NULL );
	time_t upstop = time( NULL );
	if(upstop - upstart > updateVisFileTime && Thread_Run) {				
		if(WaitForSingleObject(Thread_H, 0) == WAIT_OBJECT_0){	
			Thread_Run=false;
			glutDisplayFunc (Loading);
			glutIdleFunc    (Loading);

			mLoading_I = 30;
			mLoading   = true;
			start = time ( NULL );
		}else{			
			// File is not yet fully downloaded
		}		
		upstart = time (NULL );
	}
#else
	if( updateVisFileTime>0 && !Thread_Run) {
		char* argtosend = (char*)inputVisFileFromCard.c_str();
		if (pthread_create (&Thread_H, NULL, DownLoadFile, (void*)argtosend) < 0) {
		   printf("pthread_create error for Thread_H\n");
		   exit (1);
		}		
		Thread_Run=true;
	}

	static time_t upstart = time (NULL );
	time_t upstop = time( NULL );
	if(upstop - upstart > updateVisFileTime && Thread_Run) {
		(void)pthread_join (Thread_H, NULL);

		Thread_Run=false;
		glutDisplayFunc (Loading);
		glutIdleFunc    (Loading);

		mLoading_I = 30;
		mLoading   = true;
		start = time ( NULL );
	}

#endif
*/

}

void processNormalKeys(unsigned char key, int x, int y)
{
	int Mod = glutGetModifiers();	
	if(Mod==GLUT_ACTIVE_CTRL)key+=96;
	
	switch(key){
		case 'q':
		case 27 :
			exit(0);
			break;
		case 13 :{			
			char temp[255]; sprintf(temp,"%s%02i.%s",ScreenShotName,SCREENSHOT,SCREENSHOT_FORMAT);			
			SaveScreenshot(temp,WINDOW_WIDTH,WINDOW_HEIGHT, displayForScreenShot );			
			SCREENSHOT++;
			}break;
		case ' ':{			
			if(ViewMain->Type_==VIEW3D)	((FROG_View_3D*)ViewMain)->shouldRotate_ = ! ((FROG_View_3D*)ViewMain)->shouldRotate_;
			}break;			
		case 'p' :
			ViewMain->cam_->R*=0.95;			
			break;
		case 'm' :
			ViewMain->cam_->R*=1.05;			
			break;
		case 'r' :
        case 'R' :
            LoadCard(inputConfig.c_str());
/*			geom->updateGeomToDisplay(Card);
			events->prim->setDisplay(0);
			events->Init(frogObjects_);
            events->readEventToDisplay(Card);
*/
			event = events->GoToEvent(eventNumber);			

            break;
		case 'T' :	
		case 't' :	
			for(int j=ActiveViews.size()-1;j>=0;j--){		
				if(ActiveViews[j]->Type_==VIEWMENU){((FROG_View_Menu*)ActiveViews[j])->State =! ((FROG_View_Menu*)ActiveViews[j])->State;}
			}
			break;
		case 'F' :
		case 'f' :	
			ViewMain->FullScreen();
			break;
		case 'a':			
		case 'l':			
			if( (key=='l' && Mod == GLUT_ACTIVE_CTRL) || key=='a'){
				if(FULLSCREEN){
					glutReshapeWindow(SAVE_WINDOW_W, SAVE_WINDOW_H);
					glutPositionWindow(SAVE_WINDOW_X,SAVE_WINDOW_Y);
				}else{
					SAVE_WINDOW_W = glutGet(GLUT_WINDOW_WIDTH);
					SAVE_WINDOW_H = glutGet(GLUT_WINDOW_HEIGHT);
					SAVE_WINDOW_X = glutGet(GLUT_WINDOW_X);
					SAVE_WINDOW_Y = glutGet(GLUT_WINDOW_Y);
					glutFullScreen();
				}
				FULLSCREEN = !FULLSCREEN;
			}
			break;
		case 's':
			mEventChanging = !mEventChanging;
			break;
		case '0' :	geom->prim->setDisplay(0);			
			break;

		case '9' :	geom->prim->setDisplay(1);			
			break;

		case '1' :
		case '2' :
		case '3' :
		case '4' :
		case '5' :
		case '6' :
		case '7' :
		case '8' :
			if(frogObjects_->IsSelected_Geometry()){
				frogObjects_->selectedObject_->toogleParentDisplay(1,key-48);
				geom->prim->setDisplay(2);
			}
			break;
	}
	if(SCREENSAVER)exit(0);
}


void processSpecialKeys(int key, int x, int y) 
{
	if(ViewMenu->State){
		if(ViewMenu->processSpecialKeys(key,x,y))return;		
	}

	int Mod = glutGetModifiers();	
//	if(Mod==GLUT_ACTIVE_CTRL)key+=96;

	switch(key) {
		case GLUT_KEY_F1 : 
			mHelpScreen = !mHelpScreen;
			break;
		case GLUT_KEY_F2 : 
			ViewMenu->State = !ViewMenu->State;
			ViewMenu->Alpha = 1;
			break;

		case GLUT_KEY_F3 : 
			if(event)	event->SuperCleardisplayList();
			break;

		case GLUT_KEY_F4 : 
			mAutomaticShooter = !mAutomaticShooter;			
			if(mAutomaticShooter){
				AutomaticEventChanging(0);
				mAutomaticShooter_LastEvent = events->Current_Event;
			}
			break;			

		case GLUT_KEY_F5 :
				events->updateEventToDisplay(EVTID_SIMTRK);				
			break;
		case GLUT_KEY_F6 :
				events->updateEventToDisplay(EVTID_SIMVTX);				
			break;
		case GLUT_KEY_F7 :
				events->updateEventToDisplay(EVTID_SIMHIT);				
			break;
		case GLUT_KEY_F8 :
				events->updateEventToDisplay(EVTID_TRK);				
			break;
		case GLUT_KEY_F9 :
				events->updateEventToDisplay(EVTID_SISTRIPCLUSTER);
			break;
		case GLUT_KEY_F10 :
				events->updateEventToDisplay(EVTID_ECALHIT);				
			break;
		case GLUT_KEY_F11:
				events->updateEventToDisplay(EVTID_HCALHIT);				
			break;
		case GLUT_KEY_F12 : 				
				events->updateEventToDisplay(EVTID_MUONHIT);
				events->updateEventToDisplay(EVTID_MUONSEG);				
			break;
		case GLUT_KEY_RIGHT : 
			if(Mod==GLUT_ACTIVE_CTRL){
				ViewMain->cam_->Move(-5,0);
			}else{
				frogObjects_->selectedObject_ = NULL;				
				event = events->NextEvent();				
			}
			break;
		case GLUT_KEY_LEFT : 	
			if(Mod==GLUT_ACTIVE_CTRL){
				ViewMain->cam_->Move(5,0);
			}else{
				frogObjects_->selectedObject_ = NULL;
				event = events->PreviousEvent();
			}
			break;
		case GLUT_KEY_UP : 
			if(Mod==GLUT_ACTIVE_CTRL){
				ViewMain->cam_->Move(0,5);
			}else{				
				if(ViewMain->Type_==VIEW3D)	((FROG_View_3D*)ViewMain)->dphi_ += 0.005f;				
			}
			break;
		case GLUT_KEY_DOWN : 
			if(Mod==GLUT_ACTIVE_CTRL){
				ViewMain->cam_->Move(0,-5);
			}else{				
				if(ViewMain->Type_==VIEW3D)	((FROG_View_3D*)ViewMain)->dphi_ -= 0.005f;				
			}
			break;

		case GLUT_KEY_PAGE_UP : 
			events->NextFile();
			event = events->GoToEvent(0);
			break;
		case GLUT_KEY_PAGE_DOWN : 
			events->PreviousFile();
			event = events->GoToEvent(0);
			break;

		case GLUT_KEY_HOME :
			if(ViewMain->Type_==VIEW3D)	ViewMain->cam_->Reset();			
			break;
		case GLUT_KEY_END :			
			event = events->GoToEvent(-1);
			break;
	}
	if(SCREENSAVER)exit(0);
}

void processMouse(int button, int state, int x, int y)
{	
	if(ViewMenu->processMouse(button, state,x,y) ){
		events->keepEventToDisplay(NULL);
		events->keepOpenedMenu(NULL);
		return;	
	}

	for(int j=ActiveViews.size()-1;j>=0;j--){		
		if(ActiveViews[j]->Type_ == VIEWMENU && ActiveViews[j]->IsInViewPort(x,y)){			
			if( ((FROG_View_Menu*)ActiveViews[j])->processMouse(button, state,x,y)){
				events->keepEventToDisplay(NULL);
				events->keepOpenedMenu(NULL);
				return;			
			}
		}
	}

	int K = 0;	
	if(button == GLUT_LEFT_BUTTON){
		K = 0;
		if(state ==  GLUT_DOWN){
			int ClickedView = -1;			
			for(int j=ActiveViews.size()-1;j>=0;j--){	
				if(ActiveViews[j]!= ViewMain && ActiveViews[j]->IsInViewPort(x,y) && ActiveViews[j]->IsSwapPossible()){											
					ClickedView = j;
					break;
				}			
			}			
			if(ClickedView>=0){
				FROG_VIEW::Swap(ViewMain, ActiveViews[ClickedView]);				
				ViewMain->IsActive = false;
				ViewMain = ActiveViews[ClickedView];				
				ViewMain->IsActive = true;
			}else if(ViewMain->IsInViewPort(x,y)){
				gl_select(x,WINDOW_HEIGHT-y);				
			}
		}
	}else if(button == GLUT_MIDDLE_BUTTON ){
		K = 1;
	}else if(button == GLUT_RIGHT_BUTTON){
		K = 2;	
	}else{
	}
	
	bool old_state = MouseStates[K];
	if(state == GLUT_DOWN)	MouseStates[K] = true;
	if(state == GLUT_UP)	MouseStates[K] = false;

	if( old_state != MouseStates[K]) stateChanged=true;
	else stateChanged=false;
}

void processMotion(int x, int y) {
	static int xold=x, yold=y;
	if( stateChanged ) { xold=x; yold=y; stateChanged=false;  return; }

	if(MouseStates[2]){
		if(ViewMain->Is3D()){
			ViewMain->cam_->phi   = ViewMain->cam_->phi   + 10.0*((float)(xold-x)/(float)ViewMain->cam_->R);
			ViewMain->cam_->theta = ViewMain->cam_->theta + 10.0*((float)(yold-y)/(float)ViewMain->cam_->R);			
		}else if(ViewMain->Is2D()){
			ViewMain->cam_->Move((x-xold),(y-yold));			
		}
		xold=x; yold=y;
	}else if(MouseStates[1]){		
		if(yold-y>0){			
			ViewMain->cam_->R*=0.98;
		}else{
			ViewMain->cam_->R*=1.02;	
		}
	}
}

void processPassiveMotion(int x, int y)
{
	static int xold=x;
	static int yold=y;
	if(SCREENSAVER && (abs(x-xold)>3 || abs(y-yold)>3) )exit(0);
}

 void gl_select(int x, int y)
 {
	ViewMain->Display_Begin();

	GLuint buff[1024] = {0};
	GLint hits, view[4];

	glSelectBuffer(1024, buff);
	glGetIntegerv(GL_VIEWPORT, view);
	glRenderMode(GL_SELECT);
	glInitNames();
	glPushName(0);

 	glMatrixMode(GL_PROJECTION);
 	glPushMatrix();
 		glLoadIdentity();
		gluPickMatrix(x-4, y-4, 8.0, 8.0, view); 		        
		ViewMain->ProjectionMatrix();
 		glMatrixMode(GL_MODELVIEW);
 		glutSwapBuffers();
		ViewMain->Display_Core();
 		glMatrixMode(GL_PROJECTION);
 	glPopMatrix();

 	hits = glRenderMode(GL_RENDER);
 	list_hits(hits, buff);
 	glMatrixMode(GL_MODELVIEW);
 }
void list_hits(GLint hits, GLuint *names)
 {
 	unsigned int i; 
//	names[i * 4 + 0] = 1	names[i * 4 + 1] = MinZ
//	names[i * 4 + 3] = Name names[i * 4 + 2] = MaxZ

	//get Min in Z;
//	unsigned int MinZ = (unsigned int)-1;	
//	unsigned int NearestHit = 0;
//	for (i = 0; i < hits; i++){		
//		if( names[i*4+1]<MinZ ){MinZ=names[i*4+1]; NearestHit = i;}		
//	}

	if(hits==0)return;
	unsigned int NearestHit = rand()%hits;

	for (i = 0; (int)i < hits; i++) {
		unsigned int tmp = names[i * 4 + 3];
		//printf("--> %i/%i > %i\n",i,hits,tmp);		
		if(i == NearestHit && tmp!=0){				
			if(tmp>1000000){
				frogObjects_->selectedObject_ = dynamic_cast<FROG_Element_Base_With_DetId*>(geom->FindByDetId(tmp));
			}else if(event && tmp<event->name_map.size()){		
				frogObjects_->selectedObject_ = event->name_map[tmp];		
			}
		}
	}
 }

void LoadCard(const char* inputCard ){
	if(Card)delete Card;
	Card = new FROG_ReadCards(AbsolutePath.c_str(),inputCard);
		
	Card->GetInt  (&updateVisFileTime   , "updateVisFileTime");	

	Card->GetInt  (&eventNumber         , "Event_Number");	
	Card->GetInt  (&eventTime           , "Event_Time");		
	if(eventTime>=0)glutTimerFunc(1+eventTime*1000,AutomaticEventChanging, 0);

	Card->GetChar (SCREENSHOT_FORMAT,256, "Screenshot_Format");
	Card->GetChar (ScreenShotName,1024  , "Screenshot_Name");

	Card->GetColor(BackGround_Color     , "BackGround_Color");
	Card->GetColor(Txt_Color            , "Txt_Color");
	Card->GetColor(Framework_Color      , "Framework_Color");
	Card->GetFloat(&Framework_Thickness , "Framework_Thickness");
	Card->GetColor(ZAxis_Color          , "ZAxis_Color");
	Card->GetFloat(&ZAxis_Thickness     , "ZAxis_Thickness");    

	Geometry_WireFrame = Card->GetBool(Geometry_WireFrame,"Geometry_WireFrame");
}


void AutomaticEventChanging (int Extra)
{	
	if(mLoading || (!mAutomaticShooter && (ViewMenu->State || !mEventChanging))){glutTimerFunc(1+eventTime*1000,AutomaticEventChanging, 0);return;}

	frogObjects_->selectedObject_ = NULL;
	if(mAutomaticShooter){
		for(unsigned int j=0;j<ActiveViews.size();j++){
			ActiveViews[j]->MarkForUpdate();		
		}		
		display();
		display();
		char temp[255]; sprintf(temp,"AutomaticShooter_%04i.%s",SCREENSHOT,SCREENSHOT_FORMAT);		
		SaveScreenshot(temp,WINDOW_WIDTH,WINDOW_HEIGHT, display);		
		SCREENSHOT++;
	}

	if(!mLoading && events){
		if(event && eventNumber>=0){event = events->NextEvent();	
		}else if(eventNumber<0    ){event = events->GoToEvent(-1);}
	}
	if(!mAutomaticShooter){				
		if(eventTime>=0)glutTimerFunc(1+eventTime*1000,AutomaticEventChanging, 0);	
	}else{		
		if(mAutomaticShooter_LastEvent == events->Current_Event){
			mAutomaticShooter = false;			
		}else{
			glutTimerFunc(25,AutomaticEventChanging, 0);	
		}
	}

	EventI++;
	if(event && events)printf("%8u | Run %4i Event %4i | Event %4i in File Containing %4i Events\n",EventI,event->NRun_,event->NEvent_,events->Current_Event, (int)events->NumberOfEvents());
}


int main (int argc, char *argv[])
{	
	string ExePath = string(argv[0]);
	unsigned int n = ExePath.rfind("frog");
	AbsolutePath = ExePath.substr(0,n);

	
	for(int i=1;i<argc;i++){
		unsigned int len = strlen(argv[i]);	

		//Change to lowerCase
		char LowCase[2048];
		strcpy(LowCase,argv[i]);
		for(unsigned int j=0;j<len;j++){
			if(LowCase[j]>=65 && LowCase[j]<=90)LowCase[j]+=32;
		}

		if(      strcmp(LowCase,"-shooter"				 )==0){SHOOTER		= true;
		}else if(strcmp(LowCase,"-s"					 )==0){SCREENSAVER	= true;
		}else if(strcmp(LowCase,"-v"					 )==0){
			printf("Fast and Realistic OpenGl Event Display : FROG\n");
			printf("Version      : %6.3f of %s\n",FROG_VERSION,__DATE__);
			printf("Authors List : \n");
			printf("%s\n",FROG_AUTHORLIST);	
			exit(0);
		}else if(strcmp(LowCase,"-c"					 )==0 && i+1<argc){ 
			i++;	inputConfig = string(argv[i]);
		}else if(len>=4 && strcmp(LowCase+len-4,".vis"	 )==0){inputVisFileFromCommand.push_back(string(argv[i]));
		}else if(len>=7 && strcmp(LowCase+len-7,".vis.gz")==0){inputVisFileFromCommand.push_back(string(argv[i]));
		}else{
			printf("\n");
			printf("#######################################################################\n");
			printf("#                  http://projects.hepforge.org/frog/                 #\n");
			printf("#   Please have a look at the website for latest versions and news    #\n");
			printf("# Also register to the Frog mailing list if you are not a member yet  #\n");			
			printf("#######################################################################\n");
			printf("#                             HELP SCREEN                             #\n");
			printf("#######################################################################\n");
			printf("#  Supported Commands are :                                           #\n");
			printf("#  filename.vis        --> open the file : filename.vis               #\n");
			printf("#  filename.vis.gz     --> open the file : filename.vis.gz            #\n");
			printf("#  -help               --> Print this screen                          #\n");
			printf("#  -v                  --> Print Version and Other Info               #\n");
			printf("#  -s                  --> ScreenSaver Mode                           #\n");
			printf("#  -c <config.txt>     --> Specify the Frog Configuration Card to use #\n");
			printf("#  -shooter            --> Scan events, make a screenshot and exit    #\n");
			printf("#######################################################################\n");
			printf("\n");			
			exit(0);
		}
	}	
	
	// initialisation de GLUT
	glutInit (&argc, argv);
 
	// création d'une fenêtre OpenGL RVBA avec en simple mémoire tampon
	// avec un tampon de profondeur 
	glutInitDisplayMode (GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
	glutInitWindowSize (WINDOW_WIDTH, WINDOW_HEIGHT);
	glutCreateWindow ("FROG Displayer");

	// Charge le logo en mémoire
	LoadTexture((unsigned int*)&LogoTexture     ,FROG_PATH::GetGlobalPath("Resources/Frog_Logo.png"   ,AbsolutePath.c_str()).c_str());
	LoadTexture((unsigned int*)&LogoTxtTexture  ,FROG_PATH::GetGlobalPath("Resources/Frog_LogoTxt.png",AbsolutePath.c_str()).c_str());

	// initialisation des fonctions callback appelées par glut 
	// pour respectivement le redimensionnement de la fenêtre
	// et le rendu de la scène
	glutReshapeFunc (reshape);
	glutDisplayFunc (Loading);
	glutIdleFunc    (Loading);

	
	// initialisation of GLEW (OpenGL Extension Wrangler Library)
	GLenum err = glewInit();
	if(GLEW_OK != err){	  
	  printf("Problem: glewInit failed, something is seriously wrong\n");
	  printf("Error: %s\n", glewGetErrorString(err));
	  exit(0);
	}
	
	// entre dans la boucle d'évènements
	glutMainLoop ();
	return 0;
}