Classe CRepExplorer
Permet de créé un arbre avec tous les sous dossier et fichier d'un dossier
Permet les operation standard : ajout, suppr, modif
Permet de filtrer les type de fichier
Contient des fonction de recherche basique
Permet de poser un watch sur un dossier (on detecte les changements automatiquement)
Contenu
CRepExplorer : classe la plus haute (permet de construire l'arbre)
CRep : Represente un dossier (contient la liste de ces sous dossier et fichiers)
CRepFile : Represente un fichier quelqonque
CAudioFile : herite de CRepFile (classe abstraite permettant de spécialiser un type de fichier)
CMp3File : herite de cAudioFile (exemple de spécification d'un type de fichier)
CTreeRepCtrl : Créé un CRepExplorer et affiche un arbre des dossier (si le watch et actif le tree et remit a jour automatiquement lors de changement dans le dossier)
Les commentaires sont ds le .h
Source / Exemple :
/***********************************************
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
};
Conclusion :
Pour l'instant ca marche bien je n'ai pas trouver de bug majeur
Je mettrai (quand j'orai le temps) un exemple plus complet.
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.