www.pudn.com > LECTEUR-MP3.zip > RepExplorer.h

// RepExplorer.h: interface for the CRepExplorer class. 
// 
////////////////////////////////////////////////////////////////////// 
 
#if !defined(AFX_REPEXPLORER_H__79E21A78_CC37_4D5E_8FD4_D7B3575970D5__INCLUDED_) 
#define AFX_REPEXPLORER_H__79E21A78_CC37_4D5E_8FD4_D7B3575970D5__INCLUDED_ 
 
#if _MSC_VER > 1000 
#pragma once 
#endif // _MSC_VER > 1000 
 
/*********************************************** 
 
CRepExplorer -> CRep---> CRep 
				  | 
				  |----> CRepFile 
							^ 
							| 
						CAudioFile 
							^ 
							| 
					     CMp3File 
 
***********************************************/ 
 
 
#include "afxtempl.h" 
 
//----------------------------------------------- 
//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; } 
 
	//Retourne l'extension d'un fichier (.txt par exemple) 
	static CString ExtractExt(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 
{ 
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 * GetRepByName(CString strRepName) const; 
 
	//Permettent de lister tous les sous rep d'un rep 
	POSITION GetFirstRepPos() const; 
	CRep * GetNextRep(POSITION &pos) 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); 
 
 
private : 
 
	bool m_bFileDetected; 
	bool m_bExistFile; 
 
	CString m_strRepName; 
	CString m_strRepPath; 
 
	CList m_ListRepFile; 
	CList m_ListChildRep; 
	 
	CRep * m_pParentRep; 
	CRepExplorer * m_pRepExplorer; 
}; 
 
 
//----------------------------------------------- 
//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 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 
	bool ConstructTree(CString strRootPath, bool bOnlyFolderDetect = false); 
 
	//Retourne un pointeur sur le rep de plus haut niveau 
	CRep * GetRootRep() const {return m_pRootRep;} 
 
	//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 * GetFileExtFilterList() { return &m_FileExtFilterList;} 
 
	 
	/*******  Fonction de Recherche **************/ 
	 
	//Cherche dans tout l'arbre le dossier en param 
	//Retourne NULL si il n'existe pas 
	CList * FindRepByName(CString strRepName); 
	 
	//Cherche dans tout l'arbre le fichier en param 
	//Retourne NULL si il n'existe pas 
	CList * FindFileByName(CString strFileName); 
 
	/**********************************************/ 
 
private: 
 
	//Recherche recursive ds l'arbre 
	CRep * RecurRepFind(CRep * pRep, CString strRepName); 
	void RecurRepFileFind(CRep * pRep, CString strFileName); 
 
 
private : 
 
	CRep * m_pRootRep; 
	CString m_strRootPath; 
 
	bool m_bUseFilter; 
	bool m_bOnlyFolderDetect; 
 
	CList m_RepFindList; 
	CList m_RepFileFindList; 
 
	CList m_FileExtFilterList; 
}; 
 
 
#endif // !defined(AFX_REPEXPLORER_H__79E21A78_CC37_4D5E_8FD4_D7B3575970D5__INCLUDED_)