//-------------------------------------------------------------------------
public CResultAErreur Init(CObjetDeGroupe objet)
{
m_objet = objet;
m_typeGroupe = m_objet.TypeGroupe;
using (CGroupeStructurant tempGroupe = ((CGroupeStructurant)Activator.CreateInstance(m_typeGroupe, new object[] { m_objet.ContexteDonnee })))
{
m_typeRelationNecessite = tempGroupe.TypeRelationNecessaire;
m_strNomTable = tempGroupe.GetNomTable();
m_strChampIdGroupe = tempGroupe.GetChampId();
}
CResultAErreur result = CResultAErreur.True;
if (!m_typeGroupe.IsSubclassOf(typeof(CGroupeStructurant)))
{
throw new Exception("The group type must inherit from CGroupeStructurant.|30077");
}
Nodes.Clear();
//Lit tous les groupes et toutes les dépendances du groupe
m_listeTousLesGroupes = new CListeObjetsDonnees(objet.ContexteDonnee, m_typeGroupe);
m_listeTousLesGroupes.ReadDependances("RelationsGroupesNecessitants", "RelationsGroupesNecessaires");
FillNodes(null, null);
return(result);
}
//-------------------------------------------------------------------------
public void SaveModifs()
{
ArrayList tableRelations = new ArrayList();
foreach (IRelationGroupe rel in m_objet.RelationsGroupes)
{
tableRelations.Add(rel);
}
foreach (IRelationGroupe rel in tableRelations)
{
if (!TableGroupesIdChecked.ContainsKey(rel.Groupe.Id))
{
rel.Delete();
}
}
foreach (int nGroupeId in TableGroupesIdChecked.Keys)
{
using (CGroupeStructurant groupe = (CGroupeStructurant)Activator.CreateInstance(m_typeGroupe, new object[] { m_objet.ContexteDonnee }))
{
groupe.Id = nGroupeId;
if (!m_objet.GetGroupesDirects().Contains(groupe))
{
IRelationGroupe relation = (IRelationGroupe)Activator.CreateInstance(m_objet.RelationsGroupes.TypeObjets, new object[] { m_objet.ContexteDonnee });
relation.CreateNewInCurrentContexte();
relation.Groupe = groupe;
relation.ObjetDeGroupe = m_objet;
}
}
}
}
//-------------------------------------------------------------------------
private void AddGroupesParentsToTable(CGroupeStructurant groupe, ref Hashtable table)
{
foreach (IRelationGroupeStructurantGroupeParent rel in groupe.RelationsTousGroupesContenants)
{
table[rel.GroupeContenant.Id] = true;
}
}
/// ///////////////////////////////////////////////////////////
private void m_btnSupprimer_LinkClicked(object sender, System.EventArgs e)
{
CGroupeStructurant groupe = ElementSelectionneDansArbre;
if (groupe != null)
{
ArrayList list = new ArrayList();
list.Add(groupe);
CResultAErreur result = m_gestionnaireForArbre.Supprimer(list);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
}
TreeNode node = m_arbre.SelectedNode;
if (node != null)
{
TreeNode nodeParent = node.Parent;
if (nodeParent != null)
{
nodeParent.Nodes.Clear();
FillNode(nodeParent);
}
else
{
m_arbre.Nodes.Clear();
FillNode(null);
}
}
}
/// ///////////////////////////////////////////////////////////
private void FillNode(TreeNode nodeParent)
{
CGroupeStructurant groupe = null;
IList liste = null;
if (nodeParent != null)
{
groupe = (CGroupeStructurant)nodeParent.Tag;
liste = new ArrayList();
foreach (IRelationGroupeGroupeNecessaire relation in groupe.RelationsGroupesNecessitants)
{
liste.Add(relation.GroupeNecessitant);
}
}
else
{
liste = new CListeObjetsDonnees(sc2i.win32.data.CSc2iWin32DataClient.ContexteCourant, m_typeGroupes);
string strNomTable = CContexteDonnee.GetNomTableForType(m_typeGroupes);
((CListeObjetsDonnees)liste).Filtre = new CFiltreDataAvance(strNomTable, "HasNo(RelationsGroupesNecessitants.Id)");
}
foreach (CGroupeStructurant grp in liste)
{
TreeNode node = new TreeNode(grp.Libelle);
node.Tag = grp;
if (nodeParent == null)
{
m_arbre.Nodes.Add(node);
}
else
{
nodeParent.Nodes.Add(node);
}
FillNode(node);
}
}
/// <summary>
/// ///////////////////////////////////////////////////////////
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void m_btnAjouter_LinkClicked(object sender, System.EventArgs e)
{
CGroupeStructurant groupeParent = ElementSelectionneDansArbre;
CResultAErreur result = m_gestionnaireForArbre.Ajouter(null, null);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
}
/// ///////////////////////////////////////////////////////////
private void m_btnModifier_LinkClicked(object sender, System.EventArgs e)
{
CGroupeStructurant groupe = ElementSelectionneDansArbre;
if (groupe != null)
{
CResultAErreur result = m_gestionnaireForArbre.Modifier(groupe, null, AffectationsPourNouveauxElements);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
}
}
//-------------------------------------------------------------------------
public CGroupeStructurant[] GetGroupesForNode(TreeNode node)
{
ArrayList tableGroupes = new ArrayList();
CGroupeStructurant groupe = GetGroupeForNode(node);
tableGroupes.Add(groupe);
foreach (IRelationGroupeStructurantGroupeParent rel in groupe.RelationsTousGroupesContenants)
{
if (!tableGroupes.Contains(rel.GroupeContenant))
{
tableGroupes.Add(rel.GroupeContenant);
}
}
return((CGroupeStructurant[])tableGroupes.ToArray(typeof(CGroupeStructurant)));
}
//-------------------------------------------------------------------------
private void AddNodesToTable(TreeNodeCollection nodes, ref Hashtable table, bool bWithParents)
{
foreach (TreeNode node in nodes)
{
if ((node.Checked) && (node.Tag is CGroupeStructurant))
{
CGroupeStructurant groupe = (CGroupeStructurant)node.Tag;
table[groupe.Id] = true;
if (bWithParents)
{
AddGroupesParentsToTable(groupe, ref table);
}
AddNodesToTable(node.Nodes, ref table, bWithParents);
}
}
}
//-------------------------------------------------------------------
/// ////////////////////////////////////////////////////////////
/// Cette fonction récursive a nécéssité une heure de boulot papier. Elle a été testée et
/// fonctionne parfaitement.
/// Il ne fait absolument rien toucher dedans, j'ai eu assez de mal à la faire
public void GereRelationsInduites(CGroupeStructurant groupeContenu, IRelationGroupeStructurantGroupeParent relation, bool bAvecFils)
{
//Va chercher toutes les relations parentes du groupe parent
foreach (IRelationGroupeStructurantGroupeParent relParente in relation.GroupeContenant.RelationsGroupesContenantsDirects)
{
//Crée la relation induite
#if PDA
IRelationGroupeStructurantGroupeParent relNew = (IRelationGroupeStructurantGroupeParent)Activator.CreateInstance(GetTypeObjets());
relNew.ContexteDonnee = relation.ContexteDonnee;
#else
IRelationGroupeStructurantGroupeParent relNew = (IRelationGroupeStructurantGroupeParent)Activator.CreateInstance(GetTypeObjets(), new object[] { relation.ContexteDonnee });
#endif
relNew.CreateNewInCurrentContexte();
relNew.GroupeContenu = groupeContenu;
relNew.GroupeContenant = relParente.GroupeContenant;
relNew.RelationSourceFille = relation;
relNew.RelationSourceParent = relParente;
GereRelationsInduites(groupeContenu, relNew, false);
}
//Va chercher toutes les relations filles du groupe fils
if (bAvecFils)
{
foreach (IRelationGroupeStructurantGroupeParent relFille in groupeContenu.RelationsGroupesContenusDirects)
{
//Crée la relation induite
#if PDA
IRelationGroupeStructurantGroupeParent relNew = (IRelationGroupeStructurantGroupeParent)Activator.CreateInstance(GetTypeObjets());
relNew.ContexteDonnee = relation.ContexteDonnee;
#else
IRelationGroupeStructurantGroupeParent relNew = (IRelationGroupeStructurantGroupeParent)Activator.CreateInstance(GetTypeObjets(), new object[] { relation.ContexteDonnee });
#endif
relNew.CreateNewInCurrentContexte();
relNew.GroupeContenu = relFille.GroupeContenu;
relNew.GroupeContenant = relation.GroupeContenant;
relNew.RelationSourceFille = relFille;
relNew.RelationSourceParent = relation;
GereRelationsInduites((CGroupeStructurant)relFille.GroupeContenu, relNew, true);
}
}
}
//-------------------------------------------------------------------------
private CResultAErreur CheckNodesFromListe(TreeNodeCollection nodeCollection, CListeObjetsDonnees liste)
{
CResultAErreur result = CResultAErreur.True;
if (!liste.TypeObjets.IsSubclassOf(typeof(CGroupeStructurant)))
{
throw new Exception(I.T("The type of the list objects must inherit from CGroupeStructurant.|30078"));
}
foreach (TreeNode node in nodeCollection)
{
if (node.Tag is CGroupeStructurant)
{
CGroupeStructurant groupe = (CGroupeStructurant)node.Tag;
if (liste.Contains(groupe))
{
if (node.Parent != null)
{
node.Parent.Expand();
}
node.Checked = true;
CResultAErreur tempResult = CheckNodesFromListe(node.Nodes, liste);
if (!tempResult)
{
result.Erreur.EmpileErreurs(tempResult.Erreur);
result.SetFalse();
return(result);
}
}
else
{
node.Checked = false;
}
}
}
return(result);
}
//-------------------------------------------------------------------------
protected void FillNodes(TreeNode nodeParent, CGroupeStructurant objetParent)
{
TreeNodeCollection nodes = null;
if (nodeParent == null)
{
nodes = Nodes;
}
else
{
nodes = nodeParent.Nodes;
}
nodes.Clear();
/*CListeObjetsDonnees listeGroupesNecessitants = new CListeObjetsDonnees(CSc2iWin32DataClient.ContexteCourant, m_typeGroupe, false);
* CFiltreData filtre;*/
ArrayList listeGroupes = new ArrayList();
if (objetParent == null)
{
foreach (CGroupeStructurant groupe in m_listeTousLesGroupes)
{
if (groupe.RelationsGroupesNecessaires.Count == 0)
{
listeGroupes.Add(groupe);
}
}
//filtre = new CFiltreDataAvance ( m_strNomTable, "HasNo(RelationsGroupesNecessitants.Id)" );
}
else
{
CListeObjetsDonnees listeRelations = objetParent.RelationsGroupesNecessitants; //new CListeObjetsDonnees(CSc2iWin32DataClient.ContexteCourant, m_typeRelationNecessite, false);
//string strIds = "";
foreach (IRelationGroupeGroupeNecessaire rel in listeRelations)
{
listeGroupes.Add(rel.GroupeNecessitant);
//strIds += rel.GroupeNecessitant.Id+",";
}
/*if (strIds=="")
* filtre = new CFiltreDataImpossible();
* else
* //filtre = new CFiltreDataAvance(m_strNomTable, strIds, null); //"RelationsGroupesNecessaires.GroupeNecessaire.Id = @1", new object[] {objetParent.Id});
* {
* strIds = "("+strIds.Substring(0, strIds.Length-1)+")";
* filtre = new CFiltreData ( m_strChampIdGroupe+" in "+strIds );
* }*/
}
//listeGroupesNecessitants.Filtre = filtre;
foreach (CGroupeStructurant groupe in listeGroupes) //listeGroupesNecessitants )
{
TreeNode node = new TreeNode();
node.Text = groupe.Libelle;
node.Tag = groupe;
if (groupe.RelationsGroupesNecessitants.Count > 0)
{
FillNodes(node, groupe);
}
nodes.Add(node);
}
}
