Example #1
0
        public virtual int OpenProjectCfg(string projectCfgCanonicalName, out IVsProjectCfg projectCfg)
        {

            Debug.Assert(projectCfgCanonicalName != null, "Cannot open project configuration for a null configuration");
            
            projectCfg = null;
            
            // Be robust in release
            if (projectCfgCanonicalName == null)
            {
                return NativeMethods.E_INVALIDARG;
            }
            

            Debug.Assert(this.Project != null && this.Project.MSBuildProject != null);

            string[] configs = this.Project.MSBuildProject.GetConditionedPropertyValues("Configuration");


            foreach (string config in configs)
            {
                if (String.Compare(config, projectCfgCanonicalName, true, CultureInfo.CurrentUICulture) == 0)
                {
                    projectCfg = new ProjectConfig(this.Project, config);
                    return NativeMethods.S_OK;
                }
            }
            
            return NativeMethods.E_INVALIDARG;
        }
Example #2
0
        public virtual int get_ProjectCfg(out IVsProjectCfg p)
        {
            CCITracing.TraceCall();

            p = config;
            return VSConstants.S_OK;
        }
Example #3
0
 /// <summary>
 /// Gets the activate project configuration.
 /// </summary>
 internal static IVsProjectCfg GetActiveProjectCfg(this IServiceProvider serviceProvider, IVsHierarchy project)
 {
     var buildManager = (IVsSolutionBuildManager) serviceProvider.GetService(typeof (SVsSolutionBuildManager));
     if (buildManager == null)
         throw new InvalidOperationException("No solution build manager found");
     var ppIVsProjectCfg = new IVsProjectCfg[1];
     buildManager.FindActiveProjectCfg(IntPtr.Zero, IntPtr.Zero, project, ppIVsProjectCfg);
     return ppIVsProjectCfg[0];
 }
Example #4
0
 public virtual int get_ProjectCfg(out IVsProjectCfg p) {
     p = config;
     return VSConstants.S_OK;
 }
		/// <summary>
		/// Provides access to the IVsProjectCfg interface implemented on a project's configuration object. 
		/// </summary>
		/// <param name="projectCfgCanonicalName">The canonical name of the configuration to access.</param>
		/// <param name="projectCfg">The IVsProjectCfg interface of the configuration identified by szProjectCfgCanonicalName.</param>
		/// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code. </returns>
		public virtual int OpenProjectCfg(string projectCfgCanonicalName, out IVsProjectCfg projectCfg)
		{
			if(projectCfgCanonicalName == null)
			{
				throw new ArgumentNullException("projectCfgCanonicalName");
			}

			projectCfg = null;

			// Be robust in release
			if(projectCfgCanonicalName == null)
			{
				return VSConstants.E_INVALIDARG;
			}


			Debug.Assert(this.project != null && this.project.BuildProject != null);

			string[] configs = this.project.BuildProject.GetConditionedPropertyValues(ProjectFileConstants.Configuration);


			foreach(string config in configs)
			{
				if(String.Compare(config, projectCfgCanonicalName, StringComparison.OrdinalIgnoreCase) == 0)
				{
					projectCfg = this.GetProjectConfiguration(config);
					if(projectCfg != null)
					{
						return VSConstants.S_OK;
					}
					else
					{
						return VSConstants.E_FAIL;
					}
				}
			}

			return VSConstants.E_INVALIDARG;
		}
 /// <summary>
 /// The find active project cfg.
 /// </summary>
 /// <param name="pvReserved1">
 /// The pv reserved 1.
 /// </param>
 /// <param name="pvReserved2">
 /// The pv reserved 2.
 /// </param>
 /// <param name="pIVsHierarchy_RequestedProject">
 /// The p i vs hierarchy_ requested project.
 /// </param>
 /// <param name="ppIVsProjectCfg_Active">
 /// The pp i vs project cfg_ active.
 /// </param>
 /// <returns>
 /// The find active project cfg.
 /// </returns>
 /// <exception cref="NotImplementedException">
 /// </exception>
 public int FindActiveProjectCfg(IntPtr pvReserved1, IntPtr pvReserved2, IVsHierarchy pIVsHierarchy_RequestedProject, IVsProjectCfg[] ppIVsProjectCfg_Active)
 {
     throw new NotImplementedException();
 }
		/// <summary>
		/// Provides access to the IVsProjectCfg interface implemented on a project's configuration object. 
		/// </summary>
		/// <param name="projectCfgCanonicalName">The canonical name of the configuration to access.</param>
		/// <param name="projectCfg">The IVsProjectCfg interface of the configuration identified by szProjectCfgCanonicalName.</param>
		/// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code. </returns>
		public virtual int OpenProjectCfg(string projectCfgCanonicalName, out IVsProjectCfg projectCfg)
		{
			if (projectCfgCanonicalName == null)
			{
				throw new ArgumentNullException("projectCfgCanonicalName");
			}

			projectCfg = null;

			// Be robust in release
			if (projectCfgCanonicalName == null)
			{
				return VSConstants.E_INVALIDARG;
			}


			Debug.Assert(this.project != null && this.project.BuildProject != null);

			string[] configs = GetPropertiesConditionedOn(ProjectFileConstants.Configuration);
			string[] platforms = GetPropertiesConditionedOn(ProjectFileConstants.Platform);
			var configCanonicalName = new ConfigCanonicalName(projectCfgCanonicalName);

			foreach (string config in configs)
			{
				foreach (string platform in platforms)
				{
					if (configCanonicalName == new ConfigCanonicalName(config, platform))
					{
						projectCfg = this.GetProjectConfiguration(configCanonicalName);
						if (projectCfg != null)
						{
							return VSConstants.S_OK;
						}
						else
						{
							return VSConstants.E_FAIL;
						}
					}
				}
			}

			return VSConstants.E_INVALIDARG;
		}
        /// <summary>
        /// Gets the variables and directories for the specified project. Variables will be in
        /// the form <c>ProjectName.VariableName</c>.
        /// </summary>
        /// <param name="variables">The <see cref="NameValueCollection"/> to add the variables to.</param>
        /// <param name="hierarchy">The <see cref="IVsHierarchy"/> (project) from which to retrieve the variables.</param>
        private void GetTargetVariables(NameValueCollection variables, IVsHierarchy hierarchy, string projectPrefix)
        {
            try
            {
                int hr = NativeMethods.S_OK;

                // Now we need to get a IVsProjectCfg2 object to get the TargetX variables. We do this
                // by querying the environment for the active configuration of the specified project.
                IVsSolutionBuildManager solutionBuildManager = Package.Instance.GetService(typeof(IVsSolutionBuildManager)) as IVsSolutionBuildManager;
                if (solutionBuildManager == null)
                {
                    Tracer.WriteLine(classType, "GetTargetVariables", Tracer.Level.Warning, "Cannot get an instance of IVsSolutionBuildManager from the environment. Skipping the project's TargetX variables.");
                    return;
                }
                IVsProjectCfg[] projectCfgArray = new IVsProjectCfg[1];
                hr = solutionBuildManager.FindActiveProjectCfg(IntPtr.Zero, IntPtr.Zero, hierarchy, projectCfgArray);
                if (NativeMethods.Failed(hr))
                {
                    Tracer.WriteLineWarning(classType, "GetTargetVariables", "One of the projects in the solution does not support project configurations. Skipping the project's TargetX variables.");
                    return;
                }
                IVsProjectCfg2 projectCfg2 = projectCfgArray[0] as IVsProjectCfg2;
                if (projectCfg2 == null)
                {
                    Tracer.WriteLine(classType, "GetTargetVariables", Tracer.Level.Warning, "The IVsSolutionBuildManager.FindActiveProjectCfg returned a null object or an object that doesn't support IVsProjectCfg2. Skipping the project's TargetX variables.");
                    return;
                }

                // Get the ConfigurationName and add it to the variables.
                string configurationName;
                NativeMethods.ThrowOnFailure(projectCfg2.get_DisplayName(out configurationName));
                variables.Add(projectPrefix + "ConfigurationName", configurationName);

                // We need to get the Built output group from the list of project output groups.
                IVsOutputGroup outputGroup;
                NativeMethods.ThrowOnFailure(projectCfg2.OpenOutputGroup("Built", out outputGroup));
                if (outputGroup == null)
                {
                    Tracer.WriteLine(classType, "GetTargetVariables", Tracer.Level.Warning, "The project configuration '{0}' does not support the 'Built' output group. Skipping the TargetX variables.", configurationName);
                    return;
                }

                // Get the key output canonical name from the Built output group.
                string keyOutputCanonicalName;
                NativeMethods.ThrowOnFailure(outputGroup.get_KeyOutput(out keyOutputCanonicalName));

                // Search through the outputs until we find the key output. We have to call get_Outputs
                // twice: once to get the number of outputs (we do this by passing in 0 as the number
                // requested), and then once to get the actual outputs.
                uint numberRequested = 0;
                IVsOutput2[] outputArray = new IVsOutput2[numberRequested];
                uint[] numberFetchedArray = new uint[1];
                NativeMethods.ThrowOnFailure(outputGroup.get_Outputs(numberRequested, outputArray, numberFetchedArray));

                // We should have the number of elements in the output array now, so get them.
                numberRequested = numberFetchedArray[0];
                outputArray = new IVsOutput2[numberRequested];
                NativeMethods.ThrowOnFailure(outputGroup.get_Outputs(numberRequested, outputArray, numberFetchedArray));
                IVsOutput2 keyOutput = null;
                for (int i = 0; i < numberFetchedArray[0]; i++)
                {
                    if (outputArray.Length <= i)
                    {
                        break;
                    }

                    IVsOutput2 output = outputArray[i];
                    string outputCanonicalName;
                    NativeMethods.ThrowOnFailure(output.get_CanonicalName(out outputCanonicalName));
                    if (outputCanonicalName == keyOutputCanonicalName)
                    {
                        keyOutput = output;
                        break;
                    }
                }

                // Check to make sure that we found the key output.
                if (keyOutput == null)
                {
                    Tracer.WriteLine(classType, "GetTargetVariables", Tracer.Level.Warning, "We identified the key output from configuration '{0}' as '{1}', but when we iterated through the outputs we couldn't find the key output. Skipping the TargetX variables.", configurationName, keyOutputCanonicalName);
                    return;
                }

                // Now that we have the key output, we can finally create the TargetX variables from
                // the key output's deploy source URL.
                string deploySourceUrl;
                NativeMethods.ThrowOnFailure(keyOutput.get_DeploySourceURL(out deploySourceUrl));

                // By convention, the deploy source URL starts with file:/// for file-based outputs.
                // Strip it off if it's there.
                if (deploySourceUrl.StartsWith("file:///"))
                {
                    deploySourceUrl = deploySourceUrl.Substring("file:///".Length);
                }

                // Parse the TargetX variables from the deploy source URL.
                string targetPath = deploySourceUrl;
                string targetFileName = Path.GetFileName(targetPath);
                string targetDosFileName = this.EncodeDosFileName(targetFileName);
                string targetName = Path.GetFileNameWithoutExtension(targetFileName);
                string targetExt = PackageUtility.EnsureLeadingChar(Path.GetExtension(targetPath), '.');
                string targetDir = PackageUtility.StripTrailingChar(Path.GetDirectoryName(targetPath), Path.DirectorySeparatorChar);

                // Add the TargetX variables to the collection.
                variables.Add(projectPrefix + "TargetDir", targetDir);
                variables.Add(projectPrefix + "TargetDosFileName", targetDosFileName);
                variables.Add(projectPrefix + "TargetExt", targetExt);
                variables.Add(projectPrefix + "TargetFileName", targetFileName);
                variables.Add(projectPrefix + "TargetName", targetName);
                variables.Add(projectPrefix + "TargetPath", targetPath);
            }
            catch (Exception e)
            {
                if (ErrorUtility.IsExceptionUnrecoverable(e))
                {
                    throw;
                }

                Tracer.WriteLineWarning(classType, "GetTargetVariables", "The project does not correctly implement all of its required IVsProjectCfg2 interfaces. Skipping the TargetX variables. Exception: {0}", e);
            }
        }
Example #9
0
        /// <summary>
        /// Provides access to the IVsProjectCfg interface implemented on a project's configuration object. 
        /// </summary>
        /// <param name="projectCfgCanonicalName">The canonical name of the configuration to access.</param>
        /// <param name="projectCfg">The IVsProjectCfg interface of the configuration identified by szProjectCfgCanonicalName.</param>
        /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code. </returns>
        public override int OpenProjectCfg(string projectCfgCanonicalName, out IVsProjectCfg projectCfg)
        {
            if (String.IsNullOrEmpty(projectCfgCanonicalName))
            {
                throw new ArgumentNullException("projectCfgCanonicalName");
            }

            ConfigCanonicalName config = new ConfigCanonicalName(projectCfgCanonicalName);
            projectCfg = this.GetProjectConfiguration(config);
            return VSConstants.S_OK;
        }
Example #10
0
 private void TellMSBuildCurrentSolutionConfiguration()
 {
     IVsSolutionBuildManager buildMgr = this.Site.GetService(typeof(SVsSolutionBuildManager)) as IVsSolutionBuildManager;
     IVsProjectCfg[] cfgs = new IVsProjectCfg[] { null };
     buildMgr.FindActiveProjectCfg(System.IntPtr.Zero, System.IntPtr.Zero, this, cfgs);
     if (cfgs[0] != null)
     {
         string cfgName = "";
         cfgs[0].get_CanonicalName(out cfgName);
         // cfgName conventionally has form "Configuration|Platform"
         var canonicalCfgName = new ConfigCanonicalName(cfgName);
         if (String.IsNullOrEmpty(canonicalCfgName.Platform))
         {
             // cfgName is not conventional, just do something reasonable
             MSBuildProject.SetGlobalProperty(this.buildProject, ProjectFileConstants.Configuration, canonicalCfgName.ConfigName);
         }
         else
         {
             MSBuildProject.SetGlobalProperty(this.buildProject, ProjectFileConstants.Configuration, canonicalCfgName.ConfigName);
             MSBuildProject.SetGlobalProperty(this.buildProject, ProjectFileConstants.Platform, canonicalCfgName.MSBuildPlatform);
         }
         this.UpdateMSBuildState();
     }
 }
Example #11
0
        /// <summary>
        /// Provides access to the IVsProjectCfg interface implemented on a project's configuration object. 
        /// </summary>
        /// <param name="projectCfgCanonicalName">The canonical name of the configuration to access.</param>
        /// <param name="projectCfg">The IVsProjectCfg interface of the configuration identified by szProjectCfgCanonicalName.</param>
        /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code. </returns>
        public virtual int OpenProjectCfg(string projectCfgCanonicalName, out IVsProjectCfg projectCfg)
        {
            if (projectCfgCanonicalName == null)
                throw new ArgumentNullException("projectCfgCanonicalName");
            if (string.IsNullOrEmpty(projectCfgCanonicalName))
                throw new ArgumentException("projectCfgCanonicalName cannot be null or empty");

            projectCfg = null;

            // Be robust in release
            if(projectCfgCanonicalName == null)
            {
                return VSConstants.E_INVALIDARG;
            }

            Debug.Assert(this._project != null && this._project.BuildProject != null);

            string[] configs = GetPropertiesConditionedOn(ProjectFileConstants.Configuration);
            string[] platforms = GetPlatformsFromProject();

            foreach (string config in configs)
            {
                foreach (string platform in platforms)
                {
                    if (string.Equals(string.Format("{0}|{1}", config, platform), projectCfgCanonicalName, StringComparison.OrdinalIgnoreCase))
                    {
                        projectCfg = this.GetProjectConfiguration(config, platform);
                        if (projectCfg != null)
                            return VSConstants.S_OK;
                        else
                            return VSConstants.E_FAIL;
                    }
                }
            }

            return VSConstants.E_INVALIDARG;
        }
Example #12
0
 /// <include file='doc\Project.uex' path='docs/doc[@for="ImageNames.OpenProjectCfg"]/*' />
 public virtual int OpenProjectCfg(string name, out  IVsProjectCfg cfg){
   cfg = null;
   foreach (XmlElement e in this.projFile.SelectNodes("//Build/Settings/Config")){
     if (name == e.GetAttribute("Name")){
       cfg = new ProjectConfig(this, e);
       break;
     }
   }
   return 0;
 }
Example #13
0
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////
    //  uses the solution build manager interface to get the active config object
    //    
    //////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <include file='doc\Project.uex' path='docs/doc[@for="Project.GetActiveConfiguration"]/*' />
    public XmlElement GetActiveConfiguration(){
      IVsSolutionBuildManager pSolutionBuildManger = this.Site.GetService(typeof(SVsSolutionBuildManager)) as IVsSolutionBuildManager;
      if (pSolutionBuildManger == null) return null;

      IVsProjectCfg[] pProjectCfg = new IVsProjectCfg[1];
      HResult result = (HResult) pSolutionBuildManger.FindActiveProjectCfg(IntPtr.Zero, IntPtr.Zero, this, pProjectCfg);
      if (result == HResult.S_OK){
        ProjectConfig current = pProjectCfg[0] as ProjectConfig;
        if (current != null)
          return current.Node;
      }
      return (XmlElement)this.projFile.SelectSingleNode("*/*/Build/Settings/Config");
    }
 int IVsBuildableProjectCfg.get_ProjectCfg(out IVsProjectCfg ppIVsProjectCfg)
 {
     ppIVsProjectCfg = this.ProjectConfiguration;
     return NativeMethods.S_OK;
 }
Example #15
0
        /// <include file='doc\Project.uex' path='docs/doc[@for="ImageNames.OpenProjectCfg"]/*' />
        public virtual int OpenProjectCfg(string name, out  IVsProjectCfg cfg)
        {
            cfg = null;
            string[] configurations = this.projFile.GetConditionedPropertyValues("Configuration");
            foreach(string config in configurations)
            {
                if (String.Compare(name, config, true, CultureInfo.InvariantCulture) == 0)
                {
                    cfg = new ProjectConfig(this, config);
                    break;
                }
            }

            return cfg == null ? NativeMethods.E_INVALIDARG : NativeMethods.S_OK;
        }
 int IVsProjectCfgProvider.OpenProjectCfg(string szProjectCfgCanonicalName, out IVsProjectCfg ppIVsProjectCfg)
 {
     // TODO:  Add ConfigurationProvider.OpenProjectCfg implementation
     ppIVsProjectCfg = null;
     return 0;
 }
Example #17
0
        /// <include file='doc\ProjectConfig.uex' path='docs/doc[@for="BuildableProjectConfig.get_ProjectCfg"]/*' />
        public virtual int get_ProjectCfg(out IVsProjectCfg p)
        {
            CCITracing.TraceCall();

            p = config;
            return NativeMethods.S_OK;
        }
Example #18
0
        /// <summary>
        /// Provides access to the IVsProjectCfg interface implemented on a project's configuration object. 
        /// </summary>
        /// <param name="projectCfgCanonicalName">The canonical name of the configuration to access.</param>
        /// <param name="projectCfg">The IVsProjectCfg interface of the configuration identified by szProjectCfgCanonicalName.</param>
        /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code. </returns>
        public override int OpenProjectCfg(string projectCfgCanonicalName, out IVsProjectCfg projectCfg)
        {
            if (String.IsNullOrEmpty(projectCfgCanonicalName))
            {
                throw new ArgumentNullException("projectCfgCanonicalName");
            }

            string configName;
            string platformName;
            if (!ProjectConfig.TrySplitConfigurationCanonicalName(projectCfgCanonicalName, out configName, out platformName))
            {
                projectCfg = null;
                return VSConstants.E_INVALIDARG;
            }

            projectCfg = this.GetProjectConfiguration(configName, platformName);
            return VSConstants.S_OK;
        }
Example #19
0
    public virtual void  get_ProjectCfg(out IVsProjectCfg p) {

      CCITracing.TraceCall();

      p = config;
    }