Add "Portable Library" project template.

data/templates/project/CSharp/PortableAssemblyInfo.cs

@@ -0,0 +1,27 @@
+#region Using directives
+
+using System;
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+#endregion
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("${ProjectName}")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("${ProjectName}")]
+[assembly: AssemblyCopyright("Copyright ${DATE:yyyy}")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// The assembly version has following format :
+//
+// Major.Minor.Build.Revision
+//
+// You can specify all the values or you can use the default the Revision and 
+// Build Numbers by using the '*' as shown below:
+[assembly: AssemblyVersion("1.0.*")]

data/templates/project/CSharp/PortableLibrary.xpt

@@ -0,0 +1,54 @@
+<?xml version="1.0"?>
+<Template originator = "Daniel Grunwald" created = "05/17/2012">
+	
+	<!-- Template Header -->
+	<TemplateConfiguration>
+		<Name>Portable Library</Name>
+		<Category>C#</Category>
+		<Icon>C#.Project.Library</Icon>
+		<Description>Library that can be used on Windows, Silverlight, Windows Phone, and Xbox.</Description>
+	</TemplateConfiguration>
+	
+	<!-- Actions -->
+	<Actions>
+		<Open filename = "MyClass.cs"/>
+	</Actions>
+	
+	<!-- Template Content -->
+	<Project language="C#">
+		<PropertyGroup>
+			<OutputType>Library</OutputType>
+			<AppDesignerFolder>Properties</AppDesignerFolder>
+			<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+			<TargetFrameworkProfile>Profile1</TargetFrameworkProfile>
+		</PropertyGroup>
+		
+		<PropertyGroup escapeValue="False">
+			<ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+		</PropertyGroup>
+		
+		<ProjectItems />
+		
+		<Imports clear="True">
+			<Import Project="$(MSBuildExtensionsPath32)\Microsoft\Portable\$(TargetFrameworkVersion)\Microsoft.Portable.CSharp.targets" />
+		</Imports>
+		
+		<Files>
+			<File name="MyClass.cs"><![CDATA[${StandardHeader.C#}
+using System;
+using System.Collections.Generic;
+
+namespace ${StandardNamespace}
+{
+	/// <summary>
+	/// Description of MyClass.
+	/// </summary>
+	public class MyClass
+	{
+		
+	}
+}]]></File>
+			<File name="Properties\AssemblyInfo.cs" src="PortableAssemblyInfo.cs"/>
+		</Files>
+	</Project>
+</Template>

src/Main/Base/Project/ICSharpCode.SharpDevelop.addin

@@ -2362,6 +2362,8 @@
 	</Path>
 	
 	<Path name = "/SharpDevelop/Workbench/ProjectBehaviors">
-
+		<Condition name="ProjectBehaviorSupported" guid="{786C830F-07A1-408B-BD7F-6EE04809D6DB}">
+			<Class id="PortableLibraryBehavior" class="ICSharpCode.SharpDevelop.Project.PortableLibrary.PortableLibraryProjectBehavior" />
+		</Condition>
 	</Path>
 </AddIn>

src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj

@@ -379,6 +379,9 @@
     <Compile Include="Src\Project\MSBuildEngine\WorkerProcess.cs" />
     <Compile Include="Src\Project\MSBuildFileProject.cs" />
     <Compile Include="Src\Project\MSBuildItemWrapper.cs" />
+    <Compile Include="Src\Project\PortableLibrary\PortableLibraryProjectBehavior.cs" />
+    <Compile Include="Src\Project\PortableLibrary\Profile.cs" />
+    <Compile Include="Src\Project\PortableLibrary\SupportedFramework.cs" />
     <Compile Include="Src\Project\ProjectChangeWatcher.cs" />
     <Compile Include="Src\Project\ProjectLoadInformation.cs" />
     <Compile Include="Src\Project\ProjectStartException.cs" />
@@ -928,6 +931,7 @@
     </ProjectReference>
     <Folder Include="Src\Gui\Dialogs\ReferenceDialog\ServiceReference" />
     <Folder Include="Src\Project\Behaviors" />
+    <Folder Include="Src\Project\PortableLibrary" />
     <Folder Include="themes" />
     <Folder Include="Src\Bookmarks\Pad\Controls" />
     <Folder Include="Src\Editor\AvalonEdit" />

src/Main/Base/Project/Src/Internal/Templates/Project/ProjectDescriptor.cs

@@ -422,6 +422,24 @@ namespace ICSharpCode.SharpDevelop.Internal.Templates
 					}
 				}
 				
+				// Add properties from <PropertyGroup>
+				// This must be done before adding <Imports>, because the import path can refer to properties.
+				if (projectProperties.Count > 0) {
+					if (!(project is MSBuildBasedProject))
+						throw new Exception("<PropertyGroup> may be only used in project templates for MSBuildBasedProjects");
+					
+					foreach (ProjectProperty p in projectProperties) {
+						((MSBuildBasedProject)project).SetProperty(
+							StringParser.Parse(p.Configuration),
+							StringParser.Parse(p.Platform),
+							StringParser.Parse(p.Name),
+							StringParser.Parse(p.Value),
+							p.Location,
+							p.ValueIsLiteral
+						);
+					}
+				}
+				
 				// Add Imports
 				if (clearExistingImports || projectImports.Count > 0) {
 					MSBuildBasedProject msbuildProject = project as MSBuildBasedProject;
@@ -450,22 +468,6 @@ namespace ICSharpCode.SharpDevelop.Internal.Templates
 					}
 				}
 				
-				if (projectProperties.Count > 0) {
-					if (!(project is MSBuildBasedProject))
-						throw new Exception("<PropertyGroup> may be only used in project templates for MSBuildBasedProjects");
-					
-					foreach (ProjectProperty p in projectProperties) {
-						((MSBuildBasedProject)project).SetProperty(
-							StringParser.Parse(p.Configuration),
-							StringParser.Parse(p.Platform),
-							StringParser.Parse(p.Name),
-							StringParser.Parse(p.Value),
-							p.Location,
-							p.ValueIsLiteral
-						);
-					}
-				}
-				
 				// Add Files
 				if (project is IProjectItemListProvider) {
 					

src/Main/Base/Project/Src/Project/AbstractProject.cs

@@ -597,5 +597,15 @@ namespace ICSharpCode.SharpDevelop.Project
 				return projectBehavior;
 			}
 		}
+		
+		public virtual bool HasProjectType(Guid projectTypeGuid)
+		{
+			Guid myGuid;
+			if (Guid.TryParse(this.TypeGuid, out myGuid)) {
+				return myGuid == projectTypeGuid;
+			} else {
+				return false;
+			}
+		}
 	}
 }

src/Main/Base/Project/Src/Project/Behaviors/DotNetStartBehavior.cs

@@ -126,6 +126,22 @@ namespace ICSharpCode.SharpDevelop.Project
 			return base.GetDefaultItemType(fileName);
 		}
 		
+		public override CompilerVersion CurrentCompilerVersion {
+			get {
+				switch (Project.MinimumSolutionVersion) {
+					case Solution.SolutionVersionVS2005:
+						return CompilerVersion.MSBuild20;
+					case Solution.SolutionVersionVS2008:
+						return CompilerVersion.MSBuild35;
+					case Solution.SolutionVersionVS2010:
+					case Solution.SolutionVersionVS11:
+						return CompilerVersion.MSBuild40;
+					default:
+						throw new NotSupportedException();
+				}
+			}
+		}
+		
 		public override IEnumerable<CompilerVersion> GetAvailableCompilerVersions()
 		{
 			List<CompilerVersion> versions = new List<CompilerVersion>();
@@ -137,6 +153,28 @@ namespace ICSharpCode.SharpDevelop.Project
 			return versions;
 		}
 		
+		public override TargetFramework CurrentTargetFramework {
+			get {
+				string fxVersion = Project.TargetFrameworkVersion;
+				string fxProfile = Project.TargetFrameworkProfile;
+				if (string.Equals(fxProfile, "Client", StringComparison.OrdinalIgnoreCase)) {
+					foreach (ClientProfileTargetFramework fx in TargetFramework.TargetFrameworks.OfType<ClientProfileTargetFramework>())
+						if (fx.FullFramework.Name == fxVersion)
+							return fx;
+				} else {
+					foreach (TargetFramework fx in TargetFramework.TargetFrameworks)
+						if (fx.Name == fxVersion)
+							return fx;
+				}
+				return null;
+			}
+		}
+		
+		public override IEnumerable<TargetFramework> GetAvailableTargetFrameworks()
+		{
+			return TargetFramework.TargetFrameworks.Where(fx => fx.IsAvailable());
+		}
+		
 		public override void UpgradeProject(CompilerVersion newVersion, TargetFramework newFramework)
 		{
 			if (!Project.ReadOnly) {

src/Main/Base/Project/Src/Project/Behaviors/ProjectBehavior.cs

@@ -94,6 +94,29 @@ namespace ICSharpCode.SharpDevelop.Project
 			return Enumerable.Empty<CompilerVersion>();
 		}
 		
+		public virtual IEnumerable<TargetFramework> GetAvailableTargetFrameworks()
+		{
+			if (this.next != null)
+				return next.GetAvailableTargetFrameworks();
+			return Enumerable.Empty<TargetFramework>();
+		}
+		
+		public virtual CompilerVersion CurrentCompilerVersion {
+			get {
+				if (this.next != null)
+					return next.CurrentCompilerVersion;
+				throw new InvalidOperationException();
+			}
+		}
+		
+		public virtual TargetFramework CurrentTargetFramework {
+			get {
+				if (this.next != null)
+					return next.CurrentTargetFramework;
+				throw new InvalidOperationException();
+			}
+		}
+		
 		public virtual void UpgradeProject(CompilerVersion newVersion, TargetFramework newFramework)
 		{
 			if (this.next != null)

src/Main/Base/Project/Src/Project/Behaviors/ProjectBehaviorSupportedConditionEvaluator.cs

@@ -16,35 +16,20 @@ namespace ICSharpCode.SharpDevelop.Project
 			if (!Guid.TryParse(condition.Properties["guid"], out conditionGuid))
 				return true;
 			
-			string guidString;
+			IProject project = owner as IProject ?? ProjectService.CurrentProject;
-			if (owner is IProject)
+			if (project == null)
-				guidString = FindGuidInProject((IProject)owner);
-			else if (ProjectService.CurrentProject != null)
-				guidString = FindGuidInProject(ProjectService.CurrentProject);
-			else
 				return false;
-			
+			// TODO: simplify this once HasProjectType() is part of IProject
-			Guid result;
+			AbstractProject p2 = project as AbstractProject;
-			foreach (string guid in guidString.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)) {
+			if (p2 != null) {
-				if (Guid.TryParse(guid, out result) && conditionGuid == result)
+				return p2.HasProjectType(conditionGuid);
-					return true;
+			} else {
+				Guid projectGuid;
+				if (Guid.TryParse(project.TypeGuid, out projectGuid))
+					return conditionGuid == projectGuid;
+				else
+					return false;
 			}
-			
-			return false;
-		}
-
-		string FindGuidInProject(IProject project)
-		{
-			if (project is MSBuildBasedProject) {
-				string guid = ((MSBuildBasedProject)project).GetEvaluatedProperty("ProjectTypeGuids");
-				if (!string.IsNullOrEmpty(guid))
-					return guid;
-			} else if (project is UnknownProject || project is MissingProject) {
-				// don't return any GUID for projects that could not be loaded
-				return string.Empty;
-			}
-			
-			return project.TypeGuid;
 		}
 	}
 }

src/Main/Base/Project/Src/Project/CompilableProject.cs

@@ -277,36 +277,11 @@ namespace ICSharpCode.SharpDevelop.Project
 		}
 		
 		public virtual CompilerVersion CurrentCompilerVersion {
-			get {
+			get { return GetOrCreateBehavior().CurrentCompilerVersion; }
-				switch (MinimumSolutionVersion) {
-					case Solution.SolutionVersionVS2005:
-						return CompilerVersion.MSBuild20;
-					case Solution.SolutionVersionVS2008:
-						return CompilerVersion.MSBuild35;
-					case Solution.SolutionVersionVS2010:
-					case Solution.SolutionVersionVS11:
-						return CompilerVersion.MSBuild40;
-					default:
-						throw new NotSupportedException();
-				}
-			}
 		}
 		
 		public virtual TargetFramework CurrentTargetFramework {
-			get {
+			get { return GetOrCreateBehavior().CurrentTargetFramework; }
-				string fxVersion = this.TargetFrameworkVersion;
-				string fxProfile = this.TargetFrameworkProfile;
-				if (string.Equals(fxProfile, "Client", StringComparison.OrdinalIgnoreCase)) {
-					foreach (ClientProfileTargetFramework fx in TargetFramework.TargetFrameworks.OfType<ClientProfileTargetFramework>())
-						if (fx.FullFramework.Name == fxVersion)
-							return fx;
-				} else {
-					foreach (TargetFramework fx in TargetFramework.TargetFrameworks)
-						if (fx.Name == fxVersion)
-							return fx;
-				}
-				return null;
-			}
 		}
 		
 		public virtual IEnumerable<CompilerVersion> GetAvailableCompilerVersions()
@@ -314,6 +289,11 @@ namespace ICSharpCode.SharpDevelop.Project
 			return GetOrCreateBehavior().GetAvailableCompilerVersions();
 		}
 		
+		public virtual IEnumerable<TargetFramework> GetAvailableTargetFrameworks()
+		{
+			return GetOrCreateBehavior().GetAvailableTargetFrameworks();
+		}
+		
 		public virtual void UpgradeProject(CompilerVersion newVersion, TargetFramework newFramework)
 		{
 			GetOrCreateBehavior().UpgradeProject(newVersion, newFramework);

src/Main/Base/Project/Src/Project/Converter/IUpgradableProject.cs

@@ -28,6 +28,11 @@ namespace ICSharpCode.SharpDevelop.Project.Converter
 		/// </summary>
 		IEnumerable<CompilerVersion> GetAvailableCompilerVersions();
 		
+		/// <summary>
+		/// Gets the supported target frameworks.
+		/// </summary>
+		IEnumerable<TargetFramework> GetAvailableTargetFrameworks();
+		
 		/// <summary>
 		/// Gets the current compiler version.
 		/// </summary>
@@ -56,6 +61,7 @@ namespace ICSharpCode.SharpDevelop.Project.Converter
 		public static readonly CompilerVersion MSBuild35 = new CompilerVersion(new Version(3, 5), "MSBuild 3.5");
 		public static readonly CompilerVersion MSBuild40 = new CompilerVersion(new Version(4, 0), "MSBuild 4.0");
 		
+		[Obsolete("Use IUpgradableProject.GetAvailableTargetFrameworks() instead")]
 		public virtual IEnumerable<TargetFramework> GetSupportedTargetFrameworks()
 		{
 			return from fx in TargetFramework.TargetFrameworks

src/Main/Base/Project/Src/Project/Converter/UpgradeView.xaml.cs

@@ -121,34 +121,30 @@ namespace ICSharpCode.SharpDevelop.Project.Converter
 		void UpdateTargetFrameworkComboBox()
 		{
 			// Determine the available target frameworks
-			List<TargetFramework> availableFrameworks;
 			bool doNotChangeAllowed;
 			CompilerVersion selectedCompiler = newVersionComboBox.SelectedValue as CompilerVersion;
-			if (selectedCompiler == null || selectedCompiler is UnchangedCompilerVersion) {
+			if (selectedCompiler is UnchangedCompilerVersion)
-				// no entries or "Do not change" selected
+				selectedCompiler = null;
-				// -> available target frameworks is the intersection of all compiler's target framework,
+			
-				// and "Do not change" is always available
+			// Calculate the intersection of available frameworks for all selected projects:
-				
+			HashSet<TargetFramework> availableFrameworkSet = null;
-				availableFrameworks = (
+			foreach (Entry entry in listView.SelectedItems) {
-					from Entry entry in listView.SelectedItems
+				var entryFrameworks = entry.Project.GetAvailableTargetFrameworks()
-					where entry.CompilerVersion != null
+					.Where(fx => fx.IsCompatibleWith(selectedCompiler ?? entry.CompilerVersion));
-					from fx in entry.CompilerVersion.GetSupportedTargetFrameworks()
+				if (availableFrameworkSet == null)
-					select fx
+					availableFrameworkSet = new HashSet<TargetFramework>(entryFrameworks);
-				).Distinct().ToList();
+				else
-				
+					availableFrameworkSet.IntersectWith(entryFrameworks);
-				doNotChangeAllowed = true;
+			}
-			} else {
+			
-				// Specific compiler version is selected
+			// Allow do not change on target framework if all current frameworks are supported
-				// Show that compiler's target frameworks
+			// by the new compiler.
-				availableFrameworks = selectedCompiler.GetSupportedTargetFrameworks().ToList();
+			doNotChangeAllowed = true;
-				// Allow do not change on target framework if all current frameworks are supported
+			foreach (Entry entry in listView.SelectedItems) {
-				// by the new compiler.
+				doNotChangeAllowed &= availableFrameworkSet.Contains(entry.TargetFramework);
-				doNotChangeAllowed = true;
-				foreach (Entry entry in listView.SelectedItems) {
-					doNotChangeAllowed &= availableFrameworks.Contains(entry.TargetFramework);
-				}
 			}
 			
+			List<TargetFramework> availableFrameworks = availableFrameworkSet.ToList();
 			availableFrameworks.Sort((a, b) => a.DisplayName.CompareTo(b.DisplayName));
 			if (doNotChangeAllowed) {
 				availableFrameworks.Insert(0, new UnchangedTargetFramework());

src/Main/Base/Project/Src/Project/IProject.cs

@@ -273,6 +273,9 @@ namespace ICSharpCode.SharpDevelop.Project
 		/// Saves the project extension content with the specified name.
 		/// </summary>
 		void SaveProjectExtensions(string name, XElement element);
+		
+		// TODO:
+		// bool HasProjectType(Guid projectTypeGuid);
 	}
 	
 	/// <summary>

src/Main/Base/Project/Src/Project/MSBuildBasedProject.cs

@@ -1625,6 +1625,19 @@ namespace ICSharpCode.SharpDevelop.Project
 			}
 			return formattedText.ToString();
 		}
-		#endregion		
+		#endregion
+		
+		public override bool HasProjectType(Guid projectTypeGuid)
+		{
+			string guidList = GetEvaluatedProperty("ProjectTypeGuids");
+			if (string.IsNullOrEmpty(guidList))
+				return base.HasProjectType(projectTypeGuid);
+			foreach (string guid in guidList.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)) {
+				Guid result;
+				if (Guid.TryParse(guid, out result) && projectTypeGuid == result)
+					return true;
+			}
+			return false;
+		}
 	}
 }

src/Main/Base/Project/Src/Project/MissingProject.cs

@@ -30,5 +30,10 @@ namespace ICSharpCode.SharpDevelop.Project
 				return projectBehavior;
 			}
 		}
+		
+		public override bool HasProjectType(Guid projectTypeGuid)
+		{
+			return false;
+		}
 	}
 }

src/Main/Base/Project/Src/Project/PortableLibrary/PortableLibraryProjectBehavior.cs

@@ -0,0 +1,38 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using ICSharpCode.SharpDevelop.Project.Converter;
+
+namespace ICSharpCode.SharpDevelop.Project.PortableLibrary
+{
+	public class PortableLibraryProjectBehavior : ProjectBehavior
+	{
+		public readonly static TargetFramework PortableTargetFramework = new TargetFramework("v4.0Portable", "Portable Library") {
+			MinimumMSBuildVersion = new Version(4, 0)
+		};
+		
+		public override IEnumerable<CompilerVersion> GetAvailableCompilerVersions()
+		{
+			return base.GetAvailableCompilerVersions().Where(c => c.MSBuildVersion == new Version(4, 0));
+		}
+		
+		public override IEnumerable<TargetFramework> GetAvailableTargetFrameworks()
+		{
+			return new[] { PortableTargetFramework };
+		}
+		
+		public override TargetFramework CurrentTargetFramework {
+			get { return PortableTargetFramework; }
+		}
+		
+		public override void UpgradeProject(CompilerVersion newVersion, TargetFramework newFramework)
+		{
+			// can't upgrade portable libraries
+		}
+	}
+}

src/Main/Base/Project/Src/Project/PortableLibrary/Profile.cs

@@ -0,0 +1,45 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+
+namespace ICSharpCode.SharpDevelop.Project.PortableLibrary
+{
+	/// <summary>
+	/// Description of Profile.
+	/// </summary>
+	public class Profile
+	{
+		#region Load List of Profiles
+		static string GetPortableLibraryPath()
+		{
+			string programFiles = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86);
+			return Path.Combine(programFiles, @"Reference Assemblies\Microsoft\Framework\.NETPortable");
+		}
+		
+		public static IList<Profile> LoadProfiles()
+		{
+			throw new NotImplementedException();
+		}
+		
+		public static bool IsPortableLibraryInstalled()
+		{
+			return Directory.Exists(GetPortableLibraryPath());
+		}
+		#endregion
+		
+		public readonly string TargetFrameworkVersion;
+		public readonly string TargetFrameworkProfile;
+		public readonly IList<SupportedFramework> SupportedFrameworks;
+		
+		public Profile(string targetFrameworkVersion, string targetFrameworkProfile, IList<SupportedFramework> supportedFrameworks)
+		{
+			this.TargetFrameworkVersion = targetFrameworkVersion;
+			this.TargetFrameworkProfile = targetFrameworkProfile;
+			this.SupportedFrameworks = supportedFrameworks;
+		}
+	}
+}

src/Main/Base/Project/Src/Project/PortableLibrary/SupportedFramework.cs

@@ -0,0 +1,36 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Xml.Linq;
+
+namespace ICSharpCode.SharpDevelop.Project.PortableLibrary
+{
+	/// <summary>
+	/// A supported framework.
+	/// </summary>
+	public class SupportedFramework
+	{
+		public readonly string Identifier;
+		public readonly string Profile;
+		public readonly Version MinimumVersion;
+		public readonly string DisplayName;
+		
+		public SupportedFramework(XElement framework)
+		{
+			this.Identifier = (string)framework.Attribute("Identifier");
+			this.Profile = (string)framework.Attribute("Profile");
+			Version.TryParse((string)framework.Attribute("MinimumVersion"), out MinimumVersion);
+			string displayName = (string)framework.Attribute("DisplayName");
+			string minimumVersionDisplayName = (string)framework.Attribute("MinimumVersionDisplayName");
+			if (!string.IsNullOrEmpty(minimumVersionDisplayName))
+				displayName += " " + minimumVersionDisplayName;
+			this.DisplayName = displayName;
+		}
+		
+		public override string ToString()
+		{
+			return this.DisplayName;
+		}
+	}
+}

src/Main/Base/Project/Src/Project/Solution/Project_TypeGuids.cs

@@ -22,5 +22,6 @@ namespace ICSharpCode.SharpDevelop.Project
 		public const string WebApplication = "{349C5851-65DF-11DA-9384-00065B846F21}";
 		public const string WebSite = "{E24C65DC-7377-472B-9ABA-BC803B73C61A}";
 		public const string Silverlight = "{A1591282-1198-4647-A2B1-27E5FF5F6F3B}";
+		public static readonly Guid PortableLibrary = Guid.Parse("{786C830F-07A1-408B-BD7F-6EE04809D6DB}");
 	}
 }

src/Main/Base/Project/Src/Project/TargetFramework.cs

@@ -2,6 +2,7 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using ICSharpCode.SharpDevelop.Project.Converter;
 
 namespace ICSharpCode.SharpDevelop.Project
 {
@@ -116,6 +117,11 @@ namespace ICSharpCode.SharpDevelop.Project
 		/// </summary>
 		public TargetFramework BasedOn { get; set; }
 		
+		public virtual bool IsCompatibleWith(CompilerVersion compilerVersion)
+		{
+			return MinimumMSBuildVersion <= compilerVersion.MSBuildVersion;
+		}
+		
 		public bool IsBasedOn(TargetFramework potentialBase)
 		{
 			TargetFramework tmp = this;

src/Main/Base/Project/Src/Project/UnknownProject.cs

@@ -52,5 +52,10 @@ namespace ICSharpCode.SharpDevelop.Project
 				return projectBehavior;
 			}
 		}
+		
+		public override bool HasProjectType(Guid projectTypeGuid)
+		{
+			return false;
+		}
 	}
 }