コード例 #1
0
        public void Init(C2iObjetDeSchema objetEdite, CSchemaReseau schemaReseau)
        {
#if DEBUG
            m_btnGraphe.Visible = true;
#endif
            m_panelSchema.ObjetEdite  = objetEdite;
            m_panelSchema.Editeur     = this;
            m_panelSchema.NoClipboard = true;
            m_schemaReseau            = schemaReseau;
            m_objetDeSchema           = objetEdite;
            if (!LockEdition && m_objetDeSchema is C2iSchemaReseau)
            {
                ((C2iSchemaReseau)m_objetDeSchema).ArrangerLiaisons();
            }

            m_panelSchema.ObjetSchemaReseau = schemaReseau;
            m_panelSchema.ModeEdition       = EModeEditeurSchema.Selection;

            if (schemaReseau != null)
            {
                m_lienEdite = schemaReseau.LienReseau;
                m_panelSchema.LienReseauEdite = m_lienEdite;
            }

            m_panelElements.AddAllLoadedAssemblies();
            if (!LockEdition)
            {
                ReactualiserArbre();
            }
            m_tabDeGauche.Visible = !LockEdition;

            m_cmbVueDynamique.Init(typeof(CParametreVueSchemaDynamique), "Libelle", true);
        }
コード例 #2
0
        //------------------------------------
        public virtual void AfterDrawObjet(CContextDessinObjetGraphique ctx, C2iObjetDeSchema objet)
        {
            if (!IsConcerneParAlarme)
            {
                return;
            }
            int   nSizeTour = 2;
            Color couleur   = m_severite != null ? m_severite.Couleur : Color.White;

            Rectangle rct = objet.RectangleAbsolu;

            Brush br = new SolidBrush(couleur);

            ctx.Graphic.FillRectangle(br, new Rectangle(rct.Left - nSizeTour, rct.Top - nSizeTour, rct.Width + nSizeTour, nSizeTour));
            ctx.Graphic.FillRectangle(br, new Rectangle(rct.Right, rct.Top - nSizeTour, nSizeTour, rct.Height + nSizeTour * 2));
            ctx.Graphic.FillRectangle(br, new Rectangle(rct.Left - nSizeTour, rct.Bottom, rct.Width + 2 * nSizeTour, nSizeTour));
            ctx.Graphic.FillRectangle(br, new Rectangle(rct.Left - nSizeTour, rct.Top - nSizeTour, nSizeTour, rct.Height + nSizeTour));
            br.Dispose();
            br = new SolidBrush(Color.FromArgb(100, couleur));
            ctx.Graphic.FillRectangle(br, rct);
            br.Dispose();

            Image imgMasquage = null;

            if (HasMasquage)
            {
                imgMasquage = timos.data.Resource.Mask_adm;
            }

            if (imgMasquage != null)
            {
                ctx.Graphic.DrawImageUnscaled(imgMasquage, rct.Right - imgMasquage.Width, rct.Bottom - imgMasquage.Height);
            }
        }
コード例 #3
0
 //------------------------------------
 public virtual void BeforeDrawObjet(CContextDessinObjetGraphique ctx, C2iObjetDeSchema objet)
 {
     if (!m_bIsConcernéParAlarmes)
     {
         return;
     }
 }
コード例 #4
0
        public C2iObjetDeSchema GetObjetDeSchema(CElementDeSchemaReseau elementDeSchema)
        {
            C2iObjetDeSchema objet   = new C2iObjetDeSchema();
            C2iSymbole       symbole = SymboleADessiner;

            objet.ElementDeSchema = elementDeSchema;
            return(objet);
        }
コード例 #5
0
        public override void AfterDrawObjet(CContextDessinObjetGraphique ctx, C2iObjetDeSchema objet)
        {
            if (!IsConcerneParAlarme)
            {
                return;
            }
            base.AfterDrawObjet(ctx, objet);
            Image img = m_base.GetImageEtatOperationnel(EtatOperationnel);

            if (img != null)
            {
                ctx.Graphic.DrawImageUnscaled(img, objet.PositionAbsolue);
            }
        }
コード例 #6
0
        //--------------------------------------------------------------------
        private void m_panelDessin_MouseUp(object sender, MouseEventArgs e)
        {
            List <C2iObjetDeSchema> lst = GetObjetsFromPoint(new Point(e.X, e.Y));

            if (lst.Count > 0)
            {
                C2iObjetDeSchema obj = lst[0];
                SetSelection(obj);
            }
            if (m_objetDeSchemaSelectionne != null && (e.Button & MouseButtons.Right) == e.Button)
            {
                m_menuRightClick.Show(this, new Point(e.X, e.Y));
            }
        }
コード例 #7
0
        //---------------------------------------------------------------------------------------------
        public override void BeforeDrawObjet(CContextDessinObjetGraphique ctx, C2iObjetDeSchema objet)
        {
            if (!IsConcerneParAlarme)
            {
                return;
            }
            C2iLienDeSchemaReseau dessinLien = objet as C2iLienDeSchemaReseau;
            Color couleur = CSpvAlarmcouleur.GetColor(CouleurAlarme, dessinLien.ElementDeSchema.ContexteDonnee);
            Pen   pen     = new Pen(couleur, 3);

            Point[] pts = dessinLien.Points;
            for (int nPoint = 0; nPoint <= pts.Length - 2; nPoint++)
            {
                ctx.Graphic.DrawLine(pen, pts[nPoint], pts[nPoint + 1]);
            }
            pen.Dispose();
        }
コード例 #8
0
        //---------------------------------------------------------------------------------------------
        public override void BeforeDrawObjet(CContextDessinObjetGraphique ctx, C2iObjetDeSchema objet)
        {
            if (!IsConcerneParAlarme)
            {
                return;
            }
            C2iLienDeSchemaReseau dessinLien = objet as C2iLienDeSchemaReseau;
            Color couleur = SeveriteAlarme != null ? SeveriteAlarme.Couleur : Color.White;
            Pen   pen     = new Pen(couleur, 3);

            Point[] pts = dessinLien.Points;
            for (int nPoint = 0; nPoint <= pts.Length - 2; nPoint++)
            {
                ctx.Graphic.DrawLine(pen, pts[nPoint], pts[nPoint + 1]);
            }
            pen.Dispose();
        }
コード例 #9
0
        public bool DoDessinSupplementaireAfter(CContextDessinObjetGraphique ctx, C2iObjetGraphique objet)
        {
            C2iObjetDeSchema objetDeSchema = objet as C2iObjetDeSchema;

            if (objetDeSchema == null || objetDeSchema.ElementDeSchema == null)
            {
                return(true);
            }
            CInfoElementDeSchemaSupervise infoSupervision = null;

            if (!m_dicElementDeSchemaToInfoSupervision.TryGetValue(objetDeSchema.ElementDeSchema.Id, out infoSupervision))
            {
                return(true);
            }
            infoSupervision.AfterDrawObjet(ctx, objetDeSchema);
            return(true);
        }
コード例 #10
0
        public void Init(C2iObjetDeSchema objetEdite, CSchemaReseau schemaReseau)
        {
            m_panelSchema.ObjetEdite  = objetEdite;
            m_panelSchema.Editeur     = null;
            m_panelSchema.NoClipboard = true;
            m_schemaReseau            = schemaReseau;
            m_objetDeSchema           = objetEdite;

            m_panelSchema.ObjetSchemaReseau = schemaReseau;
            m_panelSchema.ModeEdition       = EModeEditeurSchema.Selection;

            if (schemaReseau != null)
            {
                m_lienEdite = schemaReseau.LienReseau;
                m_panelSchema.LienReseauEdite = m_lienEdite;
            }
        }
コード例 #11
0
        //----------------------------------------------------------
        //Remet à jour la liste des contrôles disponibles et compatibles avec le type édité
        public void RefreshControls()
        {
            m_listeElements.Clear();
            this.SuspendDrawing();
            Dictionary <Type, bool> typesTraites = new Dictionary <Type, bool>();
            ArrayList lstControles = new ArrayList(Controls);

            foreach (Control ctrl in lstControles)
            {
                CElementListeSchemaReseau elt = ctrl as CElementListeSchemaReseau;
                typesTraites.Add(elt.TypeAssocie, true);
                if (elt != null)
                {
                    m_listeElements.Add(elt);
                }
                else
                {
                    m_listeElements.Add(elt);
                }
            }
            m_listeTypesControlesConnus.Sort(new TypeSorter());

            foreach (Type tp in m_listeTypesControlesConnus)
            {
                if (!typesTraites.ContainsKey(tp))
                {
                    CElementListeSchemaReseau elt = new CElementListeSchemaReseau();
                    elt.Image = C2iObjetDeSchema.GetImage(tp);
                    Controls.Add(elt);
                    elt.TypeAssocie = tp;
                    elt.Size        = new Size(ClientRectangle.Width, c_nElementHeight);
                    elt.Left        = 0;
                    elt.Top         = m_listeElements.Count * (c_nElementHeight + c_nEcartYElements) + c_nEcartYElements;
                    elt.CreateControl();
                    elt.Dock = DockStyle.Top;
                    elt.SendToBack();
                    elt.Visible = true;
                    m_listeElements.Add(elt);
                }
            }
            this.ResumeDrawing();
        }
コード例 #12
0
 //--------------------------------------------------------------------
 private void SetSelection(C2iObjetDeSchema objet)
 {
     if (m_objetDeSchemaSelectionne == objet)
     {
         return;
     }
     if (m_objetDeSchemaSelectionne != null && !(m_objetDeSchemaSelectionne is C2iSchemaReseau))
     {
         Invalidate(new Rectangle(GetScreenPoint(m_objetDeSchemaSelectionne.PositionAbsolue, true),
                                  GetScreenSize(m_objetDeSchemaSelectionne.Size)), true);
     }
     //Graphics g = CreateGraphics();
     //HideSelection(g);
     m_objetDeSchemaSelectionne = objet;
     if (m_objetDeSchemaSelectionne != null && !(m_objetDeSchemaSelectionne is C2iSchemaReseau))
     {
         Invalidate(new Rectangle(GetScreenPoint(m_objetDeSchemaSelectionne.PositionAbsolue, true),
                                  GetScreenSize(m_objetDeSchemaSelectionne.Size)), true);
     }
     //Refresh();
     //DrawSelection(g);
     //g.Dispose();
 }
コード例 #13
0
        public virtual void AfterDrawObjet(CContextDessinObjetGraphique ctx, C2iObjetDeSchema objet)
        {
            if (!m_bIsConcernéParAlarmes)
            {
                return;
            }
            int   nSizeTour = 2;
            Color couleur   = CSpvAlarmcouleur.GetColor(CouleurAlarme, m_base.ContexteDonnee);
            //couleur = Color.FromArgb(255, couleur);
            Rectangle rct = objet.RectangleAbsolu;

            Brush br = new SolidBrush(couleur);

            ctx.Graphic.FillRectangle(br, new Rectangle(rct.Left - nSizeTour, rct.Top - nSizeTour, rct.Width + nSizeTour, nSizeTour));
            ctx.Graphic.FillRectangle(br, new Rectangle(rct.Right, rct.Top - nSizeTour, nSizeTour, rct.Height + nSizeTour * 2));
            ctx.Graphic.FillRectangle(br, new Rectangle(rct.Left - nSizeTour, rct.Bottom, rct.Width + 2 * nSizeTour, nSizeTour));
            ctx.Graphic.FillRectangle(br, new Rectangle(rct.Left - nSizeTour, rct.Top - nSizeTour, nSizeTour, rct.Height + nSizeTour));
            br.Dispose();
            br = new SolidBrush(Color.FromArgb(100, couleur));
            ctx.Graphic.FillRectangle(br, rct);
            br.Dispose();

            Image imgMasquage = null;

            if (HasMasquageAdministrateur)
            {
                imgMasquage = SpvDataResource.Mask_adm;
            }
            else if (HasMasquageBrigadier)
            {
                imgMasquage = SpvDataResource.mask_bri;
            }
            if (imgMasquage != null)
            {
                ctx.Graphic.DrawImageUnscaled(imgMasquage, rct.Right - imgMasquage.Width, rct.Bottom - imgMasquage.Height);
            }
        }
コード例 #14
0
        public bool AfterDrawElement(CContextDessinObjetGraphique ctx, C2iObjetGraphique objetGraphique)
        {
            C2iObjetDeSchema objetDessine = objetGraphique as C2iObjetDeSchema;

            if (objetDessine == null || objetDessine.ElementDeSchema == null)
            {
                return(true);
            }
            IElementDeSchemaReseau elementDeSchema = objetDessine.ElementDeSchema.ElementAssocie;

            if (elementDeSchema == null)
            {
                return(true);
            }
            Type tp = elementDeSchema.GetType();
            CParametreRepresentationSymbole parametre = this[tp];

            if (parametre == null)
            {
                return(true);
            }
            parametre.Draw(ctx, elementDeSchema, objetGraphique);
            return(true);
        }
コード例 #15
0
        public override void AfterDrawObjet(CContextDessinObjetGraphique ctx, C2iObjetDeSchema objet)
        {
            if (!IsConcerneParAlarme)
            {
                return;
            }
            C2iLienDeSchemaReseau dessinLien = objet as C2iLienDeSchemaReseau;

            if (dessinLien == null)
            {
                return;
            }
            //Image img = m_base.GetImageIsOperationnel(m_bIsOperationnel);
            Image img = m_base.GetImageEtatOperationnel(m_etatOperationnel);

            Point[] pts = dessinLien.Points;
            Point   pt;

            if (pts.Length % 2 == 0)
            {
                //trouve les points du milieu
                Point pt1 = pts[pts.Length / 2 - 1];
                Point pt2 = pts[pts.Length / 2];
                pt = new Point((pt1.X + pt2.X) / 2, (pt1.Y + pt2.Y) / 2);
            }
            else
            {
                pt = pts[pts.Length / 2];
            }
            Image imgMask = null;

            if (HasMasquageAdministrateur)
            {
                imgMask = SpvDataResource.Mask_adm;
            }
            else if (HasMasquageBrigadier)
            {
                imgMask = SpvDataResource.mask_bri;
            }
            Size sz = new Size(0, 0);

            if (img != null)
            {
                sz = new Size(img.Size.Width, img.Size.Height);
            }
            if (imgMask != null)
            {
                sz = new Size(sz.Width + imgMask.Width, Math.Max(sz.Height, imgMask.Height));
            }
            if (img != null)
            {
                Point ptImg = pt;
                ptImg.Offset(-sz.Width / 2, -img.Height / 2);
                pt.Offset(-sz.Width / 2 + img.Width, 0);
                ctx.Graphic.DrawImageUnscaled(img, ptImg);
            }
            else
            {
                pt.Offset(sz.Width / 2, 0);
            }


            if (imgMask != null)
            {
                pt.Offset(0, -imgMask.Height / 2);
                ctx.Graphic.DrawImageUnscaled(imgMask, pt);
            }
        }