import com.ms.wfc.io.*;
import com.ms.wfc.core.*;
import com.ms.wfc.app.*;
import com.ms.wfc.ui.*;
import com.ms.wfc.util.*;
import java.util.Vector;
import com.ms.lang.*;
import com.ms.*;



public class JavaRoof extends Form   {
Vector roofPairs;
Point mouseAt;
Point onVertex;
boolean cc2 = false;
boolean debug = false;
boolean snap = true;
int onRoof;
Cursor hand,move,area;
boolean showVertices,ext;
PictureBox picBox;
Bitmap intBitmap,extBitmap;
Point mouseDownAt=new Point(0,0);
DrawArea drawA;
Point grabbedVertex,onVertexResult,lastAt;
Color dColor = Color.RED;
Border activeBorder;
Vector tempPoints;
short[][] extArray,intArray;
ProgressBar progBar;
MenuItem EditMenu;
MenuItem EditMenuInteriors,EditMenuSnap,FileMenuOpen,FileMenuRfm;

boolean dragVertex,dragArea,dragNew;	
	public static void main (String[] args) throws Exception { 
		
		JavaRoof mainW = new JavaRoof();
		mainW.setSize(600,500);
		mainW.setVisible(true);
		mainW.setWindowState(FormWindowState.MAXIMIZED);
		try {Application.run(mainW);} catch (Exception e) {
			//System.out.println(e);
			}
		
		}
	public void formInit() {
		ResourceManager r = new ResourceManager();	
		hand = new Cursor(r.getResource(this.getClass(),"hand.cur"));
		move = new Cursor(r.getResource(this.getClass(),"move.cur"));
		area = new Cursor(r.getResource(this.getClass(),"area.cur"));
		FileMenuOpen = new MenuItem("Open TGA");FileMenuOpen.addOnClick(new EventHandler(this.FileMenuOpen_click));
		FileMenuRfm = new MenuItem("Open RFM");FileMenuRfm.addOnClick(new EventHandler(this.rfmOpen_click));
		MenuItem FileMenuSave = new MenuItem("Save");FileMenuSave.addOnClick(new EventHandler(this.FileMenuSave_click));
		MenuItem FileMenuExit = new MenuItem("Exit");FileMenuExit.addOnClick(new EventHandler(this.exitApp));
		MenuItem FileMenu = new MenuItem("File",null,new MenuItem[]{FileMenuOpen,FileMenuRfm,FileMenuSave,FileMenuExit});	
		EditMenuInteriors = new MenuItem("Show interiors");EditMenuInteriors.setChecked(!ext);EditMenuInteriors.addOnClick(new EventHandler(this.EditMenuInteriors_click));
		EditMenuSnap = new MenuItem("Snap to vertices");EditMenuSnap.setChecked(snap);EditMenuSnap.addOnClick(new EventHandler(this.EditMenuSnap_click));
		EditMenu = new MenuItem("Edit",null,new MenuItem[]{EditMenuInteriors,EditMenuSnap});
		EditMenu.setEnabled(false);
		int i;
		MainMenu myMenu = new MainMenu(new MenuItem[]{FileMenu,EditMenu});
		
		//picBox = new PictureBox();
		//picBox.setSizeMode(PictureBoxSizeMode.AUTO_SIZE);
		//System.out.println(this.toString());
		drawA = new DrawArea();
		drawA.setSize(100,100);
		this.setMenu(myMenu);
		this.setText("GRoof2");
		this.setAutoScroll(true);
		
		}
	public JavaRoof()
		{
		
		
		
		formInit();
		roofPairs = new Vector();
		Icon thisIcon = new Icon(getResource("ico.ico"));
		setIcon(thisIcon);
		this.setWindowState(FormWindowState.MAXIMIZED);
	}
	public void DrawArea_keyPressed(Object sender, KeyEvent e) {
		
		if ( (e.getKeyCode () & Key.DELETE) != 0) {
		int rTest =  isRoof(mouseAt);
		if ( rTest != -1 )
			{
			roofPairs.removeElementAt(rTest);
			drawA.repaint();	
			}
		}
		}
	public void DrawArea_down(Object sender,MouseEvent e){ 
		
		Point downAt = new Point(e.x,e.y);
		Point vertexResult;
		// mouse down on a vertex
		if ( e.button == MouseButton.LEFT ) {
		if ( roofPairs.size() != 0 ) { 
		if ( (vertexResult = isVertex(downAt)) != null ) {
				//System.out.println("VERTEX");
				dragVertex = true;
				grabbedVertex = vertexResult;
				activeBorder = (Border)roofPairs.elementAt(vertexResult.x);
				mouseDownAt=downAt;
				return;	}
		
		// mouse down inside roof border
		int roofResult;
		if ( ( roofResult = isRoof(downAt)) != -1 ) {
			//System.out.println("ROOF");
			
			dragArea = true;	
			activeBorder = (Border)roofPairs.elementAt(roofResult);	
			tempPoints = (Vector)(activeBorder.getVertexVector().clone());
			mouseDownAt=downAt;
				return;	}
						}
		// mouse down outside roof border and vertices
		dragNew = true;
		mouseDownAt=downAt;
		return;
		}
		
		
		
		}
		public Point isVertex(Point p) {
			
			int i,j;
			for ( i = 0 ; i < roofPairs.size() ; i++ )
				{
				Border currentPair = (Border)roofPairs.elementAt(i);	
				if ( (j = currentPair.isVertex(p))!= -1 ) return(new Point(i,j)); 
						
				}
			return(null);
			}	
		public int isRoof(Point p) {
			
			int i;
			for ( i = 0 ; i < roofPairs.size() ; i++ )
				{
				Border aPair = (Border)roofPairs.elementAt(i);	
				if ( aPair.contains(p) )
					{
					return(i);	
					}
				}
			
			
			return(-1);
			}
	
	public void DrawArea_move(Object sender,MouseEvent e){ 
		mouseAt = new Point(e.x,e.y);	
		//System.out.println(e);
		if ( e.button == MouseButton.NONE ) {
			
			
			onVertex = isVertex(mouseAt);
			
			
			onRoof = isRoof(mouseAt);
			//System.out.println(onVertex + " " + onRoof);
			if ( onRoof > -1 ) drawA.setCursor(hand);
			if ( onVertex != null ) drawA.setCursor(move);
			if ( onVertex == null && onRoof == -1 ) 
			drawA.setCursor(area);
			
			
			
			
						}
		 
		 
		 
		if ( e.button == MouseButton.LEFT )	{
						
		if ( dragVertex ) {
			
			activeBorder.moveVertex(grabbedVertex.y,mouseAt);
			
			
					}
		
		if ( dragArea ) {
			if ( lastAt == null ) lastAt = mouseDownAt;
			Point origPoint = (Point)(tempPoints.elementAt(0));
			Point moved = new Point(mouseAt.x-mouseDownAt.x,mouseAt.y-mouseDownAt.y);
			
			activeBorder.move(moved.x,moved.y);
			
					}
		
		if ( dragNew ) {
		
		
				}
				
				}
		drawA.repaint();			
								}
	public void DrawArea_up(Object sender,MouseEvent e){			
		Point mouseUpAt = new Point(e.x,e.y);
		
		if ( e.button == MouseButton.RIGHT ) { 
			
		 	Point vResult;
		 	if ( roofPairs.size() != 0 ) { 
				if ( (vResult = isVertex(mouseUpAt)) != null ) {
					//System.out.println("VERTEX_UP");
					Border aBorder = (Border)roofPairs.elementAt(vResult.x);
					aBorder.removeVerticeAt(vResult.y);
					drawA.repaint();
					return;
						}
				int rResult;
				if ( ( rResult = isRoof(mouseUpAt) ) != -1 )
					{
					Border aBorder = (Border)roofPairs.elementAt(rResult);
					aBorder.addVerticeAt(mouseUpAt,aBorder.getCloser(mouseUpAt,aBorder.getClosest(mouseUpAt)));
					drawA.repaint();
					return;
					} 				
							}
			 	
		
			
			
						}
						
						
		if ( e.button == MouseButton.LEFT ) { 
			if ( dragVertex ) {
				
						}
			
			if ( dragArea ) {
				lastAt = null;
						}
			
			if ( dragNew ) { 
					if ( Math.abs(mouseDownAt.x- mouseUpAt.x) > 5 && Math.abs(mouseDownAt.y- mouseUpAt.y) > 5 ) 
						{		
						Border toAdd = new Border();
						toAdd.addVertice(mouseDownAt.x,mouseDownAt.y);
						toAdd.addVertice(mouseUpAt.x,mouseDownAt.y);
						toAdd.addVertice(mouseUpAt.x,mouseUpAt.y);	
						toAdd.addVertice(mouseDownAt.x,mouseUpAt.y);
						roofPairs.addElement(toAdd);
						}
					
					
					
					
					}
	
		dragVertex = false;
		dragArea = false;
		dragNew = false;		
		}
		drawA.repaint();
				
								}
	public Bitmap loadTga(String fileName) {
		Bitmap toReturn;
		File tgaFile = File.open(fileName);
		tgaFile.setPosition(12);
		int width = tgaFile.readShort();
		int height = tgaFile.readShort();
		
		tgaFile.setPosition(18);
		
		short[] data = new short[width*height];
		tgaFile.readShorts(data,0,data.length);
		//System.out.println(data[0]);
		int i=0;
		MemoryStream bmp = new MemoryStream();
		
			bmp.write(0x42);
			bmp.write(0x4d);
			int dataSize = width*height*2;
			
			
			bmp.writeInt(0x36+dataSize);
			while ( dataSize % 4 != 0 ) dataSize++;
			bmp.writeInt(0);
			
			bmp.writeInt(0x36);
			
			bmp.writeInt(0x28);
			bmp.writeInt(width);
			bmp.writeInt(height);
			bmp.writeShort((short)1);
			bmp.writeShort((short)16);
			bmp.writeInt(0);
			bmp.writeInt(dataSize);
			bmp.writeInt(0);bmp.writeInt(0);
			bmp.writeInt(0);bmp.writeInt(0);
			bmp.writeShorts(data);
		
		
		bmp.setPosition(0);
		
		toReturn = new Bitmap(bmp);
		tgaFile.close();
		bmp.close();
		return(toReturn);
		
	}
	public short[][] getTgaArray(String filename) {
		
		File tgaFile = File.open(filename);
		int i,j;
		tgaFile.setPosition(12);
		int width = tgaFile.readShort();
		int height =tgaFile.readShort();
		short[][] tgaArray = new short[height][width];
		for ( i = height -1 ; i > -1 ; i-- )
			{
			tgaFile.readShorts(tgaArray[i],0,width);
					
			}
		return(tgaArray);
		
	}
	
	public String getFileToLoad(String title) {
		
		OpenFileDialog ofd = new OpenFileDialog();
		ofd.setInitialDir("");
		ofd.setDefaultExt("tga");
		ofd.setFilter("Tga files (*.tga)|*.tga");     
		ofd.setFilterIndex(1);
		String inFileName;
		ofd.setTitle(title);
		int dlgResult = ofd.showDialog();  
		if (dlgResult == DialogResult.OK) {
		inFileName = ofd.getFileName();   
		return(inFileName);
		}
		else return(null);
		
		
	}
	public void rfmOpen_click(Object sender,Event e) {
		if ( intBitmap == null ) return;
		OpenFileDialog ofd = new OpenFileDialog();
		ofd.setInitialDir("");
		ofd.setDefaultExt("rfm");
		ofd.setFilter("CC3,4&5 Roof files (*.rfm)|*.rfm|CC2 Roof files (Roof*.)|Roof*");     
		ofd.setFilterIndex(1);
		String inFileName;
		ofd.setTitle("Open roof file");
		int dlgResult = ofd.showDialog();  
		if (dlgResult == DialogResult.OK) {
		inFileName = ofd.getFileName();   
		int i;
		Border[] borders;
		if ( ofd.getFilterIndex() == 1 ) {
		borders = getRoofs(inFileName);
		
				}
		else {
			borders = getCC2Roofs(inFileName);
			
			}
		for ( i = 0 ; i < borders.length ; i++ )
			{
			roofPairs.addElement(borders[i]);	
			}
			
		
		}
		else return;
		
		
	}
	
	public void FileMenuOpen_click(Object sender,Event e) {
		if ( intBitmap != null ) return;
		String intFile = (getFileToLoad("Open interior file"));
		if ( intFile == null ) return;
		this.setCursor(Cursor.WAIT);
		intBitmap = loadTga(intFile);
		intArray = getTgaArray(intFile);
		Graphics tempG = intBitmap.getGraphics();
		//System.out.println(tempG.getPixel(0,0));
		
		this.setCursor(Cursor.DEFAULT);
		java.awt.Toolkit.getDefaultToolkit().beep();
		String extFile = (getFileToLoad("Open exterior file"));	
		if ( extFile == null ) return;
		this.setCursor(Cursor.WAIT);
		extBitmap = loadTga(extFile);
		extArray = getTgaArray(extFile);
		
		if ( intBitmap.getSize().x != extBitmap.getSize().x || intBitmap.getSize().y != extBitmap.getSize().y )
			{
			MessageBox.show("Image sizes are not identical", "Error...", MessageBox.OK);
			intBitmap = null;
			extBitmap = null;
			intArray = null;
			extArray = null;
			this.setCursor(Cursor.DEFAULT);
			return;	}
		drawA = new DrawArea();
		drawA.initImage();
		drawA.setSize(intBitmap.getSize());
		this.add(drawA);
		drawA.addOnMouseDown(new MouseEventHandler(DrawArea_down));
		drawA.addOnMouseUp(new MouseEventHandler(DrawArea_up));
		drawA.addOnMouseMove(new MouseEventHandler(DrawArea_move));
		this.addOnKeyDown(new KeyEventHandler(DrawArea_keyPressed));
		this.setCursor(Cursor.DEFAULT);
		EditMenu.setEnabled(true);
		FileMenuOpen.setEnabled(false);
		drawA.repaint();
		this.update();
		
		
								}
			public static int intelToMac(int i) {
         		int byte0 = i & 0xff;
         		int byte1 = (i>>8) & 0xff;
         		int byte2 = (i>>16) & 0xff;
         		int byte3 = (i>>24) & 0xff;
         		// swap the byte order
         		return (byte0<<24) | (byte1<<16) | (byte2<<8) | byte3;
     					}
     			
     			public static int shortIntelToMac(int i) {
         		int byte0 = i & 0xff;
         		int byte1 = (i>>8) & 0xff;
         		// swap the byte order
         		return (byte0<<8) | byte1 ;
     				}						
	public void FileMenuSave_click(Object sender,Event e) {
		if ( roofPairs.size() < 1 ) return;
		SaveFileDialog ofd = new SaveFileDialog();
		ofd.setInitialDir("");
		ofd.setAddExtension(false);
		ofd.setDefaultExt("rfm");
		ofd.setFilter("CC3,4 & 5 Roof files (*.rfm)|*.rfm|CC2 Roof files (Roof*)|Roof*");     
		ofd.setFilterIndex(1);
		String inFileName;
		ofd.setTitle("Save roof file");
		int dlgResult = ofd.showDialog();  
		if (dlgResult == DialogResult.OK) {
		inFileName = ofd.getFileName();   
		
		}
		else return;
		
		
		this.setCursor(Cursor.WAIT);
		if ( ofd.getFilterIndex() != 1 ) cc2 = true;
		if ( cc2 == true )
			{
			
			MemoryStream dump = new MemoryStream();
			dump.writeInt(0x464F4F52);
			int roofs = roofPairs.size();
			dump.writeInt(intelToMac(roofs));
			dump.writeInt(0);
			dump.writeInt(0);
			long[] intOffs = new long[roofPairs.size()];
			long[] extOffs = new long[roofPairs.size()];
			//********
			MemoryStream masterStream = new MemoryStream();
		for ( int i = 0 ; i < roofPairs.size() ; i++ )
			{
			//System.out.println(i);
			Border aBorder = (Border)roofPairs.elementAt(i);
			Rectangle aRoof = aBorder.getRectangle();		
			int tempp = aRoof.x-1;
			
			if ( tempp < 0 ) tempp = 0;
			dump.writeShort((short)shortIntelToMac(tempp));
			dump.writeShort((short)shortIntelToMac((tempp)+aRoof.width));
			dump.writeShort((short)shortIntelToMac(aRoof.y));
			dump.writeShort((short)shortIntelToMac(aRoof.y+aRoof.height));
			
			
			short[] data = getRoofArray(extArray,aRoof,i);		
			//extOffs[i] = masterStream.getPosition()+16+roofs*132;
			dump.writeInt(intelToMac((int)masterStream.getPosition()));
			masterStream.writeShorts(data);
			data = getRoofArray(intArray,aRoof,i);
			//intOffs[i] = masterStream.getPosition()+16+roofs*132;
			dump.writeInt(intelToMac((int)masterStream.getPosition()));
			masterStream.writeShorts(data);
			}	
		
		File out = File.create(inFileName);
		
		dump.writeTo(out);
		masterStream.writeTo(out);
		masterStream.close();
		dump.close();
		out.close();
			
		// *****************	
			}
		if ( cc2 == false ) {
		MemoryStream dump = new MemoryStream();
		dump.writeInt(0x01F002E0);
		
		
		int roofs = roofPairs.size();
		dump.writeInt(roofs);
		dump.writeInt(0);dump.writeInt(0);
		long[] intOffs = new long[roofPairs.size()];
		long[] extOffs = new long[roofPairs.size()];
		MemoryStream masterStream = new MemoryStream();
		for ( int i = 0 ; i < roofPairs.size() ; i++ )
		{
			//System.out.println(i);
			Border aBorder = (Border)roofPairs.elementAt(i);
			Rectangle aRoof = aBorder.getRectangle();		
		
			dump.writeInt(2);
			int size = aBorder.getSize();
			dump.writeInt(size);
			for ( int j = 0 ; j < 12 ; j++ )
				{
				if ( j < size ) {
					dump.writeInt(aBorder.getVerticeAt(j).x);
					dump.writeInt(aBorder.getVerticeAt(j).y);
						}
				else
					{
					dump.writeInt(0xCDCDCDCD);
					dump.writeInt(0xCDCDCDCD);	
					}
				
			}
			dump.writeInt(aRoof.width*2);
			int tempp = aRoof.x-1;
			if ( tempp < 0 ) tempp = 0;
			
			dump.writeInt(tempp);
			dump.writeInt(aRoof.y);
			
			// *old one*
			//dump.writeInt(aRoof.x+aRoof.width);
			//dump.writeInt(aRoof.y+aRoof.height);
			
			dump.writeInt(aRoof.x+aRoof.width);
			dump.writeInt(aRoof.y+aRoof.height);
			
			short[] data = getRoofArray(extArray,aRoof,i);		
			//extOffs[i] = masterStream.getPosition()+16+roofs*132;
			dump.writeInt((int)masterStream.getPosition()+16+roofs*132);
			masterStream.writeShorts(data);
			data = getRoofArray(intArray,aRoof,i);
			//intOffs[i] = masterStream.getPosition()+16+roofs*132;
			dump.writeInt((int)masterStream.getPosition()+16+roofs*132);
			masterStream.writeShorts(data);
		}	
		File out = File.create(inFileName);
		dump.writeTo(out);
		masterStream.writeTo(out);
		masterStream.close();
		dump.close();
		out.close();
			}
		this.setCursor(Cursor.DEFAULT);
		 }
	
	public void exitApp(Object sender,Event e) { Application.exit(); }
	
	public void EditMenuInteriors_click(Object sender,Event e) {
		((MenuItem)sender).setChecked(ext);
		ext = !ext;
		drawA.repaint();
	}
	public void EditMenuSnap_click(Object sender,Event e) {
		
		snap = !snap;
		EditMenuSnap.setChecked(snap);
		
	}
public Point checkSnap(Point mPoint, int origRoof, int origIndex)
	{
	double dist = 5;
	int roofIndex = -666;
	int vertexIndex = -666;
	Point returnP = mPoint;
	for ( int i = 0 ; i < roofPairs.size() ; i++ )
		{
		if ( i != origRoof ) {
		Border aBorder = (Border)roofPairs.elementAt(i);	
		for ( int j = aBorder.getSize()-1 ; j > -1 ; j-- )
			{  
			Point p = aBorder.getVerticeAt(j);
			
			double aDist = Math.sqrt( (double) ((Math.abs(p.x-mPoint.x))*(Math.abs(p.x-mPoint.x)) + (Math.abs(p.y-mPoint.y))*(Math.abs(p.y-mPoint.y)) ));			
			
			if ( aDist < dist)
				{
				//System.out.println(aDist);
				dist = aDist;
				roofIndex = i;
				vertexIndex = j;	
				returnP = ((Border)roofPairs.elementAt(roofIndex)).getVerticeAt(vertexIndex);
				}
				}
			
			}
		}
		
	
	return(returnP);
			
	}
public short[] getRoofArray(short[][] bArray,Rectangle roofRect,int index ) {
	
	int height = roofRect.height;
	int width = roofRect.width;
	int originX = roofRect.x;
	int originY = roofRect.y;
	
	/*System.out.println("\n" + originX);
	System.out.println(originY);
	System.out.println(width);
	System.out.println(height);
	*/
	
	short[] data = new short[height*width];
	Border tempB = (Border)roofPairs.elementAt(index);
	Region tempR = Region.createPolygonal(tempB.getArray());
	for ( int i = 0 ; i < height ; i++ )
		{
		for ( int j = 0 ; j < width ; j++ )
			{
			
			if ( cc2 ) data[i*width+j] = (short)shortIntelToMac(bArray[originY+i][originX+j]);
			else {
			if ( tempR.contains(originX+j,originY+i) ) data[i*width+j] = bArray[originY+i][originX+j];	
			else data[i*width+j] = 0x7FFF;
				}
				}	
		}
	return(data);
	}
public Border[] getCC2Roofs(String filename) {
	File rfmFile = File.open(filename);
	
	rfmFile.setPosition(4);
	int roofCount = intelToMac(rfmFile.readInt());
	Border[] borderArray = new Border[roofCount];
	rfmFile.setPosition(16);
	
	int i;
	for ( i = 0 ; i < roofCount ; i++ )
		{
		rfmFile.setPosition(16+16*i);
		Border toAdd = new Border();
		int x1,x2,y1,y2;
		int width = intBitmap.getSize().x;
		int height = intBitmap.getSize().y;
		x1 = shortIntelToMac(rfmFile.readShort());
		if ( x1 < 0 ) x1 = 0;
		if ( x1 > width ) x1 = width;
		x2 = shortIntelToMac(rfmFile.readShort());	
		if ( x2 < 0 ) x2 = 0;
		if ( x2 > width ) x2 = width;
		y1 = shortIntelToMac(rfmFile.readShort());
		if ( y1 < 0 ) y1 = 0;
		if ( y1 > height ) y1 = height;
		y2 = shortIntelToMac(rfmFile.readShort());	
		if ( y2 < 0 ) y2 = 0;
		if ( y2 > height ) y2 = height;
		toAdd.addVertice(x1,y1);	
		toAdd.addVertice(x2,y1);	
		toAdd.addVertice(x2,y2);
		toAdd.addVertice(x1,y2);
		borderArray[i] = toAdd;
		}
	
	return(borderArray);
	}	
public Border[] getRoofs(String filename) {
	File rfmFile = File.open(filename);
	
	rfmFile.setPosition(4);
	int roofCount = rfmFile.readShort();
	Border[] borderArray = new Border[roofCount];
	rfmFile.setPosition(16);
	
	int i;
	for ( i = 0 ; i < roofCount ; i++ )
		{
		rfmFile.setPosition(16+132*i);
		Border toAdd = new Border();
		rfmFile.readInt();
		int verticeCount = rfmFile.readInt();
		int j;
		for ( j = 0 ; j	< verticeCount ; j++ )
			{
			toAdd.addVertice(rfmFile.readInt(),rfmFile.readInt());	
			}
		borderArray[i] = toAdd;
		
		}
	
	return(borderArray);
	}
public class DrawArea extends PictureBox{
	
	protected Bitmap realBitmap;
	protected Graphics thisG;
	public DrawArea() {
		
		
		}
	public void initImage() {
		realBitmap = new Bitmap(intBitmap.getSize().x, intBitmap.getSize().y);
		thisG = realBitmap.getGraphics();
		thisG.drawImage(intBitmap,0,0);
		thisG.setBrush(Brush.HOLLOW);
		
		thisG.setPen(new Pen(dColor));
		}	
			
			
	public void repaint() {
		
		this.onPaint(null);
		}
	protected void onPaint(PaintEvent e) {
		redraw(this,e);
		}
	public void redraw(Object sender,PaintEvent e) {
		
		thisG.setClip(-drawA.getLocation().x,-drawA.getLocation().y,-drawA.getLocation().x+drawA.getForm().getSize().x,-drawA.getLocation().y+drawA.getForm().getSize().y);
		
		if ( ext ) { 
			
			thisG.drawImage(extBitmap,0,0); }
			else {
				
				thisG.drawImage(intBitmap,0,0);
			
				 } 
		if ( dragNew ) {
			thisG.invert(mouseDownAt.x,mouseDownAt.y,mouseAt.x-mouseDownAt.x,mouseAt.y-mouseDownAt.y);
			
			
			
			
			}	
		showVertices = true;
		
		if ( showVertices ) {
			
			int i;
			int roofPairSize = roofPairs.size();
			for ( i = 0 ; i < roofPairSize ; i++ )
				{
					
				
				thisG.setPen(new Pen(dColor,PenStyle.SOLID,1));
				if ( new Integer(onRoof) != null ) {
					if ( i == onRoof ) thisG.setPen(new Pen(dColor,PenStyle.DASH,1)); //thisG.setPen(new Pen(Color.BLUE));
						}
				Border aBorder = (Border)roofPairs.elementAt(i);	
				thisG.drawLines(aBorder.getArray());
				aBorder.drawVerticesTo(thisG);
				if ( onVertex != null ) {
					Point tem = ((Border)roofPairs.elementAt(onVertex.x)).getVerticeAt(onVertex.y);
					thisG.setPen(new Pen(Color.BLUE,PenStyle.SOLID,2));
					thisG.drawRect(tem.x-5,tem.y-5,10,10);
					
					thisG.setPen(new Pen(dColor,PenStyle.DOT,1));
					thisG.drawLines(((Border)roofPairs.elementAt(onVertex.x)).getArray());
				
					
								}
				}
			
				}	
			
			Graphics g = this.createGraphics();
			//g.setClip(-picBox.getLocation().x,-picBox.getLocation().y,-picBox.getLocation().x+picBox.getForm().getSize().x,-picBox.getLocation().y+picBox.getForm().getSize().y);
			g.drawImage(realBitmap,0,0);
			
			//g.dispose();
				
		}
		
	}

public class Border {
	
	private Vector vertices = new Vector();
	Point[] temp;
	public Border() {
			}
		
	public void addVertice(int x, int y) {
		this.addVertice(new Point(x,y));
		
						}
	
	public void addVerticeAt(Point aPoint,int index) {
		if ( getSize() > 11 ) return;
		vertices.insertElementAt(aPoint,index);
		temp = new Point[getVerticeCount()];
		int i;
		
		for ( i = 0 ; i < temp.length ; i++ )
			{
			temp[i] = getVerticeAt(i);	
			}
			}
	public void addVertice(Point aPoint) {
		if ( getSize() > 11 ) return;
		vertices.addElement(aPoint);
		temp = new Point[getVerticeCount()];
		int i;
		
		for ( i = 0 ; i < temp.length ; i++ )
			{
			temp[i] = getVerticeAt(i);	
			}
			}
	public void removeVerticeAt(int index) {
		if ( this.getSize() < 4 ) return;
		this.vertices.removeElementAt(index);
		temp = new Point[getVerticeCount()];
		int i;
		
		for ( i = 0 ; i < temp.length ; i++ )
			{
			temp[i] = getVerticeAt(i);	
			}
						}		
			
	public void removeVertice(Point aPoint) {
		vertices.removeElement(aPoint);
		temp = new Point[getVerticeCount()];
		int i;
		
		for ( i = 0 ; i < temp.length ; i++ )
			{
			temp[i] = getVerticeAt(i);	
			}
		
		}
	public int getSize() {
		return(vertices.size());
		}
	public int isVertex(Point p) {
		
		int i;
		
		for ( i = 0 ; i < this.getSize() ; i++ )
			{
			Point temp = this.getVerticeAt(i);
			if ( Math.abs(temp.x- p.x) < 10 && Math.abs(temp.y- p.y) < 10 ) return(i);
			}
		return(-1);
		}
	public Point[] getArray() {
		Point[] tempo = new Point[getVerticeCount()+1];
		int i;
		
		for ( i = 0 ; i < tempo.length-1 ; i++ )
			{
			tempo[i] = getVerticeAt(i);	
			}
		tempo[tempo.length-1] = this.getVerticeAt(0);
		return(tempo);
		}
	public boolean contains(Point p) {
		temp = new Point[getVerticeCount()];
		int i;
		
		for ( i = 0 ; i < temp.length ; i++ )
			{
			temp[i] = getVerticeAt(i);	
			}
		Region tempR;
		try {
		tempR = Region.createPolygonal(temp);
		
		if ( tempR.contains(p) ) return(true);
		else return(false);
		 } catch (Exception eeeee) {} 
		return(false);
	}
	public int getCloser(Point newP,int index) {
		
		int indexMinus = index -1;
		if ( indexMinus == -1 ) indexMinus = this.getSize()-1;
		int indexPlus = index +1;
		if ( indexPlus == this.getSize() ) indexPlus = 0;
		Point p = (Point)(this.vertices.elementAt(index));
		Point mPoint = (Point)(this.vertices.elementAt(indexMinus));
		Point pPoint = (Point)(this.vertices.elementAt(indexPlus));
		int mD = (int)Math.sqrt( (double) ((Math.abs(p.x-mPoint.x))*(Math.abs(p.x-mPoint.x)) + (Math.abs(p.y-mPoint.y))*(Math.abs(p.y-mPoint.y)) ));
		int pD = (int)Math.sqrt( (double) ((Math.abs(p.x-pPoint.x))*(Math.abs(p.x-pPoint.x)) + (Math.abs(p.y-pPoint.y))*(Math.abs(p.y-pPoint.y)) ));
		
		int newPToPToP;
		int newPToPToM;
		
		double l = Math.sqrt( (mPoint.x-p.x)*(mPoint.x-p.x) + (mPoint.y-p.y)*(mPoint.y-p.y) );
		double upper = (p.y-newP.y)*(mPoint.x-p.x)-(p.x-newP.x)*(mPoint.y-p.y);
		
		double rOne = Math.abs(upper/l);
		
		l = Math.sqrt( (pPoint.x-p.x)*(pPoint.x-p.x) + (pPoint.y-p.y)*(pPoint.y-p.y) );
		upper = (p.y-newP.y)*(pPoint.x-p.x)-(p.x-newP.x)*(pPoint.y-p.y);
		double rTwo = Math.abs(upper/l);
		
		
		
		
		
		int toReturn=0;
		if ( rOne < rTwo ) toReturn= (indexMinus +1);
		else  if ( indexPlus == 0 ) toReturn = this.getSize();
			else toReturn=(indexPlus);
		
		return(toReturn);
				}
	public int getClosest(Point p) {
		
		int closestTo=0;
		int shortestDistance = 1000000;
		
		for ( int i = 0 ; i < this.getSize() ; i ++ )
			{
			Point aPoint = (Point)(this.vertices.elementAt(i));	
			int inD = (int)Math.sqrt( (double) ((Math.abs(p.x-aPoint.x))*(Math.abs(p.x-aPoint.x)) + (Math.abs(p.y-aPoint.y))*(Math.abs(p.y-aPoint.y)) ));
			if ( inD < shortestDistance ) {closestTo = i ; shortestDistance = inD;}
			} 
		
		return(closestTo);
			}
	public Point getVerticeAt(int i) {
		if ( i > getSize()-1 ) i = getSize()-1; 
		return((Point)vertices.elementAt(i));
		}
	public int getVerticeCount(){
		return(vertices.size());
		}
	public Vector getVertexVector()
		{
			return(vertices);
		}
	public void move(int x,int y) {
		int i;
		for ( i = 0 ; i < this.getSize() ; i++ )
			{
			Point aPoint = (Point)tempPoints.elementAt(i);
			
			aPoint = new Point(aPoint.x+x,aPoint.y+y);
			if ( aPoint.x < 0 ) aPoint.x = 0;
			if ( aPoint.x > intBitmap.getSize().x ) aPoint.x = intBitmap.getSize().x;
		
			if ( aPoint.y < 0 ) aPoint.y = 0;
			if ( aPoint.y > intBitmap.getSize().y ) aPoint.y = intBitmap.getSize().y;
		
			activeBorder.vertices.setElementAt(aPoint,i);
			}
		
		
	}
	public Rectangle getRectangle() {
		
		int maxX=-100000;
		int maxY=-1000000;
		int minX = 1000000000;
		int minY = 1000000000;
		
		for ( int i = 0 ; i < getSize(); i++ )
			{
			Point aPoint = (Point)(vertices.elementAt(i));
			
			if ( aPoint.x > maxX ) maxX = aPoint.x;
			if ( aPoint.x < minX ) minX = aPoint.x;
			if ( aPoint.y > maxY ) maxY = aPoint.y;
			if ( aPoint.y < minY ) minY = aPoint.y;
			
				
			} 
		
		return(new Rectangle(minX,minY,maxX-minX,maxY-minY));
		}
	public void moveVertex(int index,Point newPoint) {
		if ( newPoint.x < 0 ) newPoint.x = 0;
		if ( newPoint.x > intBitmap.getSize().x ) newPoint.x = intBitmap.getSize().x;
		
		if ( newPoint.y < 0 ) newPoint.y = 0;
		if ( newPoint.y > intBitmap.getSize().y ) newPoint.y = intBitmap.getSize().y;
		if ( snap ) {
			
			newPoint = checkSnap(newPoint,roofPairs.indexOf(this),index);
				}
		this.vertices.setElementAt(newPoint,index);
		temp = new Point[getVerticeCount()];
		int i;
		
		for ( i = 0 ; i < temp.length ; i++ )
			{
			temp[i] = getVerticeAt(i);	
			}
		
		}
	public void drawVerticesTo(Graphics g) {
		int i;
		for ( i = 0 ; i < this.getSize() ; i++ )
			{
			Point tem = this.getVerticeAt(i);
			
			 g.drawRect(tem.x-5,tem.y-5,10,10);	
			if ( debug ) g.drawString(Integer.toString(i),tem.x+10,tem.y+10);
			}
		
		}
	public void drawTo ( Graphics g ) {
		
		
		g.drawLines(temp);
		
		}	
			} // end border

}