//---------------------------------------------------------------
private void CalculeFils()
{
m_listeFils = new List <CDessinSatisfaction>();
ISatisfactionBesoinAvecSousBesoins satB = Satisfaction as ISatisfactionBesoinAvecSousBesoins;
if (satB != null)
{
foreach (CBesoin besoin in satB.GetSousBesoinsDeSatisfactionDirects())
{
if (!m_niveau.BaseSatisfactions.IsDejaIntegréee(besoin))
{
CDessinSatisfaction dessin = new CDessinSatisfaction(m_niveau, besoin);
dessin.m_dessinParent = this;
m_listeFils.Add(dessin);
m_niveau.AddSatisfactionVisible(dessin);
}
}
foreach (ISatisfactionBesoin sousSat in satB.GetSousSatisfactions())
{
if (!m_niveau.BaseSatisfactions.IsDejaIntegréee(sousSat))
{
CDessinSatisfaction dessin = new CDessinSatisfaction(m_niveau, sousSat);
dessin.m_dessinParent = this;
m_listeFils.Add(dessin);
m_niveau.AddSatisfactionVisible(dessin);
}
}
}
}
//---------------------------------------------------
public void AddSatisfactionVisible(CDessinSatisfaction dessin)
{
if (!m_listeDessinsVisibleDuNiveau.Contains(dessin))
{
m_listeDessinsVisibleDuNiveau.Add(dessin);
}
}
//---------------------------------------------------
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);
}
}
//-----------------------------------------------------
private void m_panelDessin_MouseUp(object sender, MouseEventArgs e)
{
m_panelDessin.Capture = false;
m_panelDessin.Cursor = Cursors.Arrow;
m_ptStartScroll = null;
if (e.Button == MouseButtons.Right && !m_bHasScroll)
{
DoSelection(new Point(e.X, e.Y), true);
if (m_satisfactionSel != null)
{
m_menuSatisfaction.Show(m_panelDessin, new Point(e.X, e.Y));
}
else if (m_lienSel != null)
{
ContextMenuStrip strip = new ContextMenuStrip();
double fPct = CUtilSatisfaction.GetPourcentageFor(m_lienSel.Besoin, m_lienSel.Satisfaction);
CToolStripPourcentage toolStripPourcentage = new CToolStripPourcentage(fPct);
toolStripPourcentage.OnValideSaisie += new EventHandler(toolStripPourcentage_OnValideSaisie);
toolStripPourcentage.Tag = m_lienSel;
strip.Items.Add(toolStripPourcentage);
strip.Show(this, new Point(e.X, e.Y));
}
}
if (m_satisfactionSel != null)
{
CDessinSatisfaction dessin = m_baseMap.GetDessin(m_satisfactionSel);
{
Point pt = PointToLogical(new Point(e.X, e.Y));
dessin.OnMouseUp(this, pt);
}
}
Cursor = Cursors.Arrow;
}
//-----------------------------------------------------
private ISatisfactionBesoin GetSatisfactionFromDisplay(Point ptDisplay)
{
CDessinSatisfaction info = GetDessinSatisfactionFromDisplay(ptDisplay);
if (info != null)
{
return(info.Satisfaction);
}
return(null);
}
//---------------------------------------------------
public void RecalculePrecedents(CNiveauMapSatisfaction niveau)
{
//Récupère le niveau précédent
CNiveauMapSatisfaction niveauPrec = null;
foreach (CNiveauMapSatisfaction niveauAutre in m_listeNiveaux)
{
if (niveauAutre.NiveauSatisfaction == niveau.NiveauSatisfaction - 1)
{
niveauPrec = niveauAutre;
break;
}
}
if (niveauPrec == null)
{
//Création du niveau précédent
niveauPrec = new CNiveauMapSatisfaction(this, niveau.NiveauSatisfaction - 1);
m_listeNiveaux.Insert(0, niveauPrec);
}
HashSet <CDessinSatisfaction> dessinsRacinesToRemove = new HashSet <CDessinSatisfaction>();
foreach (CDessinSatisfaction dessin in niveauPrec.Dessins)
{
if (dessin.DessinParent == null)
{
dessinsRacinesToRemove.Add(dessin);
}
}
foreach (CDessinSatisfaction dessin in niveau.Dessins)
{
foreach (CRelationBesoin_Satisfaction rel in dessin.Satisfaction.RelationsSatisfaits)
{
CDessinSatisfaction dessinBesoin = GetDessin(rel.Besoin);
if (dessinBesoin == null)
{
dessinBesoin = new CDessinSatisfaction(niveauPrec, rel.Besoin);
niveauPrec.AddSatisfactionVisible(dessinBesoin);
}
dessinsRacinesToRemove.Remove(dessinBesoin);
}
}
//retire les besoins racine qui doivent virer
foreach (CDessinSatisfaction dessin in dessinsRacinesToRemove)
{
niveauPrec.RemoveDessinPourToujours(dessin);
}
if (niveauPrec.Dessins.Count() > 0)
{
RecalculePrecedents(niveauPrec);
}
}
//---------------------------------------------------
public void RemoveSatisfactionVisible(CDessinSatisfaction dessin)
{
if (m_listeDessinsVisibleDuNiveau.Contains(dessin))
{
foreach (CDessinSatisfaction dessinFils in dessin.DessinsFils)
{
RemoveSatisfactionVisible(dessinFils);
}
m_listeDessinsVisibleDuNiveau.Remove(dessin);
}
}
//-----------------------------------------------------------------
private void AddDessinADessinerAvecFils(CDessinSatisfaction dessin, List <CDessinSatisfaction> lstDessins)
{
lstDessins.Add(dessin);
foreach (CDessinSatisfaction fils in dessin.DessinsFils)
{
if (fils.IsVisible() && fils.IsPositionValide())
{
AddDessinADessinerAvecFils(fils, lstDessins);
}
}
}
//---------------------------------------------------
public CDessinSatisfaction GetDessin(ISatisfactionBesoin satisfaction)
{
CDessinSatisfaction de = null;
if (satisfaction == null)
{
return(null);
}
m_dicSatisfactionToDessin.TryGetValue(satisfaction, out de);
return(de);
}
//---------------------------------------------------
public CDessinSatisfaction GetDessinAt(Point pt)
{
CDessinSatisfaction dessinTrouve = null;
foreach (CDessinSatisfaction dessin in m_dicSatisfactionToDessin.Values)
{
if (dessin.IsVisible() && dessin.Rectangle.Contains(pt) && (dessinTrouve == null || dessinTrouve.Rectangle.Height > dessin.Rectangle.Height))
{
dessinTrouve = dessin;
}
}
return(dessinTrouve);
}
//------------------------------------------------------------------------------
private void m_menuSatisfaction_Opening(object sender, CancelEventArgs e)
{
m_menuAfficherPhase.Visible = m_satisfactionSel != null && m_satisfactionSel is CBesoin;
if (m_satisfactionSel != null)
{
CDessinSatisfaction dessin = m_baseMap.GetDessin(m_satisfactionSel);
CPhaseSpecifications phase = m_satisfactionSel as CPhaseSpecifications;
m_menuAfficherProjet.Visible = dessin != null && phase != null && phase.Projet != null && dessin.DessinParent == null;
}
m_menuMasquerProjet.Visible = false;
/*m_menuDetaillerSatisfaction.Visible = m_satisfactionSel is ISatisfactionBesoinAvecSousBesoins && m_satisfactionSel != m_satisfactionRacine;
* m_menuDetaillerSatisfaction.Checked = m_satisfactionSel != null && m_setSatisfactionsExpanded.Contains(m_satisfactionSel);*/
}
//---------------------------------------------------------------
public override bool Equals(object obj)
{
CDessinSatisfaction autre = obj as CDessinSatisfaction;
if (autre == null)
{
return(false);
}
if (autre.Satisfaction != null)
{
return(autre.Satisfaction.Equals(Satisfaction));
}
return(false);
}
//-----------------------------------------------------
private void Invalidate(ISatisfactionBesoin satisfaction)
{
if (satisfaction != null)
{
CDessinSatisfaction dessin = m_baseMap.GetDessin(satisfaction);
if (dessin != null)
{
Rectangle r = new Rectangle(PointToDisplay(new Point(dessin.Rectangle.Left - 5, dessin.Rectangle.Top - 5)),
new Size(SizeToDisplay(dessin.Rectangle.Width + 11), SizeToDisplay(dessin.Rectangle.Height + 11)));
r.Inflate(2, 2);
m_panelDessin.Invalidate(r);
}
}
}
//---------------------------------------------------
public void RemoveDessinPourToujours(CDessinSatisfaction dessin)
{
if (m_nNiveauSatisfaction != 0)//On n'enlève jamais au niveau 0, car c'est le seul
//Niveau qui n'est pas calculé
{
if (m_listeDessinsVisibleDuNiveau.Contains(dessin))
{
foreach (CDessinSatisfaction dessinFils in dessin.DessinsFils)
{
RemoveDessinPourToujours(dessinFils);
}
}
m_listeDessinsVisibleDuNiveau.Remove(dessin);
m_baseSatsifactions.UnregisterSatisfaction(dessin.Satisfaction);
}
}
//------------------------------------------------------
public void Init(ISatisfactionBesoin satisfaction)
{
m_satisfactionRacine = satisfaction;
List <ISatisfactionBesoin> lst = new List <ISatisfactionBesoin>();
lst.Add(satisfaction);
m_baseMap.Init(lst);
m_satisfactionSel = null;
m_lienSel = null;
CDessinSatisfaction dessin = m_baseMap.GetDessin(satisfaction);
if (dessin != null)
{
dessin.Expand();
}
}
//---------------------------------------------------
public void Init(List <ISatisfactionBesoin> lstSatisfactions)
{
m_dicSatisfactionToDessin = new Dictionary <ISatisfactionBesoin, CDessinSatisfaction>();
m_listeNiveaux = new List <CNiveauMapSatisfaction>();
//Création du niveau 0
CNiveauMapSatisfaction niveau = new CNiveauMapSatisfaction(this, 0);
m_listeNiveaux.Add(niveau);
foreach (ISatisfactionBesoin satisfaction in lstSatisfactions)
{
if (!IsDejaIntegréee(satisfaction))
{
CDessinSatisfaction dessin = new CDessinSatisfaction(niveau, satisfaction);
niveau.AddSatisfactionVisible(dessin);
}
}
RecalculePrecedents(niveau);
RecalculeSuivants(niveau);
}
//-----------------------------------------------------
private CSegmentDroite DrawLien(
Graphics g,
ISatisfactionBesoin besoinSatisfait,
ISatisfactionBesoin satisfaction,
Pen p)
{
if (besoinSatisfait == null || satisfaction == null)
{
return(null);
}
CDessinSatisfaction dessin1 = m_baseMap.GetDessin(besoinSatisfait);
CDessinSatisfaction dessin2 = m_baseMap.GetDessin(satisfaction);
CSegmentDroite segment = null;
if (dessin1 != null && dessin2 != null)
{
segment = new CSegmentDroite(new Point(dessin1.Rectangle.Right, dessin1.Rectangle.Top + m_baseMap.m_nHauteurSatisfactionDefaut / 2),
new Point(dessin2.Rectangle.Left, dessin2.Rectangle.Top + m_baseMap.m_nHauteurSatisfactionDefaut / 2));
g.DrawLine(p, segment.Point1, segment.Point2);
segment.DrawFlechePt1(g, p, 4);
CBesoin besoin = besoinSatisfait as CBesoin;
if (besoin != null)
{
double fCpt = CUtilSatisfaction.GetPourcentageFor(besoin, satisfaction);
if (fCpt < 99)
{
Point pt = segment.Milieu;
string strChaine = fCpt.ToString("0.##") + "%";
SizeF sz = g.MeasureString(strChaine, Font);
pt.Offset(-(int)(sz.Width / 2), -(int)(sz.Height / 2));
Rectangle rct = new Rectangle(pt, new Size((int)sz.Width, (int)sz.Height));
Brush br = new SolidBrush(Color.FromArgb(128, Color.White));
g.FillRectangle(br, rct);
br.Dispose();
g.DrawString(strChaine, Font, Brushes.Black, pt);
}
}
}
return(segment);
}
private void m_panelDessin_MouseMove(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right && m_ptStartScroll != null)
{
Point ptEcart = new Point(m_ptStartScroll.Value.X - e.X,
m_ptStartScroll.Value.Y - e.Y);
Point pt = new Point(-m_panelDessin.AutoScrollPosition.X, -m_panelDessin.AutoScrollPosition.Y);
pt.Offset(ptEcart);
m_bHasScroll = true;
m_ptStartScroll = new Point(e.X, e.Y);
m_panelDessin.AutoScrollPosition = pt;
m_panelDessin.Invalidate();
}
if (e.Button == MouseButtons.Left && m_ptStartDrag != null && m_satisfactionSel != null)
{
if (Math.Abs(m_ptStartDrag.Value.X - e.X) > 3 ||
Math.Abs(m_ptStartDrag.Value.Y - e.Y) > 3)
{
CObjetDonnee objet = m_satisfactionSel as CObjetDonnee;
if (objet != null)
{
DoDragDrop(new CReferenceObjetDonneeDragDropData(objet), DragDropEffects.Link | DragDropEffects.Copy);
}
}
}
if (e.Button == MouseButtons.None)
{
Point pt = new Point(e.X, e.Y);
pt = PointToLogical(pt);
CDessinSatisfaction info = GetDessinSatisfactionFromLogical(pt);
if (info != null)
{
info.OnMouseMove(this, pt);
}
}
}
//---------------------------------------------------
public void RegisterDessin(CDessinSatisfaction dessin)
{
m_dicSatisfactionToDessin[dessin.Satisfaction] = dessin;
}
//---------------------------------------------------------------
//Retourne la position de fin de l'élément
internal int CalculeDessin(int nX, int nYTop)
{
bool bMargeOnNext = false;
int nNextY = nYTop;
int nYTopItem = nYTop;
List <CDessinSatisfaction> lstSatisfactionsDeThis = new List <CDessinSatisfaction>();
CBesoin besoin = Satisfaction as CBesoin;
if (besoin != null)
{
foreach (CRelationBesoin_Satisfaction sat in besoin.RelationsSatisfactions)
{
CDessinSatisfaction dessinSatisfaction = Niveau.BaseSatisfactions.GetDessin(sat.Satisfaction);
if (dessinSatisfaction != null && !dessinSatisfaction.IsPositionValide() &&
dessinSatisfaction.IsVisible())
{
lstSatisfactionsDeThis.Add(dessinSatisfaction);
}
}
}
for (int nSatisfactionDeThis = 0; nSatisfactionDeThis < lstSatisfactionsDeThis.Count; nSatisfactionDeThis++)
{
CDessinSatisfaction satisfactionDeThis = lstSatisfactionsDeThis[nSatisfactionDeThis];
if (!satisfactionDeThis.IsPositionValide())
{
if (bMargeOnNext)
{
nNextY += Niveau.BaseSatisfactions.m_nMargeVerticale;
}
nNextY = satisfactionDeThis.CalculeDessin(nX, nNextY);
if (satisfactionDeThis.Niveau == Niveau)
{
nYTopItem = nNextY;
}
bMargeOnNext = true;
}
}
int nHauteurTotale = Math.Max(Niveau.BaseSatisfactions.m_nHauteurSatisfactionDefaut, nNextY - nYTop);
Rectangle rct = new Rectangle(nX, nYTopItem + nHauteurTotale / 2 - Niveau.BaseSatisfactions.m_nMargeVerticale,
Niveau.BaseSatisfactions.m_nLargeurNiveauDefaut,
Niveau.BaseSatisfactions.m_nHauteurSatisfactionDefaut);
int nYMax = nYTopItem + nHauteurTotale;
int nYMin = rct.Top;
if (m_bIsExpanded)
{
if (m_listeFils != null)
{
foreach (CDessinSatisfaction dessin in m_listeFils)
{
if (!dessin.IsPositionValide())
{
nYMax = Math.Max(dessin.CalculeDessin(nX, nYMax), nYMax);
}
else
{
nYMin = Math.Min(dessin.Rectangle.Top, nYMin);
}
}
}
rct.Offset(Niveau.BaseSatisfactions.m_nOffestNiveau / 3, 0);
}
if (nYMin < rct.Top)
{
//Un des fils est plus Haut->monte au dessus du fils
foreach (CDessinSatisfaction dessin in Niveau.Dessins)
{
if (dessin.IsPositionValide() && dessin.IsVisible() && dessin.Rectangle.Top >= nYMin)
{
dessin.Offset(0, Niveau.BaseSatisfactions.m_nHauteurSatisfactionDefaut);
}
}
rct.Offset(0, nYMin - rct.Top);
}
CDessinSatisfaction parent = DessinParent;
if (m_bIsExpanded)
{
rct.Height = nYMax - rct.Top;
}
m_nBasZoneOccupee = nYMax;
Rectangle = rct;
nNextY = Math.Max(nNextY, nYMax);
return(nNextY);
}