<?xml version="1.0" encoding="UTF-8" ?>
<?eclipse version="3.0"?>
<plugin id="org.eclipse.draw2d" name="Draw2d" version="3.0.0" 
provider-name="Eclipse.org">
<runtime>
	<library name="draw2d.jar">
		<export name="*" />
		<packages prefixes="org.eclipse.draw2d" />
	</library>
</runtime>
<requires>
	<import plugin="org.eclipse.swt" export="true" />
	<import plugin="org.eclipse.core.runtime" />
</requires>
</plugin>

                
/**
 *  
 * @return returns a Vector containing PluginData objects.
 * Each PluginData object represents a Plugin found under any of the following 
 * plugin directories
 * a. the targetPlatformLocation\eclipse\plugins directory, 
 * b. other plugin directories as specified by *.link files under 
 *    targetPlatform\eclipse\links directory 
 **/ 
public static Vector getPluginsInTargetPlatform(){
	/**
	//step1: Get path of target platform.
	//step2: Prepare path of links folder.
	//step3: Get list of files in links folder.
	//step4: Parse each link file and get the path of linked Eclipse folder.
	//step5: Prepare a list of all plugin root folders 
	//       (Eclipse plugins and linked Eclipse plugins).
	//step6: 6a. For each plugin root folder, 
	//       6b. go to each plugin directory and get path of plugin.xml.
	//step7: Parse the plugin.xml file to get plugin id, plugin version, 
	//       and store in vectors, lists, etc.
	//step8: Go back to step 6 to continue with next plugin directory.
	**/

	//step1: Get path of target platform. 
	//Fall back to Eclipse install location if targetplatform in not set.
	URL platFormURL = Platform.getInstallLocation().getURL();
	Location location = Platform.getInstallLocation();
	IPath eclipsePath = null ;		

	//Get path of target platform against which the users of this tool 
	//will compile their code.	
	IPath targetPlatFormLocation = new Path(getTargetPlatformPath(true));

	if(_useTargetPlatform == false)
		eclipsePath = new Path(platFormURL.getPath());
	else
		eclipsePath = targetPlatFormLocation;
	
	showMessage("Considering target platform to be: " + 
				eclipsePath.toString());
	
	//step2: Prepare path of links folder.
	//step3: Get list of files in links folder.		
	//step4: Parse each link file and get the path of linked Eclipse folder.
	IPath linksPath = new Path( eclipsePath.toString() ).append("/links");
	String linkedPaths[] = getLinkedPaths(linksPath.toString());
	int linkedPathLength = 0;
	if(null != linkedPaths){
		linkedPathLength = linkedPaths.length;
	}
	
	//step5: Prepare a list of all plugin root folders 
	//       (Eclipse plugins and linked Eclipse plugins).
	IPath eclipsePluginRootFolders[] = new IPath[linkedPathLength + 1];
	eclipsePluginRootFolders[0] = 
		new Path( eclipsePath.toString() ).append("/plugins");
	if(null != linkedPaths){
		for(int i=0; i<linkedPaths.length; i++){
			eclipsePluginRootFolders[i+1] = 
			new Path(linkedPaths[i]).append("/eclipse/plugins");
		}
	}

	//step6: 6a. For each plugin root folder, 
	//       6b. go to each plugin directory and get path of plugin.xml.
	//step7: Parse the plugin.xml file to get plugin id, plugin version, 
	//       and store in vectors, lists, etc.
	Vector vectorsInThisVector = new Vector();
	for(int i=0; i<eclipsePluginRootFolders.length; i++){
		System.out.println("\n========plugin IDs and Versions in " + 
		eclipsePluginRootFolders[i] + "========");
		Vector pluginDataObjs  = 
		getPluginDataForAllPlugins(
			eclipsePluginRootFolders[i].toString());
		vectorsInThisVector.add(pluginDataObjs);
		System.out.println(pluginDataObjs);
		System.out.println("\n===========|||=== end ===|||===========");
	}
	
	Vector pluginData = new Vector();
	Iterator outerIterator = vectorsInThisVector.iterator();
	while(outerIterator.hasNext()){
		Vector pluginDataObjs = (Vector)outerIterator.next();
		Iterator innerIterator = pluginDataObjs.iterator();
		while(innerIterator.hasNext()){
			PluginData pd = (PluginData)innerIterator.next();
			String pluginIdKey = pd.getPluginID();
			String versionValue = pd.getPluginVersion();
			String pluginPath = pd.getPluginLocation();
			pluginData.add(pd);
		}
	}
	
	int breakpoint=0;

	return pluginData;
}

                
private Vector alreadyNotified = new Vector();
private boolean firstCall = true;
private TreeParent root = null;

private void recursivePluginDependencyWalker(PluginData pdObject, 
					TreeParent parentNode){

	try {
		String path = pdObject.getPluginLocation();
		PluginParser pp = null;
		File pluginDotXmlFile = new File(path + "/plugin.xml");
		if(pluginDotXmlFile.exists()){
			pp = new PluginParser(pluginDotXmlFile);
		}else{
			File fragmentDotXmlFile = new File(path + 
				"/fragment.xml");
			if(fragmentDotXmlFile.exists()){
				pp = new PluginParser(fragmentDotXmlFile);
			}else{
				return;//no plugin.xml or fragment.xml found
			}	
		}

		String displayName = pdObject.getDisplayName();
		System.out.println("\nPlugin ["+ displayName + "]
			requires" + "\n");
		String requires[] = pp.getDependencyList();
		if(0 != requires.length ){ 
			for(int i=0; i<requires.length; i++){
				System.out.println("\t" + requires[i] );
				PluginData pd[] = 
				getPluginDataObjectsFromPluginID(requires[i]);
				PluginData nextPlugin = null;
				switch(pd.length){
				case 0:
					//great, we know there is 
					//something missing
					nextPlugin = null;
					break;
				case 1:
					//best case, everything will be smooth
					nextPlugin = pd[0];
					break;
				default:
					//worst case, there must be more 
					//than 1 plugin with the same id
					//at different locations.
					String msgLine1 = 
					"Plugin " + displayName + 
					" requires "  + 
					requires[i] + "\n";
					String msgLine2 = 
					"Duplicate plug-ins found for ID: \
					" " + requires[i] +
					"\"" + 
					"\n Continuing with higher version...
					" ;
				
					 //it is bad to give repeated 
					 //reminders, 
					 //so remind only once per plugin id.
					if(! alreadyNotified.contains(
						new String(requires[i]))){
					MessageDialog.openInformation(null,
					"Dependency Walker",
						    msgLine1 + 
							msgLine2);
					alreadyNotified.add(
						new String(requires[i]));
					}

					//always take the better 
					//version anyway
					nextPlugin = 
						getBetterVersionPlugin(pd);
					break;

				}//end of switch
				if( null != nextPlugin ){
					TreeParent nextinLine = 
					new TreeParent(
						nextPlugin.getDisplayName(),
						nextPlugin.isPlugin
						LoadedInRegistry()
						);
					parentNode.addChild(nextinLine);
					recursivePluginDependencyWalker(
						nextPlugin, 
						nextinLine);
				}else{
					TreeParent nextinLine = 
					new TreeParent(
						requires[i] + 
						" [This plug-in is missing]
						",
						false);
					parentNode.addChild(nextinLine);
					//obviously we can't recurse 
					//into a missing plugin...
				}
			}//end of for
		}else{
			System.out.println("\t NOTHING: 
			No further dependency \n" );
			//no further dependency
		}
	} catch (Exception e) {
		e.printStackTrace();
	}

}

                
private PluginData getBetterVersionPlugin(PluginData pdo[]){
	PluginData _pdObjs[] = pdo;
	int len = pdo.length;
	if(len==0)
		return null;
	
	Arrays.sort(_pdObjs,new Comparator() {
		/**Compares its two arguments for order. 
		 * Returns a negative integer, zero, or a positive integer 
		 * as the first argument is less than, equal to, or greater than 
		 * the second. 
		 **/
		public int compare(Object leftObj, Object riteObj) {
			
			String leftPID = ((PluginData)leftObj).
				getPluginVersion().replace('.', ':');
			String ritePID = ((PluginData)riteObj).
				getPluginVersion().replace('.', ':');
			String leftID[] = leftPID.split(":");
			String riteID[] = ritePID.split(":");
			int maxlen = leftID.length > riteID.length ? 
					leftID.length : riteID.length;
			for(int i=0; i<maxlen; i++){
				int left = 0;
				int rite = 0;
				try {
				left = new Integer(leftID[i]).intValue();
				} catch (NullPointerException e) { left = 0; }
				try {
				rite = new Integer(riteID[i]).intValue();
				} catch (NullPointerException e) { rite = 0; }
				
				if(left==rite){
					continue;
				}else{
				int bigger = left > rite ? left : rite;
					if(bigger==left)
						return 1;
					if(bigger==rite)
						return -1;
				}					
			}
			return 0;
		}
		public boolean equals(Object arg0) {
			return false;
		}
	});
	
	return _pdObjs[len-1];
	
}