//------------------------------------------------------
private void CalculeEnglobants(CNiveau niveau)
{
int nIndex = 0;
int nMaxWidth = 0;
while (nIndex < niveau.Satisfactions.Count())
{
Rectangle rct = CalculeEnglobants(niveau, ref nIndex, 0);
nMaxWidth = Math.Max(nMaxWidth, rct.Width);
}
int nOffset = nMaxWidth - m_nLargeurNiveauDefaut;
if (nOffset > 0)
{
foreach (CNiveau autreNiveau in m_listeNiveaux)
{
if (autreNiveau.Niveau > niveau.Niveau)
{
foreach (ISatisfactionBesoin sat in autreNiveau.Satisfactions)
{
CInfoDessinSatisfaction dessin = null;
m_dicSatisfactionToRect.TryGetValue(sat, out dessin);
dessin.Offset(nOffset, 0);
}
}
}
}
}
//------------------------------------------------------
private void Init(IEnumerable <ISatisfactionBesoin> lstSatisfactions)
{
m_listeNiveaux.Clear();
m_setSatisfactionsIntegrés.Clear();
CNiveau niveau = new CNiveau(0);
foreach (ISatisfactionBesoin sat in lstSatisfactions)
{
niveau.AddSatisfaction(this, sat);
}
m_listeNiveaux.Add(niveau);
CNiveau niveau0 = niveau;
while (niveau.Satisfactions.Count() != 0)
{
niveau = CalculeNiveauSuivant();
}
niveau = niveau0;
while (niveau.Satisfactions.Count() != 0)
{
niveau = CalculeNiveauPrecedent();
}
CalculeRectangles();
m_satisfactionSel = null;
m_lienSel = null;
}
//------------------------------------------------------
private Rectangle CalculeEnglobants(CNiveau niveau, ref int nIndexNext, int nIndexHierarchique)
{
ISatisfactionBesoin satisfaction = niveau.Satisfactions.ElementAt(nIndexNext);
CInfoDessinSatisfaction dessin = null;
m_dicSatisfactionToRect.TryGetValue(satisfaction, out dessin);
Rectangle rctRetour = dessin.Rectangle;
nIndexNext++;
HashSet <ISatisfactionBesoin> besoinsFils = new HashSet <ISatisfactionBesoin>();
int nIndexStartFils = nIndexNext;
ISatisfactionBesoinAvecSousBesoins satB = satisfaction as ISatisfactionBesoinAvecSousBesoins;
if (satB != null && m_setSatisfactionsExpanded.Contains(satB))
{
foreach (CBesoin besoin in satB.GetSousBesoinsDeSatisfaction())
{
besoinsFils.Add(besoin);
}
}
else if (satisfaction is CBesoin)
{
foreach (CBesoin besoin in ((CBesoin)satisfaction).BesoinsFils)
{
besoinsFils.Add(besoin);
}
}
if (besoinsFils.Count > 0)
{
while (nIndexNext < niveau.Satisfactions.Count() &&
besoinsFils.Contains(niveau.Satisfactions.ElementAt(nIndexNext)))
{
Rectangle rctFils = CalculeEnglobants(niveau, ref nIndexNext, nIndexHierarchique + 1);
rctRetour = Rectangle.Union(rctRetour, rctFils);
}
for (int nFils = nIndexStartFils; nFils < nIndexNext; nFils++)
{
ISatisfactionBesoin satFils = niveau.Satisfactions.ElementAt(nFils);
CInfoDessinSatisfaction dessinFils = null;
m_dicSatisfactionToRect.TryGetValue(satFils, out dessinFils);
dessinFils.Offset(m_nOffestNiveau, 0);
}
rctRetour.Width += m_nOffestNiveau;
dessin.Rectangle = new Rectangle(rctRetour.Left + m_nOffestNiveau / 3, rctRetour.Top, m_nLargeurNiveauDefaut, rctRetour.Height + 4);
}
dessin.NiveauHierarchique = nIndexHierarchique;
return(rctRetour);
}
//------------------------------------------------------
private CNiveau CalculeNiveauPrecedent()
{
CNiveau niveauPrec = m_listeNiveaux[0];
CNiveau niveau = new CNiveau(niveauPrec.Niveau - 1);
foreach (ISatisfactionBesoin satisfaction in niveauPrec.Satisfactions)
{
foreach (CRelationBesoin_Satisfaction rel in satisfaction.RelationsSatisfaits)
{
if (!m_setSatisfactionsIntegrés.Contains(rel.Besoin))
{
niveau.AddSatisfaction(this, rel.Besoin);
}
}
}
m_listeNiveaux.Insert(0, niveau);
return(niveau);
}
//------------------------------------------------------
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);
}
private void m_panelDessin_Paint(object sender, PaintEventArgs e)
{
Matrix m = new Matrix();
e.Graphics.FillRectangle(Brushes.White, e.ClipRectangle);
PrepareGraphic(e.Graphics);
int nX0 = PointToLogical(new Point(0, 0)).X;
int nIndexNiveauStart = (nX0) / (m_nLargeurNiveauDefaut + m_nLargeurFleches);
if (nX0 < 0)
{
nIndexNiveauStart--;
}
int nNbNiveauxVisibles = SizeToLogical(m_panelDessin.Width) / (m_nLargeurNiveauDefaut + m_nLargeurFleches) + 2;
List <ISatisfactionBesoin> satisfactionsDessines = new List <ISatisfactionBesoin>();
if (nIndexNiveauStart < 0)
{
nIndexNiveauStart = 0;
}
for (int nIndexNiveau = nIndexNiveauStart; nIndexNiveau <= nIndexNiveauStart + nNbNiveauxVisibles &&
nIndexNiveau < m_listeNiveaux.Count; nIndexNiveau++)
{
CNiveau niveau = m_listeNiveaux[nIndexNiveau];
int nNiveau = niveau.Niveau;
Color couleurNiveau = Color.LightGreen;
if (nNiveau > 0)
{
couleurNiveau = Color.White;
}
else if (nNiveau < 0)
{
couleurNiveau = Color.LightBlue;
}
foreach (ISatisfactionBesoin satisfaction in niveau.Satisfactions)
{
CInfoDessinSatisfaction dessin = null;
if (m_dicSatisfactionToRect.TryGetValue(satisfaction, out dessin))
{
Point pt = PointToDisplay(new Point(dessin.Rectangle.Left, dessin.Rectangle.Bottom));
if (pt.Y > 0)
{
pt = PointToDisplay(new Point(dessin.Rectangle.Left, dessin.Rectangle.Top));
if (pt.Y < m_panelDessin.Height)
{
bool bSel = dessin.Satisfaction.Equals(m_satisfactionSel);
dessin.Draw(this, couleurNiveau, bSel, e.Graphics);
satisfactionsDessines.Add(satisfaction);
}
}
}
}
}
//Trace les lignes
HashSet <CRelationBesoin_Satisfaction> liensDessines = new HashSet <CRelationBesoin_Satisfaction>();
Pen p = new Pen(Color.Black);
Pen pSel = new Pen(Color.Yellow, 2);
//p.EndCap = LineCap.ArrowAnchor;
m_dicSatisfactionToSegment.Clear();
foreach (ISatisfactionBesoin satDessinee in satisfactionsDessines)
{
CBesoin besoin = satDessinee as CBesoin;
if (besoin != null)
{
foreach (CRelationBesoin_Satisfaction rel in besoin.RelationsSatisfactions)
{
if (!liensDessines.Contains(rel))
{
CSegmentDroite segment = DrawLien(
e.Graphics,
rel.Besoin,
rel.Satisfaction,
rel == m_lienSel ? pSel : p);
liensDessines.Add(rel);
if (segment != null)
{
m_dicSatisfactionToSegment[rel] = segment;
}
}
}
}
foreach (CRelationBesoin_Satisfaction rel in satDessinee.RelationsSatisfaits)
{
if (!liensDessines.Contains(rel))
{
CSegmentDroite segment = DrawLien(
e.Graphics,
rel.Besoin,
rel.Satisfaction,
rel == m_lienSel ? pSel : p);
liensDessines.Add(rel);
if (segment != null)
{
m_dicSatisfactionToSegment[rel] = segment;
}
}
}
}
pSel.Dispose();
p.Dispose();
e.Graphics.ResetTransform();
}
//------------------------------------------------------
private void CalculeRectangles()
{
m_dicSatisfactionToRect.Clear();
for (int nIndex = 1; nIndex < m_listeNiveaux.Count; nIndex++)
{
int nYTop = 0;
/*
* while (nIndex < m_listeNiveaux.Count && m_listeNiveaux[nIndex].Satisfactions.Count() == 0 )
* nIndex++;*/
if (nIndex < m_listeNiveaux.Count)
{
int nWidthNiveau = 0;
//trouve le dernier élément de ce niveau
CNiveau niveau = m_listeNiveaux[nIndex];
foreach (ISatisfactionBesoin satisfaction in niveau.Satisfactions)
{
CInfoDessinSatisfaction dessin = null;
if (m_dicSatisfactionToRect.TryGetValue(satisfaction, out dessin))
{
if (dessin != null)
{
nYTop = dessin.Rectangle.Bottom + m_nMargeVerticale;
nWidthNiveau = Math.Max(dessin.Rectangle.Width, nWidthNiveau);
}
}
}
foreach (ISatisfactionBesoin satisfaction in niveau.Satisfactions)
{
if (!m_dicSatisfactionToRect.ContainsKey(satisfaction))
{
nYTop = CalculeRectangles(satisfaction, nIndex - 1, nYTop);
nYTop += m_nMargeVerticale;
}
}
}
}
//Calcule tous les englobants = remplace les rectangles simples par des rectangles englobant
//les fils qui suivent
foreach (CNiveau niveaux in m_listeNiveaux)
{
CalculeEnglobants(niveaux);
}
int?nMinX = null;
int?nMinY = null;
int?nMaxX = null;
int?nMaxY = null;
foreach (CInfoDessinSatisfaction dessin in m_dicSatisfactionToRect.Values)
{
if (dessin != null)
{
if (nMinX == null || nMinX.Value > dessin.Rectangle.Left)
{
nMinX = dessin.Rectangle.Left;
}
if (nMinY == null || nMinY.Value > dessin.Rectangle.Top)
{
nMinY = dessin.Rectangle.Top;
}
if (nMaxX == null || nMaxX.Value < dessin.Rectangle.Right)
{
nMaxX = dessin.Rectangle.Right;
}
if (nMaxY == null || nMaxY.Value < dessin.Rectangle.Bottom)
{
nMaxY = dessin.Rectangle.Bottom;
}
}
}
if (nMinX == null || nMaxX == null || nMinY == null || nMaxY == null)
{
return;
}
//Offset de tous les rectangles
Point ptOffset = new Point(-nMinX.Value, -nMinY.Value);
foreach (KeyValuePair <ISatisfactionBesoin, CInfoDessinSatisfaction> kv in m_dicSatisfactionToRect)
{
if (kv.Value != null)
{
kv.Value.Offset(ptOffset.X, ptOffset.Y);
}
}
CalcScrollSizes();
}
