Pad.java

// KicadModuleToGEDA - a utility for turning kicad modules to gEDA PCB footprints
// Pad.java v1.0
// Copyright (C) 2015 Erich S. Heinzle, a1039181@gmail.com

//    see LICENSE-gpl-v2.txt for software license
//    see README.txt
//    
//    This program 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.
//    
//    This program 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 this program; if not, write to the Free Software
//    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
//    
//    KicadModuleToGEDA Copyright (C) 2015 Erich S. Heinzle a1039181@gmail.com



/**
*
* This class is used to store and process a pad/pin definition string from a Kicad footprint
* allowing it then generate a gEDA PCB compatible footprint
* Oblong hole definitions are processed sensibly, to produce a pair of joined pins, but
* slots implemented this way as a pair of pins with joining pads on both sides of the board
* require gerbers to be post-processed with a G85 directive to join the pins to make a slot
*
*/

import java.util.Scanner;

public class Pad extends FootprintElementArchetype
{

	String kicadShapePadName = "not defined";
	String kicadShapeNetName = "not defined yet";

	long kicadShapeXsizeNm = 0;
	long kicadShapeYsizeNm = 0;

	long kicadShapeXdeltaNm = 0;    // this is used to define trapezoidal pads
					// -ve xDelta = decrease in left edge length vs right
					// +ve xDelta = increase in right edge length vs left
	long kicadShapeYdeltaNm = 0;    // this is used to define trapezoidal pads
					// -ve yDelta = decrease in top edge length vs bottom
					// +ve yDelta = increase in bottom edge length vs top
					// Note: one or both of xDelta, yDelta, must be zero

	long kicadShapeOrientation = 0; // this is specified in decidegrees by kicad

	char kicadDrillShape = '0';
	long kicadDrillOneSizeNm = 0;
	long kicadDrillOneXoffsetNm = 0;
	long kicadDrillOneYoffsetNm = 0;
	char kicadDrillShapeTwo = '0' ;
	long kicadDrillSlotWidthNm = 0;
	long kicadDrillSlotHeightNm = 0;

	long kicadPadPositionXNm = 0;
	long kicadPadPositionYNm = 0;

	String kicadPadAttributeType = "null";

	long gEDAdefaultMetalClearance = 20; // NB defined here in thousandths of an inch = mils
					// (clearance/2) = minimum distance from pad/pin metal
					// to nearest copper
					// this gets multiplied by 100 for 0.01 mil units in output
	long gEDAdefaultSolderMaskRelief = 8; // NB defined here in thousandths of an inch = mils
					// solder mask relief
					//  = ((thickness of mask aperture) - (pad or pin thickness))
                                        // this gets multiplied by 100 for 0.01 mil units in output

	long gEDAdefaultMinimumDrillSizeNm = 0; // 300000 is big enough to be vaguely sane for vias
					// this can be imposed when creating the module by passing
					// a minimum drill/via size to the setter/constructor

        String topLayerPad = "";     // we use these temporary variables when building slots  
        String bottomLayerPad = "";  // and obroid pads

	Boolean equilateralPad = true; // also used when processing obroid, round and circular pads

// Pins and SMD pads have been converted from Kicad foot prints which do not have solder
// mask relief or clearances specified. Default values used for solder mask relief and
// clearance are as specified above.
//
// Users of the foot print must ensure that the solder mask reliefs and clearances are
// compatible with the PCB manufacturer's process tolerances

	String gEDAflag = "blah"; // hex values now deprecated i.e. "0x0000"

	public Pad() // the default constructor simply creates a simple default pad for testing
	{
		kicadShapePadName = "1";
	        kicadShapeNetName = "GND";

	        kicadShapeXsizeNm = 800*2540;
	        kicadShapeYsizeNm = 800*2540;
      		kicadShapeXdeltaNm = 0;
        	kicadShapeYdeltaNm = 0;
        	kicadShapeOrientation = 0;

        	kicadDrillShape = 'C';
        	kicadDrillOneSizeNm = 600;
        	kicadDrillOneXoffsetNm = 0;
        	kicadDrillOneYoffsetNm = 0;
        	kicadDrillShapeTwo = 'C';
		kicadDrillSlotWidthNm = 0;
		kicadDrillSlotHeightNm = 0;

        	kicadPadPositionXNm = 1000*2540;
        	kicadPadPositionYNm = 1000*2540;

        	kicadPadAttributeType = "STD";

	}

	public void populateElement(String arg, boolean metric, long minimumViaAndDrillSizeNM)
	{
		gEDAdefaultMinimumDrillSizeNm = minimumViaAndDrillSizeNM;
		String parseString = "";
		String[] tokens;

//		System.out.println("Constructor has been passed:" + arg);

		float parsedValue = 0;

		Scanner padDefinition = new Scanner(arg);

// the while statement takes care of legacy pad definitions
// will need to fork here with an if, either legacy or s-file
// since s-file fits almost all of it on one line

		while (padDefinition.hasNextLine())
                {
//		        System.out.println("Now in while loop, processing: " + parseString);
			parseString = padDefinition.nextLine();
			tokens = parseString.split(" ");

			if (tokens[0].startsWith("Sh"))
			{
				kicadShapePadName = tokens[1];
                                // we get rid of leading and trailing ""
                                if (kicadShapePadName.length() >= 2) {
                                  if (kicadShapePadName.startsWith("\"") && kicadShapePadName.endsWith("\"")) {
                                    kicadShapePadName = 
                                        kicadShapePadName.substring(1,kicadShapePadName.length()-1);
                                    // System.out.println("trimmed pad name: " + kicadShapePadName);
                                  }
                                }
//                              we get rid of odd characters that may interfere with pad naming:
				kicadShapePadName = kicadShapePadName.replaceAll("[^a-zA-Z0-9.-]", "_");
				kicadDrillShape = tokens[2].charAt(0);
//				System.out.println("Drillshape: " + drillShape);
				parsedValue = Float.parseFloat(tokens[3]);
				kicadShapeXsizeNm = convertToNanometres(parsedValue, metric);
				parsedValue = Float.parseFloat(tokens[4]);
				kicadShapeYsizeNm = convertToNanometres(parsedValue, metric);
//				System.out.println(shapeXsize + " " + shapeYsize);
                                parsedValue = Float.parseFloat(tokens[5]);
				kicadShapeXdeltaNm = convertToNanometres(parsedValue, metric);
                                parsedValue = Float.parseFloat(tokens[6]);
				kicadShapeYdeltaNm = convertToNanometres(parsedValue, metric);
                                kicadShapeOrientation = Integer.parseInt(tokens[7]);
				// this is the rotation of the pad in decidegrees
                                // we need orientation to process obround pads
			}
			if (tokens[0].startsWith("Po"))
			{
				parsedValue = Float.parseFloat(tokens[1]);
				kicadPadPositionXNm = convertToNanometres(parsedValue, metric);
//				System.out.println(padPositionX);
				parsedValue = Float.parseFloat(tokens[2]);
				kicadPadPositionYNm = convertToNanometres(parsedValue, metric);
//				System.out.println(padPositionY);
			}
			if (tokens[0].startsWith("Ne"))
			{
				kicadShapeNetName = tokens[2];	
                                // we get rid of leading and trailing ""
                                if (kicadShapeNetName.length() >= 2) {
                                  if (kicadShapeNetName.startsWith("\"") && kicadShapeNetName.endsWith("\"")) {
                                    kicadShapeNetName = 
                                        kicadShapeNetName.substring(1,kicadShapeNetName.length()-1);
                                  }
                                }

//		we now need to cleanse the NetName of nasties like '$' which sometimes occur
				kicadShapeNetName = kicadShapeNetName.replaceAll("[^a-zA-Z0-9.-]", "_");
//				System.out.println("Shape's Net name: " + shapeNetName);
			}
			if (tokens[0].startsWith("At"))
			{
				kicadPadAttributeType = tokens[1];
//				System.out.println("Pad attribute type: " + padAttributeType);
			}

			if (tokens[0].startsWith("Dr"))
			{
				parsedValue = Float.parseFloat(tokens[1]);
				kicadDrillOneSizeNm = convertToNanometres(parsedValue, metric);
//				System.out.println("Drill size: " + drillOneSize);
				// we can capture drill x and y offset, but it may not be useful
				parsedValue = Float.parseFloat(tokens[2]);
				kicadDrillOneXoffsetNm = convertToNanometres(parsedValue, metric);
				parsedValue = Float.parseFloat(tokens[3]);
				kicadDrillOneYoffsetNm = convertToNanometres(parsedValue, metric);
//				System.out.println("First hole X and Y offsets: " +
//					drillOneXoffset + "  " + drillOneYoffset);

				// and now we figure out if there is a second hole defined, i.e. slot
				if (tokens.length > 5)
				{
//					System.out.print("hey, there's a second hole");
//					System.out.print(" and it is defined as ");
					kicadDrillShapeTwo = tokens[4].charAt(0);
//					System.out.println(drillShapeTwo);
					parsedValue = Float.parseFloat(tokens[5]);
					kicadDrillSlotWidthNm = convertToNanometres(parsedValue, metric);
					parsedValue = Float.parseFloat(tokens[6]);
					kicadDrillSlotHeightNm = convertToNanometres(parsedValue, metric);
//					System.out.println("DrillTwoX and DrillTwoY are: " + drillTwoX + "  " + drillTwoY);
				}
				else    // this captures scenarios where the pad is repopulated
				{       // with a pin rather than a slot
					kicadDrillShapeTwo = '0';
				}
			}
			if (parseString.startsWith("pad"))  // we move onto dedicated s-file parsing
			{
				metric = true;
//				System.out.println("Parsing s-file pad description");
//				while (padDefinition.hasNextLine())
//				{
//					parseString = parseString + " " + padDefinition.nextLine();
//				}
                                tokens = parseString.split(" ");
//				for (int counter = 0; counter < tokens.length; counter++)
//				{
//					System.out.println("Pad token #: " + counter + " : " + tokens[counter]);
//				}

				// we first grab the pad name
                                kicadShapePadName = tokens[1].replaceAll("[^a-zA-Z0-9.-]", "_");
				// and rid the Pad Name of nasties like '$' which sometimes occur

				// next we glean the type of pad
				if (tokens[2].startsWith("thru_hole"))
				{
					kicadPadAttributeType = "STD";
				}
				else if (tokens[2].startsWith("smd"))
                                {
                                        kicadPadAttributeType = "SMD";
                                }
                                else if (tokens[2].startsWith("connect"))
                                {
                                        kicadPadAttributeType = "CONN";
                                }
                                else if (tokens[2].startsWith("np_thru"))
                                {
                                        kicadPadAttributeType = "HOLE";
                                }

				// next comes the shape of the pad or hole
                                if (tokens[3].startsWith("circle"))
                                {
                                        kicadDrillShape = 'C';
                                }
                                else if (tokens[3].startsWith("rect"))
                                {
                                        kicadDrillShape = 'R';
                                }
                                else if (tokens[3].startsWith("oval"))
                                {
                                        kicadDrillShape = 'O';
                                }
                                else if (tokens[3].startsWith("trapezoid"))
                                {
                                        kicadDrillShape = 'T';
                                }

				// now we parse the less predictable remaining attributes
                                for (int parseIndex = 4; parseIndex < tokens.length; parseIndex++)
                                {
	                                if (tokens[parseIndex].startsWith("at"))
        	                        {
						parseIndex++;
		                                parsedValue = Float.parseFloat(tokens[parseIndex]);
                		                kicadPadPositionXNm = convertToNanometres(parsedValue, metric);
//                              		System.out.println(padPositionX);
						parseIndex++;
                                		parsedValue = Float.parseFloat(tokens[parseIndex]);
                                		kicadPadPositionYNm = convertToNanometres(parsedValue, metric);
//                              		System.out.println(padPositionY);
						kicadShapeOrientation = 0; // set a default value
						// we now look to see if orientation is specified
						if (!tokens[parseIndex + 1].startsWith("size"))
						{
							// them tricksy kicadians went and changed
							// from decidegrees to degrees in the s-file
							// format without telling anyone....
							// hence the multiplication by 10......
							kicadShapeOrientation = 10*Integer.parseInt(tokens[parseIndex+1]);
							parseIndex++;
						}
                        	        }
					else if (tokens[parseIndex].startsWith("size"))
					{
						parseIndex++;
		                                parsedValue = Float.parseFloat(tokens[parseIndex]);
        		                        kicadShapeXsizeNm = convertToNanometres(parsedValue, metric);
						parseIndex++;
                        		        parsedValue = Float.parseFloat(tokens[parseIndex]);
                                		kicadShapeYsizeNm = convertToNanometres(parsedValue, metric);
					}
					else if (tokens[parseIndex].startsWith("rect_delta"))
					{
                                                parseIndex++;
                                                parsedValue = Float.parseFloat(tokens[parseIndex]);
                                                kicadShapeXdeltaNm = convertToNanometres(parsedValue, metric);
                                                parseIndex++;
                                                parsedValue = Float.parseFloat(tokens[parseIndex]);
                                                kicadShapeYdeltaNm = convertToNanometres(parsedValue, metric);
					}
                                        else if (tokens[parseIndex].startsWith("drill"))
                                        {
                                                parseIndex++;
						// we look to see if it is an oval hole 
						if (tokens[parseIndex].startsWith("o"))
                                        	{
							kicadDrillShapeTwo = 'O';
							parseIndex++;
	                                        	parsedValue = Float.parseFloat(tokens[parseIndex]);
        	                                	kicadDrillSlotWidthNm = convertToNanometres(parsedValue, metric);
							parseIndex++;
                	                        	parsedValue = Float.parseFloat(tokens[parseIndex]);
                                        		kicadDrillSlotHeightNm = convertToNanometres(parsedValue, metric);
						}
						else // it isn't an oval hole
						{
                                                	parsedValue = Float.parseFloat(tokens[parseIndex]);
        		                        	kicadDrillOneSizeNm = convertToNanometres(parsedValue, metric);
		                                        kicadDrillShapeTwo = '0';// flag lack of hole 2
						}

						// we now look for x,y offset of hole, if specified
						if ((parseIndex < (tokens.length - 2)) && tokens[parseIndex + 1].startsWith("offset"))
						{
							parseIndex++; // we step past "offset"
							parseIndex++; // and get to offsetX
			                                parsedValue = Float.parseFloat(tokens[parseIndex]);
                        			        kicadDrillOneXoffsetNm = convertToNanometres(parsedValue, metric);
							parseIndex++; // and then onto offsetY
			                                parsedValue = Float.parseFloat(tokens[parseIndex]);
			                                kicadDrillOneYoffsetNm = convertToNanometres(parsedValue, metric);
						}
                                        }
                                        else if (tokens[parseIndex].startsWith("net"))
                                        {
						parseIndex++;
						// we will skip the net number
						parseIndex++;
		                                kicadShapeNetName = tokens[parseIndex];
//              		we now need to cleanse the NetName of nasties like '$' which sometimes occur
                                		kicadShapeNetName = kicadShapeNetName.replaceAll("[^a-zA-Z0-9.-]", "_");
					}

				}

			}
		}
                // might be good to default populate the net name
                // if empty 
                // System.out.println("NetName : " + kicadShapeNetName);
                // System.out.println("PadName : " + kicadShapePadName); 
                if (kicadShapeNetName.length() == 0) {
                  kicadShapeNetName =
                      kicadShapePadName;
                }
//		System.out.println("finished populating pad object");
	}




	public String generateGEDAelement(long xOffsetNm, long yOffsetNm, float magnificationRatio) 
		// offsets supplied in Nm, magnificationRatio supplied as float, not used as of yet
	{
//		System.out.println("about to generate a gEDA pad element");
		String output = "For some reason, the pad object was not populated by the constructor";
/**
* the first task is to establish if the pad is a pin, pad, hole or square
* octogons are not supported in kicad
*/
		String oblongSlotFlag = ""; // the default setting of rounded ends for a slot = ""

		// we now check to see if we have had a minimum drill and via size imposed
		// by the Footprint that constructed this pad
		// Note: could have a distinct method to change this, would be useful

		if (kicadDrillOneSizeNm != 0)
		{
			if (kicadDrillOneSizeNm < gEDAdefaultMinimumDrillSizeNm)
			{
				kicadDrillOneSizeNm = gEDAdefaultMinimumDrillSizeNm;
			}
		}

                // one of the first things to do is to establish if
		// the pad is a boring round or square pad, as this will
                // affect our processing of rectangular and obroid pads

		// but before we even do this, we have to catch an annoying deviation
		// from the file format, namely, when the pad shape is given as 'R'
		// and a kicadShapeX size is given but the given kicadShapeY is zero
		// presumably kicad automagically assumes it is square
		// this is an unusual problem, and is probably the result of an
		// eagle-kicad conversion tool quirk

		if (kicadShapeYsizeNm == 0)
		{
			kicadShapeYsizeNm = kicadShapeXsizeNm;
		} // with that out of the way, we can now decide if the pad is "equilateral"

                if (kicadShapeXsizeNm != kicadShapeYsizeNm)
                {
                        equilateralPad = false;
                }
                else
                {
                        equilateralPad = true;
                }


		switch (kicadDrillShape)
		{
			case 'O':	// an obround pad shape can be done as a circle for now
					// probably will need to implement as a pin + a pad on
					// top layer plus, on the bottom "onsolder" layer
					// plus take care of the orientation stuff too
					// when determining stop, start of pad direction
					// which might make the centre pin round or square, too
					// .......but obround pins are a little rare, though
			case 'C':	if (kicadPadAttributeType.startsWith("STD")) // = plate through
					{
						gEDAflag = ""; // WAS "pin"; // "0x0001" now deprecated
					}
					else if (kicadPadAttributeType.startsWith("HOLE")) // = NPTH, round
					{
						gEDAflag = "hole"; // "0x0008" now deprecated
					}
					break;
			case 'R':	if (kicadPadAttributeType.startsWith("STD")) // = plate through
					{
						if (equilateralPad) //  it is square, let it be square
						{
							gEDAflag = "square"; // "0x0100" now deprecated
						}
						else
						{
							gEDAflag = ""; // make obroid pad pins rounded
						}
					// i.e. we don't want "square" set for square ended obroid pads
						oblongSlotFlag = "square";
					}
					else if (kicadPadAttributeType.startsWith("HOLE"))
					{
						gEDAflag = "hole"; // "0x0008" now deprecated	
					}
                                        else if (kicadPadAttributeType.startsWith("SMD") ||
						 kicadPadAttributeType.startsWith("CONN"))
                                        {
                                                gEDAflag = "square"; // "0x0000" now deprecated
                                        }
					break;

/**
*
* additional pad "shape" options in, for example, 'Sh "2" C 1500 1500 0 0 2700' definition
* include 'O' = oblong, 'T' = trapeze
*
* this is to be distinguished from from "drillshape" options, such as 'Dr 600 0 0 O 600 650
* which can be used to specify an oblong 'O' hole which seems to be a slot 
*
*/

			default:	gEDAflag = "blah";
					break;

		}		
	
		// further refinements would include the addition of a track to make more complicated
		// non square or non round pads, with onsolder and top layer elements

// here we implement rudimentary support for pad orientation
// we do this by noting that orientations of 900 or 2700 can be achieved 
// by exchanging the value of kicadShapeXsizeNm and kicadShapeYsizeNm
// which will work for simple pads with only one, centred hole
// for this to work for pads with more than one hole, slot widths and heights
// will need to be translated as well

		while (kicadShapeOrientation < 0) // we aim to produce 0 =< orientation values =< 3599
		{
			kicadShapeOrientation = 3600 + kicadShapeOrientation;
		}

		if (((kicadShapeOrientation >= 450) && (kicadShapeOrientation <= 1350)) || ((kicadShapeOrientation >= 2250) && (kicadShapeOrientation <= 3150)))
		{
			long tempVal = kicadShapeXsizeNm;
			kicadShapeXsizeNm = kicadShapeYsizeNm;
			kicadShapeYsizeNm = tempVal;
		}
// simple support for rotation has been effected with a range of orientation values,
// quantised into either horizontal of vertical
// To support it more rigorously again, a rotation matrix would be needed 
// This rudimentary effort could break obround slots which rely on x and y offsets for the slot
// in the form of slot height and width values, so we can test for those.
// also, drill offsets in x and y would need translation

/**
*
* the simplest scenario of all is an SMD pad or edge connector and we deal with this first
* // ? have reworked the dimensions in the copied and pasted code for pins, ok so far
*
* also, the problem of pins defined with zero hole size are caught here and treated as a pad
*/
		if ((kicadPadAttributeType.startsWith("SMD") || kicadPadAttributeType.startsWith("CONN")) || (kicadPadAttributeType.startsWith("STD") && (kicadDrillOneSizeNm == 0)))
		{

// scenario with wider SMD pad than tall, which determines which dimension is used for thickness
// i.e. shapeYsize is equivalent to gEDA's "thickness" attribute for a pad
                        if (kicadShapeXsizeNm >= kicadShapeYsizeNm)
                        {
                                output = "Pad[" +
                                ((xOffsetNm + kicadPadPositionXNm - kicadShapeXsizeNm/2 + kicadShapeYsizeNm/2)/254) + " " +
                                ((yOffsetNm + kicadPadPositionYNm)/254) + " " +
                                ((xOffsetNm + kicadPadPositionXNm + kicadShapeXsizeNm/2 - kicadShapeYsizeNm/2)/254) + " " +
                                ((yOffsetNm + kicadPadPositionYNm)/254) + " " +
                                (kicadShapeYsizeNm/254) + " " +
                                (100*gEDAdefaultMetalClearance) + " " +
                                (100*gEDAdefaultSolderMaskRelief + (kicadShapeYsizeNm/254)) + " " +
                                '"' + kicadShapeNetName + "\" " +
                                '"' + kicadShapePadName + "\" " +
                                '"' +
                                gEDAflag +   // the flag is useful, square vs rounded ends of SMD pad
                                '"' + "]\n";
                        }

// scenario with taller SMD pad than wide, which determines which dimension is used for thickness
// i.e. shapeXsize is equivalent to gEDA's "thickness" attribute for a pad

                        else
                        {
                                output = "Pad[" +
                                ((xOffsetNm + kicadPadPositionXNm)/254) + " " +
                                ((yOffsetNm + kicadPadPositionYNm - kicadShapeYsizeNm/2 + kicadShapeXsizeNm/2)/254) + " " +
                                ((xOffsetNm + kicadPadPositionXNm)/254) + " " +
                                ((yOffsetNm + kicadPadPositionYNm + kicadShapeYsizeNm/2 - kicadShapeXsizeNm/2)/254) + " " +
                                (kicadShapeXsizeNm/254) + " " +
                                (100*gEDAdefaultMetalClearance) + " " +
                                (100*gEDAdefaultSolderMaskRelief + (kicadShapeXsizeNm/254)) + " " +
                                '"' + kicadShapeNetName + "\" " +
                                '"' + kicadShapePadName + "\" " +
                                '"' +
                                gEDAflag + // sets rounded or square pad
                                '"' + "]\n";
                        }

		}
/**
*
* the next simplest scenario captures a pin = "HOLE", with no additional hole, so, not an unplated
* slot, and not a plated hole pin = "STD"
*
*/

		else if (kicadPadAttributeType.startsWith("HOLE") && (kicadDrillShapeTwo == '0'))
		{
                        output = "Pin[" + // square bracket indicates 1/100 mil resolution
                        ((kicadPadPositionXNm + xOffsetNm)/254) + " " +
                        ((kicadPadPositionYNm + yOffsetNm)/254) + " " +
                        (kicadShapeXsizeNm/254) + " " + // pin outer diam., if round = shapeXsize = shapeYsize
                        (100*gEDAdefaultMetalClearance) + " " + // gEDA: clearance is specified per pad/pin
                        (100*gEDAdefaultSolderMaskRelief + (kicadShapeXsizeNm/254)) + " " +
                        (kicadDrillOneSizeNm/254) + " " + // drill hole size in 0.01mil units
                        '"' + kicadShapeNetName + "\" " + // arbitrary label for pin
                        '"' + kicadShapePadName + "\" " + // pin number for attaching nets
                        '"' + gEDAflag + '"' + "]\n"; // gEDAflag has already been set to "hole"
		}
	
/**
*
* the next simplest scenario captures a standard pin = "STD" with no additional hole, so, not a slot
* and also is an equilateralPad = true, so not oblong,
* and it is a plated hole rather than a mechanical "HOLE"
* This also captures kicadDrillShape = 'T' for trapezoidal pad shapes, which could be dealt with
* in another bit of code if support is desirable
*
*/
		else if (kicadPadAttributeType.startsWith("STD") && (kicadDrillShapeTwo == '0') && (equilateralPad)) // was: && kicadDrillShape != 'O'))
		{
			output = "Pin[" + // square bracket indicates 1/100 mil resolution
			((kicadPadPositionXNm + xOffsetNm)/254) + " " +
			((kicadPadPositionYNm + yOffsetNm)/254) + " " +
			(kicadShapeXsizeNm/254) + " " + // pin outer diam., if round = shapeXsize = shapeYsize
			(100*gEDAdefaultMetalClearance) + " " + // gEDA: clearance is specified per pad/pin
			(100*gEDAdefaultSolderMaskRelief + (kicadShapeXsizeNm/254)) + " " +
			(kicadDrillOneSizeNm/254) + " " + // drill hole size in 0.01mil units
			'"' + kicadShapeNetName + "\" " + // arbitrary label for pin
			'"' + kicadShapePadName + "\" " + // pin number for attaching nets
			'"' + gEDAflag + '"' + "]\n"; // square bracket indicates 1/100 mil resolution
		}

/**
*
* the next simplest scenario captures a standard pin = "STD" with no additional hole, so, not a slot,
* but kicadDrillShape = 'O', 'T' or 'R' and not an equilateral pad, making it an obroid pad,
* and it is a plated hole rather than a mechanical "HOLE"
*
* - we also need to consider orientation of the pad in due course with rotational
* translation of the pad
* - in the first instance, rotation of 900 or 2700 decigrees can be supported by applying
* horizontal pad processing for vertical pads, and vice versa
*
* we need to process kicadDrillShape = 'R' or 'O' or 'T' and at the same time !equilateralPad"
*
* The code produces a standard "STD" plate through hole, round, pin, with the addition
* of a suitable pad on the top and on the bottom (="onsolder") layers of necessary dimensions
*
*
* There is also the problem of some modules specifiying shape 'R' pads with arbitrary X size
* but zero Y size, presumably KiCad defaults to a sqaure pad in these cases - We tested for this
* prior and let y size = x size if y size = 0
*
*/
                else if (kicadPadAttributeType.startsWith("STD") && (kicadDrillShapeTwo == '0') &&  (!equilateralPad) )
                {
//			if (kicadShapeYsizeNm == 0)
//			{
//				kicadShapeYsizeNm = kicadShapeXsizeNm; 
//			}// this could perhaps be done during parsing in case other scenarios exist

			if (kicadShapeXsizeNm >= kicadShapeYsizeNm) // we have a horizontal obroid pad
			{
	                        output = "Pin[" + // square bracket indicates 1/100 mil resolution
        	                ((kicadPadPositionXNm + xOffsetNm)/254) + " " +
                	        ((kicadPadPositionYNm + yOffsetNm)/254) + " " +
                        	(kicadShapeYsizeNm/254) + " " +
			// pin outer diam., if horizontal obroad pad = shapeYsize
	                        (100*gEDAdefaultMetalClearance) + " " +
			// gEDA: clearance is specified per pad/pin
	                        (100*gEDAdefaultSolderMaskRelief + (kicadShapeXsizeNm/254)) + " " +
        	                (kicadDrillOneSizeNm/254) + " " + // drill hole size in 0.01mil units
                	        '"' + kicadShapeNetName + "\" " + // arbitrary label for pin
                        	'"' + kicadShapePadName + "\" " + // pin number for attaching nets
                	        '"' + gEDAflag + '"' + "]\n";
			 // square bracket indicates 1/100 mil resolution

                        // rotational transformation could maybe be applied here for
                        // kicadPadPositionXNm and kicadPadPositionYNm

                                topLayerPad = "Pad[" +
                                ((xOffsetNm + kicadPadPositionXNm - kicadShapeXsizeNm/2 + (kicadShapeYsizeNm)/2)/254) + " " + // drillTwoY is the slot height
                                ((yOffsetNm + kicadPadPositionYNm)/254) + " " +
                                ((xOffsetNm + kicadPadPositionXNm + kicadShapeXsizeNm/2 - (kicadShapeYsizeNm)/2)/254) + // drillTwoY is the slot height
// it seems that oblong slot's drillTwoX and drillTwoY are absolute slot dimensions
// not delta x,y vs first hole
                                " " +
                                ((yOffsetNm + kicadPadPositionYNm)/254) + " " +
                                (kicadShapeYsizeNm/254) + " " +
                                (100*gEDAdefaultMetalClearance) + " " +
                                (100*gEDAdefaultSolderMaskRelief + (kicadShapeYsizeNm/254)) + " " +
                                '"' + kicadShapeNetName + "\" " +
                                '"' + kicadShapePadName + "\" " +
                                '"' +
                                oblongSlotFlag;

                                bottomLayerPad = topLayerPad + ",onsolder";

                                output = output + topLayerPad + "\"]\n" + bottomLayerPad + "\"]\n";

                	}
			else if (kicadShapeXsizeNm < kicadShapeYsizeNm) // a vertical obroid pad
			{
                                output = "Pin[" + // square bracket indicates 1/100 mil resolution
                                ((kicadPadPositionXNm + xOffsetNm)/254) + " " +
                                ((kicadPadPositionYNm + yOffsetNm)/254) + " " +
                                (kicadShapeXsizeNm/254) + " " +
                        // pin outer diam., if vertical obroid pad = shapeXsize
                                (100*gEDAdefaultMetalClearance) + " " +
                        // gEDA: clearance is specified per pad/pin
                                (100*gEDAdefaultSolderMaskRelief + (kicadShapeXsizeNm/254)) + " " +
                                (kicadDrillOneSizeNm/254) + " " + // drill hole size in 0.01mil units
                                '"' + kicadShapeNetName + "\" " + // arbitrary label for pin
                                '"' + kicadShapePadName + "\" " + // pin number for attaching nets
                                '"' + gEDAflag + '"' + "]\n";
                         // square bracket indicates 1/100 mil resolution

                        // rotational transformation could maybe be applied here for
                        // kicadPadPositionXNm and kicadPadPositionYNm


                                topLayerPad = "Pad[" +
                                ((xOffsetNm + kicadPadPositionXNm)/254) + " " +
                                ((yOffsetNm + kicadPadPositionYNm - kicadShapeYsizeNm/2 + (kicadShapeXsizeNm)/2)/254) + " " +

                                ((xOffsetNm + kicadPadPositionXNm)/254) + " " +
                                ((yOffsetNm + kicadPadPositionYNm + kicadShapeYsizeNm/2 - (kicadShapeXsizeNm)/2)/254) +

                                " " +
                                (kicadShapeXsizeNm/254) + " " +
                                (100*gEDAdefaultMetalClearance) + " " +
                                (100*gEDAdefaultSolderMaskRelief + (kicadShapeXsizeNm/254)) + " " +
                                '"' + kicadShapeNetName + "\" " +
                                '"' + kicadShapePadName + "\" " +
                                '"' +
                                oblongSlotFlag;

                                bottomLayerPad = topLayerPad + ",onsolder";

                                output = output + topLayerPad + "\"]\n" + bottomLayerPad + "\"]\n";



			}
		}


/**
*
* the next section deals with oblong pins which are "STD" and drillShapeTwo = oblong "O"
* by generating two pins the appropriate distance apart
*
* we really want the pins to be rounded, not square, if the drill offsets are
* on a diagonal, and we first test to see if the oblong hole is on a diagonal 
*
* we then join the two pins with a pad of the right length and with rounded ends
*
*/
		else if (kicadPadAttributeType.startsWith("STD") && (kicadDrillShapeTwo == 'O')) // not zero, but "O" for "Obround" or oval, and a slot
		{
			if (((kicadDrillSlotWidthNm - kicadDrillOneXoffsetNm) != 0) && ((kicadDrillSlotHeightNm - kicadDrillOneYoffsetNm) != 0)) // we capture (hmm, not diagonal, if slot not rotated) slots here
			{
				oblongSlotFlag = "";  // and make the slot ends rounded != "square"
			// i'm starting to think this only rounds off the ends for all slots
			}

// next, we require an if statement to fork for the vertical or horizontal slot cases

			if (kicadShapeXsizeNm >= kicadShapeYsizeNm) // horizontal slot
			{
				output = "Pin[" + // square bracket indicates 1/100 mil resolution


                                ((kicadPadPositionXNm + kicadDrillOneXoffsetNm - kicadDrillSlotWidthNm/2 + xOffsetNm + kicadDrillOneYoffsetNm/2)/254) + " " +
                                ((kicadPadPositionYNm + kicadDrillOneYoffsetNm - yOffsetNm)/254) + 
				" " +
				(kicadShapeYsizeNm/254) + " " + // pin outer diam., slot pad height = shapeYsize
				(100*gEDAdefaultMetalClearance) + " " + // gEDA: clearance specified per pad/pin
				(100*gEDAdefaultSolderMaskRelief + (kicadShapeYsizeNm/254)) + " " +
				(kicadDrillSlotHeightNm/254) + " " + // drill two Y size = slot height
				'"' + kicadShapeNetName + "\" " + // arbitrary label for pin
				'"' + kicadShapePadName + "\" " + // pin number for attaching nets
				'"' + 
				oblongSlotFlag + //   gEDAflag + 
				'"' + "]\n" + // square bracket indicates 1/100 ml resolution

				"Pin[" +


                                ((kicadPadPositionXNm + kicadDrillOneXoffsetNm + xOffsetNm + kicadDrillSlotWidthNm/2 - kicadDrillOneXoffsetNm/2)/254) + " " +
                                ((kicadPadPositionYNm + kicadDrillOneYoffsetNm + yOffsetNm)/254) + 
				" " +
				(kicadShapeYsizeNm/254) + " " + // pin outer diameter
				(100*gEDAdefaultMetalClearance) + " " +
				(100*gEDAdefaultSolderMaskRelief + (kicadShapeYsizeNm/254)) + " " +
				(kicadDrillSlotHeightNm/254) + " " + // drill two Y equals slot height
				'"' + kicadShapeNetName + "\" " +
				'"' + kicadShapePadName + "\" " +
				'"' + 
				oblongSlotFlag + //   gEDAflag +
				'"' + "]\n";
			}
			else if (kicadShapeYsizeNm > kicadShapeXsizeNm) // vertical slot
			{

                                output = "Pin[" + // square bracket indicates 1/100 mil resolution
                                ((kicadPadPositionXNm + kicadDrillOneXoffsetNm + xOffsetNm)/254) + " " +
                                ((kicadPadPositionYNm + kicadDrillOneYoffsetNm - kicadDrillSlotHeightNm/2 + yOffsetNm + kicadDrillOneXoffsetNm/2)/254) + " " +
                                (kicadShapeXsizeNm/254) + " " + // pin outer diam., if round = shapeXsize = slot pad width
                                (100*gEDAdefaultMetalClearance) + " " + // gEDA: clearance specified per pad/pin
                                (100*gEDAdefaultSolderMaskRelief + (kicadShapeXsizeNm/254)) + " " +
                                (kicadDrillSlotWidthNm/254) + " " + // drill one hole size
                                '"' + kicadShapeNetName + "\" " + // arbitrary label for pin
                                '"' + kicadShapePadName + "\" " + // pin number for attaching nets
                                '"' +
                                oblongSlotFlag + //   gEDAflag + 
                                '"' + "]\n" + // square bracket indicates 1/100 ml resolution

                                "Pin[" +
                                ((kicadPadPositionXNm + kicadDrillOneXoffsetNm + xOffsetNm)/254) + " " +
                                ((kicadPadPositionYNm + kicadDrillOneYoffsetNm + yOffsetNm + kicadDrillSlotHeightNm/2- kicadDrillOneXoffsetNm/2)/254) + " " +
                                (kicadShapeXsizeNm/254) + " " + // pin outer diameter
                                (100*gEDAdefaultMetalClearance) + " " +
                                (100*gEDAdefaultSolderMaskRelief + (kicadShapeXsizeNm/254)) + " " +
                                (kicadDrillSlotWidthNm/254) + " " +
                                '"' + kicadShapeNetName + "\" " +
                                '"' + kicadShapePadName + "\" " +
                                '"' +
                                oblongSlotFlag + //   gEDAflag +
                                '"' + "]\n";


			}


/**
*
* If we are to join two holes with a pad, the pad will need rounded ends, and a thickness
* that increases in proportion to the sine of the angle/2, so for now we will simply
* skip the gEDAflag that would probably be "square", and use the oblongSlotFlag instead
* to keep the ends round - it is simpler this way.
*
*/


/**
*
* the first case addresses the scenario of a horizontally aligned, rectangular pad
* or square with two holes making a slot
*
*/

			if (kicadShapeXsizeNm >= kicadShapeYsizeNm) // i.e. horizontal slot
			{
				topLayerPad = "Pad[" +
				((xOffsetNm + kicadDrillOneXoffsetNm + kicadPadPositionXNm - kicadShapeXsizeNm/2 + (kicadShapeYsizeNm - kicadDrillSlotHeightNm)/2)/254) + " " + // drillTwoY is the slot height
				((yOffsetNm + kicadDrillOneYoffsetNm + kicadPadPositionYNm)/254) + " " +
				((xOffsetNm + kicadDrillOneXoffsetNm + kicadPadPositionXNm + kicadShapeXsizeNm/2 - (kicadShapeYsizeNm - kicadDrillSlotHeightNm)/2)/254) + // drillTwoY is the slot height
// it seems that oblong slot's drillTwoX and drillTwoY are absolute slot dimensions
// not delta x,y vs first hole
				" " +
				((yOffsetNm + kicadDrillOneYoffsetNm + kicadPadPositionYNm)/254) + " " +
				(kicadShapeYsizeNm/254) + " " +
				(100*gEDAdefaultMetalClearance) + " " +
				(100*gEDAdefaultSolderMaskRelief + (kicadShapeYsizeNm/254)) + " " +
				'"' + kicadShapeNetName + "\" " +
				'"' + kicadShapePadName + "\" " +
				'"' +
				oblongSlotFlag;

				bottomLayerPad = topLayerPad + ",onsolder";
 
				output = output + topLayerPad + "\"]\n" + bottomLayerPad + "\"]\n";
			}

/**
*
* versus the remaining alternative of a vertically aligned rectangular pad with a hole
* at each end to make a slot - as of yet nothing done for non orthogonal rectangular or
* square slot pads, it has been implemented with round pads for diagonal slots
*
*/
			else // vertical slot
			{
				topLayerPad = "Pad[" +
				((xOffsetNm + kicadPadPositionXNm + kicadDrillOneXoffsetNm)/254) + " " +
				((yOffsetNm + kicadPadPositionYNm + kicadDrillOneYoffsetNm - kicadShapeYsizeNm/2 + (kicadShapeXsizeNm - kicadDrillSlotWidthNm)/2)/254) + " " +

                                ((xOffsetNm + kicadPadPositionXNm + kicadDrillOneXoffsetNm)/254) + " " +
                                ((yOffsetNm + kicadPadPositionYNm + kicadDrillOneYoffsetNm + kicadShapeYsizeNm/2 - (kicadShapeXsizeNm - kicadDrillSlotWidthNm)/2)/254) +

				" " +
				(kicadShapeXsizeNm/254) + " " +
				(100*gEDAdefaultMetalClearance) + " " +
				(100*gEDAdefaultSolderMaskRelief + (kicadShapeXsizeNm/254)) + " " +
				'"' + kicadShapeNetName + "\" " +
				'"' + kicadShapePadName + "\" " +
				'"' +
				oblongSlotFlag;

                                bottomLayerPad = topLayerPad + ",onsolder";

                                output = output + topLayerPad + "\"]\n" + bottomLayerPad + "\"]\n";

			}
/**
*
* having assembled a slotted oblong pair of pins with a pad between them
* we return the string containing the gEDA compatible definition
*
*/
		}
		return output;
		
	}

	private long convertToNanometres(float rawValue, Boolean metricSystem)
	{
		if (metricSystem)
		{
			return (long)(rawValue * 1000000); // 1,000,000 nm per mm
		}
		else
		{
			return (long)(rawValue * 2540); // 2540 nm per 0.1 mil
		}
	}


}