package vnsim.gui;

import javax.media.opengl.GL;
import javax.media.opengl.glu.GLU;
import javax.media.opengl.glu.GLUquadric;

import com.sun.opengl.util.GLUT;

import vnsim.map.object.Globals;
import vnsim.map.object.Point;
import vnsim.map.object.Road;
import vnsim.map.utils.GPSutil;
import vnsim.vehicular.simulator.intersections.DirectedRoadSegment;
import vnsim.vehicular.simulator.intersections.Intersection;
import vnsim.vehicular.simulator.intersections.IntersectionWithoutTrafficLights;

public class ListBuilder {

	public static void buildList_PrioritySign(GL myGL, GLU myGLU, GLUT glut, int prioritySign) {
		myGL.glNewList(prioritySign, GL.GL_COMPILE);
		{
			myGL.glPushMatrix();
			myGL.glColor3f(1.0f, 1.0f, 1.0f);
			myGL.glBegin(GL.GL_POLYGON);
			{
				myGL.glVertex3f(0.0f, 4.0f, 0.0f);
				myGL.glVertex3f(3.0f, 0.0f, 0.0f);
				myGL.glVertex3f(0.0f, -4.0f, 0.0f);
				myGL.glVertex3f(-3.0f, 0.0f, 0.0f);
			}
			myGL.glEnd();
			myGL.glColor3f(0.0f, 0.0f, 0.0f);
			myGL.glLineWidth(0.25f);
			myGL.glBegin(GL.GL_LINE_LOOP);
			{
				myGL.glVertex3f(0.0f, 4.0f, 0.0f);
				myGL.glVertex3f(3.0f, 0.0f, 0.0f);
				myGL.glVertex3f(0.0f, -4.0f, 0.0f);
				myGL.glVertex3f(-3.0f, 0.0f, 0.0f);
			}
			myGL.glEnd();
			myGL.glColor3f(0.9f, 0.9f, 0.4f);
			myGL.glBegin(GL.GL_POLYGON);
			{
				myGL.glVertex3f(0.0f, 3.0f, 0.0f);
				myGL.glVertex3f(2.0f, 0.0f, 0.0f);
				myGL.glVertex3f(0.0f, -3.0f, 0.0f);
				myGL.glVertex3f(-2.0f, 0.0f, 0.0f);
			}
			myGL.glEnd();
			myGL.glPopMatrix();
		}
		myGL.glEndList();
	}

	/**
	 * 
	 * @param myGL
	 */
	public static void buildList_NoPrioritySign(GL myGL, GLU myGLU, GLUT glut, int noPrioritySign) {
		myGL.glNewList(noPrioritySign, GL.GL_COMPILE);
		{
			myGL.glPushMatrix();
			myGL.glColor3f(1.0f, 1.0f, 1.0f);
			myGL.glBegin(GL.GL_TRIANGLES);
			{
				myGL.glVertex3f(3.5f, 3.5f, 0.0f);
				myGL.glVertex3f(-3.5f, 3.5f, 0.0f);
				myGL.glVertex3f(0.0f, -3.5f, 0.0f);
			}
			myGL.glEnd();
			myGL.glLineWidth(0.25f);
			myGL.glColor3f(1.0f, 0.0f, 0.0f);
			myGL.glBegin(GL.GL_LINE_LOOP);
			{
				myGL.glVertex3f(3.5f, 3.5f, 0.0f);
				myGL.glVertex3f(-3.5f, 3.5f, 0.0f);
				myGL.glVertex3f(0.0f, -3.5f, 0.0f);
			}
			myGL.glEnd();
			myGL.glColor3f(1.0f, 0.0f, 0.0f);
			myGL.glBegin(GL.GL_TRIANGLES);
			{
				myGL.glVertex3f(2.0f, 2.5f, 0.0f);
				myGL.glVertex3f(-2.0f, 2.5f, 0.0f);
				myGL.glVertex3f(0.0f, -2.0f, 0.0f);
			}
			myGL.glEnd();
			myGL.glPopMatrix();
		}
		myGL.glEndList();
	}

	/**
	 * 
	 * @param myGL
	 * @param glut
	 */
	public static void buildList_StopSign(GL myGL, GLU myGLU, GLUT glut, int stopSign) {
		myGL.glNewList(stopSign, GL.GL_COMPILE);
		{
			float x2, y2;
			myGL.glPushMatrix();
			myGL.glRotatef(22.5f, 0.0f, 0.0f, 1.0f);
			myGL.glColor3f(1.0f, 0.0f, 0.0f);
			myGL.glBegin(GL.GL_POLYGON);
			{
				for (int ll = 0; ll < 8; ll++) {
					x2 = (float) (4 * (Math.cos((double) (ll * 45 * Math.PI / 180))));
					y2 = (float) (4 * (Math.sin((double) (ll * 45 * Math.PI / 180))));
					System.out.println("ll=" + ll + "; x=" + x2 + "; y=" + y2);
					myGL.glVertex3f(x2, y2, 0.0f);
				}
			}
			myGL.glEnd();
			myGL.glColor3f(1.0f, 1.0f, 1.0f);
			myGL.glBegin(GL.GL_POLYGON);
			{
				for (int ll = 0; ll < 8; ll++) {
					x2 = (float) (3.8 * (Math.cos((double) (ll * 45 * Math.PI / 180))));
					y2 = (float) (3.8 * (Math.sin((double) (ll * 45 * Math.PI / 180))));
					myGL.glVertex3f(x2, y2, 0.0f);
				}
			}
			myGL.glEnd();
			myGL.glColor3f(1.0f, 0.0f, 0.0f);
			myGL.glBegin(GL.GL_POLYGON);
			{
				for (int ll = 0; ll < 8; ll++) {
					x2 = (float) (3.4 * (Math.cos((double) (ll * 45 * Math.PI / 180))));
					y2 = (float) (3.4 * (Math.sin((double) (ll * 45 * Math.PI / 180))));
					myGL.glVertex3f(x2, y2, 0.0f);
				}
			}
			myGL.glEnd();
			myGL.glColor3f(0.0f, 0.0f, 0.0f);
			myGL.glPopMatrix();
			myGL.glPushMatrix();
			myGL.glTranslatef(-3.4f, -1.0f, 0.0f);
			myGL.glScalef(0.02f, 0.02f, 0.02f);
			glut.glutStrokeString(GLUT.STROKE_ROMAN, "STOP");
			myGL.glPopMatrix();
		}
		myGL.glEndList();
	}

	/**
	 * 
	 * @param myGL
	 */
	public static void buildList_MapList(GL myGL, GLU myGLU, GLUT glut, int mapList, int prioritySign, int stopSign,
			int noPrioritySign, Point minPoint, Point maxPoint) {
		Road currentRoad;
		Point currentPoint;
		int i, j;
		float x, y;
		byte[] ri;
		myGL.glNewList(mapList, GL.GL_COMPILE);
		{
			float x2, y2;
			// gets the distance between the maximal and minimal point on Ox and
			// OY and draws a
			// bigger green rectangle
			y2 = (float) GPSutil.getMetersLatitude(minPoint, maxPoint);
			x2 = (float) GPSutil.getMetersLongitude(minPoint, maxPoint);
			myGL.glColor3f(0.4f, 0.7f, 0.2f);
			myGL.glBegin(GL.GL_QUADS);
			{
				myGL.glVertex3f(-10000.0f, -10000.0f, 0.0f);
				myGL.glVertex3f((x2 + 10000.f), -10000.0f, 0.0f);
				myGL.glVertex3f((x2 + 10000.f), (y2 + 10000.f), 0.0f);
				myGL.glVertex3f(-10000.0f, (y2 + 10000.f), 0.0f);
			}
			myGL.glEnd();
			// Sets the initial position of the cammera in the middle of the map
			i = 0;
			int laneNr;
			while (i < Globals.map.roads.size()) {// for every road
				currentRoad = (Road) Globals.map.roads.get(i);
				ri = currentRoad.getRoadinfo();
				// depending on the road type i select a color and a line width
				MyColor roadColor = MyColor.chooseRoadColor(ri[1]);
				laneNr = currentRoad.laneNo;
				y = 0.0f;
				x = 0.0f;
				j = 0;
				double sinAlfa, cosAlfa;
				if ((currentRoad.points.size() > 0) && (j == 0)) {
					currentPoint = (Point) currentRoad.points.get(0);
					y = (float) GPSutil.getMetersLatitude(minPoint, currentPoint);
					x = (float) GPSutil.getMetersLongitude(minPoint, currentPoint);
				}
				float dx, dy;
				while (j < currentRoad.points.size() - 1) {
					y2 = y;
					x2 = x;
					currentPoint = (Point) currentRoad.points.get(j + 1);
					y = (float) GPSutil.getMetersLatitude(minPoint, currentPoint);
					x = (float) GPSutil.getMetersLongitude(minPoint, currentPoint);
					currentPoint = (Point) currentRoad.points.get(j);
					y2 = (float) GPSutil.getMetersLatitude(minPoint, currentPoint);
					x2 = (float) GPSutil.getMetersLongitude(minPoint, currentPoint);
					sinAlfa = (y2 - y) / (Math.sqrt((y2 - y) * (y2 - y) + (x2 - x) * (x2 - x)));
					cosAlfa = (x2 - x) / (Math.sqrt((y2 - y) * (y2 - y) + (x2 - x) * (x2 - x)));
					dx = (float) (laneNr * 2 * sinAlfa);
					dy = (float) (laneNr * 2 * cosAlfa);
					myGL.glPushMatrix();
					{
		//				double laneWidth = 1;
						myGL.glColor3f(roadColor.getRed(), roadColor.getGreen(), roadColor.getBlue());
						switch (currentRoad.oneWay) {
						case 0:
							myGL.glTranslatef(x, y, 0.0f);
		//					laneWidth = 2;
							break;
						case 1:
							myGL.glTranslatef(x - (dx / 2), y + (dy / 2), 0.0f);
							break;
						case 2:
							myGL.glTranslatef(x + (dx / 2), y - (dy / 2), 0.0f);
							break;
						}
						myGL.glBegin(GL.GL_POLYGON);
						{
							for (int ll = 0; ll < 8; ll++) {
								x2 = (float) (2 * laneNr * (Math.cos((double) (45 * ll * Math.PI / 180))));
								y2 = (float) (2 * laneNr * (Math.sin((double) (45 * ll * Math.PI / 180))));
								myGL.glVertex3f(x2, y2, 0.0f);
							}
						}
						myGL.glEnd();
					}
					myGL.glPopMatrix();
					j++;
				}
				i++;
			}
			i = 0;
			while (i < Globals.map.roads.size()) {// for every road
				currentRoad = (Road) Globals.map.roads.get(i);
				ri = currentRoad.getRoadinfo();
				// depending on the road type i select a color and a line width
				MyColor roadColor = MyColor.chooseRoadColor(ri[1]);
				laneNr = currentRoad.laneNo;
				j = 0;
				double sinAlfa, cosAlfa;
				if ((currentRoad.points.size() > 0) && (j == 0)) {
					currentPoint = (Point) currentRoad.points.get(0);
					y2 = (float) GPSutil.getMetersLatitude(minPoint, currentPoint);
					x2 = (float) GPSutil.getMetersLongitude(minPoint, currentPoint);
				}
				float dx, dy;
				while (j < currentRoad.points.size() - 1) {
					y = y2;
					x = x2;
					currentPoint = (Point) currentRoad.points.get(j + 1);
					y2 = (float) GPSutil.getMetersLatitude(minPoint, currentPoint);
					x2 = (float) GPSutil.getMetersLongitude(minPoint, currentPoint);
					if ((x2 != x) || (y2 != y)) {
						sinAlfa = (y2 - y) / (Math.sqrt((y2 - y) * (y2 - y) + (x2 - x) * (x2 - x)));
						cosAlfa = (x2 - x) / (Math.sqrt((y2 - y) * (y2 - y) + (x2 - x) * (x2 - x)));
						myGL.glPushMatrix();
						{
							myGL.glTranslatef(x, y, 0);
							myGL.glColor3f(roadColor.getRed(), roadColor.getGreen(), roadColor.getBlue());
							myGL.glBegin(GL.GL_QUADS);
							{
								dx = (float) (laneNr * 2 * sinAlfa);
								dy = (float) (laneNr * 2 * cosAlfa);
								switch (currentRoad.oneWay) {
								case 0:
									myGL.glVertex3f(0.0f - dx, dy, 0.0f);
									myGL.glVertex3f(dx, 0.0f - dy, 0.0f);
									myGL.glVertex3f(x2 - x + dx, y2 - y - dy, 0.0f);
									myGL.glVertex3f(x2 - x - dx, y2 - y + dy, 0.0f);
									break;
								case 1:
									myGL.glVertex3f(0.0f, 0.0f, 0.0f);
									myGL.glVertex3f(dx, 0.0f - dy, 0.0f);
									myGL.glVertex3f(x2 - x + dx, y2 - y - dy, 0.0f);
									myGL.glVertex3f(x2 - x, y2 - y, 0.0f);
									break;
								case 2:
									myGL.glVertex3f(0.0f - dx, dy, 0.0f);
									myGL.glVertex3f(0.0f, 0.0f, 0.0f);
									myGL.glVertex3f(x2 - x, y2 - y, 0.0f);
									myGL.glVertex3f(x2 - x - dx, y2 - y + dy, 0.0f);
									break;
								}
							}
							myGL.glEnd();

							myGL.glLineWidth(0.25f);
							myGL.glColor3f(0.3f, 0.3f, 0.3f);
							myGL.glBegin(GL.GL_LINES);
							{
								myGL.glVertex3f(0.0f, 0.0f, 0.0f);
								myGL.glVertex3f(x2 - x, y2 - y, 0.0f);
								for (int ln = 1; ln < laneNr; ln++) {
									dx = (float) (ln * 2 * sinAlfa);
									dy = (float) (ln * 2 * cosAlfa);
									if (j % 4 != 0) {
										myGL.glLineWidth(0.15f);
										switch (currentRoad.oneWay) {
										case 0:
											myGL.glVertex3f(0.0f - dx, dy, 0.0f);
											myGL.glVertex3f(x2 - x - dx, y2 - y + dy, 0.0f);
											myGL.glVertex3f(dx, 0.0f - dy, 0.0f);
											myGL.glVertex3f(x2 - x + dx, y2 - y - dy, 0.0f);
											break;

										case 1:
											myGL.glVertex3f(dx, 0.0f - dy, 0.0f);
											myGL.glVertex3f(x2 - x + dx, y2 - y - dy, 0.0f);
											break;

										case 2:
											myGL.glVertex3f(0.0f - dx, dy, 0.0f);
											myGL.glVertex3f(x2 - x - dx, y2 - y + dy, 0.0f);
											break;
										}
									}
								}
								dx = (float) (laneNr * 2 * sinAlfa);
								dy = (float) (laneNr * 2 * cosAlfa);
								myGL.glLineWidth(0.25f);
								switch (currentRoad.oneWay) {
								case 0:
									myGL.glVertex3f(0.0f - dx, dy, 0.0f);
									myGL.glVertex3f(x2 - x - dx, y2 - y + dy, 0.0f);
									myGL.glVertex3f(dx, 0.0f - dy, 0.0f);
									myGL.glVertex3f(x2 - x + dx, y2 - y - dy, 0.0f);
									break;

								case 1:
									myGL.glVertex3f(dx, 0.0f - dy, 0.0f);
									myGL.glVertex3f(x2 - x + dx, y2 - y - dy, 0.0f);
									break;

								case 2:
									myGL.glVertex3f(0.0f - dx, dy, 0.0f);
									myGL.glVertex3f(x2 - x - dx, y2 - y + dy, 0.0f);
									break;
								}
							}
							myGL.glEnd();

						}
						myGL.glPopMatrix();
					}
					j++;
				}
				i++;
			}
			Intersection currentInt;
			DirectedRoadSegment dr;
			int tempPointIdx;
			for (i = 0; i < Globals.map.allIntersections.size(); i++) {
				currentInt = Globals.map.allIntersections.get(i);
				if (!currentInt.hasTrafficLights()) {
					for (j = 0; j < ((IntersectionWithoutTrafficLights) currentInt).segments.size(); j++) {
						dr = ((IntersectionWithoutTrafficLights) currentInt).segments.get(j);
						currentRoad = (Road) Globals.map.roads.get(dr.roadIndex);
						tempPointIdx = dr.pointIndex;
						if (dr.direction) {
							tempPointIdx = tempPointIdx + 2;
							while (currentRoad.points.size() <= tempPointIdx) {
								tempPointIdx--;
							}
							currentPoint = (Point) currentRoad.points.get(tempPointIdx);
						} else {
							tempPointIdx = tempPointIdx - 2;
							while (tempPointIdx < 0) {
								tempPointIdx++;
							}
							currentPoint = (Point) currentRoad.points.get(tempPointIdx);
						}
						y2 = (float) GPSutil.getMetersLatitude(minPoint, currentPoint);
						x2 = (float) GPSutil.getMetersLongitude(minPoint, currentPoint);
						if (j < 2) {
							// priority road
							myGL.glPushMatrix();
							myGL.glTranslatef(x2, y2, 0.0f);
							myGL.glCallList(prioritySign);
							myGL.glPopMatrix();
						} else {
							// no priority
							myGL.glPushMatrix();
							myGL.glTranslatef(x2, y2, 0.0f);
							if (((IntersectionWithoutTrafficLights) currentInt).mustStop.get(j)) {
								myGL.glCallList(stopSign);
							} else {
								myGL.glCallList(noPrioritySign);
							}
							myGL.glPopMatrix();
						}
					}
				}
			}
		}
		myGL.glEndList();
	}

	/**
	 * 
	 * @param myGL
	 * @param myGLU
	 * @param glut
	 */
	public static void buildList_CarList(GL myGL, GLU myGLU, GLUT glut, int carList) {
		myGL.glNewList(carList, GL.GL_COMPILE);
		{
			myGL.glColor3f(0.2f, 0.2f, 1.0f);
			// glut.glutSolidSphere(myGLU, 15, 40, 40);
			GLUquadric quadric = myGLU.gluNewQuadric();
			myGLU.gluDisk(quadric, 0, 15, 10, 5);
		}
		myGL.glEndList();
	}

	/**
	 * 
	 * @param myGL
	 * @param myGLU
	 * @param glut
	 */
	public static void buildList_AccCar(GL myGL, GLU myGLU, GLUT glut, int accCar) {
		myGL.glNewList(accCar, GL.GL_COMPILE);
		{
			myGL.glColor3f(0f, 1f, 0f);
			GLUquadric quadric = myGLU.gluNewQuadric();
			myGLU.gluDisk(quadric, 0, 15, 10, 5);
		}
		myGL.glEndList();
	}

	/**
	 * 
	 * @param myGL
	 * @param myGLU
	 * @param glut
	 */
	public static void buildList_HAccCar(GL myGL, GLU myGLU, GLUT glut, int hAccCar) {
		myGL.glNewList(hAccCar, GL.GL_COMPILE);
		{
			myGL.glColor3f(0f, 0.7f, 0f);
			GLUquadric quadric = myGLU.gluNewQuadric();
			myGLU.gluDisk(quadric, 0, 15, 10, 5);
		}
		myGL.glEndList();
	}

	/**
	 * 
	 * @param myGL
	 * @param myGLU
	 * @param glut
	 */
	public static void buildList_StoppedCar(GL myGL, GLU myGLU, GLUT glut, int stoppedCar) {
		myGL.glNewList(stoppedCar, GL.GL_COMPILE);
		{
			myGL.glColor3f(0.7f, 0f, 0f);
			GLUquadric quadric = myGLU.gluNewQuadric();
			myGLU.gluDisk(quadric, 0, 15, 10, 5);
		}
		myGL.glEndList();
	}

	/**
	 * 
	 * @param myGL
	 * @param myGLU
	 * @param glut
	 */
	public static void buildList_DecCar(GL myGL, GLU myGLU, GLUT glut, int decCar) {
		myGL.glNewList(decCar, GL.GL_COMPILE);
		{
			myGL.glColor3f(1.0f, 1.0f, 0.0f);
			GLUquadric quadric = myGLU.gluNewQuadric();
			myGLU.gluDisk(quadric, 0, 15, 10, 5);
		}
		myGL.glEndList();
	}

	/**
	 * 
	 * @param myGL
	 * @param myGLU
	 * @param glut
	 */
	public static void buildList_HDecCar(GL myGL, GLU myGLU, GLUT glut, int hDecCar) {
		myGL.glNewList(hDecCar, GL.GL_COMPILE);
		{
			myGL.glColor3f(0.75f, 0.75f, 0.0f);
			GLUquadric quadric = myGLU.gluNewQuadric();
			myGLU.gluDisk(quadric, 0, 15, 10, 5);
		}
		myGL.glEndList();
	}

	/**
	 * 
	 * @param myGL
	 * @param myGLU
	 * @param glut
	 */
	public static void buildList_SignalCar(GL myGL, GLU myGLU, GLUT glut, int signalCar) {
		myGL.glNewList(signalCar, GL.GL_COMPILE);
		{
			myGL.glColor3f(0.9f, 0.9f, 0.05f);
			GLUquadric quadric = myGLU.gluNewQuadric();
			myGLU.gluDisk(quadric, 0, 15, 10, 5);
		}
		myGL.glEndList();
	}

	/**
	 * 
	 * @param myGL
	 * @param myGLU
	 * @param glut
	 */
	public static void buildList_WhiteCar(GL myGL, GLU myGLU, GLUT glut, int whiteCar) {
		myGL.glNewList(whiteCar, GL.GL_COMPILE);
		{
			myGL.glColor3f(1.0f, 1.0f, 1.0f);
			GLUquadric quadric = myGLU.gluNewQuadric();
			myGLU.gluDisk(quadric, 0, 15, 10, 5);
		}
		myGL.glEndList();
	}

	/**
	 * 
	 * @param myGL
	 * @param myGLU
	 * @param glut
	 */
	public static void buildList_PinkCar(GL myGL, GLU myGLU, GLUT glut, int pinkCar) {
		myGL.glNewList(pinkCar, GL.GL_COMPILE);
		{
			myGL.glColor3f(0.7f, 1.0f, 1.0f);
			GLUquadric quadric = myGLU.gluNewQuadric();
			myGLU.gluDisk(quadric, 0, 15, 10, 5);
		}
		myGL.glEndList();
	}

	/**
	 * 
	 * @param myGL
	 * @param myGLU
	 * @param glut
	 */
	public static void buildList_TraceCar(GL myGL, GLU myGLU, GLUT glut, int traceCar) {
		myGL.glNewList(traceCar, GL.GL_COMPILE);
		{
			myGL.glColor3f(0.8f, 1.0f, 1.0f);
			GLUquadric quadric = myGLU.gluNewQuadric();
			myGLU.gluDisk(quadric, 0, 15, 10, 5);

		}
		myGL.glEndList();
	}

	/**
	 * 
	 * @param myGL
	 * @param myGLU
	 * @param glut
	 */
	public static void buildList_CarListOut(GL myGL, GLU myGLU, GLUT glut, int carListOut) {
		myGL.glNewList(carListOut, GL.GL_COMPILE);
		{
			myGL.glColor3f(1.0f, 0.0f, 0.0f);
			GLUquadric quadric = myGLU.gluNewQuadric();
			myGLU.gluDisk(quadric, 0, 10, 10, 5);
		}
		myGL.glEndList();
	}

	/**
	 * 
	 * @param myGL
	 * @param myGLU
	 * @param glut
	 */
	public static void buildList_Neighbor(GL myGL, GLU myGLU, GLUT glut, int neighbor) {
		myGL.glNewList(neighbor, GL.GL_COMPILE);
		{
			myGL.glColor3f(1.0f, 0.0f, 1.0f);
			GLUquadric quadric = myGLU.gluNewQuadric();
			myGLU.gluDisk(quadric, 0, 7, 10, 5);

		}
		myGL.glEndList();
	}

	/**
	 * 
	 * @param myGL
	 * @param myGLU
	 * @param glut
	 */
	public static void buildList_EndOfQueue(GL myGL, GLU myGLU, GLUT glut, int endOfQueue) {
		myGL.glNewList(endOfQueue, GL.GL_COMPILE);
		{
			myGL.glColor3f(0.0f, 0.0f, 0.0f);
			// glut.glutSolidSphere(myGLU, 7, 40, 40);
			GLUquadric quadric = myGLU.gluNewQuadric();
			myGLU.gluDisk(quadric, 0, 7, 10, 5);

		}
		myGL.glEndList();
	}

	/**
	 * Creeaza sagetile de orientare pe harta.
	 * 
	 * @param myGL
	 */
	public static void buildList_Arrows(GL myGL, GLU myGLU, GLUT glut, int arrows, double width, double height, double dx) {
		myGL.glNewList(arrows, GL.GL_COMPILE);
		{
			myGL.glLineWidth(3.0f);
			// UP arrow
			myGL.glPushMatrix();
			{
				myGL.glColor3f(0.7f, 0.7f, 0.9f);
				myGL.glTranslatef(0.0f, (float) (height / 2 - dx), 0.0f);
				myGL.glBegin(GL.GL_QUADS);
				{
					myGL.glVertex3f(0.0f, 0.0f, 0.0f);
					myGL.glVertex3f(-20.0f, -20.0f, 0.0f);
					myGL.glVertex3f(0.0f, -15.0f, 0.0f);
					myGL.glVertex3f(20.0f, -20.0f, 0.0f);
				}
				myGL.glEnd();
				myGL.glColor3f(0.8f, 0.8f, 0.9f);
				myGL.glBegin(GL.GL_LINE_LOOP);
				{
					myGL.glVertex3f(0.0f, 0.0f, 0.0f);
					myGL.glVertex3f(-20.0f, -20.0f, 0.0f);
					myGL.glVertex3f(0.0f, -15.0f, 0.0f);
					myGL.glVertex3f(20.0f, -20.0f, 0.0f);
				}
				myGL.glEnd();
			}
			myGL.glPopMatrix();
			// DOWN arrow
			myGL.glPushMatrix();
			{
				myGL.glColor3f(0.7f, 0.7f, 0.9f);
				myGL.glTranslatef(0.0f, (float) (0 - (height / 2 - dx)), 0.0f);
				myGL.glBegin(GL.GL_QUADS);
				{
					myGL.glVertex3f(0.0f, 0.0f, 0.0f);
					myGL.glVertex3f(20.0f, 20.0f, 0.0f);
					myGL.glVertex3f(0.0f, 15.0f, 0.0f);
					myGL.glVertex3f(-20.0f, 20.0f, 0.0f);
				}
				myGL.glEnd();
				myGL.glColor3f(0.8f, 0.8f, 0.9f);
				myGL.glBegin(GL.GL_LINE_LOOP);
				{
					myGL.glVertex3f(0.0f, 0.0f, 0.0f);
					myGL.glVertex3f(20.0f, 20.0f, 0.0f);
					myGL.glVertex3f(0.0f, 15.0f, 0.0f);
					myGL.glVertex3f(-20.0f, 20.0f, 0.0f);
				}
				myGL.glEnd();
			}
			myGL.glPopMatrix();
			// LEFT arrow
			myGL.glPushMatrix();
			{
				myGL.glColor3f(0.7f, 0.7f, 0.9f);
				myGL.glTranslatef((float) (width / 2 - dx), 0.0f, 0.0f);
				myGL.glBegin(GL.GL_QUADS);
				{
					myGL.glVertex3f(0.0f, 0.0f, 0.0f);
					myGL.glVertex3f(-20.0f, 20.0f, 0.0f);
					myGL.glVertex3f(-15.0f, 0.0f, 0.0f);
					myGL.glVertex3f(-20.0f, -20.0f, 0.0f);
				}
				myGL.glEnd();
				myGL.glColor3f(0.8f, 0.8f, 0.9f);
				myGL.glBegin(GL.GL_LINE_LOOP);
				{
					myGL.glVertex3f(0.0f, 0.0f, 0.0f);
					myGL.glVertex3f(-20.0f, 20.0f, 0.0f);
					myGL.glVertex3f(-15.0f, 0.0f, 0.0f);
					myGL.glVertex3f(-20.0f, -20.0f, 0.0f);
				}
				myGL.glEnd();
			}
			myGL.glPopMatrix();
			// RIGHT arrow
			myGL.glPushMatrix();
			{
				myGL.glColor3f(0.7f, 0.7f, 0.9f);
				myGL.glTranslatef((float) (0 - (width / 2 - dx)), 0.0f, 0.0f);
				myGL.glBegin(GL.GL_QUADS);
				{
					myGL.glVertex3f(0.0f, 0.0f, 0.0f);
					myGL.glVertex3f(20.0f, 20.0f, 0.0f);
					myGL.glVertex3f(15.0f, 0.0f, 0.0f);
					myGL.glVertex3f(20.0f, -20.0f, 0.0f);
				}
				myGL.glEnd();
				myGL.glColor3f(0.8f, 0.8f, 0.9f);
				myGL.glBegin(GL.GL_LINE_LOOP);
				{
					myGL.glVertex3f(0.0f, 0.0f, 0.0f);
					myGL.glVertex3f(20.0f, 20.0f, 0.0f);
					myGL.glVertex3f(15.0f, 0.0f, 0.0f);
					myGL.glVertex3f(20.0f, -20.0f, 0.0f);
				}
				myGL.glEnd();
			}
			myGL.glPopMatrix();
			myGL.glLineWidth(2.0f);
			// UpLeft arrow
			myGL.glPushMatrix();
			{
				myGL.glColor3f(0.7f, 0.7f, 0.9f);
				myGL.glTranslatef((float) (0 - (width / 2 - dx)), (float) (height / 2 - dx), 0.0f);
				myGL.glBegin(GL.GL_QUADS);
				{
					myGL.glVertex3f(0.0f, 0.0f, 0.0f);
					myGL.glVertex3f(5.0f, -20.0f, 0.0f);
					myGL.glVertex3f(8.0f, -8.0f, 0.0f);
					myGL.glVertex3f(20.0f, -5.0f, 0.0f);
				}
				myGL.glEnd();
				myGL.glColor3f(0.8f, 0.8f, 0.9f);
				myGL.glBegin(GL.GL_LINE_LOOP);
				{
					myGL.glVertex3f(0.0f, 0.0f, 0.0f);
					myGL.glVertex3f(5.0f, -20.0f, 0.0f);
					myGL.glVertex3f(8.0f, -8.0f, 0.0f);
					myGL.glVertex3f(20.0f, -5.0f, 0.0f);
				}
				myGL.glEnd();
			}
			myGL.glPopMatrix();
			// UpRight
			myGL.glPushMatrix();
			{
				myGL.glColor3f(0.7f, 0.7f, 0.9f);
				myGL.glTranslatef((float) (width / 2 - dx), (float) (height / 2 - dx), 0.0f);
				myGL.glBegin(GL.GL_QUADS);
				{
					myGL.glVertex3f(0.0f, 0.0f, 0.0f);
					myGL.glVertex3f(-5.0f, -20.0f, 0.0f);
					myGL.glVertex3f(-8.0f, -8.0f, 0.0f);
					myGL.glVertex3f(-20.0f, -5.0f, 0.0f);
				}
				myGL.glEnd();
				myGL.glColor3f(0.8f, 0.8f, 0.9f);
				myGL.glBegin(GL.GL_LINE_LOOP);
				{
					myGL.glVertex3f(0.0f, 0.0f, 0.0f);
					myGL.glVertex3f(-5.0f, -20.0f, 0.0f);
					myGL.glVertex3f(-8.0f, -8.0f, 0.0f);
					myGL.glVertex3f(-20.0f, -5.0f, 0.0f);
				}
				myGL.glEnd();
			}
			myGL.glPopMatrix();
			// DownLeft
			myGL.glPushMatrix();
			{
				myGL.glColor3f(0.7f, 0.7f, 0.9f);
				myGL.glTranslatef((float) (0 - (width / 2 - dx)), (float) (0 - (height / 2 - dx)), 0.0f);
				myGL.glBegin(GL.GL_QUADS);
				{
					myGL.glVertex3f(0.0f, 0.0f, 0.0f);
					myGL.glVertex3f(5.0f, 20.0f, 0.0f);
					myGL.glVertex3f(8.0f, 8.0f, 0.0f);
					myGL.glVertex3f(20.0f, 5.0f, 0.0f);
				}
				myGL.glEnd();
				myGL.glColor3f(0.8f, 0.8f, 0.9f);
				myGL.glBegin(GL.GL_LINE_LOOP);
				{
					myGL.glVertex3f(0.0f, 0.0f, 0.0f);
					myGL.glVertex3f(5.0f, 20.0f, 0.0f);
					myGL.glVertex3f(8.0f, 8.0f, 0.0f);
					myGL.glVertex3f(20.0f, 5.0f, 0.0f);
				}
				myGL.glEnd();
			}
			myGL.glPopMatrix();
			// DownRight
			myGL.glPushMatrix();
			{
				myGL.glColor3f(0.7f, 0.7f, 0.9f);
				myGL.glTranslatef((float) (width / 2 - dx), (float) (0 - (height / 2 - dx)), 0.0f);
				myGL.glBegin(GL.GL_QUADS);
				{
					myGL.glVertex3f(0.0f, 0.0f, 0.0f);
					myGL.glVertex3f(-5.0f, 20.0f, 0.0f);
					myGL.glVertex3f(-8.0f, 8.0f, 0.0f);
					myGL.glVertex3f(-20.0f, 5.0f, 0.0f);
				}
				myGL.glEnd();
				myGL.glColor3f(0.8f, 0.8f, 0.9f);
				myGL.glBegin(GL.GL_LINE_LOOP);
				{
					myGL.glVertex3f(0.0f, 0.0f, 0.0f);
					myGL.glVertex3f(-5.0f, 20.0f, 0.0f);
					myGL.glVertex3f(-8.0f, 8.0f, 0.0f);
					myGL.glVertex3f(-20.0f, 5.0f, 0.0f);
				}
				myGL.glEnd();
			}
			myGL.glPopMatrix();
		}
		myGL.glEndList();
	}

	/**
	 * Creeaza 5 nivele de text.
	 * 
	 * @param myGL
	 * @param myGLU
	 * @param glut
	 */
	public static void buildList_MapLevels(GL myGL, GLU myGLU, GLUT glut, int[] mapLevel, Point minPoint) {
		Road currentRoad;
		Point currentPoint;
		int i, j;
		float x, y, s;
		byte[] ri;
		// creates 5 different levels of text
		// Firs level has only one name for highways, placed in the middle of
		// the road
		myGL.glNewList(mapLevel[0], GL.GL_COMPILE);
		{
			i = 0;
			while (i < Globals.map.roads.size()) {
				// for every road
				currentRoad = (Road) Globals.map.roads.get(i);
				ri = currentRoad.getRoadinfo();
				if ((ri[1] >= 49) && (ri[1] < 51)) {// if it is a big road
					// (highway or primary road)
					// i put
					// the road name in the middle of it
					currentPoint = (Point) currentRoad.points.get((int) ((currentRoad.points.size() - 1) / 2));
					y = (float) GPSutil.getMetersLatitude(minPoint, currentPoint);
					x = (float) GPSutil.getMetersLongitude(minPoint, currentPoint);
					myGL.glColor3f(0.0f, 0.0f, 0.0f);
					myGL.glPushMatrix();
					{
						myGL.glTranslatef(x - 10, y - 10, 0.0f);
						myGL.glScalef(2.0f, 2.0f, 2.0f);
						glut.glutStrokeString(GLUT.STROKE_ROMAN, currentRoad.getName());
					}
					myGL.glPopMatrix();
				}
				i++;
			}
		}
		myGL.glEndList();
		// the rest of text levels
		for (j = 1; j < 5; j++) {
			mapLevel[j] = mapLevel[j - 1] + 1;
			myGL.glNewList(mapLevel[j], GL.GL_COMPILE);
			{
				i = 0;
				while (i < Globals.map.roads.size()) {// for every road
					currentRoad = (Road) Globals.map.roads.get(i);
					ri = currentRoad.getRoadinfo();
					if (j == 1) {
						// for the second level of text big roads (highways and
						// primary roads)
						// will have their name written 3 times: at start, in
						// the middle and
						// in the end, with a smaller font than the previous
						// level
						if ((ri[1] >= 49) && (ri[1] < 51)) {
							s = 1.0f;
							currentPoint = (Point) currentRoad.points.get(1);
							y = (float) GPSutil.getMetersLatitude(minPoint, currentPoint);
							x = (float) GPSutil.getMetersLongitude(minPoint, currentPoint);
							myGL.glColor3f(0.0f, 0.0f, 0.0f);
							myGL.glPushMatrix();
							{
								myGL.glTranslatef(x - 5, y - 5, 0.0f);
								myGL.glScalef(s, s, s);
								glut.glutStrokeString(GLUT.STROKE_ROMAN, currentRoad.getName());
							}
							myGL.glPopMatrix();
							currentPoint = (Point) currentRoad.points.get((int) ((currentRoad.points.size() - 1) / 2));
							y = (float) GPSutil.getMetersLatitude(minPoint, currentPoint);
							x = (float) GPSutil.getMetersLongitude(minPoint, currentPoint);
							myGL.glColor3f(0.0f, 0.0f, 0.0f);
							myGL.glPushMatrix();
							{
								myGL.glTranslatef(x - 5, y - 5, 0.0f);
								myGL.glScalef(s, s, s);
								glut.glutStrokeString(GLUT.STROKE_ROMAN, currentRoad.getName());
							}
							myGL.glPopMatrix();
							currentPoint = (Point) currentRoad.points.get((int) ((currentRoad.points.size() - 2)));
							y = (float) GPSutil.getMetersLatitude(minPoint, currentPoint);
							x = (float) GPSutil.getMetersLongitude(minPoint, currentPoint);
							myGL.glColor3f(0.0f, 0.0f, 0.0f);
							myGL.glPushMatrix();
							{
								myGL.glTranslatef(x - 5, y - 5, 0.0f);
								myGL.glScalef(s, s, s);
								glut.glutStrokeString(GLUT.STROKE_ROMAN, currentRoad.getName());
							}
							myGL.glPopMatrix();
						}
					}
					if (j == 2) {// the third level
						// for big roads the text is written 3 times, smaller
						// than the previous level
						// for secondary roads the name will be written once in
						// the middle
						if ((ri[1] <= 51) && (ri[1] >= 49)) {
							s = 0.4f;
							if (ri[1] > 51) {
								currentPoint = (Point) currentRoad.points.get(1);
								y = (float) GPSutil.getMetersLatitude(minPoint, currentPoint);
								x = (float) GPSutil.getMetersLongitude(minPoint, currentPoint);
								myGL.glColor3f(0.0f, 0.0f, 0.0f);
								myGL.glPushMatrix();
								{
									myGL.glTranslatef(x - 5, y - 5, 0.0f);
									myGL.glScalef(s, s, s);
									glut.glutStrokeString(GLUT.STROKE_ROMAN, currentRoad.getName());
								}
								myGL.glPopMatrix();
								currentPoint = (Point) currentRoad.points.get((int) ((currentRoad.points.size() - 2)));
								y = (float) GPSutil.getMetersLatitude(minPoint, currentPoint);
								x = (float) GPSutil.getMetersLongitude(minPoint, currentPoint);
								myGL.glColor3f(0.0f, 0.0f, 0.0f);
								myGL.glPushMatrix();
								{
									myGL.glTranslatef(x - 5, y - 5, 0.0f);
									myGL.glScalef(s, s, s);
									glut.glutStrokeString(GLUT.STROKE_ROMAN, currentRoad.getName());
								}
								myGL.glPopMatrix();
							}
							currentPoint = (Point) currentRoad.points.get((int) ((currentRoad.points.size() - 1) / 2));
							y = (float) GPSutil.getMetersLatitude(minPoint, currentPoint);
							x = (float) GPSutil.getMetersLongitude(minPoint, currentPoint);
							myGL.glColor3f(0.0f, 0.0f, 0.0f);
							myGL.glPushMatrix();
							{
								myGL.glTranslatef(x - 5, y - 5, 0.0f);
								myGL.glScalef(s, s, s);
								glut.glutStrokeString(GLUT.STROKE_ROMAN, currentRoad.getName());
							}
							myGL.glPopMatrix();
						}
					}
					if ((j == 3) || (j == 4)) {// for the last two levels the
						// small roads have their name
						// written in the middle with 2 sizes of fonts
						if (ri[1] >= 52) {
							if (j == 4) {
								s = 0.1f;
							} else {
								s = 0.2f;
							}
							currentPoint = (Point) currentRoad.points.get((int) ((currentRoad.points.size() - 1) / 2));
							y = (float) GPSutil.getMetersLatitude(minPoint, currentPoint);
							x = (float) GPSutil.getMetersLongitude(minPoint, currentPoint);
							myGL.glColor3f(0.0f, 0.0f, 0.0f);
							myGL.glPushMatrix();
							{
								myGL.glTranslatef(x - 5, y - 5, 0.0f);
								myGL.glScalef(s, s, s);
								glut.glutStrokeString(GLUT.STROKE_ROMAN, currentRoad.getName());
							}
							myGL.glPopMatrix();
						}
					}
					i++;
				}
			}
			myGL.glEndList();
		}
	}

	/**
	 * Petroaca - the FV,NFV,LAV,RAV display
	 * 
	 * @param myGL
	 * @param myGLU
	 * @param glut
	 */
	public static void buildList_DSRCapp(GL myGL, GLU myGLU, GLUT glut, int DSRCapp) {
		myGL.glNewList(DSRCapp, GL.GL_COMPILE);
		{
			myGL.glColor3f(1.0f, 1.0f, 1.0f);
			glut.glutSolidSphere(10, 40, 40);
		}
		myGL.glEndList();
	}

}