Footprint.java

// KicadModuleToGEDA - a utility for turning kicad modules to gEDA PCB footprints
// Footprint.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 object coordinates the header, text descriptors, drawn lines, drawn arcs, drawn circles
* and also the pads for a given Kicad module, passed as a string array of the form (String[] args)
* and is then able to produce a gEDA footprint
*
*/

import java.util.Scanner;

public class Footprint
{
        String footprintName = "newFootprint";
	String assembledGEDAelement = "";
	String passedString = "";
	FootprintHeader[] moduleTextDescriptors = new FootprintHeader[200];

	FootprintElementArchetype footprintElements[] =  new FootprintElementArchetype[2000];
	int FPFeatureCount = 0;


//	DrawnElement[] moduleSilkLines = new DrawnElement[1900];
//	Circle[] moduleSilkCircles = new Circle[200];
//	Arc[] moduleSilkArcs = new Arc[200];
//	KicadPad[] modulePads = new KicadPad[200];

	Boolean metricSystem = false;   // this will be changed to "true", if needed,
					// with parsing in due course

	int moduleLineCountTotal = 0;	
	int padDefinitionLineCount = 0;

	String padDefinitionLines;

	int lineCount = 0;

	int padCount = 0;
	int drawSegmentCount = 0;
	int drawArcCount = 0;
	int drawCircleCount = 0;
	int textDescriptorCount = 0;

	String licenceText1 = "# Footprint converted from Kicad Module ";

	String licenceText2 = "\n# dist-license: GPL\n# use-license: unlimited\n"; //# unless specified otherwise in source Kicad module\n";

        String clearanceWarningNotice1 = "# Users of the foot print must ensure that the solder mask reliefs and clearances\n# are compatible with the PCB manufacturer's process tolerances\n";

        String clearanceWarningNotice2 = "# Pins and SMD pads have been converted from Kicad foot prints which\n# do not have solder mask relief or clearances specified.\n# Fairly sane default values have been used for solder mask relief and clearances.\n";

	long xOffset = 0; // in case we wish to translate the footprint silkscreen in x or y plane
	long yOffset = 0; // useful for building complex multiple device footprints
	float parsedValue = 0;	

	String reconstructedKicadModuleAsString = ""; // we'll return this from the toString() method

	public Footprint(String args, Boolean MmMetricUnits, long minimumViaAndDrillSizeNM)
	{

		metricSystem = MmMetricUnits;
		boolean moduleFinished = false;

		Scanner moduleDefinition = new Scanner(args);

		String parseString = "";
		String trimmedString = "";
		String[] tokens;

//		System.out.println(args);

		while (moduleDefinition.hasNext() && !moduleFinished)
		{			
			parseString = moduleDefinition.nextLine();
			trimmedString = parseString.trim();
			tokens = trimmedString.split(" ");

			// we now move into the main parsing section
			// which decides what each line is all about and then deploys
			// it to construct the relevant footprint element object 

			if (tokens[0].startsWith("$INDEX"))
			{
			//	System.out.println(footprintName); // we don't care about the index
			}
			else if (tokens[0].startsWith("$MODULE") || tokens[0].startsWith("module"))
			{       // it all starts here, with the module header
			// first we look for double quotes inserted by the likes of madparts
				footprintName = tokens[1];
				if (footprintName.length() > 2) {
					if (footprintName.charAt(0) == '"') {
						footprintName = footprintName.substring(1);
					}
                        	        if (footprintName.charAt(footprintName.length()-1) == '"') {
                                	        footprintName = footprintName.substring(0,footprintName.length()-1);
                             		}
				}
				// now we get rid of characters ![a-zA-Z0-9.-] which
				// may be unacceptable for a filename
				footprintName = footprintName.replaceAll("[^a-zA-Z0-9.-]", "_");
                                //				System.out.println(footprintName + " is the footprint name found.");

				// we now step through the module line by line
				while (moduleDefinition.hasNext() && !moduleFinished)
				{
					parseString = moduleDefinition.nextLine();
		                        trimmedString = parseString.trim();
				//	System.out.println("Current footprint def line:" + 
				//			trimmedString);

					// we tokenize the line
        		                tokens = trimmedString.split(" ");
					

					// and we then decide what to do with the tokenized lines
					// we ignore "attr" lines at this stage
					if (tokens[0].startsWith("Po") || tokens[0].startsWith("at "))
					{
						// we find the xOffset in the position, and remember
						// it is passed in Nm units
						parsedValue = Float.parseFloat(tokens[1]);
						xOffset = convertToNanometres(parsedValue, metricSystem);
						parsedValue = Float.parseFloat(tokens[2]);
						yOffset = convertToNanometres(parsedValue, metricSystem);
					}
					else if (tokens[0].startsWith("T0"))
					{
						moduleTextDescriptors[textDescriptorCount] = new FootprintHeader();
						moduleTextDescriptors[textDescriptorCount].populateHeader(trimmedString, metricSystem);
						textDescriptorCount++;
					}
					else if (tokens[0].startsWith("T") && !tokens[0].startsWith("T1"))
					{
                                          // we exclude the component value T1, and look for other text to render
						footprintElements[FPFeatureCount] = new FootprintText();
						footprintElements[FPFeatureCount].populateElement(trimmedString, metricSystem);
						FPFeatureCount++;
					}
					else if (tokens[0].startsWith("fp_text") && tokens[1].startsWith("reference"))
					{
                                                moduleTextDescriptors[textDescriptorCount] = new FootprintHeader();
                                                moduleTextDescriptors[textDescriptorCount].populateHeader(trimmedString, metricSystem);
                                                textDescriptorCount++;
						// we only want to know what the reference text is
					}

					else if (tokens[0].startsWith("DS"))
					{
						footprintElements[FPFeatureCount] = new DrawnElement();
						footprintElements[FPFeatureCount].populateElement(trimmedString, metricSystem);
						FPFeatureCount++;
						drawSegmentCount++;
					}
                                        else if (tokens[0].startsWith("fp_line"))
                                        {
                                                footprintElements[FPFeatureCount] = new DrawnElement();
                                                footprintElements[FPFeatureCount].populateElement(trimmedString, metricSystem);
						FPFeatureCount++;
                                                drawSegmentCount++;
                                        }
					else if (tokens[0].startsWith("DC"))
					{
						footprintElements[FPFeatureCount] = new Circle();
                                                footprintElements[FPFeatureCount].populateElement(trimmedString, metricSystem);
						FPFeatureCount++;
                                                drawCircleCount++;

					}
                                        else if (tokens[0].startsWith("fp_circle"))
                                        {
                                                footprintElements[FPFeatureCount] = new Circle();
                                                footprintElements[FPFeatureCount].populateElement(trimmedString, metricSystem);
						FPFeatureCount++;
                                                drawCircleCount++;
                                        }
                                        else if (tokens[0].startsWith("DA"))
                                        {
						footprintElements[FPFeatureCount] = new Arc();
                                                footprintElements[FPFeatureCount].populateElement(trimmedString, metricSystem);
						FPFeatureCount++;
                                                drawArcCount++;
                                        }
                                        else if (tokens[0].startsWith("fp_arc"))
                                        {
                                                footprintElements[FPFeatureCount] = new Arc();
                                                footprintElements[FPFeatureCount].populateElement(trimmedString, metricSystem);
						FPFeatureCount++;
                                                drawArcCount++;
                                        }
		                        else if (tokens[0].startsWith("pad"))
                		        {  // we have identified a pad definition in the module
		                                padDefinitionLines = trimmedString;
                		                padCount++;

		                                footprintElements[FPFeatureCount] = new Pad();
                                		footprintElements[FPFeatureCount].populateElement(padDefinitionLines, metricSystem, minimumViaAndDrillSizeNM);
                                		FPFeatureCount++;	
                        		}
		                        else if (tokens[0].startsWith("$PAD"))
                		        {  // we have identified a $PAD definition in the module
		                                padDefinitionLines = "";
		                                padDefinitionLineCount = 0;
		                                padCount++;
      			                        while (!trimmedString.startsWith("$EndPAD") && moduleDefinition.hasNext())
                               			{ 	// we now turn the multiline $PAD definition 
							// into a single string
		                                        padDefinitionLines = padDefinitionLines +
                		                                trimmedString + " \n" ;
                               			        parseString = moduleDefinition.nextLine();
                                        		trimmedString = parseString.trim();
                                        		padDefinitionLineCount++;
                                		}
                                		padDefinitionLines = padDefinitionLines + "$EndPad \n";
                                		// having created a single string containing the
						// $PAD definition
                                		// we can now pass it to a Pad constructor
                                		footprintElements[FPFeatureCount] = new Pad();
                                		footprintElements[FPFeatureCount].populateElement(padDefinitionLines, metricSystem, minimumViaAndDrillSizeNM);
                                		FPFeatureCount++;
					}

					if (tokens[0].startsWith("$EndMOD"))
					{
						moduleFinished = true;
					}

				}

			}

		}

                // we also create a single string version of the module for
		// use by the toString() method
                reconstructedKicadModuleAsString = args;

	}

	public String generateGEDAfootprintFilename()
	{
		return footprintName + ".fp";
	}

        public String generateGEDAglyph(float magnificationRatio)
        {
                String gEDAglyph = "";
                for (int counter = 0; counter < FPFeatureCount; counter++)
                {
                        gEDAglyph = gEDAglyph +
                                footprintElements[counter].generateGEDAglyph(xOffset,yOffset,magnificationRatio);
                }
                return gEDAglyph;
	}

	public String generateGEDAfootprint(float magnificationRatio)
	{
		assembledGEDAelement = licenceText1 + footprintName + licenceText2;
		if (padCount > 0)
		{
			assembledGEDAelement = assembledGEDAelement + 
				clearanceWarningNotice1 + clearanceWarningNotice2 ;
		}

		if (metricSystem)
		{
			assembledGEDAelement = assembledGEDAelement +
					"# Kicad module units: mm\n";
		}
		else
		{
			assembledGEDAelement = assembledGEDAelement +
					"# Kicad module units: 0.1 mil\n";
		}

		// we start by generating a generic gEDA footprint Element[...] field
		// in case the Kicad module failed to have a text field "T0 .... "
		// to base the gEDA element field on
		// We use the file name for the description, default text orientation
		// of 0, with an offset 250 mils to the right of centre, and 
		// text scaling of 100

		String gEDAfootprintElementField =
		"# Since the Kicad Module did not have a 'T0' field,\n" +
		"# The module name has been used for the Element description field\n" +
			"Element[\"\" \"" + footprintName +
			"\" \"\" \"\" 0 0 0 25000 0 100 \"\"]\n(\n";

		if (textDescriptorCount > 0)
		{
			gEDAfootprintElementField = moduleTextDescriptors[0].generateGEDAtextField(0,0);
		}

		assembledGEDAelement = assembledGEDAelement +
		("# Footprint = module name: " + footprintName + "\n" +
		"# Text descriptor count: " + textDescriptorCount + "\n" +
		"# Draw segment object count: " + drawSegmentCount + "\n" +
		"# Draw circle object count: " + drawCircleCount + "\n" +
		"# Draw arc object count: " + drawArcCount + "\n" +
		"# Pad count: " + padCount + "\n#\n" +
		gEDAfootprintElementField );

//		System.out.println(assembledGEDAelement);

		for (int counter = 0; counter < FPFeatureCount; counter++)
		{
			assembledGEDAelement = assembledGEDAelement +
				footprintElements[counter].generateGEDAelement(xOffset,yOffset,magnificationRatio);
		}
		return assembledGEDAelement;
	}


        public String getKicadModuleName()
        {
                return footprintName;
        }

	public String toString()
	{
		return reconstructedKicadModuleAsString;
	}

        private long convertToNanometres(float rawValue, boolean metricSystem)
        {
                if (metricSystem) // metricSystem = units mm
                {
                        return (long)(1000000 * rawValue);
                                        // multiply mm by 1000000 to turn into nm
                }
                else
                {
                        return (long)(2540 * rawValue);
                                        // multiply 0.1 mil units by 2540 to turn into nm
                }
        }



}