Пример #1
0
        //------------------------------------------------------------------------------------------
        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();
        }
Пример #3
0
        //---------------------------------------------------
        public override void BringToFront(I2iObjetGraphique child)
        {
            C2iObjetDeSchema obj = child as C2iObjetDeSchema;

            if (m_listeSousObjets.Contains(obj))
            {
                m_listeSousObjets.Remove(obj);
                m_listeSousObjets.Add(obj);
            }
        }
Пример #4
0
        //---------------------------------------------------
        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);
            }
        }
Пример #5
0
 //---------------------------------------------------
 public void ClearDrawingCache()
 {
     foreach (I2iObjetGraphique objet in Childs)
     {
         C2iObjetDeSchema o = objet as C2iObjetDeSchema;
         if (o != null)
         {
             o.ClearDrawingCache();
         }
     }
 }
Пример #6
0
        //---------------------------------------------------
        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);
        }
Пример #7
0
 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;
     }
 }
Пример #8
0
 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);
 }
Пример #9
0
        /// <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);
        }
Пример #10
0
 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);
 }
Пример #11
0
 //---------------------------------------------------
 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();
         }
     }
 }
Пример #12
0
        /// ////////////////////////////////////////////////////////
        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);
        }
Пример #13
0
        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;
                    }
                }
            }
        }
Пример #14
0
        //---------------------------------------------------
        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);
        }
Пример #15
0
        //------------------------------------------------------------
        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);
        }
Пример #16
0
 //---------------------------------------------------
 /// <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);
 }
Пример #17
0
        //---------------------------------------------------
        public override void RemoveChild(I2iObjetGraphique child)
        {
            C2iObjetDeSchema obj = child as C2iObjetDeSchema;

            m_listeSousObjets.Remove(obj);
        }
Пример #18
0
        //---------------------------------------------------------------------------
        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();
            }
        }
Пример #19
0
        //---------------------------------------------------
        public override bool ContainsChild(I2iObjetGraphique child)
        {
            C2iObjetDeSchema obj = child as C2iObjetDeSchema;

            return(m_listeSousObjets.Contains(obj));
        }
Пример #20
0
        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);
        }