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);
}
//------------------------------------
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);
}
}
//------------------------------------
public virtual void BeforeDrawObjet(CContextDessinObjetGraphique ctx, C2iObjetDeSchema objet)
{
if (!m_bIsConcernéParAlarmes)
{
return;
}
}
public C2iObjetDeSchema GetObjetDeSchema(CElementDeSchemaReseau elementDeSchema)
{
C2iObjetDeSchema objet = new C2iObjetDeSchema();
C2iSymbole symbole = SymboleADessiner;
objet.ElementDeSchema = elementDeSchema;
return(objet);
}
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);
}
}
//--------------------------------------------------------------------
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));
}
}
//---------------------------------------------------------------------------------------------
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();
}
//---------------------------------------------------------------------------------------------
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();
}
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);
}
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;
}
}
//----------------------------------------------------------
//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();
}
//--------------------------------------------------------------------
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();
}
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);
}
}
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);
}
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);
}
}