/// <summary> /// Sets the node property. /// </summary> /// <param name="propid">Property id.</param> /// <param name="value">Property value.</param> /// <returns>Returns success or failure code.</returns> public override int SetProperty(int propid, object value) { int result; __VSHPROPID id = (__VSHPROPID)propid; switch (id) { case __VSHPROPID.VSHPROPID_IsNonMemberItem: if (value == null) { throw new ArgumentNullException("value"); } bool boolValue = false; CciTracing.TraceCall(this.Id + "," + id.ToString()); if (bool.TryParse(value.ToString(), out boolValue)) { this.IsNonmemberItem = boolValue; } else { Trace.WriteLine("Could not parse the IsNonMemberItem property value."); } result = VSConstants.S_OK; break; default: result = base.SetProperty(propid, value); break; } return(result); }
public virtual int AdviseBuildStatusCallback(IVsBuildStatusCallback callback, out uint cookie) { CciTracing.TraceCall(); cookie = callbacks.Add(callback); return(VSConstants.S_OK); }
public virtual int get_ProjectCfg(out IVsProjectCfg p) { CciTracing.TraceCall(); p = config; return(VSConstants.S_OK); }
public virtual void CreateDirectory(string newName) { if (String.IsNullOrEmpty(newName)) { throw new ArgumentException(SR.GetString(SR.ParameterCannotBeNullOrEmpty, CultureInfo.CurrentUICulture), "newName"); } try { // on a new dir && enter, we get called with the same name (so do nothing if name is the same char[] dummy = new char[1]; dummy[0] = Path.DirectorySeparatorChar; string oldDir = this.Url; oldDir = oldDir.TrimEnd(dummy); string strNewDir = Path.Combine(Path.GetDirectoryName(oldDir), newName); if (!String.Equals(strNewDir, oldDir, StringComparison.OrdinalIgnoreCase)) { if (Directory.Exists(strNewDir)) { throw new InvalidOperationException(SR.GetString(SR.DirectoryExistError, CultureInfo.CurrentUICulture)); } Directory.CreateDirectory(strNewDir); } } //TODO - this should not digest all exceptions. catch (System.Exception e) { CciTracing.Trace(e); throw; } }
public virtual int QueryStatus(out int done) { CciTracing.TraceCall(); done = (this.config.ProjectManager.BuildInProgress) ? 0 : 1; return(VSConstants.S_OK); }
public virtual int UnadviseBuildStatusCallback(uint cookie) { CciTracing.TraceCall(); callbacks.RemoveAt(cookie); return(VSConstants.S_OK); }
public virtual int StartClean(IVsOutputWindowPane pane, uint options) { CciTracing.TraceCall(); config.PrepareBuild(true); // Current version of MSBuild wish to be called in an STA this.Build(options, pane, MSBuildTarget.Clean); return(VSConstants.S_OK); }
public static void Trace(System.Exception exception) { if (exception == null) { throw new ArgumentNullException("exception"); } CciTracing.InternalTraceCall(2); System.Diagnostics.Trace.WriteLine("ExceptionInfo: \t" + exception.ToString()); }
public virtual int get_IsReleaseOnly(out int fRelease) { CciTracing.TraceCall(); fRelease = 0; if (this.ConfigName == "Release") { fRelease = 1; } return(VSConstants.S_OK); }
public virtual int get_BuildableProjectCfg(out IVsBuildableProjectCfg pb) { CciTracing.TraceCall(); if (buildableCfg == null) { buildableCfg = new BuildableProjectConfig(this); } pb = buildableCfg; return(VSConstants.S_OK); }
public virtual int get_UpdateSequenceNumber(ULARGE_INTEGER[] li) { if (li == null) { throw new ArgumentNullException("li"); } CciTracing.TraceCall(); li[0] = new ULARGE_INTEGER(); li[0].QuadPart = 0; return(VSConstants.S_OK); }
public virtual int QueryStartBuild(uint options, int[] supported, int[] ready) { CciTracing.TraceCall(); if (supported != null && supported.Length > 0) { supported[0] = 1; } if (ready != null && ready.Length > 0) { ready[0] = (this.config.ProjectManager.BuildInProgress) ? 0 : 1; } return(VSConstants.S_OK); }
/// <summary> /// Determines whether the debugger can be launched, given the state of the launch flags. /// </summary> /// <param name="flags">Flags that determine the conditions under which to launch the debugger. /// For valid grfLaunch values, see __VSDBGLAUNCHFLAGS or __VSDBGLAUNCHFLAGS2.</param> /// <param name="fCanLaunch">true if the debugger can be launched, otherwise false</param> /// <returns>S_OK if the method succeeds, otherwise an error code</returns> public virtual int QueryDebugLaunch(uint flags, out int fCanLaunch) { CciTracing.TraceCall(); string assembly = this._project.GetAssemblyName(this.ConfigName, this.Platform); fCanLaunch = (assembly != null && assembly.ToUpperInvariant().EndsWith(".exe", StringComparison.OrdinalIgnoreCase)) ? 1 : 0; if (fCanLaunch == 0) { string property = GetConfigurationProperty("StartProgram", _PersistStorageType.PST_USER_FILE, true); fCanLaunch = (property != null && property.Length > 0) ? 1 : 0; } return(VSConstants.S_OK); }
public virtual int StartBuild(IVsOutputWindowPane pane, uint options) { CciTracing.TraceCall(); config.PrepareBuild(false); // Current version of MSBuild wish to be called in an STA uint flags = VSConstants.VS_BUILDABLEPROJECTCFGOPTS_REBUILD; // If we are not asked for a rebuild, then we build the default target (by passing null) this.Build(options, pane, ((options & flags) != 0) ? MSBuildTarget.Rebuild : null); return(VSConstants.S_OK); }
public virtual int get_ProjectCfgProvider(out IVsProjectCfgProvider p) { CciTracing.TraceCall(); p = null; IVsCfgProvider cfgProvider = null; this._project.GetCfgProvider(out cfgProvider); if (cfgProvider != null) { p = cfgProvider as IVsProjectCfgProvider; } return((null == p) ? VSConstants.E_NOTIMPL : VSConstants.S_OK); }
public virtual void CreateDirectory() { try { if (Directory.Exists(this.Url) == false) { Directory.CreateDirectory(this.Url); } } //TODO - this should not digest all exceptions. catch (System.Exception e) { CciTracing.Trace(e); throw; } }
/// <summary> /// Sets the value of a configuration dependent property. /// If the attribute does not exist it is created. /// If value is null it will be set to an empty string. /// </summary> /// <param name="name">property name.</param> /// <param name="value">value of property</param> public virtual void SetConfigProperty(string name, _PersistStorageType storageType, string value) { CciTracing.TraceCall(); if (value == null) { value = String.Empty; } if (this.ProjectManager != null) { for (int i = 0, n = this.projectConfigs.Length; i < n; i++) { ProjectConfig config = projectConfigs[i]; config.SetConfigurationProperty(name, storageType, value); } this.ProjectManager.SetProjectFileDirty(true); } }
public virtual int OpenOutput(string name, out IVsOutput output) { CciTracing.TraceCall(); output = null; return(VSConstants.E_NOTIMPL); }
public virtual int StartUpToDateCheck(IVsOutputWindowPane pane, uint options) { CciTracing.TraceCall(); return(VSConstants.E_NOTIMPL); }
public virtual int get_TargetCodePage(out uint target) { CciTracing.TraceCall(); target = (uint)System.Text.Encoding.Default.CodePage; return(VSConstants.S_OK); }
public virtual int get_RootURL(out string root) { CciTracing.TraceCall(); root = null; return(VSConstants.S_OK); }
public virtual int get_Platform(out Guid platform) { CciTracing.TraceCall(); platform = Guid.Empty; return(VSConstants.E_NOTIMPL); }
public static void TraceCall() { // skip this one as well CciTracing.InternalTraceCall(2); }
public virtual int get_IsPackaged(out int pkgd) { CciTracing.TraceCall(); pkgd = 0; return(VSConstants.S_OK); }
public virtual int Stop(int fsync) { CciTracing.TraceCall(); return(VSConstants.S_OK); }
public virtual int EnumOutputs(out IVsEnumOutputs eo) { CciTracing.TraceCall(); eo = null; return(VSConstants.E_NOTIMPL); }
public virtual int Wait(uint ms, int fTickWhenMessageQNotEmpty) { CciTracing.TraceCall(); return(VSConstants.E_NOTIMPL); }
/// <summary> /// Called by the vs shell to start debugging (managed or unmanaged). /// Override this method to support other debug engines. /// </summary> /// <param name="grfLaunch">A flag that determines the conditions under which to start the debugger. For valid grfLaunch values, see __VSDBGLAUNCHFLAGS</param> /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code</returns> public virtual int DebugLaunch(uint grfLaunch) { CciTracing.TraceCall(); try { VsDebugTargetInfo info = new VsDebugTargetInfo(); info.cbSize = (uint)Marshal.SizeOf(info); info.dlo = Microsoft.VisualStudio.Shell.Interop.DEBUG_LAUNCH_OPERATION.DLO_CreateProcess; // On first call, reset the cache, following calls will use the cached values string property = GetConfigurationProperty("StartProgram", _PersistStorageType.PST_USER_FILE, true); if (string.IsNullOrEmpty(property)) { info.bstrExe = this._project.GetOutputAssembly(this.ConfigName, this.Platform); } else { info.bstrExe = property; } property = GetConfigurationProperty("WorkingDirectory", _PersistStorageType.PST_USER_FILE, false); if (string.IsNullOrEmpty(property)) { info.bstrCurDir = Path.GetDirectoryName(info.bstrExe); } else { info.bstrCurDir = property; } property = GetConfigurationProperty("CmdArgs", _PersistStorageType.PST_USER_FILE, false); if (!string.IsNullOrEmpty(property)) { info.bstrArg = property; } property = GetConfigurationProperty("RemoteDebugMachine", _PersistStorageType.PST_USER_FILE, false); if (property != null && property.Length > 0) { info.bstrRemoteMachine = property; } info.fSendStdoutToOutputWindow = 0; property = GetConfigurationProperty("EnableUnmanagedDebugging", _PersistStorageType.PST_USER_FILE, false); if (property != null && string.Equals(property, "true", StringComparison.OrdinalIgnoreCase)) { //Set the unmanged debugger info.clsidCustom = VSConstants.DebugEnginesGuids.NativeOnly_guid; } else { //Set the managed debugger info.clsidCustom = VSConstants.DebugEnginesGuids.ManagedOnly_guid; } info.grfLaunch = grfLaunch; VsShellUtilities.LaunchDebugger(this._project.Site, info); } catch (Exception e) { Trace.WriteLine("Exception : " + e.Message); return(Marshal.GetHRForException(e)); } return(VSConstants.S_OK); }
public static void TraceCall(string parameters) { CciTracing.InternalTraceCall(2); System.Diagnostics.Trace.WriteLine("\tParameters: \t" + parameters); }
public virtual int get_IsSpecifyingOutputSupported(out int f) { CciTracing.TraceCall(); f = 1; return(VSConstants.S_OK); }