public void Initialize()
{
if (initialize)
{
// on recupere le fichier racine
folderRoot = SyndicationManager.getInstance().Root;
// creation du repertoire "/Informatique" dans le repertoire
// racine "/"
folderRoot.CreateSubFolder("Informatique");
// creation du repertoire "/zdnet"
folderRoot.CreateSubFolder("zdnet");
// creation du repertoire "/Informatique/Clubic" dans
// le repertoire "/Informatique"
folderRoot.GetSubFolder("Informatique").CreateSubFolder("Clubic");
// creation du repertoire "/Informatique/Google" dans
// le repertoire "/Informatique"
folderRoot.GetSubFolder("Informatique").CreateSubFolder("Google");
// creation du repertoire "/Site Web" dans le repertoire
// racine "/"
folderRoot.CreateSubFolder("Site web");
// creation du channel "clubic" dans le repertoire "/Informatique"
folderRoot.GetSubFolder("Informatique").CreateChannel("clubic", "http://www.clubic.com/");
// creation du repertoire /Informatique/ordinateur
folderRoot.GetSubFolder("Informatique").CreateSubFolder("ordinateur");
initialize = false;
}
}
/// <summary>
/// Instancie un nouveau repertoire. L'instanciation d'un repertoire
/// doit obligatoirement spécifié son nom et le parent du repertoire.
/// Seul le repertoire "root" a un parent egal à la valeur null
/// </summary>
/// <param name="folderName">nom du repertoire</param>
/// <param name="parent">parent du repertoire</param>
public SyndicationFolder(String folderName, SyndicationFolder parent)
{
_name = folderName;
_parent = parent;
_channels = new Dictionary<String, Channel>();
_subFolders = new List<SyndicationFolder>();
}
/// <summary>
/// Initialise la combox en ajoutant l'arbre des repertoires
/// à partir du repertoire root
/// </summary>
/// <param name="folderRoot">repertoire root</param>
public void InitializeComboBox(SyndicationFolder folderRoot)
{
if (folderRoot.Path == "")
FolderComboBox.Items.Add("Default");
foreach (SyndicationFolder folder in folderRoot.SubFolders)
{
FolderComboBox.Items.Add(folder.Path);
InitializeComboBox(folder);
}
}
public void Initialize()
{
if (initialize)
{
manager = SyndicationManager.getInstance();
manager.Root = new SyndicationFolder("root", null);
folderRoot = manager.Root;
// creation des repertoires et des channel
// /Informatique
// /Informatique/clubic/Clubic
// /Informatique/zdnet
// /informatique/matbe/Marb
SyndicationFolder informatique = folderRoot.CreateSubFolder("Informatique");
informatique.CreateSubFolder("clubic").CreateChannel("Clubic", "lien_clubic"); ;
informatique.CreateSubFolder("zdnet");
informatique.CreateSubFolder("matbe").CreateChannel("Processeur", "lien_marb");
// creation des repertoires et channels
// /Maison
// /Maison/Jardin
// /Maison/Cuisine
// /Maison/Cuisine/Four
SyndicationFolder Maison = folderRoot.CreateSubFolder("Maison");
Maison.CreateSubFolder("Jardin");
Maison.CreateSubFolder("Cuisine").CreateChannel("Four", "lien_four");
// creation des repertoires et channels
// /monde
// /monde/europe
// /monde/europe/france
// /monde/europe/france/Paris
// /monde/asie
// /monde/asie/chine
SyndicationFolder monde = folderRoot.CreateSubFolder("monde");
monde.CreateSubFolder("europe").CreateSubFolder("france").CreateChannel("Paris", "lien_paris");
monde.CreateSubFolder("asie").CreateSubFolder("chine");
initialize = false;
}
}
/// <summary>
/// Instancie un nouveau gestionnaire de syndication
/// </summary>
public SyndicationManager()
{
_root = new SyndicationFolder("root", null);
}
/// <summary>
/// Sauvegarde les sous-repertoires et les channels d'un repertoire
/// dans un fichier xml.
/// </summary>
/// <param name="folderParent">repertoire</param>
/// <param name="nodeParent">node xml associé au repertoire</param>
/// <param name="xmlDocument">fichier xml</param>
private void Save(SyndicationFolder folderParent, XmlNode nodeParent, XmlDocument xmlDocument)
{
XmlNode folderNode = null;
XmlNode channelNode = null;
XmlNode nameNode = null;
XmlNode linkNode = null;
// sauvegarde les sous-repertoires
foreach (SyndicationFolder folder in folderParent.SubFolders)
{
// creation du node repertorie
folderNode = xmlDocument.CreateNode(XmlNodeType.Element, "folder", null);
nameNode = xmlDocument.CreateNode(XmlNodeType.Element, "name", null);
nameNode.AppendChild(xmlDocument.CreateTextNode(folder.Name));
folderNode.AppendChild(nameNode);
// associe le node du sous-repertoire au repertoire
nodeParent.AppendChild(folderNode);
// sauvegarde les repertoires et les channels de ce sous-repertoires
Save(folder, folderNode, xmlDocument);
}
// sauvegarde les channels
foreach (Channel channel in folderParent.Channels)
{
// creation du node du channel
channelNode = xmlDocument.CreateNode(XmlNodeType.Element, "channel", null);
nameNode = xmlDocument.CreateNode(XmlNodeType.Element, "name", null);
nameNode.AppendChild(xmlDocument.CreateTextNode(channel.Name));
channelNode.AppendChild(nameNode);
linkNode = xmlDocument.CreateNode(XmlNodeType.Element, "link", null);
linkNode.AppendChild(xmlDocument.CreateTextNode(channel.Link));
channelNode.AppendChild(linkNode);
// associé le node du channel au node du repertoire
nodeParent.AppendChild(channelNode);
}
}
/// <summary>
/// Charge les repertoires et les channels d'un repertoire
/// </summary>
/// <param name="nodeParent">node xml associé au repertoire</param>
/// <param name="folderParent">repertoire à charger</param>
public void Load(XmlNode nodeParent, SyndicationFolder folderParent)
{
XmlElement element = (XmlElement)nodeParent;
// charge les sous-repertories de ce repertoires.
foreach (XmlNode folderNode in element.GetElementsByTagName("folder"))
{
if (folderNode.ParentNode.Equals(nodeParent))
{
// creation du sous-repertoire
folderParent.CreateSubFolder(folderNode["name"].InnerText);
// charge les repertoires et les channels de ce sous-repertoire.
Load(folderNode, folderParent.GetSubFolder(folderNode["name"].InnerText));
}
}
// charge les channels de ce repertoire
foreach (XmlNode channelNode in element.GetElementsByTagName("channel"))
{
if (channelNode.ParentNode.Equals(nodeParent))
{
// creation du channel
folderParent.CreateChannel(channelNode["name"].InnerText, channelNode["link"].InnerText);
}
}
}
/// <summary>
/// Deplace le channel dans un nouveau repertoire
/// </summary>
public void Move(String newParentPath)
{
// INITIALISATION
SyndicationFolder newParent;
String[] _folders;
// on pose un verrou
lock (_locker)
{
try
{
// on change l'etat du repertoire
_isMoved = true;
_folders = newParentPath.Split('/');
// recupere la racine de l'arbre des repertoires
newParent = GetFolderRoot();
// on recherche le repertoire associé à ce chemin
for (int i = 1; i < _folders.Length; i++)
{
newParent = newParent.GetSubFolder(_folders[i]);
}
// on indique le repertoire de destination
_folderMovedTo = newParent.Path;
// on deplace le repertoire
newParent.Move(this);
if (DeleteChannelRequest != null)
{
DeleteChannelRequest(Name, Parent.Path);
}
_parent = newParent;
}
catch (FolderNotFoundException exception1)
{
_isMoved = false;
_folderMovedTo = "";
throw new ChannelMovedException(exception1.Message);
}
catch (ChannelAlreadyCreatedException exception2)
{
_isMoved = false;
_folderMovedTo = "";
throw new ChannelMovedException(exception2.Message);
}
_isMoved = false;
_folderMovedTo = "";
}
}
/// <summary>
/// Instancie un nouveau channel de flux RSS
/// </summary>
/// <param name="name">titre ou nom du channel</param>
/// <param name="link">url du site web contenant le channel</param>
/// <param name="channel"></param>
public Channel(String name, String link, SyndicationFolder parent)
{
_name = name;
_link = link;
_parent = parent;
_categories = new List<string>();
_items = new Dictionary<String, Item>();
_backgroundTask = new Thread(new ThreadStart(Load));
}
/// <summary>
/// Deplace le repertoire dans le chemin "newParentPath" indiqué
/// en arguments.
/// </summary>
/// <param name="newParentPath"></param>
public void Move(String newParentPath)
{
// verifie que le repertoire de destination
// n'est pas un sous-repertoire de ce repertoire.
if (newParentPath.Contains(Path))
{
throw new FolderMovedException("Impossible de deplacer le repertoire \"" + Path + "\" dans le sous-repertoire \"" + newParentPath + "\"");
}
// INITIALISATION
SyndicationFolder newParent = null;
String oldPath = null;
String[] _folders = newParentPath.Split('/');
List<String> keys = new List<string>();
try
{
// on change l'etat du repertoire
_isMoved = true;
// recupere la racine de l'arbre des repertoires
newParent = GetFolderRoot();
// on recherche le repertoire associé à ce chemin
for (int i = 1; i < _folders.Length; i++)
{
newParent = newParent.GetSubFolder(_folders[i]);
}
// on indique le repertoire de destination
_folderMovedTo = newParent.Path;
// on deplace le repertoire
newParent.Move(this);
if (DeleteFolderRequest != null)
{
DeleteFolderRequest(Name, _parent.Path);
}
oldPath = Path;
_parent = newParent;
// --------------------------------------------
// update la table de hashage "link" => "path"
// --------------------------------------------
foreach (String key in _mapLinkToPath.Keys)
{
if (_mapLinkToPath[key].Contains(oldPath))
{
keys.Add(key);
}
}
for (int i = 0; i < keys.Count; i++)
{
_mapLinkToPath[keys[i]] = _mapLinkToPath[keys[i]].Replace(oldPath, Path);
}
}
catch (FolderNotFoundException exception1)
{
_isMoved = false;
_folderMovedTo = "";
throw new FolderMovedException(exception1.Message);
}
catch (FolderAlreadyCreatedException exception2)
{
_isMoved = false;
_folderMovedTo = "";
throw new FolderMovedException(exception2.Message);
}
_isMoved = false;
_folderMovedTo = "";
}
/// <summary>
/// Deplace le repertoire spécifié en parametre
/// dans ce repertoire
/// </summary>
/// <param name="folder">
/// repertoire à deplacer dans ce repertoire
/// </param>
public void Move(SyndicationFolder folder)
{
if ((folder.IsMoved) && (folder.FolderMovedTo == Path))
{
if (ExistsSubFolder(folder.Name))
{
throw new FolderAlreadyCreatedException("Un repertoire avec le meme nom existe dans ce repertoire");
}
_subFolders.Add(folder);
folder.DeleteFolderRequest += new DeleteRequestDelegate(OnDeleteFolderRequest);
}
}
/// <summary>
/// Creation d'un nouveau sous-repertoire associé à ce repertoire.
/// Si un sous-repertoire dont le nom correspond à "folderName",
/// le sous-repertoire ne sera pas crée.
/// </summary>
/// <param name="folderName">nom du sous-repertoire à créer</param>
public SyndicationFolder CreateSubFolder(String folderName)
{
// on verifie la taille du nom du repertoire
if (folderName.Length > MAX_NAME_SIZE)
{
throw new IllegalNameException("Le nom du répertoire est limité à " + MAX_NAME_SIZE + " caracteres.");
}
// on verifie que le nom du repertoire ne possede pas de caracteres interdits
else if (!pattern.IsMatch(folderName))
{
throw new IllegalNameException("Le nom du répertoire est limité aux lettres, aux chiffres et aux espaces.");
}
// on verifie que ce sous-repertoire n'existe pas
else if (ExistsSubFolder(folderName))
{
throw new FolderAlreadyCreatedException("Le repertoire \"" + folderName + "\" existe déjà dans le repertoire \"" + Path + "\".");
}
// creation du nouveau repertoire
SyndicationFolder subFolder = new SyndicationFolder(folderName, this);
// ecoute de l'evenement DeleteFolderRequest
subFolder.DeleteFolderRequest += new DeleteRequestDelegate(OnDeleteFolderRequest);
// on ajoute le sous-repertoire à ce repertoire
_subFolders.Add(subFolder);
return subFolder;
}
public void Initialize()
{
folder = SyndicationManager.getInstance().Root;
channel = new Channel("Zdnet", "http://www.zdnet.fr/feeds/rss/", folder);
}
/// <summary>
/// Methode de l'evenement declenché lors de l'ajout
/// d'un repertoire dans le model de l'application.
/// On met à jour la treeview de la frame principale
/// </summary>
void NewFolderAdded(SyndicationFolder folder)
{
Manager.Save(filename);
View.AddTreeViewNode(folder);
// ancienne methode
// View.UpdateTreeView(Manager.Root);
}
