GBackupSolution - Visual Studio Extension VSX 2008/2010

��using System;

using Extensibility;

using EnvDTE;

using EnvDTE80;

using Microsoft.VisualStudio.CommandBars;

using System.Resources;

using System.Reflection;

using System.Globalization;

using System.Windows.Forms;

using GBackupSolution.Core;



namespace GBackupSolution

{

	/// <summary>The object for implementing an Add-in.</summary>

	/// <seealso class='IDTExtensibility2' />

	public class Connect : IDTExtensibility2, IDTCommandTarget

	{

        CommandBar cmbGbackup;



		/// <summary>Implements the constructor for the Add-in object. Place your initialization code within this method.</summary>

		public Connect()

		{

		}



		/// <summary>Implements the OnConnection method of the IDTExtensibility2 interface. Receives notification that the Add-in is being loaded.</summary>

		/// <param term='application'>Root object of the host application.</param>

		/// <param term='connectMode'>Describes how the Add-in is being loaded.</param>

		/// <param term='addInInst'>Object representing this Add-in.</param>

		/// <seealso class='IDTExtensibility2' />

		public void OnConnection(object application, ext_ConnectMode connectMode, object addInInst, ref Array custom)

		{

			_applicationObject = (DTE2)application;

			_addInInstance = (AddIn)addInInst;

			if(connectMode == ext_ConnectMode.ext_cm_UISetup)

			{

				object []contextGUIDS = new object[] { };

				Commands2 commands = (Commands2)_applicationObject.Commands;

				string toolsMenuName;



				try

				{

					//If you would like to move the command to a different menu, change the word "Tools" to the 

					//  English version of the menu. This code will take the culture, append on the name of the menu

					//  then add the command to that menu. You can find a list of all the top-level menus in the file

					//  CommandBar.resx.

					string resourceName;

					ResourceManager resourceManager = new ResourceManager("GBackupSolution.CommandBar", Assembly.GetExecutingAssembly());

					CultureInfo cultureInfo = new CultureInfo(_applicationObject.LocaleID);

					

					if(cultureInfo.TwoLetterISOLanguageName == "zh")

					{

						CultureInfo parentCultureInfo = cultureInfo.Parent;

						resourceName = String.Concat(parentCultureInfo.Name, "Tools");

					}

					else

					{

						resourceName = String.Concat(cultureInfo.TwoLetterISOLanguageName, "Tools");

					}

					toolsMenuName = resourceManager.GetString(resourceName);

				}

				catch

				{

					//We tried to find a localized version of the word Tools, but one was not found.

					//  Default to the en-US word, which may work for the current culture.

					toolsMenuName = "Tools";

				}

                

				//Place the command on the tools menu.

				//Find the MenuBar command bar, which is the top-level command bar holding all the main menu items:

				CommandBar menuBarCommandBar = ((CommandBars)_applicationObject.CommandBars)["MenuBar"];



                //Find the Tools command bar on the MenuBar command bar:

				CommandBarControl toolsControl = menuBarCommandBar.Controls[toolsMenuName];

				CommandBarPopup toolsPopup = (CommandBarPopup)toolsControl;



				//This try/catch block can be duplicated if you wish to add multiple commands to be handled by your Add-in,

				//  just make sure you also update the QueryStatus/Exec method to include the new command names.

				try

				{

                    // Searching if submenu already exists

                    for (int iloop = 1; iloop <= toolsPopup.CommandBar.Controls.Count; iloop++)

                    {

                        if (toolsPopup.CommandBar.Controls[iloop].Caption == "GBackupSolution")

                        {

                            var op = (CommandBarPopup)toolsPopup.CommandBar.Controls[iloop];

                            cmbGbackup = op.CommandBar;

                            break;

                        }

                    }



                    //Add a command to the Commands collection:

                    Command cmdBackupNow = commands.AddNamedCommand2(_addInInstance, "BackupNow", "Backup solution now", "Press Shift + Alt + G to backup now.", false, 1, ref contextGUIDS, (int)vsCommandStatus.vsCommandStatusSupported + (int)vsCommandStatus.vsCommandStatusEnabled, (int)vsCommandStyle.vsCommandStylePictAndText, vsCommandControlType.vsCommandControlTypeButton);

                    Command cmdOptions = commands.AddNamedCommand2(_addInInstance, "Options", "Options...", "Executes the command for Options...", true, 13, ref contextGUIDS, (int)vsCommandStatus.vsCommandStatusSupported + (int)vsCommandStatus.vsCommandStatusEnabled, (int)vsCommandStyle.vsCommandStylePictAndText, vsCommandControlType.vsCommandControlTypeButton);



                    if (cmbGbackup == null)

                        cmbGbackup = (CommandBar) commands.AddCommandBar("GBackupSolution", vsCommandBarType.vsCommandBarTypeMenu, toolsPopup.CommandBar, 1);



                    //Add a control for the command to the tools menu:

                    if ((cmdOptions != null) && (toolsPopup != null))

                    {

                        cmdOptions.AddControl(cmbGbackup, 1);

                        // a default keybinding specified

                        var bindings = (object[])cmdOptions.Bindings;

                        if (0 >= bindings.Length)

                        {

                            // there is no preexisting key binding, so add the default

                            bindings = new object[1];

                            bindings[0] = "Global::SHIFT+ALT+O";

                            cmdOptions.Bindings = bindings;

                        }

                    }



				    //Add a control for the command to the tools menu:

                    if ((cmdBackupNow != null) && (toolsPopup != null))

                    {

                        cmdBackupNow.AddControl(cmbGbackup, 1);



                        var bindings = (object[])cmdBackupNow.Bindings;

                        if (0 >= bindings.Length)

                        {

                           bindings = new object[1];

                            bindings[0] = "Global::SHIFT+ALT+G";

                            cmdBackupNow.Bindings = bindings;

                        }

                    }

                    

				}

				catch(ArgumentException)

				{

					//If we are here, then the exception is probably because a command with that name

					//  already exists. If so there is no need to recreate the command and we can 

                    //  safely ignore the exception.

				}

			}

		}



		/// <summary>Implements the OnDisconnection method of the IDTExtensibility2 interface. Receives notification that the Add-in is being unloaded.</summary>

		/// <param term='disconnectMode'>Describes how the Add-in is being unloaded.</param>

		/// <param term='custom'>Array of parameters that are host application specific.</param>

		/// <seealso class='IDTExtensibility2' />

		public void OnDisconnection(ext_DisconnectMode disconnectMode, ref Array custom)

		{

		}



		/// <summary>Implements the OnAddInsUpdate method of the IDTExtensibility2 interface. Receives notification when the collection of Add-ins has changed.</summary>

		/// <param term='custom'>Array of parameters that are host application specific.</param>

		/// <seealso class='IDTExtensibility2' />		

		public void OnAddInsUpdate(ref Array custom)

		{

		}



		/// <summary>Implements the OnStartupComplete method of the IDTExtensibility2 interface. Receives notification that the host application has completed loading.</summary>

		/// <param term='custom'>Array of parameters that are host application specific.</param>

		/// <seealso class='IDTExtensibility2' />

		public void OnStartupComplete(ref Array custom)

		{

		}



		/// <summary>Implements the OnBeginShutdown method of the IDTExtensibility2 interface. Receives notification that the host application is being unloaded.</summary>

		/// <param term='custom'>Array of parameters that are host application specific.</param>

		/// <seealso class='IDTExtensibility2' />

		public void OnBeginShutdown(ref Array custom)

		{

		}

		

		/// <summary>Implements the QueryStatus method of the IDTCommandTarget interface. This is called when the command's availability is updated</summary>

		/// <param term='commandName'>The name of the command to determine state for.</param>

		/// <param term='neededText'>Text that is needed for the command.</param>

		/// <param term='status'>The state of the command in the user interface.</param>

		/// <param term='commandText'>Text requested by the neededText parameter.</param>

		/// <seealso class='Exec' />

		public void QueryStatus(string commandName, vsCommandStatusTextWanted neededText, ref vsCommandStatus status, ref object commandText)

		{

			if(neededText == vsCommandStatusTextWanted.vsCommandStatusTextWantedNone)

			{

                if (commandName == "GBackupSolution.Connect.BackupNow" || commandName == "GBackupSolution.Connect.Options")

                {

                    status = vsCommandStatus.vsCommandStatusSupported | vsCommandStatus.vsCommandStatusEnabled;

                    return;

                }

			}

		}



		/// <summary>Implements the Exec method of the IDTCommandTarget interface. This is called when the command is invoked.</summary>

		/// <param term='commandName'>The name of the command to execute.</param>

		/// <param term='executeOption'>Describes how the command should be run.</param>

		/// <param term='varIn'>Parameters passed from the caller to the command handler.</param>

		/// <param term='varOut'>Parameters passed from the command handler to the caller.</param>

		/// <param term='handled'>Informs the caller if the command was handled or not.</param>

		/// <seealso class='Exec' />

		public void Exec(string commandName, vsCommandExecOption executeOption, ref object varIn, ref object varOut, ref bool handled)

		{

            handled = false;

            if (executeOption == vsCommandExecOption.vsCommandExecOptionDoDefault)

            {

                if (commandName == "GBackupSolution.Connect.BackupNow")

                {

                    if (!_applicationObject.Solution.IsOpen)

                    {

                        MessageBox.Show("Please load your solution first!","Solution is unloaded!", MessageBoxButtons.OK, MessageBoxIcon.Warning);

                        handled = true;

                        return;

                    }



                    var backUp = new ClsBackup(_applicationObject);



                    // If there are empty fields, just promt it.

                    if (!backUp.settings.OtherBackupLocally)

                    {

                        if (string.IsNullOrEmpty(backUp.settings.GmailUsername) || string.IsNullOrEmpty(backUp.settings.GmailPassword))

                        {

                            MessageBox.Show("Your Gmail username or password is now empty, please go to Options page (Shift + Alt + O) to fill it!", "Enter your Gmail Username or Password!", MessageBoxButtons.OK, MessageBoxIcon.Warning);

                            handled = true;

                            return;

                        }

                    }

                    

                    if(string.IsNullOrEmpty(backUp.settings.GmailSubject) ||

                        (backUp.settings.GmailToOther && string.IsNullOrEmpty(backUp.settings.Gmail2OtherEmail))||

                        string.IsNullOrEmpty(backUp.settings.BackupPath) ||

                        string.IsNullOrEmpty(backUp.settings.BackupName)

                        )

                    {

                        if(MessageBox.Show("There are some fields empty now, would you like to use default settings?", "Use default settings", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) == DialogResult.Cancel)

                        {

                            handled = true;

                            return;

                        }

                    }



                    if (backUp.settings.BackupPromptFileName)

                    {

                        if (MessageBox.Show(

                           "The backup file name will be:\n\n\t" +

                           backUp.GetFormatString(backUp.settings.BackupName) + "\n\nAre you sure?\n", "Confirm backup file name",

                           MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK)

                        {

                            if (backUp.settings.OtherSaveAll)

                            {

                                _applicationObject.StatusBar.Text = "Save All Files...";

                                _applicationObject.ExecuteCommand("File.SaveAll", "");

                            }



                            // Start to backup

                            backUp.StartToBackup();

                        }

                    }

                    else

                    {

                        if (backUp.settings.OtherSaveAll)

                        {

                            _applicationObject.StatusBar.Text = "Save All Files...";

                            _applicationObject.ExecuteCommand("File.SaveAll", "");

                        }



                        backUp.StartToBackup();

                    }

                   

                    

                    handled = true;

                    return;

                }



                if (commandName == "GBackupSolution.Connect.Options")

                {

                    var frmOption = new FrmOption(_applicationObject);

                    frmOption.ShowDialog();

                    handled = true;

                    return;

                }

            }

		}

		private DTE2 _applicationObject;

		private AddIn _addInInstance;

	}

}