//---------------------------------------------------------------
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);
}
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 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 override void RemoveItem(int nIndex, bool bRedraw)
{
if (nIndex >= 0 && nIndex < Items.Count())
{
CItemBesoin item = Items[nIndex] as CItemBesoin;
if (item != null)
{
CurrentItemIndex = null;
List <CCustomizableListItemANiveau> lstToDelete = GetItemsDependants(item);
lstToDelete.Insert(0, item);
lstToDelete.Reverse();
foreach (CItemBesoin toDelete in lstToDelete)
{
CResultAErreur result = item.Besoin.Delete(true);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
else
{
base.RemoveItem(item.Index, false);
}
}
Refresh();
}
}
}
//--------------------------------------------------
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;
}
}
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 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);
}
}
//---------------------------------------------------------------
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;
}
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 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 CResultAErreur MajChamps()
{
CResultAErreur result = CResultAErreur.True;
if (m_besoin == null || m_calculProjet != null && m_items != null)
{
//Trouve les éléments avec les indexs demandés
string[] strIndexs = m_txtReferences.Text.Split(';');
Dictionary <CBesoin, bool> dicDepsASupprimer = new Dictionary <CBesoin, bool>();
foreach (CBesoinDependance dep in m_besoin.LiensBesoinsDontJeDepend)
{
dicDepsASupprimer[dep.BesoinReference] = true;
}
foreach (string strIndex in strIndexs)
{
try{
int nItem = Int32.Parse(strIndex);
if (nItem >= 0 && nItem < m_items.Count())
{
CItemBesoin item = m_items.ElementAt(nItem);
if (item != null && item.Besoin != null && item.Besoin.TypeBesoinCode == (int)ETypeDonneeBesoin.Projet)
{
m_besoin.AddDependance(item.Besoin);
dicDepsASupprimer[item.Besoin] = false;
}
}
}
catch {}
}
foreach (KeyValuePair <CBesoin, bool> kv in dicDepsASupprimer)
{
if (kv.Value)
{
m_besoin.RemoveDependance(kv.Key);
}
}
m_calculProjet.SetTypePRojet(m_txtSelectTypeProjet.ElementSelectionne as CTypeProjet);
if (m_txtDuree.UnitValue != null)
{
m_calculProjet.DureeJours = m_txtDuree.UnitValue.ConvertTo(CClasseUniteTemps.c_idDAY).Valeur;
}
else
{
m_calculProjet.DureeJours = 0;
}
m_calculProjet.CleProjetTemplate = m_txtTemplateKey.Text.Trim();
}
return(result);
}
private void m_iconPlusMoins_Click(object sender, EventArgs e)
{
CItemBesoin item = CurrentItem as CItemBesoin;
if (item != null)
{
if (item.IsCollapse)
{
((CControleListeBesoins)AssociatedListControl).Expand(item);
}
else
{
((CControleListeBesoins)AssociatedListControl).Collapse(item);
}
}
}
//--------------------------------------------------------------------
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 CResultAErreur MajChamps()
{
CResultAErreur result = CResultAErreur.True;
if (m_besoin == null || m_calculPourcentage != null && m_items != null)
{
if (m_txtPourcentage.DoubleValue != null)
{
m_calculPourcentage.Pourcentage = m_txtPourcentage.DoubleValue.Value;
}
else
{
m_calculPourcentage.Pourcentage = 0;
}
//Trouve les éléments avec les indexs demandés
string[] strIndexs = m_txtReferences.Text.Split(';');
Dictionary <CBesoin, bool> dicDepsASupprimer = new Dictionary <CBesoin, bool>();
foreach (CBesoinDependance dep in m_besoin.LiensBesoinsDontJeDepend)
{
dicDepsASupprimer[dep.BesoinReference] = true;
}
foreach (string strIndex in strIndexs)
{
try{
int nItem = Int32.Parse(strIndex);
if (nItem >= 0 && nItem < m_items.Count())
{
CItemBesoin item = m_items.ElementAt(nItem);
if (item != null && item.Besoin != null)
{
m_besoin.AddDependance(item.Besoin);
dicDepsASupprimer[item.Besoin] = false;
}
}
}
catch {}
}
foreach (KeyValuePair <CBesoin, bool> kv in dicDepsASupprimer)
{
if (kv.Value)
{
m_besoin.RemoveDependance(kv.Key);
}
}
}
return(result);
}
//----------------------------------------------
public override bool OnChangeParent(CCustomizableListItemANiveau item)
{
CItemBesoin b = item as CItemBesoin;
if (Besoin != null && (b != null || item == null))
{
if (b != null)
{
Besoin.BesoinParent = b.Besoin;
return(Besoin.BesoinParent == b.Besoin);
}
else
{
Besoin.BesoinParent = null;
}
return(true);
}
return(false);
}
//--------------------------------------------------
internal void Collapse(CItemBesoin item)
{
if (item == null || item.Besoin == null)
{
return;
}
int nNiveauSuivant = item.Besoin.Niveau + 1;
item.SetIsCollapse(true);
foreach (CItemBesoin child in GetItemsDependants(item))
{
if (child.Besoin != null)
{
child.IsMasque = true;
RefreshItem(child);
}
}
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 void m_btnMenuQuantite_Click(object sender, EventArgs e)
{
CItemBesoin item = CurrentItem as CItemBesoin;
if (item != null)
{
if (m_controleQuantite.CurrentItem != null)
{
m_controleQuantite.MajChamps();
}
CBesoinQuantite qte = new CBesoinQuantite(item.Besoin.ContexteDonnee);
qte.CreateNewInCurrentContexte();
qte.Besoin = item.Besoin;
CCustomizableListItem newItem = new CCustomizableListItem();
newItem.Tag = qte;
m_wndListeQuantites.AddItem(newItem, false);
CalcHeight();
m_wndListeQuantites.CurrentItemIndex = m_wndListeQuantites.Items.Count() - 1;
}
}
public void Init(IDonneeBesoin calcul, CBesoin besoin, CItemBesoin itemBesoin, IEnumerable <CItemBesoin> items)
{
m_bIsInitializing = true;
m_donneeOperation = calcul as CDonneeBesoinTypeOperation;
m_besoin = besoin;
if (m_donneeOperation != null)
{
Visible = true;
CFiltreData filtre = null;
if (besoin.BesoinParent != null && besoin.BesoinParent.TypeOperation != null)
{
filtre = new CFiltreData(CTypeOperation.c_champIdOperationParente + "=@1",
besoin.BesoinParent.TypeOperation.Id);
}
m_txtSelectTypeOperation.InitAvecFiltreDeBase(typeof(CTypeOperation),
"LibelleComplet", filtre, false);
m_txtSelectTypeOperation.ElementSelectionne = m_donneeOperation.GetTypeOperation(besoin.ContexteDonnee);
}
m_bIsInitializing = false;
}
//--------------------------------------------------------
private void m_btnDelete_Click(object sender, EventArgs e)
{
if (m_extModeEdition.ModeEdition)
{
CControleListeBesoins ctrlListe = AssociatedListControl as CControleListeBesoins;
if (ctrlListe != null && CurrentItem != null)
{
CItemBesoin item = CurrentItem as CItemBesoin;
if (item != null)
{
if (MessageBox.Show("Supprimer l'élément " +
item.Besoin.Libelle + " ?", "",
MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
ctrlListe.RemoveItem(CurrentItem, true);
}
}
}
}
}
public void Init(IDonneeBesoin calcul, CBesoin besoin, CItemBesoin itemBesoin, IEnumerable <CItemBesoin> items)
{
m_bIsInitializing = true;
m_calculProjet = calcul as CDonneeBesoinProjet;
m_besoin = besoin;
m_items = items;
if (m_calculProjet != null && besoin != null)
{
m_txtSelectTypeProjet.Init(typeof(CTypeProjet), "Libelle", false);
m_txtSelectTypeProjet.ElementSelectionne = (m_calculProjet.GetTypeProjet(besoin.ContexteDonnee));
Visible = true;
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();
if (m_calculProjet.DureeJours == 0)
{
m_txtDuree.UnitValue = null;
}
else
{
m_txtDuree.UnitValue = new CValeurUnite(m_calculProjet.DureeJours, CClasseUniteTemps.c_idDAY);
}
m_txtTemplateKey.Text = m_calculProjet.CleProjetTemplate;
}
else
{
Visible = false;
}
m_bIsInitializing = false;
}
//--------------------------------------------------
internal void Expand(CItemBesoin item)
{
if (item == null || item.Besoin == null)
{
return;
}
int nNiveauSuivant = item.Besoin.Niveau + 1;
item.SetIsCollapse(false);
Dictionary <int, bool> dicMasquage = new Dictionary <int, bool>();
dicMasquage[nNiveauSuivant] = false;
RefreshItem(item);
foreach (CItemBesoin child in GetItemsDependants(item))
{
child.IsMasque = dicMasquage[child.Besoin.Niveau];
dicMasquage[child.Besoin.Niveau + 1] = child.IsCollapse;
RefreshItem(child);
}
Refresh();
}
//--------------------------------------------------------------------
private bool ItemControl_OnLeaveLastControl(object sender, EventArgs args)
{
if (sender != null)
{
//Regarde si le dernier item est vide
if (Items.Count() > 0 && !LockEdition && m_phaseSpecifications != null)
{
CItemBesoin item = Items.ElementAt(Items.Count() - 1) as CItemBesoin;
if (item.Besoin != null && item.Besoin.Libelle.Trim().Length > 0)
{
CBesoin besoin = new CBesoin(m_phaseSpecifications.ContexteDonnee);
besoin.CreateNewInCurrentContexte();
if (m_phaseSpecifications.Projet != null && m_phaseSpecifications.Projet.TypeProjet != null)
{
besoin.TypeBesoinCode = m_phaseSpecifications.Projet.TypeProjet.CodeTypeBesoinParDefaut;
}
besoin.PhaseSpecifications = m_phaseSpecifications;
CItemBesoin prec = null;
if (Items.Count() > 0)
{
prec = GetVisibleItemBefore(Items.Count()) as CItemBesoin;
if (prec != null)
{
besoin.BesoinParent = prec.Besoin.BesoinParent;
}
}
item = new CItemBesoin(besoin, prec != null?prec.ItemParent as CItemBesoin:null);
AddItem(item, true);
CurrentItemIndex = item.Index;
ItemControl.GetTabOrderedControlsList()[0].Focus();
return(true);
}
}
}
return(false);
}
public void Init(IDonneeBesoin donnee, CBesoin besoin, CItemBesoin itemBesoin, IEnumerable <CItemBesoin> items)
{
m_besoin = besoin;
m_itemBesoin = itemBesoin;
FillDatas();
}
//--------------------------------------------------------------------
protected override void m_panelDessin_DragDrop(object sender, DragEventArgs e)
{
HideHighlight();
DragDropEffects eff = GetDragDropEffect(e);
if (eff == DragDropEffects.Move && !LockEdition)
{
base.m_panelDessin_DragDrop(sender, e);
}
if (eff == DragDropEffects.Link && m_nIdBesoinLinkingSatisfaction != null && m_satisfactionEnCoursDragDrop != null)
{
CItemBesoin item = Items[m_nIdBesoinLinkingSatisfaction.Value] as CItemBesoin;
if (item != null && item.Besoin != null && m_satisfactionEnCoursDragDrop.CanSatisfaire(item.Besoin))
{
if (CUtilElementACout.IsSourceDe(item.Besoin, m_satisfactionEnCoursDragDrop))
{
CFormAlerte.Afficher(I.T("Can not perform requested operation. @1 is a solution of @2|20675",
item.Besoin.Libelle,
m_satisfactionEnCoursDragDrop.LibelleSatisfactionComplet), EFormAlerteType.Exclamation);
return;
}
if (CFormAlerte.Afficher(I.T("@1 will be considered as a solution of @2. Continue ?|20631",
m_satisfactionEnCoursDragDrop.LibelleSatisfactionComplet, item.Besoin.Libelle),
EFormAlerteBoutons.OuiNon, EFormAlerteType.Question) == DialogResult.Yes)
{
CBesoin besoin = item.Besoin;
if (LockEdition)
{
besoin = item.Besoin;
besoin.BeginEdit();
}
besoin.AddSatisfaction(m_satisfactionEnCoursDragDrop, null);
if (LockEdition)
{
CResultAErreur result = besoin.CommitEdit();
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
besoin.CancelEdit();
}
}
RefreshItem(item);
m_panelDessin.Invalidate();
}
else
{
e.Effect = DragDropEffects.None;
}
}
}
else if (eff == DragDropEffects.Copy && m_phaseSpecifications != null && !LockEdition)
{
CBesoin besoinDrag = m_satisfactionEnCoursDragDrop as CBesoin;
if (besoinDrag != null && besoinDrag.PhaseSpecifications != m_phaseSpecifications)
{
CItemBesoin newItem = CreateSoluce(besoinDrag);
RenumerotteItems();
Refresh();
}
}
}
public void ShowMenuDetailCalcul(
IElementACout utilisateur,
CItemBesoin itemBesoin,
ContextMenuStrip menu,
bool bCoutReel,
Control ctrlRepere)
{
m_bMenuForCoutReel = bCoutReel;
foreach (ToolStripItem item in new ArrayList(menu.Items))
{
menu.Items.Remove(item);
item.Dispose();
}
if (utilisateur != null)
{
foreach (IElementACout elt in utilisateur.GetSourcesDeCout(bCoutReel))
{
ToolStripItem item = CreateItemSatisfaction(utilisateur, elt);
if (item != null)
{
menu.Items.Add(item);
}
}
if (menu.Items.Count > 0)
{
menu.Items.Add(new ToolStripSeparator());
}
ToolStripMenuItem itemSatisfaction = new ToolStripMenuItem();
double fCout = bCoutReel ? utilisateur.CoutReel : utilisateur.CoutPrevisionnel;
itemSatisfaction.Text = (menu.Items.Count > 0 ? "--->" : "") + fCout.ToString("0.####");
itemSatisfaction.Image = Resources.PuzzleMal20;
menu.Items.Add(itemSatisfaction);
bool bShouldAddSeparateur = true;
if (itemBesoin != null)
{
foreach (CItemBesoin childItem in itemBesoin.ChildItems)
{
if (childItem.Besoin.GetImputationsAFaireSurUtilisateursDeCout().GetCoutImputéeA(utilisateur, bCoutReel) == 0)
{
if (bShouldAddSeparateur)
{
menu.Items.Add(new ToolStripSeparator());
}
bShouldAddSeparateur = false;
ToolStripMenuItem item = new ToolStripMenuItem();
double fVal = bCoutReel ? childItem.CoutReel : childItem.CoutPrevisionnel;
item.Text = fVal.ToString("0.####") + " " + childItem.Besoin.Libelle;
item.Image = DynamicClassAttribute.GetImage(childItem.Besoin.GetType());
menu.Items.Add(item);
}
}
}
}
if (menu.Items.Count > 0)
{
menu.Show(ctrlRepere, new Point(0, ctrlRepere.Height));
}
}
protected override CResultAErreur MyInitChamps(CCustomizableListItem item)
{
m_bIsInitializing = true;
m_txtLibelle.TextAlign = HorizontalAlignment.Left;
CResultAErreur result = base.MyInitChamps(item);
m_btnDelete.Visible = m_extModeEdition.ModeEdition;
foreach (IEditeurDonneeBesoin editeur in m_dicEditeursEnCours.Values)
{
if (editeur != null)
{
((Control)editeur).Visible = false;
}
}
m_dicEditeursEnCours.Clear();
if (item != null && Besoin != null && Besoin.IsValide())
{
Color c = item.ColorInactive.Value;
c = Color.FromArgb((int)(c.R * 0.9), (int)(c.G * 0.9), (int)(c.B * 0.9));
m_panelFiletBas.BackColor = c;
m_panelFiletTop.BackColor = c;
m_panelFiletGauche.BackColor = c;
CItemBesoin itemBesoin = item as CItemBesoin;
CBesoin besoin = item.Tag as CBesoin;
if (besoin != null && !item.IsMasque)
{
UpdateMarge();
m_txtLibelle.Text = besoin.Libelle;
if (besoin.HasSatisfactions)
{
m_picBoxSatisfait.Image = Resources.puzzlePlein20;
}
else
{
m_picBoxSatisfait.Image = Resources.alerte;
}
if (!besoin.HasChildren)
{
m_iconPlusMoins.Image = null;
}
else
{
m_iconPlusMoins.Image = itemBesoin.IsCollapse ?
timos.Properties.Resources.miniplus :
timos.Properties.Resources.minimoins;
}
UpdateVisuInfo();
m_lblIndex.Text = item.Index.ToString().PadLeft(3, '0');
m_wndListeQuantites.Init(Besoin);
CBesoinQuantite[] qtesPossibles = besoin.QuantitesParentes;
if (qtesPossibles.Count() > 0)
{
m_panelRegroupement.Visible = true;
m_cmbRegroupement.Fill(qtesPossibles, "Libelle", true);
m_cmbRegroupement.SelectedValue = besoin.RegroupementQuantite;
}
else
{
m_panelRegroupement.Visible = false;
}
ModifContrôleCout();
UpdateVisibiliteCout();
CalcHeight();
if (IsCreatingImage)
{
m_wndListeQuantites.CurrentItemIndex = null;
m_controleQuantite.BringToFront();
}
else
{
m_wndListeQuantites.CurrentItemIndex = m_wndListeQuantites.CurrentItemIndex;
}
m_panelFiletTop.BackColor = CurrentItem.ColorInactive.Value;
m_ctrlSatisfaction.Init(besoin, !LockEdition);
}
}
m_bIsInitializing = false;
return(result);
}
//--------------------------------------------------
public CItemBesoin(CBesoin besoin, CItemBesoin itemParent)
: base(itemParent)
{
Tag = besoin;
}