internal ProtobuildStandardDefinition (ProtobuildModuleInfo modulel, ProtobuildDefinitionInfo definitionl, XmlDocument document, IProtobuildModule moduleObj) {
			module = modulel;
			definition = definitionl;
			this.document = document;
			this.moduleObj = moduleObj;

			Initialize(this);
		}
		private void ImportContentProject(XmlDocument document, IProtobuildModule module)
		{
			var sourceNodes = document.SelectNodes ("/ContentProject/Source");

			foreach (var sourceNode in sourceNodes.OfType<XmlElement>())
			{
				Items.Add(ImportContentSourceRule(sourceNode));
			}
		}
		protected ProtobuildNonStandardDefinition (ProtobuildModuleInfo modulel, ProtobuildDefinitionInfo definitionl, XmlDocument document, IProtobuildModule moduleObj)
        {
            module = modulel;
			definition = definitionl;
			this.document = document;
			this.moduleObj = moduleObj;

			Items = new ProjectItemCollection();

			Initialize(this);
		}
		public ProtobuildPackage (ProtobuildModuleInfo moduleInfo, ProtobuildPackageRef reference, IProtobuildModule parentModule)
        {
            module = moduleInfo;
            package = reference;
			parentModuleRef = parentModule;
			Packages = new ProtobuildPackages(this);
			Definitions = new ItemCollection<IProtobuildDefinition>();
			Submodules = new ItemCollection<ProtobuildSubmodule>();

			IsBinary = File.Exists(Path.Combine(FullPath, ".pkg")) &&
				!File.Exists(Path.Combine(FullPath, ".git")) &&
				!Directory.Exists(Path.Combine(FullPath, ".git"));
        }
		public static IProtobuildDefinition CreateDefinition(ProtobuildModuleInfo modulel, ProtobuildDefinitionInfo definitionl, IProtobuildModule moduleObj)
		{
			var document = new XmlDocument ();
			document.Load(definitionl.DefinitionPath);

			switch (definitionl.Type) {
			case "External":
				return new ProtobuildExternalDefinition(modulel, definitionl, document, moduleObj);
			case "Content":
				return new ProtobuildContentDefinition(modulel, definitionl, document, moduleObj);
			default:
				return new ProtobuildStandardDefinition(modulel, definitionl, document, moduleObj);
			}
		}
		private void ImportExternalProject(XmlDocument document, IProtobuildModule module)
		{
			var nodes = document.SelectNodes ("/ExternalProject/*");

			foreach (var node in nodes.OfType<XmlElement>())
			{
				ImportExternalProjectNode(x => this.Items.Add (x), node);
			}

		}
		internal ProtobuildExternalDefinition (ProtobuildModuleInfo modulel, ProtobuildDefinitionInfo definitionl, XmlDocument document, IProtobuildModule moduleObj)
			: base(modulel, definitionl, document, moduleObj) {
			Initialize(this);
		}
	    private static IEnumerable<IProtobuildDefinition> WalkModuleTreeForDefinitions (IProtobuildModule module)
	    {
            if (module.Definitions != null)
            {
                foreach (var definition in module.Definitions)
                {
                    yield return definition;
                }
            }

            if (module.Packages != null)
            {
                foreach (var package in module.Packages)
                {
                    foreach (var definition in WalkModuleTreeForDefinitions(package))
                    {
                        yield return definition;
                    }
                }
            }

            if (module.Submodules != null)
            {
                foreach (var submodule in module.Submodules)
                {
                    foreach (var definition in WalkModuleTreeForDefinitions(submodule))
                    {
                        yield return definition;
                    }
                }
            }
	    }
	    private void LoadSubmodule (IProtobuildModule folder, ProtobuildModuleInfo moduleInfo)
        {
	        if (folder.Packages == null) {
	            folder.Packages = new ProtobuildPackages (folder);
	        }

	        if (folder.Definitions == null) {
	            folder.Definitions = new ItemCollection<IProtobuildDefinition> ();
	        }

	        if (folder.Submodules == null) {
	            folder.Submodules = new ItemCollection<ProtobuildSubmodule> ();
	        }

	        var packagesByFolder = new Dictionary<string, ProtobuildPackage> ();

            foreach (var package in moduleInfo.Packages)
            {
				var packageItem = new ProtobuildPackage(moduleInfo, package, folder);
                //packageItem.SetItemHandler(new MSBuildHandler(Guid.NewGuid().ToString(), Guid.NewGuid().ToString()));
                folder.Packages.Add(packageItem);
				packagesByFolder.Add(moduleInfo.Path + '/' + package.Folder.Replace ('\\','/'), packageItem);
            }

            foreach (var submodule in moduleInfo.LoadedSubmodules) {
				//var submoduleRelativeFolder = GetRelativePath(moduleInfo.Path, submodule.Path);
                //submoduleRelativeFolder = submoduleRelativeFolder.Replace ('\\', '/');

				if (packagesByFolder.ContainsKey (submodule.Path)) {
                    // Place all the projects under the package's folder instead.
					LoadSubmodule(packagesByFolder[submodule.Path], submodule);
                }
                else
                {
					var submoduleItem = new ProtobuildSubmodule(moduleInfo, submodule, this.RootFolder);
                    //submoduleItem.SetItemHandler(new MSBuildHandler(Guid.NewGuid().ToString(), Guid.NewGuid().ToString()));
                    folder.Submodules.Add(submoduleItem);

                    LoadSubmodule(submoduleItem, submodule);
                }
            }

            foreach (var definition in moduleInfo.LoadedDefinitions)
            {
				var definitionItem = ProtobuildDefinitionLoader.CreateDefinition(moduleInfo, definition, folder);
				var standardDefinition = definitionItem as ProtobuildStandardDefinition;
				if (standardDefinition != null) {
					standardDefinition.ModuleOwnerForConfiguration = this;
				}
                //definitionItem.SetItemHandler(new MSBuildHandler(definition.Guid.ToString(), definition.Guid.ToString()));
                folder.Definitions.Add(definitionItem);

				// Add the definition to the root folder as well so that events
				// get hooked up correctly.
				folder.RootFolder.Items.Add((SolutionFolderItem)definitionItem);

				if (standardDefinition != null) {
					foreach (var config in standardDefinition.GetConfigurations ()) {
						EnsureConfigurationPresent (config, standardDefinition);
	                }
				}

                if (moduleInfo.DefaultStartupProject == definition.Name) {
                    this.SingleStartup = true;
					if (standardDefinition != null) {
						this.StartupItem = standardDefinition;
					}
                }
            }
		}
		private void ImportStandardProject(XmlDocument document, IProtobuildModule moduleObj)
		{
			var specificPlatforms = false;

			if (document.DocumentElement != null) {
				if (document.DocumentElement.HasAttribute ("Platforms")) {
					specificPlatforms = true;
					var platforms = document.DocumentElement.Attributes["Platforms"].Value.Split (',');
					foreach (var platform in platforms) {
						AddNewConfiguration (platform);
					}
				}
			}

			if (!specificPlatforms) {
				foreach (var platform in moduleObj.SupportedPlatformsArray) {
					AddNewConfiguration (platform);
				}
			}

			if (definition.Path != null) {
				BaseDirectory = Path.Combine (module.Path, definition.Path);

				// TODO See ReadProjectFile in MSBuildProjectHandler
				var filesNode = document.SelectSingleNode ("/Project/Files");
				if (filesNode != null) {
					foreach (var child in filesNode.ChildNodes.OfType<XmlElement> ()) {
						Items.Add (ImportFile (child));
					}
				}

				References = new ProtobuildReferences();

				var referencesNode = document.SelectSingleNode ("/Project/References");
				if (referencesNode != null) {
					foreach (var child in referencesNode.ChildNodes.OfType<XmlElement> ()) {
						References.Add (ImportReference (child));
					}
				}

				Dependencies = new ProtobuildDependencies();

				var dependenciesNode = document.SelectSingleNode("/Project/Dependencies");
				if (dependenciesNode != null)
				{
					foreach (var child in dependenciesNode.ChildNodes.OfType<XmlElement>())
					{
						Dependencies.Add(ImportDependency(child));
					}
				}

				Services = new ProtobuildServices();

				var servicesNode = document.SelectSingleNode("/Project/Services");
				if (servicesNode != null)
				{
					foreach (var child in servicesNode.ChildNodes.OfType<XmlElement>())
					{
						Services.Add(ImportService(child));
					}
				}
			}
		}