Ejemplo n.º 1
0
        protected void RunScript(int aCommandId)
        {
            try
            {
                var dte = VsServiceProvider.GetService(typeof(DTE)) as DTE2;
                dte.Solution.SaveAs(dte.Solution.FullName);

                IBuilder <string> runModeScriptBuilder = new RunModeScriptBuilder();
                runModeScriptBuilder.Build();
                var runModeParameters = runModeScriptBuilder.GetResult();

                IBuilder <string> genericScriptBuilder = new GenericScriptBuilder(VsEdition, VsVersion, aCommandId);
                genericScriptBuilder.Build();
                var genericParameters = genericScriptBuilder.GetResult();

                string solutionPath = dte.Solution.FullName;

                InitPowerShell();
                ClearWindows();
                mOutputWindow.Write($"\n{OutputWindowConstants.kStart} {OutputWindowConstants.kCommandsNames[aCommandId]}\n");

                StatusBarHandler.Status(OutputWindowConstants.kCommandsNames[aCommandId] + " started...", 1, vsStatusAnimation.vsStatusAnimationBuild, 1);

                VsServiceProvider.TryGetService(typeof(SVsSolution), out object vsSolutionService);
                var vsSolution = vsSolutionService as IVsSolution;

                foreach (var item in mItemsCollector.GetItems)
                {
                    if (!mCommandsController.Running)
                    {
                        break;
                    }

                    IBuilder <string> itemRelatedScriptBuilder = new ItemRelatedScriptBuilder(item);
                    itemRelatedScriptBuilder.Build();
                    var itemRelatedParameters = itemRelatedScriptBuilder.GetResult();

                    // From the first parameter is removed the last character which is mandatory "'"
                    // and added to the end of the string to close the script
                    var script = $"{runModeParameters.Remove(runModeParameters.Length - 1)} {itemRelatedParameters} {genericParameters}'";

                    if (null != vsSolution)
                    {
                        mOutputWindow.Hierarchy = AutomationUtil.GetItemHierarchy(vsSolution as IVsSolution, item);
                    }

                    var process = mPowerShell.Invoke(script, mRunningProcesses);

                    if (mOutputWindow.MissingLlvm)
                    {
                        mOutputWindow.Write(ErrorParserConstants.kMissingLlvmMessage);
                        break;
                    }
                }

                if (!mOutputWindow.MissingLlvm)
                {
                    mOutputWindow.Show();
                    mOutputWindow.Write($"\n{OutputWindowConstants.kDone} {OutputWindowConstants.kCommandsNames[aCommandId]}\n");
                }

                if (mOutputWindow.HasErrors)
                {
                    mErrorWindow.AddErrors(mOutputWindow.Errors);
                }
            }
            catch (Exception)
            {
                mOutputWindow.Show();
                mOutputWindow.Write($"\n{OutputWindowConstants.kDone} {OutputWindowConstants.kCommandsNames[aCommandId]}\n");
            }
            finally
            {
                StatusBarHandler.Status(OutputWindowConstants.kCommandsNames[aCommandId] + " finished", 0, vsStatusAnimation.vsStatusAnimationBuild, 0);
            }
        }
Ejemplo n.º 2
0
        /// <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 async System.Threading.Tasks.Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
        {
            // Switches to the UI thread in order to consume some services used in command initialization
            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);

            await RegisterVsServices();

            var vsOutputWindow = VsServiceProvider.GetService(typeof(SVsOutputWindow)) as IVsOutputWindow;

            mOutputController = new OutputWindowController();
            mOutputController.Initialize(this, vsOutputWindow);

            mRunningDocTableEvents = new RunningDocTableEvents(this);
            mErrorWindow           = new ErrorWindowController(this);

            mCommandsController = new CommandsController(this);

            #region Get Pointer to IVsSolutionEvents

            if (VsServiceProvider.TryGetService(typeof(SVsSolution), out object vsSolutionService))
            {
                var vsSolution = vsSolutionService as IVsSolution;
                UnadviseSolutionEvents(vsSolution);
                AdviseSolutionEvents(vsSolution);
            }

            #endregion

            // Get the build and command events from DTE
            if (VsServiceProvider.TryGetService(typeof(DTE), out object dte))
            {
                var dte2 = dte as DTE2;
                mBuildEvents   = dte2.Events.BuildEvents;
                mCommandEvents = dte2.Events.CommandEvents;
                mDteEvents     = dte2.Events.DTEEvents;
            }

            // Get the general clang option page
            var generalOptions = (ClangGeneralOptionsView)GetDialogPage(typeof(ClangGeneralOptionsView));

            // Detect the first install
            if (null == generalOptions.Version || string.IsNullOrWhiteSpace(generalOptions.Version))
            {
                ShowToolbare(); // Show the toolbar on the first install
            }
            var currentVersion = GetPackageVersion();

            if (0 != string.Compare(generalOptions.Version, currentVersion))
            {
                mOutputController.Show();
                mOutputController.Write($"🎉\tClang Power Tools was upgraded to v{currentVersion}\n" +
                                        $"\tCheck out what's new at http://www.clangpowertools.com/CHANGELOG");

                generalOptions.Version = currentVersion;
                generalOptions.SaveSettingsToStorage();
            }


            await InitializeAsyncCommands();

            RegisterToVsEvents();

            await base.InitializeAsync(cancellationToken, progress);
        }
        /// <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 async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
        {
            // Switches to the UI thread in order to consume some services used in command initialization
            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);

            await RegisterVsServicesAsync();

            mCommandController = new CommandController(this);
            CommandTestUtility.CommandController = mCommandController;

            var vsOutputWindow = VsServiceProvider.GetService(typeof(SVsOutputWindow)) as IVsOutputWindow;

            mOutputWindowController = new OutputWindowController();
            mOutputWindowController.Initialize(this, vsOutputWindow);

            mRunningDocTableEvents = new RunningDocTableEvents(this);
            mErrorWindowController = new ErrorWindowController(this);

            #region Get Pointer to IVsSolutionEvents

            if (VsServiceProvider.TryGetService(typeof(SVsSolution), out object vsSolutionService))
            {
                var vsSolution = vsSolutionService as IVsSolution;
                UnadviseSolutionEvents(vsSolution);
                AdviseSolutionEvents(vsSolution);
            }

            #endregion

            // Get the build and command events from DTE
            if (VsServiceProvider.TryGetService(typeof(DTE), out object dte))
            {
                var dte2 = dte as DTE2;
                mBuildEvents   = dte2.Events.BuildEvents;
                mCommandEvents = dte2.Events.CommandEvents;
                mDteEvents     = dte2.Events.DTEEvents;
            }

            DispatcherHandler.Initialize(dte as DTE2);
            SettingsProvider.Initialize(this);

            // Detect the first install
            if (string.IsNullOrWhiteSpace(SettingsProvider.GeneralSettings.Version))
            {
                ShowToolbare(); // Show the toolbar on the first install
            }
            if (string.IsNullOrWhiteSpace(SettingsProvider.GeneralSettings.Version) ||
                0 > string.Compare(SettingsProvider.GeneralSettings.Version, "5.0.0"))
            {
                System.Diagnostics.Process.Start(new ProcessStartInfo("https://clangpowertools.com/blog/future-of-clang-power-tools.html"));
            }

            var currentVersion = PackageUtility.GetVersion();
            if (!string.IsNullOrWhiteSpace(currentVersion) &&
                0 > string.Compare(SettingsProvider.GeneralSettings.Version, currentVersion))
            {
                mOutputWindowController.Clear();
                mOutputWindowController.Show();
                mOutputWindowController.Write($"🎉\tClang Power Tools was upgraded to v{currentVersion}\n" +
                                              $"\tCheck out what's new at http://www.clangpowertools.com/CHANGELOG");

                SettingsProvider.GeneralSettings.Version = currentVersion;
            }

            SettingsHandler.SaveGeneralSettings();

            await mCommandController.InitializeCommandsAsync(this);

            mLicenseController = new LicenseController();

            RegisterToEvents();
            await mLicenseController.CheckLicenseAsync();

            await base.InitializeAsync(cancellationToken, progress);
        }
Ejemplo n.º 4
0
        /// <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 async System.Threading.Tasks.Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
        {
            // Switches to the UI thread in order to consume some services used in command initialization
            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);

            await RegisterVsServices();

            mCommandsController = new CommandsController(this);
            SettingsProvider.Initialize(this);

            var vsOutputWindow = VsServiceProvider.GetService(typeof(SVsOutputWindow)) as IVsOutputWindow;

            mOutputWindowController = new OutputWindowController();
            mOutputWindowController.Initialize(this, vsOutputWindow);

            //mCommandsController.ClangCommandMessageEvent += mOutputWindowController.Write;

            //PowerShellWrapper.DataHandler += mOutputWindowController.OutputDataReceived;
            //PowerShellWrapper.DataErrorHandler += mOutputWindowController.OutputDataErrorReceived;
            //PowerShellWrapper.ExitedHandler += mOutputWindowController.ClosedDataConnection;

            mRunningDocTableEvents = new RunningDocTableEvents(this);
            mErrorWindowController = new ErrorWindowController(this);

            //mOutputWindowController.ErrorDetectedEvent += mErrorWindowController.OnErrorDetected;


            #region Get Pointer to IVsSolutionEvents

            if (VsServiceProvider.TryGetService(typeof(SVsSolution), out object vsSolutionService))
            {
                var vsSolution = vsSolutionService as IVsSolution;
                UnadviseSolutionEvents(vsSolution);
                AdviseSolutionEvents(vsSolution);
            }

            #endregion

            // Get the build and command events from DTE
            if (VsServiceProvider.TryGetService(typeof(DTE), out object dte))
            {
                var dte2 = dte as DTE2;
                mBuildEvents   = dte2.Events.BuildEvents;
                mCommandEvents = dte2.Events.CommandEvents;
                mDteEvents     = dte2.Events.DTEEvents;
            }

            DispatcherHandler.Initialize(dte as DTE2);

            // Get the general clang option page
            var generalSettings = SettingsProvider.GetSettingsPage(typeof(ClangGeneralOptionsView)) as ClangGeneralOptionsView;

            // Detect the first install
            if (string.IsNullOrWhiteSpace(generalSettings.Version))
            {
                ShowToolbare(); // Show the toolbar on the first install
            }
            var currentVersion = GetPackageVersion();
            if (0 > string.Compare(generalSettings.Version, currentVersion))
            {
                mOutputWindowController.Clear();
                mOutputWindowController.Show();
                mOutputWindowController.Write($"🎉\tClang Power Tools was upgraded to v{currentVersion}\n" +
                                              $"\tCheck out what's new at http://www.clangpowertools.com/CHANGELOG");

                generalSettings.Version = currentVersion;
                generalSettings.SaveSettingsToStorage();
            }

            await mCommandsController.InitializeAsyncCommands(this);

            //mCommandsController.HierarchyDetectedEvent += mOutputWindowController.OnFileHierarchyDetected;
            //mOutputWindowController.MissingLlvmEvent += mCommandsController.OnMissingLLVMDetected;

            //RegisterToCPTEvents();
            //RegisterToVsEvents();

            RegisterToEvents();

            await base.InitializeAsync(cancellationToken, progress);
        }