///****************************************************************************

//! \file glview.cpp
//! \date 23-05-2003

//*****************************************************************************

//     This file is part of the Dataview.
//
//     Dataview is free software; you can redistribute it and/or modify
//     it under the terms of the GNU General Public License as published by
//     the Free Software Foundation; either version 2 of the License, or
//     (at your option) any later version.
//
//     The Dataview is distributed in the hope that it will be useful,
//     but WITHOUT ANY WARRANTY; without even the implied warranty of
//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//     GNU General Public License for more details.
//
//     You should have received a copy of the GNU General Public License
//     along with DataView; if not, write to the Free Software
//     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#include "glview.hpp"
//***************************************************************************
// GLView methods
//***************************************************************************
// public methods
//***************************************************************************

//***************************************************************************
GLView::GLView( QWidget *parent, char const *name): WEngine(parent,name), pSize( 1.0),
		obj( true), col( true), boxmode( false), nl( 0), op( false), ssel( false)
//***************************************************************************
{
}

//***************************************************************************
GLView::~GLView()
//***************************************************************************
{

}

//***************************************************************************
void GLView::setupReplayMode( const bool r, const QString file, const int s, const bool d, const Tcoord *koo)
//***************************************************************************
{
	if( RFile.is_open()) RFile.close();

	if( r)
	{
		if( koo) Cam->copy( *koo);
			else resetKoo();
		Replaypps = s;
		Replaydel = d;
		RFile.open( file.latin1());
		dellen = finddel();
		op = true;
		replaylist = pointl[ listn[ of]];
	}else
	{
		RFile.close();
		RFile.clear();
		stop();
	}
	Replay = r;
	pInFile = 0;
}

//***************************************************************************
// public slots
//***************************************************************************
//***************************************************************************
void GLView::UpdateObj()
//***************************************************************************
{
	open( of, numPCpoints, Cam, true);
	update();
}

//***************************************************************************
int GLView::open( const QString filename, const int points)
//***************************************************************************
{
	int tr;

	boxmode = false;
	if( listn.count( filename))
	{
		QMessageBox::critical( this, "Alert", "Could not open File: \n Allready open", QMessageBox::Ok, QMessageBox::NoButton);
		tr = -1;
	}else
	{
		Cam->copy( Tcoord( 0, 0, -15, 0, 0, 0, 0, 0, 0, 0, 0, 0));
		ois.clear();
		op = true;
		of = filename;
		tr = LoadPoints( filename, points);
		if( boxmode)ois.push_back( *( new TGLObject( &boxl, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)));
		ois.push_back( *( new TGLObject( &pointl[listn[filename]], 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)));

		drawStatic();
	}

	return tr;
}

//***************************************************************************
int GLView::open( const QString filename, const int points, const Tcoord *koo, const bool ro)
//***************************************************************************
{
	int tr;
	Cam->copy( *koo);
	ois.clear();
	op = true;
	of = filename;
	boxmode = false;

	if( listn.count( filename) && ro)tr = LoadPoints( filename, points);
	if( boxmode)ois.push_back( *( new TGLObject( &boxl, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)));
	ois.push_back( *( new TGLObject( &pointl[listn[filename]], 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)));

	drawStatic();
	//cerr<<listn[filename]<<endl;
	return tr;
}

//***************************************************************************
void GLView::clear()
//***************************************************************************
{
	Cam->copy( Tcoord( 0, 0, -15, 0, 0, 0, 0, 0, 0, 0, 0, 0));
	ois.clear();
	update();
}

//***************************************************************************
Tcoord GLView::currentConfig() const
//***************************************************************************
{
	Tcoord erg( *Cam);

	return erg;
}

//***************************************************************************
void GLView::enableSectSel( bool sw)
//***************************************************************************
{
	boxmode = sw;
	if( boxmode)
	{
		setMouseTracking( true);

		cxh = this->width()/2.;
		cx1 = .55/cxh;
		cyh = this->height()/2.;
		cy1 = .35/cyh;

		curs2 = cursor().shape();
		if( curs2==Qt::BlankCursor) curs2 = Qt::ArrowCursor;
		setCursor( Qt::BlankCursor);
		hidecursor = true;

		cursx = cursy = cursz = 0;
		boxlen = 2.;

		drawBox();
		ois.push_back( *( new TGLObject( &boxl, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)));
		drawStatic();
	}
	else
	{
		setMouseTracking( false);
		setCursor( curs2);
		hidecursor = false;
		boxPos[0] = cursx - boxlen;
		boxPos[1] = cursz - boxlen;
		boxPos[2] = cursy - boxlen;
		boxPos[3] = cursx + boxlen;
		boxPos[4] = cursz + boxlen;
		boxPos[5] = cursy + boxlen;
	}
}

//***************************************************************************
// protected methods
//***************************************************************************

//***************************************************************************
int GLView::LoadPoints( const QString fname, const int inPCp)
{

	numPCpoints = inPCp;

	int i = 0;
	int j = 0;
	RFile.open( fname.latin1());
	dellen = finddel();

	int col1 = 255;
	int col2 = 0;
	int col3 = 0;
	int m = 1;

	int sPCpoints2;
	if( numPCpoints>499) sPCpoints2 = numPCpoints/499;
	else
	{
	 sPCpoints2 = 1;
 		m = 499/numPCpoints;
	}
	bool t = true;
	if( !listn.count( fname))
	{
		listn[fname]=nl;
		pointl[nl] = glGenLists( 1);

		++nl;
	}
	glNewList( pointl[listn[fname]], GL_COMPILE );
	qglColor( white);
	glPointSize( pSize);

	if( !obj)glBegin( GL_POINTS);
	if( !ssel)
	{
		do
		{
			if( RFile.peek()=='#')
			{
				RFile.getline( tr2, 256);
				std::cout<<tr2<<std::endl;
				continue;
			}

			if( col)if( !( i % (sPCpoints2)) )
			{
				if( t)
				{
					col1-=m;
					t = false;
				}else
				{
					col2+=m;
					t = true;
				}
				qglColor( QColor( col1, col2, col3));
			}
			RFile>>p[0];
			RFile.read( tr2, dellen);
			RFile>>p[1];
			RFile.read( tr2, dellen);
			RFile>>p[2];
			RFile.getline( tr2, 256);
			++i;
			drawPoint( p);
		}while( ( RFile.good()) && (i<numPCpoints));
		numPCpoints = i;
	}else
	{
		do
		{
			if( RFile.peek()=='#')
			{
				RFile.getline( tr2, 256);
				std::cout<<tr2<<std::endl;
				continue;
			}
			if( col)if( !(i % (sPCpoints2)) )
			{
				if( t)
				{
					col1-=m;
					t = false;
				}else
				{
					col2+=m;
					t = true;
				}
				qglColor( QColor( col1, col2, col3));
			}
			RFile>>p[0];
			RFile.read( tr2, dellen);
			RFile>>p[1];
			RFile.read( tr2, dellen);
			RFile>>p[2];
			RFile.getline( tr2, 256);
			++j;
			if( (p[0]>boxPos[0]) && (p[1]>boxPos[1]) && (p[2]>boxPos[2]) &&
				(p[0]<boxPos[3]) && (p[1]<boxPos[4]) && (p[2]<boxPos[5]))
			{
				drawPoint( p);
				++i;
			}
		}while( ( RFile.good()) && (j<numPCpoints));
	}
	if( !obj)glEnd();
	glEndList();

	RFile.close();
	cerr<<" loading done\n loaded Points ="<<i<<endl;

	return i;
}

//***************************************************************************
void GLView::evKeyPress( QKeyEvent *e)
//***************************************************************************
{
	switch ( e->key())
	{
		case Qt::Key_V:
			ssel =  boxmode;
			enableSectSel( !boxmode);
			if( ssel)UpdateObj();
			break;
		case Qt::Key_Control:
			if( boxmode) GPoint = mapFromGlobal( cursor().pos());
			break;
		case Qt::Key_Shift:
			if( boxmode) GPoint = mapFromGlobal( cursor().pos());
			break;
		case Qt::Key_Escape:
			if( boxmode)enableSectSel( false);
			boxmode = false;
			ssel = false;
			UpdateObj();
			setCursor( curs2);
		default:
			break;
	}
}

//***************************************************************************
void GLView::evMouseMove( QMouseEvent *e)
//***************************************************************************
{
	double phi = Cam->ay/P3;
	if( e->state() & Qt::ShiftButton)
	{
		double h = -sin( ( 90.+Cam->ax)/P3);
		h/=fabs( h);
		cursz -= -1.*h*Cam->z*cy1*(  GPoint.y()-e->y());
		cursor().setPos( mapToGlobal( GPoint));
	}else if( e->state() & ControlButton )
	{
		double h = -sin( ( 90.+Cam->ax)/P3);
		h/=fabs( h);
		boxlen -= -1.*h*Cam->z*cy1*(  GPoint.y()-e->y());
		cursor().setPos( mapToGlobal( GPoint));
	}else
	{
		cursx = e->x()-cxh;
		cursy = ( e->y()-cyh)/cos( ( 90. - Cam->ax)/P3);
		cursx *= -1.*Cam->z*cx1;
		double h2 = cursx;
		cursy *= -1.*Cam->z*cy1;
		cursx = cursx*cos( phi)-cursy*sin( phi);
		cursy = h2*sin( phi)+cursy*cos( phi);
	}
	drawBox( boxlen);
	update();
}

//***************************************************************************
void GLView::initializeGL()
//***************************************************************************
{
	WEngine::initializeGL();
	quad=gluNewQuadric();
	gluQuadricNormals( quad, GLU_SMOOTH);
	gluQuadricOrientation( quad, GLU_OUTSIDE);
	boxl = glGenLists( 1);
}

//***************************************************************************
void GLView::director()
//***************************************************************************
{
if( RFile.good())
	{

		glNewList( replaylist, GL_COMPILE );

		glPointSize( pSize);

		qglColor( white);
		if( !obj)glBegin( GL_POINTS);

// 		if( !Replaydel)glCallList( object);
		for( int i = 0; i < Replaypps; i++)
		{
			if( RFile.good())
			{
				if( RFile.peek()=='#')
				{
					RFile.getline( tr2, 256);
					cout<<tr2<<endl;
					continue;
				}
				RFile>>p[0];
				RFile.read( tr2, dellen);
				RFile>>p[1];
				RFile.read( tr2, dellen);
				RFile>>p[2];
				RFile.getline( tr2, 256);

				pInFile++;
				drawPoint( p);
			}else
			{
				setupReplayMode();
			}
		}
		if( !obj)glEnd();
		glEndList();

		update();
	}
}

//***************************************************************************
// private methods
//***************************************************************************

//***************************************************************************
void GLView::resetKoo()
//***************************************************************************
{
	Cam->copy( Tcoord( 0, 0, -15, 0, 0, 0, 0, 0, 0, 0, 0, 0));
}

//***************************************************************************
int GLView::finddel()
//***************************************************************************
{
	int del = 0;
	bool f = false;
	do
	{
		RFile.getline( tr2, 256);
	}while( tr2[0]=='#');

	for( int i = 0; i<256; i++)
	{
		if( ( ( tr2[i]>='0')&&( tr2[i]<='9'))||( tr2[i]=='.')||(tr2[i]=='-'))
		{
			if( f)break;
		}else
		{
			f = true;
			del++;
		}
	}
	RFile.seekg( 0, ios::beg);
	return del;
}

//***************************************************************************
void GLView::drawPoint( const double *p)
//***************************************************************************
{
	if(!obj) glVertex3d( p[0], p[1], p[2]);
	else
	{
		glTranslated( p[0], p[1], p[2]);
		gluSphere( quad, 0.15f, 8, 8);
		glTranslated( -p[0], -p[1], -p[2]);
	}
}

//***************************************************************************
void GLView::drawBox( const double r)
//***************************************************************************
{
	glNewList( boxl, GL_COMPILE );
	qglColor( green);
		glDisable( GL_LIGHTING);
		glBegin( GL_LINES);
			glVertex3d( r+cursx, r+cursz, r+cursy);
			glVertex3d( r+cursx, r+cursz, -r+cursy);
			glVertex3d( r+cursx, r+cursz, r+cursy);
			glVertex3d( r+cursx, -r+cursz, r+cursy);
			glVertex3d( r+cursx, r+cursz, r+cursy);
			glVertex3d( -r+cursx, r+cursz, r+cursy);

			glVertex3d( -r+cursx, -r+cursz, -r+cursy);
			glVertex3d( r+cursx, -r+cursz, -r+cursy);
			glVertex3d( -r+cursx, -r+cursz, -r+cursy);
			glVertex3d( -r+cursx, r+cursz, -r+cursy);
			glVertex3d( -r+cursx, -r+cursz, -r+cursy);
			glVertex3d( -r+cursx, -r+cursz, r+cursy);

			glVertex3d( -r+cursx, -r+cursz, r+cursy);
			glVertex3d( -r+cursx, r+cursz, r+cursy);
			glVertex3d( -r+cursx, -r+cursz, r+cursy);
			glVertex3d( r+cursx, -r+cursz, r+cursy);

			glVertex3d( r+cursx, -r+cursz, -r+cursy);
			glVertex3d( r+cursx, -r+cursz, r+cursy);
			glVertex3d( r+cursx, -r+cursz, -r+cursy);
			glVertex3d( r+cursx, r+cursz, -r+cursy);

			glVertex3d( -r+cursx, r+cursz, -r+cursy);
			glVertex3d( -r+cursx, r+cursz, r+cursy);
			glVertex3d( -r+cursx, r+cursz, -r+cursy);
			glVertex3d( r+cursx, r+cursz, -r+cursy);
		glEnd();
// 		glEnable( GL_LIGHTING);
	glEndList();
}