private void m_imageTache_MouseMove(object sender, MouseEventArgs e)
{
m_bHasDrag = false;
if ((e.Button & MouseButtons.Left) == MouseButtons.Left && m_ptMouseDownTache != null)
{
Point pt = new Point(Math.Abs(e.X - m_ptMouseDownTache.Value.X),
Math.Abs(e.Y - m_ptMouseDownTache.Value.Y));
if (pt.X > 4 || pt.Y > 4)
{
CItemBesoin item = CurrentItem as CItemBesoin;
StartDragDrop(
new Point(e.X, e.Y),
DragDropEffects.Move | DragDropEffects.Link | DragDropEffects.Copy,
new CDonneeAdditionnelleDragDrop(typeof(sc2i.data.CReferenceObjetDonnee), new sc2i.data.CReferenceObjetDonnee(Besoin))
);
m_bHasDrag = true;
CBesoin besoin = item.Besoin;
((CControleListeBesoins)AssociatedListControl).RefreshBesoin(besoin, true);
besoin = besoin.BesoinParent;
while (besoin != null)
{
((CControleListeBesoins)AssociatedListControl).RefreshBesoin(besoin, false);
besoin = besoin.BesoinParent;
}
AssociatedListControl.Refresh();
}
}
}
//------------------------------------------------------------------------------------------------------------------------------
public static void SetPourcentageFor(CBesoin besoin, ISatisfactionBesoin satisfaction, double fPourcentageSouhaité)
{
CImputationsCouts imputations = satisfaction.GetImputationsAFaireSurUtilisateursDeCout();
CImputationCout imputation = imputations.GetImputation(besoin);
if (fPourcentageSouhaité < 100 && fPourcentageSouhaité >= 0)
{
if (imputations != null)
{
double fPoids = imputations.PoidsTotal - imputation.Poids;
if (fPoids == 0)
{
return;
}
CListeObjetsDonnees lst = satisfaction.RelationsSatisfaits;
lst.Filtre = new CFiltreData(CBesoin.c_champId + "=@1", besoin.Id);
if (lst.Count != 0)
{
double fCalc = fPourcentageSouhaité / 100.0 * fPoids / (1 - fPourcentageSouhaité / 100.0);
CRelationBesoin_Satisfaction rel = lst[0] as CRelationBesoin_Satisfaction;
rel.RatioCoutReel = fCalc;
}
}
}
}
//--------------------------------------------------
private void m_btnAddBesoin_LinkClicked(object sender, EventArgs e)
{
if (m_phaseSpecifications != null && !LockEdition)
{
CBesoin besoin = new CBesoin(PhaseSpecifications.ContexteDonnee);
besoin.CreateNewInCurrentContexte();
besoin.PhaseSpecifications = PhaseSpecifications;
if (m_phaseSpecifications.Projet != null && m_phaseSpecifications.Projet.TypeProjet != null)
{
besoin.TypeBesoinCode = m_phaseSpecifications.Projet.TypeProjet.CodeTypeBesoinParDefaut;
}
CItemBesoin item = new CItemBesoin(besoin, null);
item.Tag = besoin;
if (Items.Length > 0)
{
CItemBesoin lastItem = Items[Items.Length - 1] as CItemBesoin;
if (lastItem != null && lastItem.Besoin != null)
{
besoin.BesoinParent = lastItem.Besoin.BesoinParent;
}
}
AddItem(item, true);
CurrentItemIndex = item.Index;
}
}
//---------------------------------------------------------------
private CItemBesoin CreateSoluce(CBesoin besoinSolutionné)
{
CBesoin newBesoin = new CBesoin(m_phaseSpecifications.ContexteDonnee);
newBesoin.CreateNewInCurrentContexte();
newBesoin.PhaseSpecifications = m_phaseSpecifications;
Dictionary <int, int> dicMap = newBesoin.CopyFromTemplate(besoinSolutionné);
if (dicMap != null)
{
foreach (KeyValuePair <int, int> kv in dicMap)
{
CBesoin bOriginal = new CBesoin(m_phaseSpecifications.ContexteDonnee);
if (bOriginal.ReadIfExists(kv.Key, false))
{
if (!bOriginal.HasChildren)
{
CBesoin bNew = new CBesoin(m_phaseSpecifications.ContexteDonnee);
if (bNew.ReadIfExists(kv.Value, false))
{
bOriginal.AddSatisfaction(bNew, null);
}
}
}
}
}
CItemBesoin item = new CItemBesoin(newBesoin, null);
AddItem(item, false);
item.Index = Items.Count();
AddItemsFils(item);
return(item);
}
//---------------------------------------------------
public void RecalculeSuivants(CNiveauMapSatisfaction niveau)
{
//Récupère le niveau suivant
CNiveauMapSatisfaction niveauSuiv = null;
foreach (CNiveauMapSatisfaction niveauAutre in m_listeNiveaux)
{
if (niveauAutre.NiveauSatisfaction == niveau.NiveauSatisfaction + 1)
{
niveauSuiv = niveauAutre;
break;
}
}
if (niveauSuiv == null)
{
//Création du niveau précédent
niveauSuiv = new CNiveauMapSatisfaction(this, niveau.NiveauSatisfaction + 1);
m_listeNiveaux.Add(niveauSuiv);
}
HashSet <CDessinSatisfaction> dessinsRacinesToRemove = new HashSet <CDessinSatisfaction>();
foreach (CDessinSatisfaction dessin in niveauSuiv.Dessins)
{
if (dessin.DessinParent == null)
{
dessinsRacinesToRemove.Add(dessin);
}
}
foreach (CDessinSatisfaction dessin in niveau.Dessins)
{
CBesoin besoin = dessin.Satisfaction as CBesoin;
if (besoin != null)
{
string strLib = besoin.Libelle;
foreach (CRelationBesoin_Satisfaction rel in besoin.RelationsSatisfactions)
{
CDessinSatisfaction dessinBesoin = GetDessin(rel.Satisfaction);
if (dessinBesoin == null && rel.Satisfaction != null)
{
dessinBesoin = new CDessinSatisfaction(niveauSuiv, rel.Satisfaction);
niveauSuiv.AddSatisfactionVisible(dessinBesoin);
}
dessinsRacinesToRemove.Remove(dessinBesoin);
}
}
}
//retire les besoins racine qui doivent virer
foreach (CDessinSatisfaction dessin in dessinsRacinesToRemove)
{
niveauSuiv.RemoveDessinPourToujours(dessin);
}
if (niveauSuiv.Dessins.Count() > 0)
{
RecalculeSuivants(niveauSuiv);
}
}
//--------------------------------------------------------------
public void InitFrom(CBesoin besoin, IDonneeBesoin donnee)
{
CDonneeBesoinTypeEquipement dT = donnee as CDonneeBesoinTypeEquipement;
if (dT != null)
{
if (dT.Quantite != null)
{
Quantite = new CValeurUnite(dT.Quantite, "");
}
if (dT.CoutUnitaire != null)
{
CoutUnitaire = new CValeurUnite(dT.CoutUnitaire.Value, "");
}
return;
}
CDonneeBesoinQuantiteCU dQ = donnee as CDonneeBesoinQuantiteCU;
if (dQ != null)
{
Quantite = dQ.Quantite;
CoutUnitaire = dQ.CoutUnitaire;
return;
}
}
//------------------------------------------------------
public void Init(IDonneeBesoin calcul, CBesoin besoin, CItemBesoin itemBesoin, IEnumerable <CItemBesoin> items)
{
m_calculPourcentage = calcul as CDonneeBesoinPourcentage;
m_besoin = besoin;
m_items = items;
if (m_calculPourcentage != null && besoin != null)
{
Visible = true;
m_txtPourcentage.DoubleValue = m_calculPourcentage.Pourcentage;
StringBuilder bl = new StringBuilder( );
foreach (CBesoinDependance dep in besoin.LiensBesoinsDontJeDepend)
{
bl.Append(dep.BesoinReference.Index);
bl.Append(';');
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
}
m_txtReferences.Text = bl.ToString();
}
else
{
Visible = false;
}
}
public void Init(IDonneeBesoin calcul, CBesoin besoin, CItemBesoin itemBesoin, IEnumerable <CItemBesoin> items)
{
m_bIsInitializing = true;
m_calculQte = calcul as CDonneeBesoinQuantiteCU;
if (m_calculQte != null)
{
Visible = true;
m_txtQuantité.UnitValue = m_calculQte.Quantite;
m_lblUniteCU.Text = "";
m_uniteCU = null;
if (m_calculQte.CoutUnitaire != null)
{
m_txtCoutUnitaire.DoubleValue = m_calculQte.CoutUnitaire.Valeur;
if (m_calculQte.Quantite != null && m_calculQte.Quantite.IUnite != null)
{
string strU = CUtilUnite.GetUniteInverse(m_calculQte.CoutUnitaire.Unite);
IUnite u = CGestionnaireUnites.GetUnite(strU);
if (u != null && u.Classe.GlobalId == m_calculQte.Quantite.IUnite.Classe.GlobalId)
{
m_uniteCU = u;
m_lblUniteCU.Text = u.LibelleCourt;
}
}
}
else
{
m_txtCoutUnitaire.DoubleValue = null;
}
}
m_bIsInitializing = false;
}
//-----------------------------------------------------------------------
private void UpdateMarge()
{
if (CurrentItem != null)
{
CBesoin besoin = CurrentItem.Tag as CBesoin;
m_picMarge.Width = besoin.Niveau * 10;
}
}
//--------------------------------------------------------------
public double?CalculeCout(CBesoin besoin)
{
double?fCU = CoutUnitaire;
if (fCU != null)
{
return(fCU * (double)m_nQuantite);
}
return(null);
}
//--------------------------------------------------------------------
private void AddItemBesoinEtFils(CItemBesoin itemParent, CBesoin besoin, List <CCustomizableListItem> lstItems)
{
CItemBesoin item = new CItemBesoin(besoin, itemParent);
lstItems.Add(item);
foreach (CBesoin besoinFils in besoin.BesoinsFils)
{
AddItemBesoinEtFils(item, besoinFils, lstItems);
}
}
//------------------------------------------------------------------------------
private void afficherLaPhaseToolStripMenuItem_Click(object sender, EventArgs e)
{
CBesoin besoin = m_satisfactionSel as CBesoin;
if (besoin != null && besoin.PhaseSpecifications != null)
{
CPhaseSpecifications phase = besoin.PhaseSpecifications;
Init(phase);
Refresh();
}
}
//---------------------------------------------------------------
internal void AddItemsFils(CItemBesoin itemParent)
{
CBesoin b = itemParent.Besoin;
foreach (CBesoin fils in b.BesoinsFils)
{
CItemBesoin item = new CItemBesoin(fils, itemParent);
item.Index = fils.Index;
AddItem(item, false);
AddItemsFils(item);
}
}
public void Init(IDonneeBesoin calcul, CBesoin besoin, CItemBesoin itemBesoin, IEnumerable <CItemBesoin> items)
{
m_bIsInitializing = true;
m_besoin = besoin;
m_donneeOperation = calcul as CDonneeBesoinTypeOperation;
if (m_donneeOperation != null)
{
Visible = true;
FillFromDonnee();
}
m_bIsInitializing = false;
}
private void m_picDragBesoin_DragEnter(object sender, DragEventArgs e)
{
CReferenceObjetDonnee refObj = e.Data.GetData(typeof(CReferenceObjetDonnee)) as CReferenceObjetDonnee;
if (refObj != null)
{
CBesoin besoin = refObj.GetObjet(m_commande.ContexteDonnee) as CBesoin;
if (besoin.DonneeBesoin is CDonneeBesoinTypeEquipement)
{
e.Effect = DragDropEffects.Link;
}
}
}
public virtual void Init(IDonneeBesoin calcul, CBesoin besoin, CItemBesoin itemBesoin, IEnumerable <CItemBesoin> items)
{
m_bIsInitializing = true;
m_besoin = besoin;
m_donneeConsommable = calcul as CDonneeBesoinTypeConsommable;
if (m_donneeConsommable != null)
{
Visible = true;
InitTypeConsommable();
m_txtSelectTypeConsommable.ElementSelectionne = m_donneeConsommable.GetTypeConsommable(besoin.ContexteDonnee);
}
m_bIsInitializing = false;
}
//------------------------------------------------------------------------------------------------------------------------------
public static bool IsDirectSatisfactionFor(ISatisfactionBesoin satisfaction, CBesoin besoin)
{
if (besoin == null || satisfaction == null)
{
return(false);
}
CListeObjetsDonnees lstSatisfaits = satisfaction.RelationsSatisfaits;
lstSatisfaits.Filtre = new CFiltreData(CBesoin.c_champId + "=@1",
besoin.Id);
int nCoutn = lstSatisfaits.Count;
return(nCoutn > 0);
}
public void Init(IDonneeBesoin calcul, CBesoin besoin, CItemBesoin itemBesoin, IEnumerable <CItemBesoin> items)
{
m_bIsInitializing = true;
m_donneeEquipement = calcul as CDonneeBesoinTypeEquipement;
m_besoin = besoin;
if (m_donneeEquipement != null)
{
Visible = true;
m_txtSelectTypeEquipement.Init(typeof(CTypeEquipement),
"Libelle", false);
m_txtSelectTypeEquipement.ElementSelectionne = m_donneeEquipement.GetTypeEquipement(besoin.ContexteDonnee);
}
m_bIsInitializing = false;
}
//---------------------------------------------
public double CalcImputationAFaireSur(IElementACout elementACout, bool bCoutReel)
{
if (elementACout == null || elementACout.Row.RowState == DataRowState.Deleted)
{
return(0);
}
CBesoin besoin = elementACout as CBesoin;
if (besoin != null)
{
return(CUtilElementACout.CalcImputationAFaireSur(this, besoin, bCoutReel));
}
return(0);
}
//------------------------------------------------------------------------------------------------------------------------------
public static double GetPourcentageFor(CBesoin besoin, ISatisfactionBesoin satisfaction)
{
CImputationsCouts imputations = satisfaction.GetImputationsAFaireSurUtilisateursDeCout();
CImputationCout imputation = imputations.GetImputation(besoin);
if (imputations == null)
{
return(0);
}
if (imputations.PoidsTotal > 0)
{
return(imputation.Poids / imputations.PoidsTotal * 100);
}
return(0);
}
//--------------------------------------------------------------------
public CItemBesoin GetItem(CBesoin besoin)
{
if (besoin == null)
{
return(null);
}
foreach (CItemBesoin item in Items)
{
if (besoin.Equals(item.Besoin))
{
return(item);
}
}
return(null);
}
//--------------------------------------------------------------
public double?CalculeCout(CBesoin besoin)
{
double?fValeur = null;
if (m_valeurQuantite != null && m_valeurCU != null)
{
try
{
CValeurUnite v = m_valeurQuantite * m_valeurCU;
fValeur = v.Valeur;
}
catch { }
}
return(fValeur);
}
//--------------------------------------------------------------------
public void RefreshBesoin(CBesoin besoin, bool bAvecFils)
{
CItemBesoin item = GetItem(besoin);
if (item != null)
{
RefreshItem(item);
if (bAvecFils)
{
foreach (CBesoin fils in besoin.BesoinsFils)
{
RefreshBesoin(fils, true);
}
}
}
}
public override DragDropEffects GetDragDropEffect(DragEventArgs eventArgs)
{
m_nIdBesoinLinkingSatisfaction = null;
IDataObject data = eventArgs.Data;
DragDropEffects e = DragDropEffects.None;
if (!LockEdition)
{
e = base.GetDragDropEffect(eventArgs);
}
if (e != DragDropEffects.None)
{
return(e);
}
if (m_phaseSpecifications == null)
{
return(e);
}
if (m_satisfactionEnCoursDragDrop != null)
{
//Regarde si la satisfaction peut satisfaire le besoin sous la souris
Point pt = m_panelDessin.PointToClient(new Point(eventArgs.X, eventArgs.Y));
int? nItemIndex = GetItemIndexAtPosition(pt.Y);
if (nItemIndex != null)
{
CItemBesoin item = Items[nItemIndex.Value] as CItemBesoin;
if (item != null && item.Besoin != null &&
m_satisfactionEnCoursDragDrop.CanSatisfaire(item.Besoin))
{
m_nIdBesoinLinkingSatisfaction = item.Index;
return(DragDropEffects.Link);
}
}
else
{
CBesoin besoinDrag = m_satisfactionEnCoursDragDrop as CBesoin;
if (besoinDrag != null && besoinDrag.PhaseSpecifications != m_phaseSpecifications && !LockEdition)
{
return(DragDropEffects.Copy);
}
}
}
return(e);
}
//--------------------------------------------------------------
public void InitFrom(CBesoin besoin, IDonneeBesoin donnee)
{
CDonneeBesoinQuantiteCU dCU = donnee as CDonneeBesoinQuantiteCU;
if (dCU != null)
{
if (dCU.Quantite != null)
{
Quantite = (int)dCU.Quantite.Valeur;
}
if (dCU.CoutUnitaire != null)
{
m_bIsCoutTarif = false;
CoutUnitaire = dCU.CoutUnitaire.Valeur;
}
}
}
//---------------------------------------------------------------
public double?CalculeCout(CBesoin besoin)
{
if (besoin.HasChildren)
{
double fTotal = 0;
foreach (CBesoin b in besoin.BesoinsFils)
{
double?fCout = b.CoutSaisiTotalSansRegroupement;
if (fCout != null)
{
fTotal += fCout.Value;
}
}
return(fTotal);
}
return(CoutSaisi);
}
//------------------------------------------------------
private int CalculeRectangles(ISatisfactionBesoin satisfaction, int nIndexNiveau, int nYTop)
{
int nNextPos = nYTop;
bool bMargeOnNext = false;
List <ISatisfactionBesoin> lstFils = new List <ISatisfactionBesoin>();
CBesoin besoin = satisfaction as CBesoin;
if (besoin != null)
{
foreach (CRelationBesoin_Satisfaction sat in besoin.RelationsSatisfactions)
{
ISatisfactionBesoin fils = sat.Satisfaction;
if (fils != null)
{
if (m_setSatisfactionsIntegrés.Contains(fils) && !m_dicSatisfactionToRect.ContainsKey(fils))
{
lstFils.Add(fils);
}
}
}
}
for (int nFils = 0; nFils < lstFils.Count; nFils++)
{
ISatisfactionBesoin fils = lstFils[nFils];
if (!m_dicSatisfactionToRect.ContainsKey(fils))
{
if (bMargeOnNext)
{
nNextPos += m_nMargeVerticale;
}
m_dicSatisfactionToRect[fils] = null;
nNextPos = CalculeRectangles(fils, nIndexNiveau + 1, nNextPos);
bMargeOnNext = true;
}
}
int nHauteurTotale = Math.Max(m_nHauteurSatisfactionDefaut, nNextPos - nYTop);
int nX = GetXIndexNiveau(nIndexNiveau, m_nLargeurNiveauDefaut, m_nLargeurFleches);
Rectangle rct = new Rectangle(nX, nYTop + nHauteurTotale / 2 - m_nMargeVerticale,
m_nLargeurNiveauDefaut,
m_nHauteurSatisfactionDefaut);
m_dicSatisfactionToRect[satisfaction] = new CInfoDessinSatisfaction(rct, satisfaction, m_setSatisfactionsExpanded.Contains(satisfaction));
return(nYTop + nHauteurTotale);
}
//--------------------------------------------------------------------
public void Init(CBesoin besoin)
{
CurrentItemIndex = null;
Items = new CCustomizableListItem[0];
m_besoin = besoin;
if (m_besoin != null)
{
List <CCustomizableListItem> items = new List <CCustomizableListItem>();
CListeObjetsDonnees lstQuantites = m_besoin.Quantites;
lstQuantites.Filtre = new CFiltreData(CBesoinQuantite.c_champIdQteParente + " is null");
foreach (CBesoinQuantite q in lstQuantites)
{
AddItemQuantiteEtFils(null, q, items);
}
Items = items.ToArray();
}
Refresh();
}
public void Init(IDonneeBesoin calcul, CBesoin besoin, CItemBesoin itemBesoin, IEnumerable <CItemBesoin> items)
{
m_bIsInitializing = true;
m_donneeProjet = calcul as CDonneeBesoinProjet;
m_besoin = besoin;
if (m_donneeProjet != null)
{
if (!besoin.HasChildren)
{
m_txtCoutUnitaire.Visible = true;
m_txtCoutUnitaire.DoubleValue = m_donneeProjet.CoutSaisi;
}
else
{
m_txtCoutUnitaire.Visible = false;
}
}
m_bIsInitializing = false;
}
//------------------------------------------------------
private CNiveau CalculeNiveauSuivant( )
{
CNiveau niveauSuiv = m_listeNiveaux[m_listeNiveaux.Count - 1];
CNiveau niveau = new CNiveau(m_listeNiveaux[m_listeNiveaux.Count - 1].Niveau + 1);
foreach (ISatisfactionBesoin sat in niveauSuiv.Satisfactions)
{
CBesoin besoin = sat as CBesoin;
if (besoin != null)
{
foreach (CRelationBesoin_Satisfaction rel in besoin.RelationsSatisfactions)
{
niveau.AddSatisfaction(this, rel.Satisfaction);
}
}
}
m_listeNiveaux.Add(niveau);
return(niveau);
}
