//------------------------------------------------------------------------------------------
public override I2iObjetGraphique GetCloneAMettreDansParent(I2iObjetGraphique parent, Dictionary <Type, object> dicObjetsPourCloner)
{
C2iObjetDeSchema parentAsC2iObjet = parent as C2iObjetDeSchema;
if (m_elementAssocie != null && parentAsC2iObjet != null && parentAsC2iObjet.SchemaContenant != null)
{
IElementDeSchemaReseau eltDeSchema = (IElementDeSchemaReseau)m_elementAssocie.GetObjet(parentAsC2iObjet.SchemaContenant.ContexteDonnee);
CElementDeSchemaReseau newElement = new CElementDeSchemaReseau(eltDeSchema.ContexteDonnee);
newElement.CreateNewInCurrentContexte();
newElement.ElementAssocie = eltDeSchema;
newElement.SchemaReseau = parentAsC2iObjet.SchemaContenant;
if (!m_bSizeIsSet)
{
C2iSymbole symbole = eltDeSchema.SymboleADessiner;
if (symbole != null)
{
Size = symbole.Size;
m_bSizeIsSet = true;
}
}
newElement.Width = Size.Width;
newElement.Height = Size.Height;
C2iObjetDeSchema obj = eltDeSchema.GetObjetDeSchema(newElement);
return(obj);
}
return(null);
}
protected override void MyDraw(CContextDessinObjetGraphique ctx)
{
if (LienReseau == null)
{
return;
}
if (LienReseau.SchemaReseau == null)
{
return;
}
ForeColor = Color.Cyan;
LineWidth = 2;
//Trouve l'objet de schéma associé à elt 1 et à elt2
C2iObjetDeSchema objet1 = null;
C2iObjetDeSchema objet2 = null;
IElementALiensReseau elt1 = LienReseau.Element1;
IElementALiensReseau elt2 = LienReseau.Element2;
bool bTmp = false;
objet1 = GetObjetElement(elt1, ref bTmp);
objet2 = GetObjetElement(elt2, ref bTmp);
if (objet1 == null || objet2 == null)
{
return;
}
//on interdit de supprimer les éléments à l'extrémité du lien
objet1.SetNoDelete(true);
objet2.SetNoDelete(true);
//calcul des extrémités du lien
Point pt1 = new Point(objet1.Position.X + objet1.Size.Width / 2,
objet1.Position.Y + objet1.Size.Height / 2);
Point pt2 = new Point(objet2.Position.X + objet2.Size.Width / 2,
objet2.Position.Y + objet2.Size.Height / 2);
Position = new Point(Math.Min(pt1.X, pt2.X), Math.Min(pt1.Y, pt2.Y));
Size = new Size(Math.Abs(pt2.X - pt1.X), Math.Abs(pt2.Y - pt1.Y));
//dessin du lien
Pen pen = new Pen(ForeColor, LineWidth);
ctx.Graphic.DrawLine(pen, pt1, pt2);
DrawFleches(ctx, pen, null, pt1, pt2, LienReseau.Direction);
pen.Dispose();
}
//---------------------------------------------------
public override void BringToFront(I2iObjetGraphique child)
{
C2iObjetDeSchema obj = child as C2iObjetDeSchema;
if (m_listeSousObjets.Contains(obj))
{
m_listeSousObjets.Remove(obj);
m_listeSousObjets.Add(obj);
}
}
//---------------------------------------------------
public override void FrontToBack(I2iObjetGraphique child)
{
C2iObjetDeSchema obj = child as C2iObjetDeSchema;
if (m_listeSousObjets.Contains(obj))
{
m_listeSousObjets.Remove(obj);
m_listeSousObjets.Insert(0, obj);
}
}
//---------------------------------------------------
public void ClearDrawingCache()
{
foreach (I2iObjetGraphique objet in Childs)
{
C2iObjetDeSchema o = objet as C2iObjetDeSchema;
if (o != null)
{
o.ClearDrawingCache();
}
}
}
//---------------------------------------------------
public override bool AddChild(I2iObjetGraphique child)
{
C2iObjetDeSchema obj = child as C2iObjetDeSchema;
if (obj != null && !m_listeSousObjets.Contains(obj))
{
m_listeSousObjets.Add(obj);
obj.IdObjetDeSchema = AlloueNextIdObjet();
return(true);
}
return(false);
}
public void InitFrom(C2iObjetDeSchema objet)
{
if (objet.ElementDeSchema != null)
{
if (objet.ElementDeSchema.ElementAssocie != null)
{
m_elementAssocie = new CReferenceObjetDonnee((CObjetDonnee)objet.ElementDeSchema.ElementAssocie);
}
Size = objet.Size;
m_bSizeIsSet = true;
}
}
public C2iObjetDeSchema GetObjetFromPoint(Point pt)
{
foreach (I2iObjetGraphique child in Childs)
{
C2iObjetDeSchema objet = child as C2iObjetDeSchema;
if ((objet != null) && (child.RectangleAbsolu.Contains(pt.X, pt.Y)))
{
return(objet);
}
}
return(null);
}
/// <summary>
/// Crée l'objet correspondant à l'une des extremités du lien
/// </summary>
private C2iObjetDeSchema CreateObjetFor(IElementDeSchemaReseau elementACreer)
{
CElementDeSchemaReseau eltDeSchema = new CElementDeSchemaReseau(ElementDeSchema.ContexteDonnee);
eltDeSchema.CreateNewInCurrentContexte();
eltDeSchema.SchemaReseau = ElementDeSchema.SchemaReseau;
eltDeSchema.ElementAssocie = elementACreer;
C2iObjetDeSchema objetDeSchema = eltDeSchema.ObjetDeSchema;
Parent.AddChild(objetDeSchema);
objetDeSchema.Parent = Parent;
return(objetDeSchema);
}
public C2iObjetDeSchema GetChildFromId(int id)
{
foreach (I2iObjetGraphique child in Childs)
{
C2iObjetDeSchema objet = child as C2iObjetDeSchema;
if (objet != null)
{
if (objet.IdObjetDeSchema == id)
{
return(objet);
}
}
}
return(null);
}
//---------------------------------------------------
public void ClearDrawingCache()
{
if (m_imageCache != null)
{
m_imageCache.Dispose();
}
m_imageCache = null;
foreach (I2iObjetGraphique objet in Childs)
{
C2iObjetDeSchema o = objet as C2iObjetDeSchema;
if (o != null)
{
o.ClearDrawingCache();
}
}
}
/// ////////////////////////////////////////////////////////
public override I2iObjetGraphique GetCloneAMettreDansParent(I2iObjetGraphique parent, Dictionary <Type, object> dicObjetsPourCloner)
{
C2iObjetDeSchema objet = (C2iObjetDeSchema)base.GetCloneAMettreDansParent(parent, dicObjetsPourCloner);
C2iObjetDeSchema parentAsC2iObjet = parent as C2iObjetDeSchema;
if (ElementDeSchema != null && parentAsC2iObjet != null && parentAsC2iObjet.SchemaContenant != null)
{
CElementDeSchemaReseau newElement = new CElementDeSchemaReseau(parentAsC2iObjet.SchemaContenant.ContexteDonnee);
newElement.CreateNewInCurrentContexte();
newElement.ElementAssocie = ElementDeSchema.ElementAssocie;
newElement.SchemaReseau = parentAsC2iObjet.SchemaContenant;
newElement.Width = Size.Width;
newElement.Height = Size.Height;
objet.ElementDeSchema = newElement;
}
return(objet);
}
public void ArrangerLien(C2iLienDeSchemaReseau lien)
{
if (lien.Points.Length != 2)
{
return;
}
C2iObjetDeSchema parent = lien.Parent as C2iObjetDeSchema;
if (parent == null)
{
return;
}
foreach (C2iObjetDeSchema objetDeSchema in parent.Childs)
{
C2iLienDeSchemaReseau lien2 = objetDeSchema as C2iLienDeSchemaReseau;
if (lien2 != null && lien2 != lien && lien2.Points.Length == 2 &&
lien2.PositionAbsolue == lien.PositionAbsolue &&
lien2.Size == lien.Size)
{
//Les deux liens se chevauchent : Ajoute un point intermédiaire
Point ptMilieu = new Point((lien.Points[0].X + lien.Points[1].X) / 2,
(lien.Points[0].Y + lien.Points[1].Y) / 2);
if (lien.Points[0].Y == lien.Points[1].Y)
{
ptMilieu.Offset(00, 20);
}
else
{
double fPente = -((lien.Points[0].X - lien.Points[1].X) / (lien.Points[0].Y - lien.Points[1].Y));
double fX = 20 / (Math.Sqrt(1 + fPente * fPente));
double fY = fPente * fX;
ptMilieu.Offset((int)fX, (int)fY);
Point[] pts = new Point[]
{
lien.Points[0],
ptMilieu,
lien.Points[1]
};
lien.Points = pts;
}
}
}
}
//---------------------------------------------------
public override void DeleteChild(I2iObjetGraphique child)
{
C2iObjetDeSchema objDeSchema = child as C2iObjetDeSchema;
if (objDeSchema != null && objDeSchema.ElementDeSchema != null && objDeSchema.ElementDeSchema.IsValide())
{
C2iSchemaReseauDansSchemaReseau schemaFilsAsupprimer = objDeSchema as C2iSchemaReseauDansSchemaReseau;
if (schemaFilsAsupprimer != null)
{
if (schemaFilsAsupprimer.ElementDeSchema != null)
{
if (schemaFilsAsupprimer.ElementDeSchema.SchemaReseauInclus != null)
{
if (schemaFilsAsupprimer.ElementDeSchema.SchemaReseauInclus.SchemaParent == objDeSchema.ElementDeSchema.SchemaReseau)
{
objDeSchema.ElementDeSchema.DeleteObjetLie(true);
}
}
}
}
if (!objDeSchema.ElementDeSchema.Delete(true))
{
return;
}
}
foreach (I2iObjetGraphique fils in Childs)
{
C2iEtiquetteSchema etiq = fils as C2iEtiquetteSchema;
if (etiq != null)
{
if (etiq.ObjetSchemaAssocie == child)
{
DeleteChild(etiq);
}
}
}
base.DeleteChild(child);
}
//------------------------------------------------------------
protected C2iObjetDeSchema GetObjetElement(IElementDeSchemaReseau elt, ref bool bCreate)
{
bool bAutoriseCreate = bCreate;
bCreate = false;
if (elt == null)
{
return(null);
}
C2iObjetDeSchema objetParent = Parent as C2iObjetDeSchema;
if (objetParent == null)
{
return(null);
}
while ((objetParent.Parent as C2iObjetDeSchema) != null)
{
objetParent = objetParent.Parent as C2iObjetDeSchema;
}
C2iObjetDeSchema objetElement = objetParent.FindChildRepresentant(elt);
if (objetElement != null)
{
return(objetElement);
}
if (bAutoriseCreate)
{
C2iObjetDeSchema objet = CreateObjetFor(elt);
if (objet == null)
{
return(null);
}
objet.Position = new Point(Position.X - objet.Size.Width / 2,
Position.Y - objet.Size.Height / 2);
bCreate = true;
return(objet);
}
return(null);
}
//---------------------------------------------------
/// <summary>
/// Recherche l'objet représentant un objet spécifique dans le schéma
/// </summary>
/// <param name="element"></param>
/// <returns></returns>
public C2iObjetDeSchema FindChildRepresentant(IElementDeSchemaReseau element)
{
if (element == null)
{
return(null);
}
foreach (C2iObjetDeSchema objet in Childs)
{
if (objet.ElementDeSchema != null && objet.ElementDeSchema.IsValide() && element.Equals(objet.ElementDeSchema.ElementAssocie))
{
return(objet);
}
}
//Si pas trouvé dans les fils, cherche dans les fils des fils
foreach (C2iObjetDeSchema objet in Childs)
{
C2iObjetDeSchema objetDansFils = objet.FindChildRepresentant(element);
if (objetDansFils != null)
{
return(objetDansFils);
}
}
return(null);
}
//---------------------------------------------------
public override void RemoveChild(I2iObjetGraphique child)
{
C2iObjetDeSchema obj = child as C2iObjetDeSchema;
m_listeSousObjets.Remove(obj);
}
//---------------------------------------------------------------------------
protected override void MyDraw(sc2i.drawing.CContextDessinObjetGraphique ctx)
{
if (ElementDeSchema == null || !ElementDeSchema.IsValide())
{
return;
}
bool bNewObjet1 = true;
bool bNewObjet2 = true;
C2iObjetDeSchema objet1 = GetObjetElement1(ref bNewObjet1);
C2iObjetDeSchema objet2 = GetObjetElement2(ref bNewObjet2);
if (objet1 == null || objet2 == null)
{
return;
}
if (bNewObjet1)
{
objet1.Position = Position;
}
if (bNewObjet2)
{
objet2.Position = new Point(Position.X + Size.Width, Position.Y + Size.Height);
}
//Vérifie que la position des objets 1 et 2 permet de voir le lien
if (objet1.RectangleAbsolu.IntersectsWith(objet2.RectangleAbsolu))
{
//Il faut déplacer l'un des deux objets
if (bNewObjet1)
{
//On déplace l'objet 1
if (objet1.Position.X < objet2.Position.X)
{
objet1.Position = new Point(objet2.RectangleAbsolu.Left - objet1.Size.Width * 2, objet1.Position.Y);
}
if (objet1.Position.X > objet2.Position.X)
{
objet1.Position = new Point(objet2.RectangleAbsolu.Right + objet1.Size.Width, objet1.Position.Y);
}
}
else if (bNewObjet2)
{
//On déplace l'objet 2
if (objet2.Position.X < objet1.Position.X)
{
objet2.Position = new Point(objet1.RectangleAbsolu.Left - objet2.Size.Width * 2, objet2.Position.Y);
}
if (objet2.Position.X > objet1.Position.X)
{
objet2.Position = new Point(objet1.RectangleAbsolu.Right + objet2.Size.Width, objet2.Position.Y);
}
}
}
Point pt1 = new Point(objet1.Position.X + objet1.Size.Width / 2,
objet1.Position.Y + objet1.Size.Height / 2);
Point pt2 = new Point(objet2.Position.X + objet2.Size.Width / 2,
objet2.Position.Y + objet2.Size.Height / 2);
List <Point> pts = new List <Point>(Points);
//Calcule la position de départ
if (OffsetElement1.X >= 0)
{
pt1.X = objet1.Position.X + OffsetElement1.X;
}
if (OffsetElement1.Y >= 0)
{
pt1.Y = objet1.Position.Y + OffsetElement1.Y;
}
if (OffsetElement2.X >= 0)
{
pt2.X = objet2.Position.X + OffsetElement2.X;
}
if (OffsetElement2.Y >= 0)
{
pt2.Y = objet2.Position.Y + OffsetElement2.Y;
}
if (pts.Count < 1)
{
pts.Add(pt1);
}
else
{
pts[0] = pt1;
}
if (pts.Count < 2)
{
pts.Add(pt2);
}
else
{
pts[pts.Count - 1] = pt2;
}
Points = pts.ToArray();
Pen pen = new Pen(ForeColor);
pen.Width = LineWidth;
switch (DonneeDessinLien.Forward_Backward)
{
case ESensAllerRetourLienReseau.Backward:
pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Custom;
pen.DashPattern = new float[] { 5.0f, 5.0f, 1.0f, 5.0f };
break;
}
Pen penFleche = new Pen(ForeColor);
penFleche.Width = LineWidth;
if (pts.Count > 2 && DonneeDessinLien.Curve)
{
ctx.Graphic.DrawCurve(pen, pts.ToArray());
for (int n = 1; n < pts.Count - 1; n++)
{
DrawFleches(ctx, penFleche, pts[n], pts[n - 1], pts[n + 1], ElementDeSchema.LienReseau.Direction);
}
}
else
{
for (int i = 0; i < pts.Count - 1; i++)
{
ctx.Graphic.DrawLine(pen, (Point)pts[i], (Point)pts[i + 1]);
DrawFleches(ctx, penFleche, null, (Point)pts[i], (Point)pts[i + 1], ElementDeSchema.LienReseau.Direction);
}
}
pen.Dispose();
penFleche.Dispose();
if (m_bModeSelection == false)
{
Brush bPoint = new SolidBrush(Color.FromArgb(128, ForeColor));
for (int i = 0; i < pts.Count; i++)
{
ctx.Graphic.FillRectangle(bPoint, pts[i].X - 2, pts[i].Y - 2, 5, 5);
}
bPoint.Dispose();
}
}
//---------------------------------------------------
public override bool ContainsChild(I2iObjetGraphique child)
{
C2iObjetDeSchema obj = child as C2iObjetDeSchema;
return(m_listeSousObjets.Contains(obj));
}
public C2iSchemaReseau GetSchemaReseauADessiner(bool bCreationAutorisee)
{
C2iSchemaReseau schemaADessiner;
if (SchemaReseau != null)
{
if (SchemaReseau.GetSchema(bCreationAutorisee) != null)
{
schemaADessiner = SchemaReseau.GetSchema(bCreationAutorisee);
}
else
{
schemaADessiner = new C2iSchemaReseau(SchemaReseau);
}
}
else if (bCreationAutorisee)
{
CSchemaReseau schema = GetSchemaReseauCreateIfNull();
schema.CreateNewInCurrentContexte();
schema.LienReseau = this;
schema.Libelle = this.Libelle;
schemaADessiner = schema.GetSchema(bCreationAutorisee);
}
else
{
return(null);
}
bool bFindObjet1 = false;
bool bFindObjet2 = false;
foreach (C2iObjetDeSchema objet in schemaADessiner.Childs)
{
if (objet.ElementDeSchema != null && objet.ElementDeSchema.ElementAssocie != null)
{
if (objet.ElementDeSchema.ElementAssocie.Equals(Element1))
{
bFindObjet1 = true;
}
if (objet.ElementDeSchema.ElementAssocie.Equals(Element2))
{
bFindObjet2 = true;
}
}
}
if (!bFindObjet1 && Element1 != null)
{
CElementDeSchemaReseau elt1 = new CElementDeSchemaReseau(ContexteDonnee);
elt1.CreateNewInCurrentContexte();
elt1.SchemaReseau = SchemaReseau;
elt1.ElementAssocie = Element1;
C2iObjetDeSchema objet1 = elt1.ObjetDeSchema;
schemaADessiner.AddChild(objet1);
objet1.Parent = schemaADessiner;
objet1.Position = new Point(10, 10);
elt1.X = objet1.Position.X;
elt1.Y = objet1.Position.Y;
}
if (!bFindObjet2 && Element2 != null)
{
CElementDeSchemaReseau elt2 = new CElementDeSchemaReseau(ContexteDonnee);
elt2.CreateNewInCurrentContexte();
elt2.SchemaReseau = SchemaReseau;
elt2.ElementAssocie = Element2;
C2iObjetDeSchema objet2 = elt2.ObjetDeSchema;
schemaADessiner.AddChild(objet2);
objet2.Parent = schemaADessiner;
objet2.Position = new Point(10, 400);
elt2.X = objet2.Position.X;
elt2.Y = objet2.Position.Y;
}
C2iLienDeSchemaReseauNoDelete lienGraphiqueEdite = new C2iLienDeSchemaReseauNoDelete();
lienGraphiqueEdite.LienReseau = this;
schemaADessiner.AddChild(lienGraphiqueEdite);
lienGraphiqueEdite.Parent = schemaADessiner;
schemaADessiner.FrontToBack(lienGraphiqueEdite);
return(schemaADessiner);
}
