Exemple #1
0
        private async System.Threading.Tasks.Task InitializeAsyncCommands()
        {
            if (null == CompileCommand.Instance)
            {
                await CompileCommand.InitializeAsync(mCommandsController, mErrorWindow, mOutputController, this, CommandSet, CommandIds.kCompileId);
            }

            if (null == TidyCommand.Instance)
            {
                await TidyCommand.InitializeAsync(mCommandsController, mErrorWindow, mOutputController, this, CommandSet, CommandIds.kTidyId);

                await TidyCommand.InitializeAsync(mCommandsController, mErrorWindow, mOutputController, this, CommandSet, CommandIds.kTidyFixId);
            }

            if (null == ClangFormatCommand.Instance)
            {
                await ClangFormatCommand.InitializeAsync(mCommandsController, mErrorWindow, mOutputController, this, CommandSet, CommandIds.kClangFormat);
            }

            if (null == StopClang.Instance)
            {
                await StopClang.InitializeAsync(mCommandsController, mErrorWindow, mOutputController, this, CommandSet, CommandIds.kStopClang);
            }

            if (null == SettingsCommand.Instance)
            {
                await SettingsCommand.InitializeAsync(this, CommandSet, CommandIds.kSettingsId);
            }
        }
        public async System.Threading.Tasks.Task InitializeAsyncCommands(AsyncPackage aAsyncPackage,
                                                                         ErrorWindowController aErrorController, OutputWindowController aOutputWindowController)
        {
            if (null == CompileCommand.Instance)
            {
                await CompileCommand.InitializeAsync(this, aErrorController, aOutputWindowController, aAsyncPackage, mCommandSet, CommandIds.kCompileId);
            }

            if (null == TidyCommand.Instance)
            {
                await TidyCommand.InitializeAsync(this, aErrorController, aOutputWindowController, aAsyncPackage, mCommandSet, CommandIds.kTidyId);

                await TidyCommand.InitializeAsync(this, aErrorController, aOutputWindowController, aAsyncPackage, mCommandSet, CommandIds.kTidyFixId);
            }

            if (null == ClangFormatCommand.Instance)
            {
                await ClangFormatCommand.InitializeAsync(this, aErrorController, aOutputWindowController, aAsyncPackage, mCommandSet, CommandIds.kClangFormat);
            }

            if (null == StopClang.Instance)
            {
                await StopClang.InitializeAsync(this, aErrorController, aOutputWindowController, aAsyncPackage, mCommandSet, CommandIds.kStopClang);
            }

            if (null == SettingsCommand.Instance)
            {
                await SettingsCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kSettingsId);
            }
        }
        /// <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();

            TidyCommand TidyCmd = new TidyCommand(this, CommandSet, CommandIds.kTidyId);

            CompileCommand CompileCmd = new CompileCommand(this, CommandSet, CommandIds.kCompileId);

            StopClang stopClang = new StopClang(this, CommandSet, CommandIds.kStopClang);

            SettingsCommand SettingsCmd = new SettingsCommand(this, CommandSet, CommandIds.kSettingsId);
        }
Exemple #4
0
        public async System.Threading.Tasks.Task InitializeCommandsAsync(AsyncPackage aAsyncPackage)
        {
            if (CompileCommand.Instance == null)
            {
                await CompileCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kCompileId);

                await CompileCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kCompileToolbarId);
            }

            if (TidyCommand.Instance == null)
            {
                await TidyCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kTidyId);

                await TidyCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.TidyToolbarId);

                await TidyCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kTidyFixId);

                await TidyCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kTidyFixToolbarId);
            }

            if (ClangFormatCommand.Instance == null)
            {
                await ClangFormatCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kClangFormat);

                await ClangFormatCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kClangFormatToolbarId);
            }

            if (IgnoreFormatCommand.Instance == null)
            {
                await IgnoreFormatCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kIgnoreFormatId);
            }

            if (IgnoreCompileCommand.Instance == null)
            {
                await IgnoreCompileCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kIgnoreCompileId);
            }

            if (StopClang.Instance == null)
            {
                await StopClang.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kStopClang);
            }

            if (SettingsCommand.Instance == null)
            {
                await SettingsCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kSettingsId);
            }

            if (TidyConfigCommand.Instance == null)
            {
                await TidyConfigCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kITidyExportConfigId);
            }
        }
        public async System.Threading.Tasks.Task InitializeAsyncCommands(AsyncPackage aAsyncPackage)
        {
            if (null == CompileCommand.Instance)
            {
                await CompileCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kCompileId);
            }

            if (null == TidyCommand.Instance)
            {
                await TidyCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kTidyId);

                await TidyCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kTidyFixId);

                await TidyCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kTidyFixMenuId);
            }

            if (null == ClangFormatCommand.Instance)
            {
                await ClangFormatCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kClangFormat);
            }

            if (IgnoreFormatCommand.Instance == null)
            {
                await IgnoreFormatCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kIgnoreFormatId);
            }

            if (IgnoreCompileCommand.Instance == null)
            {
                await IgnoreCompileCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kIgnoreCompileId);
            }

            if (null == StopClang.Instance)
            {
                await StopClang.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kStopClang);
            }

            if (null == SettingsCommand.Instance)
            {
                await SettingsCommand.InitializeAsync(this, aAsyncPackage, mCommandSet, CommandIds.kSettingsId);
            }
        }
        public int OnAfterOpenSolution(object pUnkReserved, int fNewSolution)
        {
            //Load the rest of the commands when a solution is loaded

            if (null == mTidyCmd)
            {
                mTidyCmd = new TidyCommand(this, CommandSet, CommandIds.kTidyId);
            }

            if (null == mCompileCmd)
            {
                mCompileCmd = new CompileCommand(this, CommandSet, CommandIds.kCompileId);
            }

            if (null == mStopClang)
            {
                mStopClang = new StopClang(this, CommandSet, CommandIds.kStopClang);
            }

            var generalOptions = (GeneralOptions)this.GetDialogPage(typeof(GeneralOptions));
            var currentVersion = GetPackageVersion();

            if (0 != string.Compare(generalOptions.Version, currentVersion))
            {
                var           dte           = GetService(typeof(DTE)) as DTE2;
                OutputManager outputManager = new OutputManager(dte);
                outputManager.Show();
                outputManager.AddMessage($"🎉\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();
            }

            return(VSConstants.S_OK);
        }