namespace NarfAddin
                   

using System;
using Microsoft.Office.Core;
using Extensibility;
using System.Runtime.InteropServices;
using EnvDTE;

#region Read me for Add-in installation and setup information.
// When run, the Add-in wizard prepared the registry for the Add-in.
// At a later time, if the Add-in becomes unavailable for reasons such as:
// 1) You moved this project to a computer other than which is was originally created on.
// 2) You chose 'Yes' when presented with a message asking if you wish to remove the Add-in.
// 3) Registry corruption.
// you will need to re-register the Add-in by building the MyAddin21Setup project
// by right clicking the project in the Solution Explorer, then choosing install.
#endregion

[GuidAttribute("A8989C04-130B-4F30-913C-7ED1BF6107B8"), ProgId("NarfAddin.Connect")]
public class Connect : Object, Extensibility.IDTExtensibility2, IDTCommandTarget

public Connect()
{
}

public void OnConnection(object application, Extensibility.ext_ConnectMode connectMode, object addInInst, 
ref System.Array custom)
{
}

public void OnDisconnection(Extensibility.ext_DisconnectMode disconnectMode, ref System.Array custom)
{
}

public void OnAddInsUpdate(ref System.Array custom)
{
}

public void OnStartupComplete(ref System.Array custom)
{
}

public void OnBeginShutdown(ref System.Array custom)
{
}

public void QueryStatus(string commandName, EnvDTE.vsCommandStatusTextWanted neededText, 
ref EnvDTE.vsCommandStatus status, ref object commandText)
{
}

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

}

applicationObject = (_DTE)application;
addInInstance = (AddIn)addInInst;

if(connectMode == Extensibility.ext_ConnectMode.ext_cm_UISetup)
{
  object []contextGUIDS = new object[] { };
  Commands commands = applicationObject.Commands;
  _CommandBars commandBars = applicationObject.CommandBars;
  try
  {
    CommandBar commandBar = (CommandBar)commandBars["Code Window"];
    Command command = commands.AddNamedCommand(addInInstance, 
	                                           "NomUniqueDeMonMenu", 
	                                           "Texte du menu ", 
	                                           "Tooltip de mon menu ", 
	                                           true, 
	                                           1, 
	                                           ref contextGUIDS, 
	                                           (int)vsCommandStatus.vsCommandStatusSupported+
                                               (int)vsCommandStatus.vsCommandStatusEnabled);
    CommandBarControl commandBarControl = command.AddControl(commandBar, 1); // j'ajoute mon menu à la barre d'outils
  }
  catch
  {
  }
}

commands.AddNamedCommand(
addInInstance,    // Instance de notre Add-in (autogénéré pas VS et se trouvant au debut de OnConnection( )
"NomMenu",        // Nom unique du menu. Donnera : Addin.progid.<le nom choisi>
"Texte du menu",  // Texte du menu (le texte affiché :D)
"Tooltip",        // Tooltip pour donner plus d'explications
true,             // si le menu est un MSOButton ou non (bouton utilisant une image office)
1,                // id d'un bitmap dans les ressources Office (car true). Image dessinée devant le menu
ref contextGUIDS, // contextes d'environnement (mode débogage, mode design, etc.) activent la commande
(int)blabla....   // flags d'activation ou non de la commande
)

public void Exec(string commandName, EnvDTE.vsCommandExecOption executeOption, ref object varIn, 
ref object varOut, ref bool handled)
{
  if(commandName == "MonAddin.Connect.Menu1")
  {
    // je fais l'action du Menu1
  }
  if(commandName == "MonAddin.Connect.Menu2")
  {
    // je fais l'action du Menu2
  }
}

 // activation
   status = (vsCommandStatus)vsCommandStatus.vsCommandStatusSupported | vsCommandStatus.vsCommandStatusEnabled;
 // désactivation
   status = (vsCommandStatus)vsCommandStatus.vsCommandStatusUnsupported;

private _DTE applicationObject;

applicationObject = (_DTE)application;

private AddIn addInInstance;
addInInstance = (AddIn)addInInst;

applicationObject.StatusBar.Progress(parametres);

System.Array theProjects = (System.Array)applicationObject.ActiveSolutionProjects;

EnvDTE.Project theProject = null;
// On vérifie que la solution contient au moins un projet
if (theProjects.Length > 0)
{
  theProject = (EnvDTE.Project)(theProjects.GetValue(0)); // je récupère uniquement le premier projet
  // voir la source pour la gestion de plusieurs projets
}

FileInfo f= new FileInfo(theProject.FullName);
StreamWriter strW = new StreamWriter(TB_Chemin.Text+"\\[export] "+ f.Name.Substring(0,f.Name.Length-7) +".htm");

applicationObject.Solution.FileName

foreach (ProjectItem p in theProject.ProjectItems)
{
  try
  {
    Compteur=Compteur+1; // compteur de fichier

    FileInfo Fichier=new FileInfo(f.DirectoryName+"\\"+p.Name);
    string taille=(CKB_Det.Checked)?" ("+ FormatSize(Fichier.Length)+")":""; // formattage (ko,Mo,etc)
    strW.WriteLine("<FONT class=content>- "+p.Name+ taille+"</FONT><br>"); // j'écris le nom du fichier et sa taille

    // On vérifie que les fichiers correspondent au type d'export souhaité
    if (Fichier.Extension == sFiltre) // le filtre étant récupéré dans un switch en fonction de la combobox du langage
    {
      SpecCompteur = SpecCompteur+1; // compteur de fichier code
      TotLiCompteur=TotLiCompteur+CompteLigne(f.DirectoryName+"\\"+p.Name); // appel de la fonction CompteLigne( )
    }
  }
  catch{}
}

#region Fonction CompteLigne
/// <summary>
/// Fonction retournant le nombre de lignes du fichier passé en paramètre.
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
private int CompteLigne(string path)
{
   StreamReader srFile = new StreamReader(path);    // création d'un streamreader sur le fichier de code
   string strLine=string.Empty;                                    // variable contenant la ligne courrante
   int LiCompteur=0;                                                     // compteur de lignes
   while ((strLine = srFile.ReadLine()) != null)
   {
      LiCompteur++;
   }
   srFile.Close();                                                            // je ferme le streamreader
   return LiCompteur;                                                 // je retourne le nombre de lignes de ce fichier
}
#endregion

#region Fonction Arbo
/// <summary>
/// Génère un listing hiérachique à partir d'un dossier root
/// </summary>
/// <param name="path">string</param>
/// <param name="strW">StreamWriter</param>
/// <param name="count">int</param>
private void Arbo(string path,StreamWriter strW,int count)
{
  DirectoryInfo di = new DirectoryInfo(path);
  string tmp=string.Empty;
  for(int i=0;i < count; i++) tmp= tmp+"";
  strW.WriteLine(tmp+"<img src=data/folder.ico ><FONT class=content>"+di.Name+"</FONT><br>");
  tmp= string.Empty;
  for(int i=0;i < count+2; i++) tmp= tmp+"";
  foreach(FileInfo fi in di.GetFiles())
  {
    strW.WriteLine(tmp +"<img src=data/file.ico ><FONT class=content>" +fi.Name+"</FONT><br>");
  }
  foreach(DirectoryInfo dii in di.GetDirectories())
  {
    Arbo(dii.FullName,strW,count+2); // appel récursif avec nouveaux paramètres
  }
}
#endregion

#region Fonction Backup
/// <summary>
/// Crée un dossier contenant les sources du projet
/// </summary>
/// <param name="path"></param>
/// <param name="Addpath"></param>
private void Backup(string path, string AddPath)
{
  DirectoryInfo di = new DirectoryInfo(TB_Chemin.Text + "\\" + AddPath);
  di.Create();
  DirectoryInfo diSource =new DirectoryInfo(path);
  foreach(FileInfo fi in diSource.GetFiles())
  {
    try
    {
      fi.CopyTo(di.FullName+"\\"+fi.Name, true);
    }
    catch{};
  }
  foreach(DirectoryInfo dii in diSource.GetDirectories())
  {
    Backup(dii.FullName,AddPath+"\\"+ dii.Name);
  }
}
#endregion

// on vérifie qu'une solution a été chargée
System.Array theProjects = (System.Array)applicationObject.ActiveSolutionProjects;
if(theProjects.Length <= 0)// Si la solution courante ne contient pas de projet
{
  MessageBox.Show("Aucun projet ou solution n'est actuellement chargé \n L'add-in va alors se fermer");
  this.Close();
}

#region OnConnection
public void OnConnection(object application, Extensibility.ext_ConnectMode connectMode, 
object addInInst, ref System.Array custom)
{
	applicationObject = (_DTE)application;
	addInInstance = (AddIn)addInInst;
	object []contextGUIDS = new object[] { };        // ref vide mais necessaires
	Commands commands = applicationObject.Commands;  // représente les menus de visual studio
	_CommandBars commandBars = applicationObject.CommandBars; // représente les barres de menu de visual studio

	// Création des menus
	try
	{ 
        CommandBar commandBar = (CommandBar)commandBars["Code Window"];  // menu contextuel des pages de code
        Command command = commands.AddNamedCommand(addInInstance, 
                                                   "AjoutRegione", 
                                                   "Ajouter une region", 
                                                   "Ajoute une region autour de la selection", 
                                                   true, 
                                                   1554, 
                                                   ref contextGUIDS, 
                                                   (int)vsCommandStatus.vsCommandStatusSupported+
                                                   (int)vsCommandStatus.vsCommandStatusEnabled);
        CommandBarControl commandBarControl = command.AddControl(commandBar, 1); // j'ajoute le menu au menu contextuel
        command = commands.AddNamedCommand(addInInstance, 
                                           "AjouterHeadere", 
                                           "Ajouter un entête",
                                           "Ajoute