EXPLORATEUR DE FICHIER

/***********************************************

CRepExplorer -> CRep---> CRep
				  |
				  |----> CRepFile
							^
							|
						CAudioFile
							^
							|
					     CMp3File

***********************************************/

//-----------------------------------------------
#define TYPE_UNKNOW -1
#define TYPE_FOLDER  0
#define TYPE_FILE    1

#define WM_EXT_EXPLORER_INIT WM_APP + 104
#define WM_EXT_FOLDER_CHANGE WM_APP + 105
#define WM_EXT_FILE_CHANGE   WM_APP + 106

#define WM_INIT_TREE_START   WM_APP + 107
#define WM_INIT_TREE_END     WM_APP + 108
//-----------------------------------------------

#include "afxtempl.h"
#include "afxmt.h" // pour CEvent

//-----------------------------------------------
//Il est possible de gerer tout type de fichier
//en créent des classes qui herite de CRepFile
//Ensuite celon l'extension du nouveau type 
//de fichier il faut modifier la fct
//CRep::CreateFilebyType pour créé un object de
//votre nouveau type celon l'extension du fichier
//-----------------------------------------------
class CRep;
class CRepFile
{
public:
	CRepFile(WIN32_FIND_DATA * pFindFileData, CRep * pFileRep);
	virtual ~CRepFile();

	//Retourne les attributs du fichier
	CString GetFileName() { return m_strFileName;}
	int		GetFileSize() { return m_iFileSize;}
	CString GetFileExt()  { return m_strFileExt;}

	//Retourne la date de création, du dernier acces et de la dernière modif
	void GetTimeAttribute(FILETIME * pftCreationTime, FILETIME * pftLastAccessTime, FILETIME * pftLastWriteTime);

	//Retourne un ptr sur le dossier qui contient ce fichier
	CRep * GetFileRep() { return m_pFileRep; }

	//Relit les params du fichier et ce met a jour (nom, extension, taille...)
	void ReloadFileAttribute();

	//Retourne l'extension d'un fichier (.txt par exemple)
	static CString ExtractExt(CString strFileName);

	//Met a jour le nom du fichier lors d'une modif extèrieure
	void friend UpdateFileName(CRepFile * pThisFile, CString strFileName);

protected :

	CString m_strFileName;
	CString m_strFileExt;
	int m_iFileSize;

	FILETIME m_ftCreationTime;
    FILETIME m_ftLastAccessTime;
    FILETIME m_ftLastWriteTime;
	
	CRep * m_pFileRep;
};


//-----------------------------------------------
//Par exemple cette classe derive de CRepFile et
//et destinné a gerer des fichier de type audio
//Mais chaque fichier audio (wma, mp3 ...) a 
//des carracteristiques differentes, donc cette
//classe abstraite doit etre redefinit pour 
//chaque type de fichier audio
//-----------------------------------------------
class CAudioFile : public CRepFile
{
public :
	CAudioFile(WIN32_FIND_DATA * pFindFileData, CRep * pFileRep);

	virtual CString GetTitle() = 0;
	virtual CString GetArtist() = 0;
	virtual CString GetAlbum() = 0;
	virtual CString GetYear() = 0;
	virtual CString GetComment() = 0;

	virtual CTimeSpan GetFileLenght();
	void SetFileLenght(CTimeSpan Lenght) {m_FileLenght = Lenght;}

	CString GetStringLenght();

protected :

	CTimeSpan m_FileLenght;
};


//-----------------------------------------------
//Voila c'est la classe la plus bas niveau, elle
//herite de CAudioFile et ne gere que les fichier
//de type mp3.
//Mais on peut recuperer les infos de cette 
//classe a traver les fct virtuelle de CAudioFile
//-----------------------------------------------
class CMp3File : public CAudioFile
{
public:

	CMp3File(WIN32_FIND_DATA * pFindFileData, CRep * pFileRep);
	virtual ~CMp3File();

	//Recuperer les info du tag
	CString GetTitle() {return m_strTitle;}
	CString GetArtist(){return m_strArtist;}
	CString GetAlbum(){return m_strAlbum;}
	CString GetYear(){return m_strYear;}
	CString GetComment(){return m_strComment;}


private :

	//Permet de trier les infos du tag
	void Copy(DWORD nBegin, DWORD nLength, LPSTR lpSrc, char szDest[]);

	//Retourne la duréé du mp3
	CTimeSpan ReadLenght(CString strFilePath);

private :

	CString m_strTitle;
	CString m_strArtist;
	CString m_strAlbum;
	CString m_strYear;
	CString m_strComment;
	int m_nGenre;
};



//-----------------------------------------------
//Classe qui s'occupe de gerer les dossiers
//Chaque CRep contient la liste de ces fichiers
//(CRepFile) et la liste de ces sous dossiers
//(CRep).Permet toutes les operation sur 
//les dossiers.
//-----------------------------------------------
class CRepExplorer;
class CRep
{
friend class CWatchThread; //Permet au WatchThread de tapez ds le fct private

public:
	CRep(CString strPath, CRepExplorer * pRepExplorer, CRep * pParent);
	virtual ~CRep();
	
	/****************** NAVIGATION *******************/

	//Retourne un ptr sur le sous rep du rep courant si il existe NULL sinon
	CRep * GetSubRepByName(CString strRepName) const;

	//Permettent de lister tous les sous rep d'un rep
	POSITION GetFirstRepPos() const;
	CRep * GetNextRep(POSITION &pos) const;

	//Retourne un ptr sur le fichier portant le nom en param NULL sinon
	CRepFile * GetFileByName(CString strFileName) const;

	//Permettent de lister tous les fichiers d'un rep
	POSITION GetFirstFilePos();
	CRepFile * GetNextFile(POSITION &pos) const;

    /*************************************************/

	/************ AJOUT / MODIF / SUPPRESION *********/

	//Ajoute un sous repertoire au repertoire courant
	CRep * AddSubRep(CString strRepName);

	//Modifie le nom du repertoire
	bool ModifRepName(CString strRepNewName);

	//Fonction de suppresion RECURSIVE
	//Un dossier est supprimer avec tous ces sous dossier et fichiers
	bool DeleteSubRep(CString strRepName);
	bool DeleteThisRep();

	/*************************************************/


	//Retourne le Nom du repertoire
	CString GetRepName() {return m_strRepName; }

	//Retourne le chemin complet du dossier
	CString GetRepPath() {return m_strRepPath;}

	//Retourne vrai si le dossier contient des sous dossier
	bool bIsExistSubRep() {return !m_ListChildRep.IsEmpty(); }

	//Retourne vrai si le dossier contien des fichiers
	bool bIsExistFile();

	//retourne vrai si le dossier ou un de ces sous dossier contien un fichier
	bool bIsExistSubFile();

	//Retourne vrai si l'extension du fichier existe dans la liste 
	//Retourne toujours vrai si on utilise pas les filtre (CRepExplorer::m_bUseFilter)
	bool VerifFileInFilterList(CRepFile * pRepFile);

	//Retourne un ptr sur le père
	CRep * GetParentRep() { return m_pParentRep;}


private:

	//Recupère les fichier du dossier
	//fct utiliser uniquement si l'arbre a été construit
	//avec bOnlyFolderDetect = true
	void GetFolderFile();

	//Supprime recursivement tous les dossier et fichier d'un dossier
	bool DeleteRoutine(CString strRepPath);
	
	//lorsqu'un dossier est supprimer pour supprimer de la liste du père 
	bool DeleteInChildList(CRep * pRep);

	//Crée les fichier en fonction du type 
	CRepFile * CreateFilebyType(WIN32_FIND_DATA * pFindFileData);

	//Retourne vrai si l'extension en param et ds la liste
	//Retourne toujours vrai si on utilise pas les filtre (CRepExplorer::m_bUseFilter)
	bool VerifExtInFilterList(CString strExt);

	//Retourne vrai si les fichiers du dossier ont deja été detecter
	bool bIsFileDetected() { return m_bFileDetected;}

	//Sorte de callBack qui permet de mettre la liste de fichier et de dossier a jour 
	//lors d'un modif exterieure;
	bool UpdateFileList(int iFlag, CString strFileName);
	bool UpdateRepList(int  iFlag, CString strFolderName);

	//Met a jour les ttribut du dossier
	void ReloadRepAttribute();

	//Met a jour les attribut du dossier et de ces sous dossier
	void UpdateRepName(CString strNewName, CString strOldName);

private :

	bool m_bFileDetected;
	bool m_bExistFile;

	CString m_strRepName;
	CString m_strRepPath;

	CList<CRepFile*,CRepFile*> m_ListRepFile;
	CList<CRep*,CRep*> m_ListChildRep;
	
	CRep * m_pParentRep;
	CRepExplorer * m_pRepExplorer;

	int		 m_iFolderSize;
	FILETIME m_ftCreationTime;
    FILETIME m_ftLastAccessTime;
    FILETIME m_ftLastWriteTime;

	//utiliser pour la mise a jour extèrieure
	CRepFile * m_UpdateRepFile;
	CRep * m_UpdateRep;
	CString m_strOldRepName;
	CEvent m_LockAddEvent;
};


//-----------------------------------------------
//Classe la plus haute, c'est elle qui lance
//la construction de l'arbre (ConstructTree)
//Elle permet d'ajouter des filtres (pour ne 
//detecter que certain type de fichier)
//Elle contient aussi quelque fct de recherche 
//-----------------------------------------------
class CWatchThread;
class CRepExplorer 
{

public:
	CRepExplorer();
	CRepExplorer(CString strRootPath);
	virtual ~CRepExplorer();

	//Construit l'arbre a partir du rep strRootPath
	//Si bOnlyFolderDetect les fichier ne seront pas analyser pendant la cration de l'arbre (plus rapide)
	//mais a chaque apel de GetFirstFilePos
	//bStartWatchRoutine : si a vrai un watch sera lancer et surveillera les modif
	//de dossier ou fichier automatiquement
	//bActiveAllLog : au demarage tous les fichier dossier detecter sont loger (peut etre long !)
	//pRedirectWnd : CWnd vers laquelle les msg de maj seront rediriger (NULL = pas de redirection)
	bool ConstructTree(CString strRootPath, bool bOnlyFolderDetect = false, bool bStartWatchRoutine = false
					  ,bool bActiveAllLog = false, CWnd * pRedirectWnd = NULL);

	//Retourne un pointeur sur le rep de plus haut niveau
	CRep * GetRootRep() const {return m_pRootRep;}
	
	//Retourne le dossier corespondant au chemin en param
	CRep * GetRepByPath(CString strPath); 

	//Ajoute ou supprime un extension de fichier a la liste 
	//si bUseFilter = true, seul les fichiers portant une extension
	//ds la liste seront traiter
	void AddFileExtInFilter(CString strFileExt);

	//Retourne faux si l'extension n'existe pas ds la liste
	bool DelFileExtInFilter(CString strFileExt);

	//Vide la liste d'extension de fichier
	void RazFilterList() {m_FileExtFilterList.RemoveAll();}

	void SetUseFilter(bool bUse = false) {m_bUseFilter = bUse;}
	bool bUseFilter() {return m_bUseFilter;}

	//Retourne vrai si seulement les dossier sont detecter
	bool IsOnlyFolderDectect() {return m_bOnlyFolderDetect;}

	//Retourne un ptr sur la liste des filtres
	CList<CString,CString> * GetFileExtFilterList() { return &m_FileExtFilterList;}

	//retourne le ptr sur la CWnd sur laquelle sera rediriger le msg lors de modif
	CWnd * GetWndMsg() {return m_pWndMsg;}

	//Prend en param un ptr sur la fenetre vers laquelle tout les msgs
	//seront rediriger
	//void SetWndMsg(CWnd * pWnd) {m_pWndMsg = pWnd;}

	//Si a vrai tous les logs sont actif 
	bool bIsActiveAllLog() {return m_bActiveAllLog;}

	
	/*******  Fonction de Recherche **************/
	
	//Cherche dans tout l'arbre le dossier en param
	//Retourne NULL si il n'existe pas
	CList<CRep*,CRep*> * FindRepByName(CString strRepName);
	
	//Cherche dans tout l'arbre le fichier en param
	//Retourne NULL si il n'existe pas
	CList<CRepFile*,CRepFile*> * FindFileByName(CString strFileName);

	/**********************************************/

	/*********  Fonction de copie *****************/

	//Copie de dossier
	//ATTENTION : tient compte si vs avez utiliser SetUseFilter
	static bool Copy(CRep * pSrcRep, CRep * pDestRep, bool bCopyFile = true,bool bCopySubFolder = true);
	static bool Copy(CRep * pSrcRep, CString strDest, bool bCopyFile = true,bool bCopySubFolder = true);

	//methode de classe
	static bool Copy(CString strSrc, CString strDest, bool bCopyFile = true,bool bCopySubFolder = true);
	
	/**********************************************/

private:

	static bool RecurCopy(CRep * pSrcRep, CRep * pDestRep, bool bCopyFile ,bool bCopySubFolder, bool bStart);

	//Recherche recursive ds l'arbre
	CRep * RecurRepFind(CRep * pRep, CString strRepName);
	void RecurRepFileFind(CRep * pRep, CString strFileName, bool bInit = false);


private :

	CRep * m_pRootRep;
	CString m_strRootPath;

	bool m_bUseFilter;
	bool m_bOnlyFolderDetect;
	bool m_bActiveAllLog; //Log toutes les création de fichier

	CList<CRep*,CRep*> m_RepFindList;
	CList<CRepFile*,CRepFile*> m_RepFileFindList;

	CList<CString,CString> m_FileExtFilterList;

	CWatchThread * m_pThread;//Thread de surveillance des modif exterieures
	CWnd * m_pWndMsg;//tous les message de modif extèrieur sont rediriger si != NULL
};


//-----------------------------------------------
//Gere les Ajout/Modif/Supp extérieure de 
//dossier ou de fichiers
//-----------------------------------------------
class CWatchThread
{
public:

    CWatchThread(void * pParam, CString strPathToWatch)
    {
		m_hThread			= 0;
		m_bStop				= false;
		m_pParam			= pParam;
		m_strPathToWatch	= strPathToWatch;
		dwChangeHandle		= NULL;
	}
    
    ~CWatchThread()
    {
        this->StopThread();
    }
    
    bool InitThread();
 	bool StopThread();
	
    
private:

    CWinThread * m_hThread;
	volatile bool m_bStop;

	void * m_pParam;
	CString m_strPathToWatch;
	HANDLE dwChangeHandle;
	
	static CString CorrectFileName(FILE_NOTIFY_INFORMATION * pInfo);
	static bool ComparePath(CString str1, CString str2);
	static int GetType(FILE_NOTIFY_INFORMATION * pInfo, CString strPath, CRepExplorer * pRepExp);
	static CString ExtractFileName(CString strPath);
	static UINT TabThreadFunc(LPVOID pvParam);
};


class CTreeRepCtrl : public CTreeCtrl
{
	DECLARE_DYNAMIC(CTreeRepCtrl)

public:
	CTreeRepCtrl();
	virtual ~CTreeRepCtrl();


	//Construit le tree avec les params ( tous les msg recu du repexplorer seront
	//rediriger vers pParentWnd si ce n'est pas null)
	bool ConstructTree(CString strRootPath, bool bOnlyFolderDetect = false
								 , bool bStartWatchRoutine = false, bool bActiveAllLog = false, CWnd * pParentWnd = NULL);


	//Insère un nouvel item (créé aussi le dossier sur le disque)
    HTREEITEM InsertItem(CString strItemName,HTREEITEM hFatherItem);

	//Supprime l'item en param et le dossier sur le disque
	bool DeleteItem(HTREEITEM hItem);


	HTREEITEM GetItem(CRep * pRep);
	CRep * GetItem(HTREEITEM hItem);

	HTREEITEM GetParentItem(CRep * pRep);
	CRep * GetParentItem(HTREEITEM hItem);

	//retourne le ptr sur le repExplorer (permet de faire des recherche,
	//d'appliquer des filtres ...)
	const CRepExplorer * GetRepExplorer() const {return m_pRepExplorer;}

private :

	//Initialise l'arbre avec les infos du repExplorer
	void InitTree(CRep * pRep, HTREEITEM hItem);

	//Parcour le tree a la recherche du crep en param
	HTREEITEM RecurGetRephItem(CRep * pRep, HTREEITEM hItem);

protected:

	//Interception des msg du RepExplorer
	LRESULT InitTreeSet(WPARAM w, LPARAM l);
	LRESULT OnFolderChange(WPARAM w, LPARAM l);
	LRESULT OnFileChange(WPARAM w, LPARAM l);
    
	DECLARE_MESSAGE_MAP()

private :

	CRepExplorer * m_pRepExplorer;
	bool m_bWaitForEnd;

	CWnd * m_pParentWnd;//fenetre parent vers laquelle les msg sont rediriger
};