TÉLECHARGEMENT D'UN FICHIER RSS ET SON PARCOURS AVEC MFC

/*CANAL.CPP*/
canal::canal()
{	
	pszerr=NULL;
	pstm=NULL;
	pdoc=NULL;
	ppsi=NULL;
	pxelt=NULL;
	pchildren_root=NULL,pchildren_channel=NULL,pchildren_item=NULL;
	nbrfils=0;
	var_item.vt=VT_I4;
	varempty.vt=VT_EMPTY;
	var_item.lVal=0;
	var_sous_item.vt=VT_I4;
	var_sous_item.lVal=0;


}

canal::~canal()
{

}
/************************** Fonction permettant de télécharger un fichier XML distant *********************
*******************************************       ou local      ******************************************/
//On envoie comme paramètre un adresse ou se trouve le fichier
bool canal::Download_File(CString url)
{
	hr=URLOpenBlockingStream(0,url,&pstm,0,0);
	if(!SUCCEEDED(hr) && pstm)
	{
		AfxMessageBox("Impossible d'ouvrir le fichier distant.\n\n Le problème peut être dû à un URL invalide\n ou un problème avec le serveur distant.",MB_OK||MB_ICONINFORMATION);
		return false;
	}
	hr=CoInitialize(NULL);
	ASSERT(SUCCEEDED(hr));
	hr=CoCreateInstance(CLSID_XMLDocument,NULL,CLSCTX_INPROC_SERVER,IID_IXMLDocument,(void **) &pdoc);
	if(!pdoc)
	{
		AfxMessageBox("Objet XML NULL !",MB_OK||MB_ICONSTOP);
		return false;
	}
	hr=pdoc->QueryInterface(IID_IPersistStreamInit,(void **) &ppsi);
	if(!SUCCEEDED(hr))
	{
		AfxMessageBox("Impossible de récupérer IPersistStreamInit !",MB_OK||MB_ICONSTOP);
		return false;
	}
	hr=ppsi->Load(pstm);
	if(SUCCEEDED(hr))
	{
		AfxMessageBox("Un fichier XML à été télecharhger avec succes.\n\n Extraction et affichage de résultat en cours ...",MB_OK||MB_ICONINFORMATION);
		return true;
	}
	else 
	{
		AfxMessageBox("Impossible de charger le fichier!",MB_OK||MB_ICONSTOP);
		return false;
	}
}

/************************** Fonction permettant de retourner un pointeur **********************************
***********************************      Sur la racine (root)     **********************************************/
//Cette fonction n'a besoin de rien 
IXMLElement *canal::get_me_the_root()
{
	hr=pdoc->get_root(&pxelt);
	if(SUCCEEDED(hr))
		return pxelt;
	else
	{
		AfxMessageBox("Impossible de pointer sur la racine",MB_OK||MB_ICONSTOP);
		return NULL;
	}
}

/************************* Fonction permettant de retourner le nombre des fils ***********************************
*********************************** d'un noeud quelconque ainsi travailler sa collection ***************************************/
/*on envoie comme parramètre pour cette fonction un pointeur sur le noeud voulue et un indice identifiant 
l'appelant de cette fonction
Noter que j'ai choisit comme identifiant pour:
            0->root(racine)
            1->channel
            2->item
*/
long canal::get_me_this_nod_collection(IXMLElement *pxelt,int id_caller)
{
	switch (id_caller)
	{
	case 0:{hr=pxelt->get_children(&pchildren_root);pchildren_root->get_length(&nbrfils);break;}
	case 1:{hr=pxelt->get_children(&pchildren_channel);pchildren_channel->get_length(&nbrfils);break;}
	case 2:{hr=pxelt->get_children(&pchildren_item);pchildren_item->get_length(&nbrfils);break;}
	}
	if(nbrfils>0)
	return nbrfils;
	else 
	return 0;
	
}

/************************* Fonction permettant de retourner un pointeur ***********************************
*************************************      sur le noeud channel      **************************************/
/*On envoie comme parametre pour cette fonction un pointeur sur root pour pointer sur channel (ou
un pointeur sur channel pour pointer sur un item) , indice de l'élément cherche(par defaut il est égal à 
zéro en cas d'appel de fonction par un pointeur sur root) et un indice identifiant l'appelant de cette fonction
pour acceder au bonne collection*/
IXMLElement *canal::get_me_the_channel(IXMLElement *pxelt_root,int index,int caller)
{
	IXMLElement *pxelt_target;
	var_item.lVal=index;
	IDispatch *pdisp=NULL;
	if(caller==2)
		hr=pchildren_channel->item(var_item,varempty,&pdisp);
	else
		hr=pchildren_root->item(var_item,varempty,&pdisp);

	if(SUCCEEDED(hr) && pdisp)
	{
		if(SUCCEEDED(pdisp->QueryInterface(IID_IXMLElement,(void **) &pxelt_target)))
		{
			pxelt_target->get_tagName(&bstr);
			CString c(bstr);
			//Cette ligne n'est que pour le teste
			        //AfxMessageBox(c);          
			return pxelt_target;
		}

	}

}

/************************* Fonction permettant de retouner un pointeur ************************************
**************************       sur un item dont on passe son indice   ************************************/
//On envoie comme paramètre l'ndice de l'item voulue et un pointeur sur "channel"
IXMLElement *canal::get_me_the_wanted_item(int indice,IXMLElement *pxelt_channel)
{
	IXMLElement *pxelt_item;
	pxelt_item=canal::get_me_the_channel(pxelt_channel,indice,2);
	return pxelt_item;

}

/************************ Fonction permettant de retourner les noms des tags et sa contenu ****************
**********************************************************************************************************/
//on envoie à cette méthode un pointeur sur un noeud(précisement sur un item), un entier pour indiquer quelle
//tag on veut extraire du fichier et enfin un entier quelle doit la modifier la méthode telque(et cela pour eviter les test 
/*                       1->il s'agit d'un tag title
                         2->il s'agit d'un tag catégorie
						 3->il s'agit d'un description
						 4->il s'agit d'une date de publication
						 5->il s'agit d'un URL
						 6->il s'agit d'un tag author(auteur)
						 7->il s'agit d'un commentaire*/
CString canal::get_me_tagname_and_content(IXMLElement *pxelt_item,int indice_tag,int &place)
{
	var_sous_item.lVal=indice_tag;
	CString tag[]={"TITLE","CATEGORY","DESCRIPTION","PUBDATE","LINK","AUTHOR","COMMENTS"};
	CString c;
	IDispatch *pdisp=NULL;
	hr=pchildren_item->item(var_sous_item,varempty,&pdisp);
	if(SUCCEEDED(hr) && pdisp)
	{
		if(SUCCEEDED(pdisp->QueryInterface(IID_IXMLElement,(void **) &pxelt_item)))
		{
			pxelt_item->get_tagName(&bstr);
			CString c(bstr);
			for(int i=0;i<7;i++)
			if(c==tag[i])
				place=i+1;
			pxelt_item->get_text(&bstr);
			CString c1(bstr);
			return c1;
		}
	}
return c;
	
}

///////////////////////////////////////////////////////////////
/*CANAL.H*/
class canal  
{
public:
	canal();
	virtual ~canal();
	bool Download_File(CString);
	IXMLElement *get_me_the_root();
	long get_me_this_nod_collection(IXMLElement *,int);
	IXMLElement *get_me_the_channel(IXMLElement *,int =0,int =0);
	IXMLElement *get_me_the_wanted_item(int,IXMLElement*);
	CString get_me_tagname_and_content(IXMLElement *,int,int&);

private :
	IXMLElement *pxelt;
	PSTR pszerr;
	IXMLDocument *pdoc;
	IStream *pstm;
	IPersistStreamInit *ppsi;
	HRESULT hr;
	IXMLElementCollection *pchildren_channel,*pchildren_item,*pchildren_root;
	long nbrfils;
	VARIANT var_item,var_sous_item,varempty;
	BSTR bstr;

};

/////////////////////////////////////////////////////////////////
/*EXEMPLE D'APPEL*/
void CLecteurdeFluxrssbyBoubakerKhmiliDlg::Ondownload() 
{
	// TODO: Add your control notification handler code here
	canal c;
	result dlg;
	long n_root=0,n_channel=0,n_item=0;
	IXMLElement *pxelt_root,*pxelt_channel,*pxelt_item;
	UpdateData(true);
	bool op=c.Download_File(m_url);
	pxelt_root=c.get_me_the_root();
	n_root=c.get_me_this_nod_collection(pxelt_root,0);
	/*if(n!=0)
		MessageBox("tada");*/
	pxelt_channel=c.get_me_the_channel(pxelt_root);
	n_channel=c.get_me_this_nod_collection(pxelt_channel,1);
	/*if(n_channel!=0)
		MessageBox("tada");*/
	CString tagname;
	int tag_id;
	long cpt=0;
	do
	{
		for(int j=0;j<=cpt;j++)
	    pxelt_item=c.get_me_the_wanted_item(j,pxelt_channel);
	    n_item=c.get_me_this_nod_collection(pxelt_item,2);
	    for(int i=0;i<n_item;i++)
 	    
		{
			tagname=c.get_me_tagname_and_content(pxelt_item,i,tag_id);
			switch(tag_id)
			{
			case 1:{dlg.m_titre=tagname;break;}
			case 2:{dlg.m_cat=tagname;break;}
			case 3:{dlg.m_desc=tagname;break;}
			case 4:{dlg.m_pubdate=tagname;break;}
			case 5:{dlg.m_inner_url=tagname;break;}
			case 6:{dlg.m_auteur=tagname;break;}
			case 7:{dlg.m_comm=tagname;break;}
			}
			UpdateData(false);
		}
		cpt++;
		dlg.DoModal();
	}
	while(cpt<n_channel);	
}