/// <summary>
/// Standard constructor for the tool window.
/// </summary>
public TabbedDebugLogToolWindow() :
base(null)
{
// Set the window title reading it from the resources.
this.Caption = Resources.ToolWindowTitle;
// Set the image that will appear on the tab of the window frame
// when docked with an other window
// The resource ID correspond to the one defined in the resx file
// while the Index is the offset in the bitmap strip. Each image in
// the strip being 16x16.
this.BitmapResourceID = 301;
this.BitmapIndex = 1;
// This is the user control hosted by the tool window; Note that, even if this class implements IDisposable,
// we are not calling Dispose on this object. This is because ToolWindowPane calls Dispose on
// the object returned by the Content property.
base.Content = new TabbedLogControl();
m_previousDebuggerMode = DBGMODE.DBGMODE_Design;//Assume we are in design mode to start with.
IVsDebugger debugService = Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(SVsShellDebugger)) as IVsDebugger;
if (debugService != null)
{
debugService.AdviseDebuggerEvents(this, out cookie);
debugService.AdviseDebugEventCallback(this);
}
}
public ReAttachDebugger(IReAttachPackage package)
{
_package = package;
_debugger = package.GetService(typeof(SVsShellDebugger)) as IVsDebugger;
_dte = _package.GetService(typeof(SDTE)) as DTE2;
if (_dte != null)
_dteDebugger = _dte.Debugger as Debugger2;
if (_package == null || _debugger == null || _dte == null || _dteDebugger == null)
{
_package.Reporter.ReportError(
"Unable to get required services for ReAttachDebugger in ctor.");
return;
}
// TODO: Unadvise, or did I find something telling me otherwise?
if (_debugger.AdviseDebuggerEvents(this, out _cookie) != VSConstants.S_OK)
_package.Reporter.ReportError("ReAttach: AdviserDebuggerEvents failed.");
if (_debugger.AdviseDebugEventCallback(this) != VSConstants.S_OK)
_package.Reporter.ReportError("AdviceDebugEventsCallback call failed in ReAttachDebugger ctor.");
foreach (Engine engine in _dteDebugger.Transports.Item("Default").Engines)
{
var engineId = Guid.Parse(engine.ID);
if (ReAttachConstants.IgnoredDebuggingEngines.Contains(engineId))
continue;
_engines.Add(engineId, engine.Name);
}
}
private static bool IsDebugging(IServiceProvider provider, IVsDebugger debugger)
{
return(provider.GetUIThread().Invoke(() => {
var mode = new[] { DBGMODE.DBGMODE_Design };
return ErrorHandler.Succeeded(debugger.GetMode(mode)) && mode[0] != DBGMODE.DBGMODE_Design;
}));
}
internal void InjectService(IVsDebugger vsDebugger)
{
if (RevitToolsControl != null)
{
RevitToolsControl.ViewModel.VsDebugger = vsDebugger;
}
}
private void Attach(IVsDebugger debugger)
{
var process = Process;
if (process != null)
{
if (!VsEnvironment.IsDebuggerPresent(process))
{
try
{
debugger.Attach(process.Id);
AttachVisibility = System.Windows.Visibility.Collapsed;
DetachVisibility = System.Windows.Visibility.Visible;
DetachCommand = new ActionCommand(() => { Detach(debugger); },
Service.Status == ServiceControllerStatus.Running &&
VsEnvironment.Debuggers.Any());
OnPropertyChanged("DetachCommand");
}
catch (COMException e)
{
MessageBox.Show(e.Message);
}
}
}
((ActionCommand)AttachCommand).Enabled =
Service.Status == ServiceControllerStatus.Running &&
VsEnvironment.Debuggers.Any();
}
internal DebuggerEvents()
{
ThreadHelper.ThrowIfNotOnUIThread();
IVsDebugger svc = VS.GetRequiredService <IVsDebugger, IVsDebugger>();
svc.AdviseDebuggerEvents(this, out _);
}
public DebugManager(ExcelDnaToolsPackage package, ExcelConnection connection)
{
_package = package;
_connection = connection;
var packageServiceProvider = (IServiceProvider)package;
_debugger = packageServiceProvider.GetService(typeof(SVsShellDebugger)) as IVsDebugger;
// var dgr = Package.GetGlobalService(typeof(SVsShellDebugger)) ;
// _debugger = dgr as IVsDebugger;
_dte = packageServiceProvider.GetService(typeof(SDTE)) as DTE;
if (_dte != null)
{
_dteDebugger = _dte.Debugger as Debugger2;
}
if (_package == null || _debugger == null || _dte == null || _dteDebugger == null)
{
Debug.Fail("DebugManager setup failed");
return;
}
if (_debugger.AdviseDebuggerEvents(this, out _debuggerEventsCookie) != VSConstants.S_OK)
{
Debug.Fail("DebugManager setup failed");
}
if (_debugger.AdviseDebugEventCallback(this) != VSConstants.S_OK)
{
Debug.Fail("DebugManager setup failed");
}
}
/// <devdoc>
/// Launch the debugger.
/// </devdoc>
/// <param name="serviceProvider">The service provider.</param>
/// <param name="info">A reference to a VsDebugTargetInfo object.</param>
public static void LaunchDebugger(IServiceProvider serviceProvider, VsDebugTargetInfo info)
{
if (serviceProvider == null)
{
throw new ArgumentException("serviceProvider");
}
info.cbSize = (uint)Marshal.SizeOf(info);
IntPtr ptr = Marshal.AllocCoTaskMem((int)info.cbSize);
Marshal.StructureToPtr(info, ptr, false);
try
{
IVsDebugger d = serviceProvider.GetService(typeof(IVsDebugger)) as IVsDebugger;
if (d == null)
{
throw new InvalidOperationException();
}
ErrorHandler.ThrowOnFailure(d.LaunchDebugTargets(1, ptr));
}
finally
{
if (ptr != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(ptr);
}
}
}
public VsDebuggerEvents(IVsDebugger debugger)
{
ThreadHelper.ThrowIfNotOnUIThread();
service = debugger;
service.AdviseDebuggerEvents(this, out cookie);
}
public static async Task InitializeAsync(Shell.IAsyncServiceProvider provider)
{
await Shell.ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
{
s_ServerId = SERVER_PREFIX;// + System.Diagnostics.Process.GetCurrentProcess().Id.ToString();
s_PipePool = new PipePool(s_ServerId);
s_PipePool.Start();
}
{
s_Service = await provider.GetServiceAsync(typeof(SVsShellDebugger)) as IVsDebugger;
s_DTE = await provider.GetServiceAsync(typeof(SDTE)) as DTE;
}
if (s_Service != null)
{
s_Service.AdviseDebuggerEvents(Instance, out s_Cookie);
s_Service.AdviseDebugEventCallback(Instance);
}
try
{
await Task.Run(() => InitAdresses());
}
catch (Exception ex)
{
service.Output.WriteError(ex.ToString());
}
}
private void OnStartupComplete()
{
CreateOutputWindow();
CreateStatusBarIcon();
solutionEvents = events.SolutionEvents;
buildEvents = events.BuildEvents;
windowEvents = events.WindowEvents;
solutionEvents.Opened += OnSolutionOpened;
solutionEvents.AfterClosing += OnSolutionClosed;
buildEvents.OnBuildBegin += OnBuildBegin;
buildEvents.OnBuildDone += OnBuildDone;
debugService = (IVsDebugger)GetGlobalService(typeof(SVsShellDebugger));
debugService.AdviseDebuggerEvents(this, out debugCookie);
var componentModel = (IComponentModel)GetGlobalService(typeof(SComponentModel));
operationState = componentModel.GetService <IOperationState>();
operationState.StateChanged += OperationStateOnStateChanged;
application = Application.Current;
application.Activated += OnApplicationActivated;
application.Deactivated += OnApplicationDeactivated;
windowEvents.WindowActivated += OnWindowActivated;
SystemEvents.SessionSwitch += OnSessionSwitch;
SystemEvents.PowerModeChanged += OnPowerModeChanged;
VSColorTheme.ThemeChanged += OnThemeChanged;
chart.Loaded += (s, a) =>
{
Window window = Window.GetWindow(chart);
new Lid(window).StatusChanged += OnLidStatusChanged;
};
ListenToScreenSaver();
sm = new VSStateMachine();
if (application.Windows.OfType <Window>()
.All(w => !w.IsActive))
{
sm.On(VSStateMachine.Events.LostFocus);
}
if (dte.Solution.Count > 0)
{
sm.On(VSStateMachine.Events.SolutionOpened);
}
sm.StateChanged += s => Output("Current state: {0}", s.ToString());
Output("Startup complete");
Output("Current state: {0}", sm.CurrentState.ToString());
}
protected override void Dispose(bool disposing)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (this.debugCookie != 0)
{
this.debuggerForCookie.UnadviseDebuggerEvents(this.debugCookie);
this.debuggerForCookie = null;
this.debugCookie = 0;
}
if (this.frameCookie != 0)
{
this.frameForCookie.Unadvise(this.frameCookie);
this.frameForCookie = null;
this.frameCookie = 0;
}
if (this.debugTextBuffer != null)
{
this.debugTextBuffer.Changed -= this.OnTextBufferChanged;
}
this.cancellationTokenSource.Cancel();
this.cancellationTokenSource.Dispose();
this.dataBindingOutputLevelKey.Dispose();
this.viewModel.Dispose();
base.Dispose(disposing);
}
public DebugManager(ExcelDnaToolsPackage package, ExcelConnection connection)
{
_package = package;
_connection = connection;
var packageServiceProvider = (IServiceProvider)package;
_debugger = packageServiceProvider.GetService(typeof(SVsShellDebugger)) as IVsDebugger;
// var dgr = Package.GetGlobalService(typeof(SVsShellDebugger)) ;
// _debugger = dgr as IVsDebugger;
_dte = packageServiceProvider.GetService(typeof(SDTE)) as DTE;
if (_dte != null)
{
_dteDebugger = _dte.Debugger as Debugger2;
}
if (_package == null || _debugger == null || _dte == null || _dteDebugger == null)
{
Debug.Fail("DebugManager setup failed");
return;
}
if (_debugger.AdviseDebuggerEvents(this, out _debuggerEventsCookie) != VSConstants.S_OK)
{
Debug.Fail("DebugManager setup failed");
}
if (_debugger.AdviseDebugEventCallback(this) != VSConstants.S_OK)
{
Debug.Fail("DebugManager setup failed");
}
}
public ReAttachDebugger(IReAttachPackage package)
{
_package = package;
_debugger = package.GetService(typeof(SVsShellDebugger)) as IVsDebugger;
_dte = _package.GetService(typeof(SDTE)) as DTE2;
if (_dte != null)
{
_dteDebugger = _dte.Debugger as Debugger2;
}
if (_package == null || _debugger == null || _dte == null || _dteDebugger == null)
{
_package.Reporter.ReportError(
"Unable to get required services for ReAttachDebugger in ctor.");
return;
}
if (_debugger.AdviseDebuggerEvents(this, out _cookie) != VSConstants.S_OK)
{
_package.Reporter.ReportError("ReAttach: AdviserDebuggerEvents failed.");
}
if (_debugger.AdviseDebugEventCallback(this) != VSConstants.S_OK)
{
_package.Reporter.ReportError("AdviceDebugEventsCallback call failed in ReAttachDebugger ctor.");
}
foreach (Engine engine in _dteDebugger.Transports.Item("Default").Engines)
{
_engines.Add(Guid.Parse(engine.ID), engine.Name);
}
}
public static void RegisteDefaultTypes(this IUnityContainer container)
{
container.RegisterType <ILog, OutputWindowLogger>();
var ev = new VSEnvironmentEvents.VSEnvironmentEventsPublisher();
container.RegisterInstance <IVSEnvironmentEventsPublisher>(ev);
container.RegisterInstance <IVsEnvironmentEvents>(ev);
container.RegisterType <ExpressioEvaluation.ISearchStatus, SearchStatusLister>();
container.RegisterInstance <ITaskSchedulerProvider>(new TaskSchedulerProvider());
var provider = new ExpressionEvaluatorProvider(ev);
container.RegisterInstance <IExpressionEvaluatorProvider>(provider);
container.RegisterInstance <IExpressionEvaluatorContainer>(provider);
// Use this to disable cache while debugging
//container.RegisterType<IExpressionsCache, DisabledExpressionsCache>();
container.RegisterType <IExpressionsCache, ExpressionsCache>();
IVsDebugger _debugger = VisualStudioServices.VsDebugger;
ExpressionEvaluatorDispatcher _dispatcher;
_dispatcher = ExpressionEvaluatorDispatcher.Create(VisualStudioServices.VsDebugger,
container.Resolve <IExpressionEvaluatorContainer>(),
container.Resolve <IExpressionsCache>());
container.RegisterInstance <ExpressionEvaluatorDispatcher>(_dispatcher, new ContainerControlledLifetimeManager());
container.RegisterType <IExpressionEvaluatorViewModel, ExpressionEvaluatorViewModel>();
}
/// <summary>
/// Initializes a new instance of the <see cref="TracePointHostWindow1"/> class.
/// </summary>
public TracePointHostWindow1() : base(null)
{
ThreadHelper.ThrowIfNotOnUIThread();
this.Caption = AppStringResources.lblToolWindowCaption;
this._ucTracePoint = new TracePointHostWindow1Control();
this._debugEventCallback = new VSEventCallbackWrapper();
this._debugEventCallback.OnSessionStart += _debugEventCallback_OnSessionStart;
this._debugEventCallback.OnTracePointAdded += _debugEventCallback_OnTracePointAdded;
IVsDebugger debugService = Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(SVsShellDebugger)) as IVsDebugger;
if (debugService != null)
{
// Register for debug events.
// Assumes the current class implements IDebugEventCallback2.
debugService.AdviseDebugEventCallback(this._debugEventCallback);
}
// This is the user control hosted by the tool window; Note that, even if this class implements IDisposable,
// we are not calling Dispose on this object. This is because ToolWindowPane calls Dispose on
// the object returned by the Content property.
this.Content = _ucTracePoint;
}
protected void LaunchDebugTarget()
{
Microsoft.VisualStudio.Shell.ServiceProvider sp =
new Microsoft.VisualStudio.Shell.ServiceProvider((IOleServiceProvider)Dte);
IVsDebugger dbg = (IVsDebugger)sp.GetService(typeof(SVsShellDebugger));
VsDebugTargetInfo info = new VsDebugTargetInfo();
info.cbSize = (uint)Marshal.SizeOf(info);
info.dlo = DEBUG_LAUNCH_OPERATION.DLO_CreateProcess;
info.bstrExe = Moniker;
info.bstrCurDir = @"C:\";
string connectionString = HierarchyAccessor.Connection.ConnectionSupport.ConnectionString + ";Allow User Variables=true;Allow Zero DateTime=true;";
if (connectionString.IndexOf("password", StringComparison.OrdinalIgnoreCase) == -1)
{
var connection = (MySqlConnection)HierarchyAccessor.Connection.GetLockedProviderObject();
try
{
var settings = (MySqlConnectionStringBuilder)connection.GetType().GetProperty("Settings", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(connection, null);
connectionString += "password="******";Persist Security Info=true;";
}
finally
{
HierarchyAccessor.Connection.UnlockProviderObject();
}
}
info.bstrArg = connectionString;
info.bstrRemoteMachine = null; // Environment.MachineName; // debug locally
info.fSendStdoutToOutputWindow = 0; // Let stdout stay with the application.
info.clsidCustom = new Guid("{EEEE0740-10F7-4e5f-8BC4-1CC0AC9ED5B0}"); // Set the launching engine the sample engine guid
info.grfLaunch = 0;
IntPtr pInfo = Marshal.AllocCoTaskMem((int)info.cbSize);
Marshal.StructureToPtr(info, pInfo, false);
try
{
int result = dbg.LaunchDebugTargets(1, pInfo);
if (result != 0 && result != VSConstants.E_ABORT)
{
throw new ApplicationException("COM error " + result);
}
}
catch (Exception ex)
{
InfoDialog.ShowDialog(InfoDialogProperties.GetErrorDialogProperties("Debugger Error", ex.GetBaseException().Message));
}
finally
{
if (pInfo != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(pInfo);
}
}
}
public EpochQuickInfoSource(EpochQuickInfoSourceProvider provider, ITextBuffer subjectBuffer, IVsDebugger debugger, IVsEditorAdaptersFactoryService adapter)
{
m_provider = provider;
m_subjectBuffer = subjectBuffer;
m_debugger = debugger;
m_adapter = adapter;
m_parsedProject = subjectBuffer.Properties.GetProperty <Parser.Project>(typeof(Parser.Project));
}
public IDebuggerEvents AdviseDebuggerEvents(IDebugUserControl control, out uint cookie)
{
VisualStudioDebuggerEvents vsde = new VisualStudioDebuggerEvents(r_dte, control);
IVsDebugger vsd = control.GetDebugService(typeof(IVsDebugger)) as IVsDebugger;
int hr = vsd.AdviseDebuggerEvents(vsde, out cookie);
return(vsde);
}
public ExitEventListener()
{
_debugger = Package.GetGlobalService(typeof(SVsShellDebugger)) as IVsDebugger;
if (_debugger != null)
{
_debugger.AdviseDebugEventCallback(this);
}
}
private static bool TryGetQuickInfoFromDebugger(IQuickInfoSession session, SnapshotSpan span, IVsTextView viewAdapter, out string tipText)
{
IVsTextLines lines;
tipText = null;
IVsDebugger debuggerService = GetDebuggerService(session.TextView);
if (debuggerService == null)
{
return(false);
}
IVsTextView vsTextView = viewAdapter;
var txtSpan = GetTextSpan(viewAdapter, span); //GetTextSpan(session.TextView.TextBuffer, span, out vsTextView);
TextSpan[] dataBufferTextSpan = new TextSpan[] { txtSpan };
int hr = -2147467259;
if ((dataBufferTextSpan[0].iStartLine == dataBufferTextSpan[0].iEndLine) && (dataBufferTextSpan[0].iStartIndex == dataBufferTextSpan[0].iEndIndex))
{
int iStartIndex = dataBufferTextSpan[0].iStartIndex;
int iStartLine = dataBufferTextSpan[0].iStartLine;
//if (ErrorHandler.Failed(textViewWindow.GetWordExtent(iStartLine, iStartIndex, 0, dataBufferTextSpan)))
//{
// return false;
//}
if ((iStartLine < dataBufferTextSpan[0].iStartLine) || (iStartLine > dataBufferTextSpan[0].iEndLine))
{
return(false);
}
if ((iStartLine == dataBufferTextSpan[0].iStartLine) && (iStartIndex < dataBufferTextSpan[0].iStartIndex))
{
return(false);
}
if ((iStartLine == dataBufferTextSpan[0].iEndLine) && (iStartIndex >= dataBufferTextSpan[0].iEndIndex))
{
return(false);
}
}
if (ErrorHandler.Failed(vsTextView.GetBuffer(out lines)))
{
return(false);
}
hr = debuggerService.GetDataTipValue(lines, dataBufferTextSpan, null, out tipText);
if (hr == 0x45001)
{
HandoffNoDefaultTipToDebugger(session);
session.Dismiss();
tipText = null;
return(true);
}
if (ErrorHandler.Failed(hr))
{
return(false);
}
return(true);
}
public DataTipTextViewFilter(System.IServiceProvider serviceProvider, IVsTextView vsTextView) {
_debugger = (IVsDebugger)NodejsPackage.GetGlobalService(typeof(IVsDebugger));
vsTextView.GetBuffer(out _vsTextLines);
var editorAdaptersFactory = serviceProvider.GetComponentModel().GetService<IVsEditorAdaptersFactoryService>();
_wpfTextView = editorAdaptersFactory.GetWpfTextView(vsTextView);
ErrorHandler.ThrowOnFailure(vsTextView.AddCommandFilter(this, out _next));
}
///--------------------------------------------------------------------------------------------
/// <summary>
/// Quit listening to debug mode changes
/// </summary>
///--------------------------------------------------------------------------------------------
private void UnadviseDebugger()
{
if (_debuggerCookie != 0 && _debugger != null)
{
_debugger.UnadviseDebuggerEvents(_debuggerCookie);
}
_debugger = null;
_debuggerCookie = 0;
}
public static void Instantiate(IVsDebugger debugger)
{
lock (_locker)
{
if (_instance != null)
throw new InvalidOperationException(string.Format("{0} of Resurrect is already instantiated.", _instance.GetType().Name));
_instance = new DebugEventsHunter(debugger);
}
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override void Initialize()
{
base.Initialize();
ICPServiceProvider cpServProv = ICPServiceProvider.GetProvider();
cpServProv.RegisterService <ICPTracerService>(new CPTracerService());
IVsDebugger vsDebugService = Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(SVsShellDebugger)) as IVsDebugger;
if (vsDebugService != null)
{
cpServProv.RegisterService <ICPDebugService>(new CPDebugService(vsDebugService));
}
ICPExtension extensionServ = new CPExtension();
cpServProv.RegisterService <ICPExtension>(extensionServ);
Globals.dte = (DTE)GetService(typeof(DTE));
//factory = new ChartPntFactoryImpl();
if (Globals.processor == null)
{
Globals.processor = CP.Utils.IClassFactory.GetInstance().CreateCPProc();
}
Globals.orchestrator = CP.Utils.IClassFactory.GetInstance().CreateCPOrchestrator();
IVsSolution vsSolution = GetService(typeof(SVsSolution)) as IVsSolution;
object objLoadMgr = this; //the class that implements IVsSolutionManager
vsSolution.SetProperty((int)__VSPROPID4.VSPROPID_ActiveSolutionLoadManager, objLoadMgr);
solEvents = new VsSolutionEvents(this);
uint solEvsCookie;
vsSolution.AdviseSolutionEvents(solEvents, out solEvsCookie);
buildManager3 = GetService(typeof(SVsSolutionBuildManager)) as IVsSolutionBuildManager3;
cmdEvsHandler = new CmdEventsHandler(vsSolution);
string vsixInstPath = extensionServ.GetVSIXInstallPath();
string regSrvFName = vsixInstPath + "\\cper.exe";
if (File.Exists(regSrvFName))
{
string message = "First time registration.\nAdministration privileges needed.";
string caption = "ChartPoints";
MessageBoxButtons buttons = MessageBoxButtons.OK;
MessageBox.Show(message, caption, buttons);
var p = new System.Diagnostics.Process();
p.StartInfo.FileName = regSrvFName;
p.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
p.StartInfo.Verb = "runas";
if (p.Start())
{
p.WaitForExit();
File.Delete(regSrvFName);
}
}
}
public VsImmediateWindowProvider(
SVsServiceProvider serviceProvider,
IVsInteractiveWindowFactory interactiveWindowFactory,
IViewClassifierAggregatorService classifierAggregator,
IContentTypeRegistryService contentTypeRegistry,
VisualStudioWorkspace workspace)
{
_vsInteractiveWindowFactory = interactiveWindowFactory;
_vsDebugger = (IVsDebugger)serviceProvider.GetService(typeof(IVsDebugger));
}
public EpochTextViewFilter(IVsDebugger debugger, CodeWindowManager mgr, IVsTextView textView, IWpfTextView wpfTextView)
: base(mgr, textView)
{
ThreadHelper.ThrowIfNotOnUIThread();
Debugger = debugger;
WpfTextView = wpfTextView;
textView.GetBuffer(out TextLines);
}
public VsImmediateWindowProvider(
SVsServiceProvider serviceProvider,
IVsInteractiveWindowFactory interactiveWindowFactory,
IViewClassifierAggregatorService classifierAggregator,
IContentTypeRegistryService contentTypeRegistry,
VisualStudioWorkspace workspace)
{
_vsInteractiveWindowFactory = interactiveWindowFactory;
_vsDebugger = (IVsDebugger)serviceProvider.GetService(typeof(IVsDebugger));
}
public static DBGMODE GetMode(this IVsDebugger debugger)
{
DBGMODE[] mode = new DBGMODE[1];
if (ErrorHandler.Failed(debugger.GetMode(mode)))
{
return(DBGMODE.DBGMODE_Design);
}
return(mode[0]);
}
public async Task <IReadOnlyList <IDebugLaunchSettings> > QueryDebugTargetsAsync(DebugLaunchOptions launchOptions, ILaunchProfile profile)
{
// NOTE: This method is called from the main (UI) thread and must remain on that thread!
if (profile.IsSnapshotDebuggerProfile())
{
IVsDebugger dbg = ServiceProvider.GetService(typeof(IVsDebugger)) as IVsDebugger;
}
return(new List <IDebugLaunchSettings>());
}
public TextViewFilter(IServiceProvider serviceProvider, IVsTextView vsTextView) {
var compModel = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
_vsEditorAdaptersFactoryService = compModel.GetService<IVsEditorAdaptersFactoryService>();
_debugger = (IVsDebugger)serviceProvider.GetService(typeof(IVsDebugger));
vsTextView.GetBuffer(out _vsTextLines);
_wpfTextView = _vsEditorAdaptersFactoryService.GetWpfTextView(vsTextView);
ErrorHandler.ThrowOnFailure(vsTextView.AddCommandFilter(this, out _next));
}
public TextViewFilter(PythonEditorServices editorServices, IVsTextView vsTextView)
{
_editorServices = editorServices;
_debugger = (IVsDebugger)_editorServices.Site.GetService(typeof(IVsDebugger));
vsTextView.GetBuffer(out _vsTextLines);
_wpfTextView = _editorServices.EditorAdaptersFactoryService.GetWpfTextView(vsTextView);
ErrorHandler.ThrowOnFailure(vsTextView.AddCommandFilter(this, out _next));
}
internal void Initialize()
{
DTE dte = GetService(typeof(DTE)) as DTE;
_debugEvents = new VsDebuggerEvents(dte, this);
IVsDebugger vsd = GetService(typeof(IVsDebugger)) as IVsDebugger;
int hr = vsd.AdviseDebuggerEvents(_debugEvents, out _debugEventsCookie);
this.ContextMenuStrip = _contextMenuStrip;
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
/// <param name="cancellationToken">A cancellation token to monitor for initialization cancellation, which can occur when VS is shutting down.</param>
/// <param name="progress">A provider for progress updates.</param>
/// <returns>A task representing the async work of package initialization, or an already completed task if there is none. Do not return null from this method.</returns>
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
// When initialized asynchronously, the current thread may be a background thread at this point.
// Do any initialization that requires the UI thread after switching to the UI thread.
await this.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
VsDebugger = await this.GetServiceAsync(typeof(IVsDebugger)) as IVsDebugger;
await RevitToolsCommand.InitializeAsync(this);
}
public void Dispose() {
_timer?.Stop();
_timer?.Dispose();
_timer = null;
if(_debuggerEventCookie != 0 && _debugger != null) {
_debugger.UnadviseDebuggerEvents(_debuggerEventCookie);
_debuggerEventCookie = 0;
_debugger = null;
}
}
public virtual void DebugLaunch(uint flags)
{
CCITracing.TraceCall();
try {
IVsDebugger d = (IVsDebugger)project.QueryService(typeof(IVsDebugger).GUID, typeof(IVsDebugger));
VsDebugTargetInfo info = new VsDebugTargetInfo();
info.cbSize = (uint)Marshal.SizeOf(info);
info.dlo = Microsoft.VisualStudio.Shell.Interop.DEBUG_LAUNCH_OPERATION.DLO_CreateProcess;
if (this.node.HasAttribute("StartProgram") && this.node.GetAttribute("StartProgram").Length > 0)
{
info.bstrExe = this.node.GetAttribute("StartProgram");
}
else
{
info.bstrExe = this.project.GetOutputAssembly(node);
}
if (this.node.HasAttribute("WorkingDirectory") && this.node.GetAttribute("WorkingDirectory").Length > 0)
{
info.bstrCurDir = this.node.GetAttribute("WorkingDirectory");
}
else
{
info.bstrCurDir = Path.GetDirectoryName(info.bstrExe);
}
if (this.node.HasAttribute("CmdArgs") && this.node.GetAttribute("CmdArgs").Length > 0)
{
info.bstrArg = this.node.GetAttribute("CmdArgs");
}
if (this.node.HasAttribute("RemoteDebugMachine") && this.node.GetAttribute("RemoteDebugMachine").Length > 0)
{
info.bstrRemoteMachine = this.node.GetAttribute("RemoteDebugMachine");
}
info.fSendStdoutToOutputWindow = 0;
info.clsidCustom = CLSID_ComPlusOnlyDebugEngine;
info.grfLaunch = flags;
IntPtr ptr = Marshal.AllocCoTaskMem((int)info.cbSize);
Marshal.StructureToPtr(info, ptr, false);
try {
d.LaunchDebugTargets(1, ptr);
} finally{
Marshal.FreeCoTaskMem(ptr);
}
}
catch (Exception e) {
throw new SystemException("Could not launch debugger - " + e.Message);
}
}
public DataTipTextViewFilter(System.IServiceProvider serviceProvider, IVsTextView vsTextView)
{
_debugger = (IVsDebugger)NodejsPackage.GetGlobalService(typeof(IVsDebugger));
vsTextView.GetBuffer(out _vsTextLines);
var editorAdaptersFactory = serviceProvider.GetComponentModel().GetService <IVsEditorAdaptersFactoryService>();
_wpfTextView = editorAdaptersFactory.GetWpfTextView(vsTextView);
ErrorHandler.ThrowOnFailure(vsTextView.AddCommandFilter(this, out _next));
}
public ToolWindowTracker() {
_debugger = VsAppShell.Current.GetGlobalService<IVsDebugger>(typeof(IVsDebugger));
if (_debugger != null) {
_debugger.AdviseDebuggerEvents(this, out _debuggerEventCookie);
_timer.Interval = new TimeSpan(0, 0, 10).TotalMilliseconds;
_timer.AutoReset = true;
_timer.Elapsed += OnElapsed;
_timer.Start();
}
}
private DataTipTextViewFilter(IWpfTextView textView, IVsEditorAdaptersFactoryService adapterService, IVsDebugger debugger) {
Trace.Assert(textView.TextBuffer.ContentType.IsOfType(RContentTypeDefinition.ContentType));
_textView = textView;
_debugger = debugger;
_vsTextView = adapterService.GetViewAdapter(textView);
_vsTextView.AddCommandFilter(this, out _nextTarget);
_vsTextView.GetBuffer(out _vsTextLines);
textView.Properties.AddProperty(typeof(DataTipTextViewFilter), this);
}
public ReAttachDebugger(IReAttachPackage package)
{
_package = package;
_debugger = package.GetService(typeof(SVsShellDebugger)) as IVsDebugger;
_dte = _package.GetService(typeof(SDTE)) as DTE2;
if (_dte != null)
_dteDebugger = _dte.Debugger as Debugger2;
if (_package == null || _debugger == null || _dte == null || _dteDebugger == null)
{
_package.Reporter.ReportError(
"Unable to get required services for ReAttachDebugger in ctor.");
return;
}
if (_debugger.AdviseDebuggerEvents(this, out _cookie) != VSConstants.S_OK)
_package.Reporter.ReportError("ReAttach: AdviserDebuggerEvents failed.");
if (_debugger.AdviseDebugEventCallback(this) != VSConstants.S_OK)
_package.Reporter.ReportError("AdviceDebugEventsCallback call failed in ReAttachDebugger ctor.");
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public DebuggerEventListener (EnvDTE.DTE dteService, IVsDebugger debuggerService, IDebuggerConnectionService debuggerConnectionService)
{
m_dteService = dteService;
m_debuggerService = debuggerService;
m_debuggerConnectionService = debuggerConnectionService;
LoggingUtils.RequireOk (m_debuggerService.AdviseDebuggerEvents (this, out m_debuggerServiceCookie));
LoggingUtils.RequireOk (m_debuggerService.AdviseDebugEventCallback (this));
//
// Register required listener events and paired process function callbacks.
//
m_eventCallbacks = new Dictionary<Guid, DebuggerEventListenerDelegate> ();
m_eventCallbacks.Add (ComUtils.GuidOf (typeof (DebugEngineEvent.SessionCreate)), OnSessionCreate);
m_eventCallbacks.Add (ComUtils.GuidOf (typeof (DebugEngineEvent.SessionDestroy)), OnSessionDestroy);
m_eventCallbacks.Add (ComUtils.GuidOf (typeof (DebugEngineEvent.EngineCreate)), OnEngineCreate);
m_eventCallbacks.Add (ComUtils.GuidOf (typeof (DebugEngineEvent.ProgramCreate)), OnProgramCreate);
m_eventCallbacks.Add (ComUtils.GuidOf (typeof (DebugEngineEvent.ProgramDestroy)), OnProgramDestroy);
m_eventCallbacks.Add (ComUtils.GuidOf (typeof (DebugEngineEvent.AttachComplete)), OnAttachComplete);
m_eventCallbacks.Add (ComUtils.GuidOf (typeof (DebugEngineEvent.Error)), OnError);
m_eventCallbacks.Add (ComUtils.GuidOf (typeof (DebugEngineEvent.DebuggerConnectionEvent)), OnDebuggerConnectionEvent);
m_eventCallbacks.Add (ComUtils.GuidOf (typeof (DebugEngineEvent.DebuggerLogcatEvent)), OnDebuggerLogcatEvent);
}
public ReAttachDebugger(IReAttachPackage package)
{
_package = package;
_debugger = package.GetService(typeof(SVsShellDebugger)) as IVsDebugger;
_dte = _package.GetService(typeof(SDTE)) as DTE2;
if (_dte != null)
_dteDebugger = _dte.Debugger as Debugger2;
if (_package == null || _debugger == null || _dte == null || _dteDebugger == null)
{
_package.Reporter.ReportError(
"Unable to get required services for ReAttachDebugger in ctor.");
return;
}
if (_debugger.AdviseDebuggerEvents(this, out _cookie) != VSConstants.S_OK)
_package.Reporter.ReportError("ReAttach: AdviserDebuggerEvents failed.");
if (_debugger.AdviseDebugEventCallback(this) != VSConstants.S_OK)
_package.Reporter.ReportError("AdviceDebugEventsCallback call failed in ReAttachDebugger ctor.");
foreach (Engine engine in _dteDebugger.Transports.Item("Default").Engines)
_engines.Add(Guid.Parse(engine.ID), engine.Name);
}
public DebugEventsHunter(IVsDebugger debugger)
{
_debugger = debugger;
}
// IDebugExceptionEvent2
// Debugger core interfaces
// http://msdn.microsoft.com/en-US/library/bb146305(v=VS.80).aspx
// New Debugging stuff in Visual 2010, data tips, etc
// http://msdn.microsoft.com/en-us/library/envdte90.debugger3_members.aspx
// http://channel9.msdn.com/Shows/10-4/10-4-Episode-34-Debugger-Enhancements-and-Improvements
public bool Register(EnvDTE.DTE dte, GanjiContext context)
{
_applicationObject = dte;
m_debugger = Package.GetGlobalService(typeof(SVsShellDebugger)) as IVsDebugger;
if (m_debugger != null)
{
HandleException.Debugger = m_debugger as IVsDebugger2;
m_debugger.AdviseDebuggerEvents(this, out m_debugEventsCookie);
m_debugger.AdviseDebugEventCallback(this);
}
return true;
}
internal DebuggerEvaluator(IVsDebugger debugger)
{
_debugger = debugger;
}
private static bool IsDebugging(IServiceProvider provider, IVsDebugger debugger) {
return provider.GetUIThread().Invoke(() => {
var mode = new[] { DBGMODE.DBGMODE_Design };
return ErrorHandler.Succeeded(debugger.GetMode(mode)) && mode[0] != DBGMODE.DBGMODE_Design;
});
}
public static DataTipTextViewFilter GetOrCreate(IWpfTextView textView, IVsEditorAdaptersFactoryService adapterService, IVsDebugger debugger) {
return textView.Properties.GetOrCreateSingletonProperty(() => new DataTipTextViewFilter(textView, adapterService, debugger));
}
internal IVsDebugger GetIVsDebugger()
{
if (this.debugger == null)
{
Guid guid = typeof(Microsoft.VisualStudio.Shell.Interop.IVsDebugger).GUID;
this.debugger = this.GetService(typeof(IVsDebugger)) as IVsDebugger;
if (this.debugger != null)
{
NativeMethods.ThrowOnFailure(debugger.AdviseDebuggerEvents(this, out this.cookie));
DBGMODE[] mode = new DBGMODE[1];
NativeMethods.ThrowOnFailure(debugger.GetMode(mode));
this.dbgMode = mode[0];
}
}
return debugger;
}
/// <include file='doc\LanguageService.uex' path='docs/doc[@for="LanguageService.Done"]/*' />
/// <summary>
/// Cleanup the sources, uiShell, shell, preferences and imageList objects
/// and unregister this language service with VS.
/// </summary>
public virtual void Dispose() {
OnActiveViewChanged(null);
this.disposed = true;
this.StopThread();
this.lastActiveView = null;
if (this.sources != null) {
foreach (Source s in this.sources) {
s.Dispose();
}
this.sources.Clear();
this.sources = null;
}
if (this.colorizers != null) {
foreach (Colorizer c in this.colorizers) {
c.Dispose();
}
this.colorizers.Clear();
this.colorizers = null;
}
if (this.codeWindowManagers != null) {
foreach (CodeWindowManager m in this.codeWindowManagers) {
m.Close();
}
this.codeWindowManagers.Clear();
this.codeWindowManagers = null;
}
if (this.preferences != null) {
this.preferences.Dispose();
this.preferences = null;
}
if (this.debugger != null && this.cookie != 0) {
NativeMethods.ThrowOnFailure(this.debugger.UnadviseDebuggerEvents(this.cookie));
this.cookie = 0;
this.debugger = null;
}
if (this.task != null)
this.task.Dispose();
this.task = null;
this.site = null;
}
/// <include file='doc\LanguageService.uex' path='docs/doc[@for="LanguageService.GetIVsDebugger"]/*' />
public IVsDebugger GetIVsDebugger() {
if (this.debugger == null) {
Guid guid = typeof(Microsoft.VisualStudio.Shell.Interop.IVsDebugger).GUID;
this.debugger = this.GetService(typeof(IVsDebugger)) as IVsDebugger;
if (this.debugger != null) {
NativeMethods.ThrowOnFailure(debugger.AdviseDebuggerEvents(this, out this.cookie));
}
}
return debugger;
}