//-----------------------------------------------------
private CSegmentDroite DrawLien(
Graphics g,
ISatisfactionBesoin besoinSatisfait,
ISatisfactionBesoin satisfaction,
Pen p)
{
if (besoinSatisfait == null || satisfaction == null)
{
return(null);
}
CInfoDessinSatisfaction dessin1 = null;
CInfoDessinSatisfaction dessin2 = null;
m_dicSatisfactionToRect.TryGetValue(besoinSatisfait, out dessin1);
m_dicSatisfactionToRect.TryGetValue(satisfaction, out dessin2);
CSegmentDroite segment = null;
if (dessin1 != null && dessin2 != null)
{
segment = new CSegmentDroite(new Point(dessin1.Rectangle.Right, dessin1.Rectangle.Top + m_nHauteurSatisfactionDefaut / 2),
new Point(dessin2.Rectangle.Left, dessin2.Rectangle.Top + m_nHauteurSatisfactionDefaut / 2));
g.DrawLine(p, segment.Point1, segment.Point2);
segment.DrawFlechePt1(g, p, 4);
}
return(segment);
}
//------------------------------------------------------
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 ISatisfactionBesoin GetSatisfactionFromDisplay(Point ptDisplay)
{
CInfoDessinSatisfaction info = GetInfoFromDisplay(ptDisplay);
if (info != null)
{
return(info.Satisfaction);
}
return(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 void Invalidate(ISatisfactionBesoin satisfaction)
{
if (satisfaction != null)
{
CInfoDessinSatisfaction dessin = null;
m_dicSatisfactionToRect.TryGetValue(satisfaction, out dessin);
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);
}
}
}
//-----------------------------------------------------
private CInfoDessinSatisfaction GetInfoFromLogical(Point ptLogique)
{
CInfoDessinSatisfaction infoSel = null;
foreach (KeyValuePair <ISatisfactionBesoin, CInfoDessinSatisfaction> kv in m_dicSatisfactionToRect)
{
if (kv.Value != null && kv.Value.Rectangle.Contains(ptLogique))
{
if (infoSel == null || infoSel.Rectangle.Height > kv.Value.Rectangle.Height)
{
infoSel = kv.Value;
}
}
}
return(infoSel);
}
//------------------------------------------------------
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 CenterOn(ISatisfactionBesoin satisfaction)
{
CInfoDessinSatisfaction dessin = null;
if (m_dicSatisfactionToRect.TryGetValue(satisfaction, out dessin))
{
if (dessin != null)
{
Point ptCentre = new Point(dessin.Rectangle.Left + dessin.Rectangle.Width / 2,
dessin.Rectangle.Top + dessin.Rectangle.Height / 2);
ptCentre = PointToDisplay(ptCentre);
//Calcule la position des scrollBars pour être centré sur cet élément
ptCentre.Offset(-m_panelDessin.Width / 2, -m_panelDessin.Height / 2);
m_panelDessin.AutoScrollPosition = new Point(ptCentre.X, ptCentre.Y);
Refresh();
}
}
}
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);
CInfoDessinSatisfaction info = GetInfoFromLogical(pt);
if (info != null)
{
info.OnMouseMove(this, info.PointToClient(pt));
}
}
}
//-----------------------------------------------------
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));
}
}
if (m_satisfactionSel != null)
{
CInfoDessinSatisfaction info = null;
if (m_dicSatisfactionToRect.TryGetValue(m_satisfactionSel, out info))
{
Point pt = info.PointToClient(PointToLogical(new Point(e.X, e.Y)));
info.OnMouseUp(this, pt);
}
}
Cursor = Cursors.Arrow;
}
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();
}
