//-----------------------------------------------------------------
public override void OnMouseUpNonStandard(object sender, MouseEventArgs e)
{
if (ModeSourisCustom == EModeSourisCustom.Join && e.Button == MouseButtons.Left)
{
Point ptLogique = GetLogicalPointFromDisplay(new Point(e.X, e.Y));
CODEQBase table = ObjetEdite.SelectionnerElementDuDessus(ptLogique) as CODEQBase;
if (table != null && table != m_table1Join)
{
IColumnDeEasyQuery colEndJoin = table.GetColonneAt(ptLogique);
if (colEndJoin != null)
{
CODEQJointure jointure = new CODEQJointure();
jointure.Parent = ObjetEdite;
jointure.ElementsSource = new IObjetDeEasyQuery[] { m_table1Join, table };
jointure.NomFinal = m_table1Join.NomFinal + "-" + table.NomFinal;
if (jointure.AddParametre(m_colStartJoin, colEndJoin))
{
Rectangle rct = Rectangle.Union(m_table1Join.RectangleAbsolu, table.RectangleAbsolu);
rct.Offset(rct.Width / 2 - jointure.Size.Width / 2, rct.Height / 2 - jointure.Size.Height / 2);
jointure.Position = new Point(rct.Left, rct.Top);
ObjetEdite.AddChild(jointure);
ModeSouris = EModeSouris.Selection;
}
}
}
m_colStartJoin = null;
m_table1Join = null;
Refresh();
}
}
//------------------------------------------
public void FillFromTable(CODEQBase objetDeRequete)
{
CEasyQuery query = objetDeRequete.Query;
if (query == null)
{
return;
}
IdObjetDeQuerySource = objetDeRequete.Id;
HashSet <string> champsASupprimer = new HashSet <string>();
foreach (IChampEntiteSNMP champ in Champs.ToArray())
{
if (champ is CChampEntiteSnmpStandard)
{
champsASupprimer.Add(champ.Id);
}
}
foreach (IColumnDeEasyQuery col in objetDeRequete.Columns)
{
CChampEntiteFromQuery champ = Champs.FirstOrDefault(c =>
c is CChampEntiteFromQuery && ((CChampEntiteFromQuery)c).ColonneSource.Id == col.Id) as CChampEntiteFromQuery;
if (champ == null)
{
champ = new CChampEntiteFromQuery();
ChampsListe.Add(champ);
}
champ.InitFromColonneSource(col, objetDeRequete);
}
}
public void InitFromColonneSource(IColumnDeEasyQuery colonne, CODEQBase objetDeQuery)
{
m_colonneSource = colonne;
CEasyQuery query = objetDeQuery.Query;
if (query != null)
{
//cherche la source
ITableDefinition tableDef = null;
IColumnDefinition colDef = null;
IsReadOnly = true;
Description = "";
if (query.FindSource(colonne, objetDeQuery, out tableDef, out colDef))
{
CColumnDefinitionSNMP colSnmp = colDef as CColumnDefinitionSNMP;
if (colSnmp != null)
{
if (tableDef is CTableDefinitionSNMP ||
tableDef is CTableDefinitionSnmpOfScalar)
{
Description = colSnmp.Description;
IsReadOnly = colSnmp.IsReadOnly;
}
}
}
}
}
//-------------------------------------------------------
public override void Draw(CContextDessinObjetGraphique ctx)
{
base.Draw(ctx);
if (SourceEntites is CSourceEntitesPourTableDataChampDeTable)
{
string strIdTable = ((CSourceEntitesPourTableDataChampDeTable)SourceEntites).IdTable;
IObjetDeEasyQuery tableSource = null;
foreach (IObjetDeEasyQuery objet in Query.Childs)
{
CODEQBase o = objet as CODEQBase;
if (o != null && o.Id == strIdTable)
{
tableSource = o;
break;
}
}
if (tableSource != null)
{
Pen pen = new Pen(Brushes.Black, 2);
CLienTracable lien = CTraceurLienDroit.GetLienPourLier(tableSource.RectangleAbsolu, RectangleAbsolu, EModeSortieLien.Automatic);
lien.RendVisibleAvecLesAutres(ctx.Liens);
ctx.AddLien(lien);
pen.DashStyle = DashStyle.Dot;
AdjustableArrowCap cap = new AdjustableArrowCap(4, 4, true);
pen.CustomEndCap = cap;
lien.Draw(ctx.Graphic, pen);
pen.Dispose();
cap.Dispose();
}
}
}
//------------------------------------------------------------------------
public void Init(CODEQBase odeqBase)
{
m_odeqTable = odeqBase;
m_postFilter = m_odeqTable != null ? m_odeqTable.PostFilter : null;
CDefPostFilter def = m_postFilter != null?CAllocateurPostFilter.GetDef(m_postFilter.GetType()) : c_defNull;
m_cmbTypePostFilter.SelectedItem = def;
UpdatePanelPostFilter();
}
//-------------------------------------------------------------------
private void UpdateLabelSource()
{
CODEQBase objet = GetObjetDeQuerySource();
if (objet != null && objet.Query != null)
{
m_lblRequeteSource.Text = objet.Query.Libelle + " (" + objet.NomFinal + ")";
}
}
//--------------------------------------------------------------------------------------
public void Init(CODEQBase odeqBase, IPostFilter postFilter)
{
CPostFilterFromQueryTable postFromQuery = postFilter as CPostFilterFromQueryTable;
if (postFromQuery == null)
{
postFromQuery = new CPostFilterFromQueryTable();
}
Init(odeqBase, postFromQuery, odeqBase.Query);
}
//-----------------------------------------------------------------
private void m_menuCommentaires_Click(object sender, EventArgs e)
{
if (Selection.Count == 1)
{
CODEQBase ob = Selection[0] as CODEQBase;
if (ob != null)
{
ob.Commentaires = CFormCommentaires.GetTexte(ob.Commentaires);
}
}
}
//-------------------------------------------------------------------
void menuDeRequete_Click(object sender, EventArgs e)
{
CMenuTableDeRequete menu = sender as CMenuTableDeRequete;
if (menu != null)
{
CODEQBase objet = menu.ObjetDeQuery;
m_typeEntite.FillFromTable(objet);
UpdateLabelSource();
FillListeChamps();
}
}
//------------------------------------------------------------------------------
private void m_lnkEditSourceQuery_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
string strId = m_typeEntite.IdObjetDeQuerySource;
if (strId != "")
{
CODEQBase objet = GetObjetDeQuerySource();
if (objet != null && objet.Query != null)
{
CFormEditEasyQuery.EditeQuery(objet.Query);
}
}
}
//-----------------------------------------------------------------
private void m_menuExpandTable_Click(object sender, EventArgs e)
{
foreach (IObjetDeEasyQuery objet in Selection)
{
CODEQBase o = objet as CODEQBase;
if (o != null)
{
o.IsExpanded = m_menuExpandTable.CheckState == CheckState.Unchecked;
}
;
}
Refresh();
}
//-----------------------------------------------------------------
public override void OnMouseMoveNonStandard(object sender, MouseEventArgs e)
{
if (ModeSourisCustom == EModeSourisCustom.Join && m_colStartJoin != null && e.Button == MouseButtons.Left)
{
Graphics g = CreateGraphics();
Point ptCentre = new Point(m_rectColStartJoin.Left + m_rectColStartJoin.Width / 2,
m_rectColStartJoin.Top + m_rectColStartJoin.Height / 2);
Rectangle rct = m_rectJoin;
Point ptLogique = GetLogicalPointFromDisplay(new Point(e.X, e.Y));
IColumnDeEasyQuery colDest = null;
CODEQBase dest = ObjetEdite.SelectionnerElementDuDessus(ptLogique) as CODEQBase;
if (dest == m_table1Join)
{
dest = null;
}
colDest = dest != null?dest.GetColonneAt(ptLogique) : null;
Rectangle rctDest = new Rectangle(e.X, e.Y, 1, 1);
if (colDest != null)
{
rctDest = dest.GetRectAbsoluColonne(colDest);
rctDest = new Rectangle(GetDisplayPointFromLogical(rctDest.Location),
GetDisplaySizeFromLogical(rctDest.Size));
}
rct.Inflate(2, 2);
using (Bitmap bmp = DernierApercuToDispose)
g.DrawImage(bmp, rct, rct, GraphicsUnit.Pixel);
Pen pen = new Pen(Color.Blue);
pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dot;
Brush br = new SolidBrush(Color.FromArgb(128, 0, 0, 255));
g.FillRectangle(br, m_rectColStartJoin);
if (colDest != null)
{
g.FillRectangle(br, rctDest);
}
br.Dispose();
g.DrawLine(pen, ptCentre, new Point(e.X, e.Y));
pen.Dispose();
g.Dispose();
m_rectJoin = Rectangle.Union(m_rectColStartJoin, rctDest);
}
}
public override void OnMouseDownNonStandard(object sender, MouseEventArgs e)
{
m_colStartJoin = null;
if (ModeSourisCustom == EModeSourisCustom.Join && e.Button == MouseButtons.Left)
{
Point ptLogique = GetLogicalPointFromDisplay(new Point(e.X, e.Y));
m_table1Join = ObjetEdite.SelectionnerElementDuDessus(ptLogique) as CODEQBase;
if (m_table1Join != null)
{
m_colStartJoin = m_table1Join.GetColonneAt(ptLogique);
if (m_colStartJoin != null)
{
Rectangle rctCol = m_table1Join.GetRectAbsoluColonne(m_colStartJoin);
rctCol = new Rectangle(GetDisplayPointFromLogical(rctCol.Location),
GetDisplaySizeFromLogical(rctCol.Size));
m_rectColStartJoin = rctCol;
m_rectJoin = m_rectColStartJoin;
}
}
}
}
//--------------------------------------------------------------------
private void UpdateColonnes()
{
m_panelChamp.Visible = false;
string strId = m_cmbTable.SelectedValue as string;
if (strId != null && strId.Length > 0)
{
foreach (IObjetDeEasyQuery obj in m_tableFromHotel.Query.Childs)
{
CODEQBase table = obj as CODEQBase;
if (table != null && table.Id == strId)
{
m_panelChamp.Visible = true;
m_cmbColonne.DataSource = table.Columns;
m_cmbColonne.DisplayMember = "ColumnName";
m_cmbColonne.ValueMember = "Id";
m_cmbColonne.SelectedValue = m_source.IdColonne;
}
}
}
}
//------------------------------------------------------
public IEnumerable <string> GetListeIdsEntites(CEasyQuery query)
{
HashSet <string> lst = new HashSet <string>();
if (query != null)
{
CODEQBase table = query.GetObjet(m_strIdTable) as CODEQBase;
IColumnDeEasyQuery colSel = null;
if (table != null)
{
foreach (IColumnDeEasyQuery col in table.Columns)
{
if (col.Id == m_strIdColonne)
{
colSel = col;
}
}
}
if (colSel != null)
{
CResultAErreur result = table.GetDatas(new CListeQuerySource(query.Sources));
if (result && result.Data is DataTable)
{
DataTable tableRes = result.Data as DataTable;
if (tableRes.Columns[colSel.ColumnName] != null)
{
foreach (DataRow row in tableRes.Rows)
{
object val = row[colSel.ColumnName];
if (val != DBNull.Value && val != null)
{
lst.Add(val.ToString());
}
}
}
}
}
}
return(lst);
}
//-------------------------------------------------------------------
private void AssureMenuFromRequete()
{
if (m_menuFromRequete.Items.Count != 0)
{
return;
}
foreach (CEasyQuery query in m_typeAgent.Queries)
{
ToolStripMenuItem item = new ToolStripMenuItem(query.Libelle);
foreach (I2iObjetGraphique objet in query.Childs)
{
CODEQBase objDeQuery = objet as CODEQBase;
if (objDeQuery != null)
{
CMenuTableDeRequete menu = new CMenuTableDeRequete(objDeQuery);
item.DropDownItems.Add(menu);
menu.Click += new EventHandler(menuDeRequete_Click);
}
}
m_menuFromRequete.Items.Add(item);
}
}
//---------------------------------------------------------------------
public void Init(ISourceEntitesPourTableDataHotel source, CODEQTableFromDataHotel table)
{
m_source = source as CSourceEntitesPourTableDataChampDeTable;
m_tableFromHotel = table;
if (m_source == null)
{
m_source = new CSourceEntitesPourTableDataChampDeTable();
}
List <CODEQBase> lstTables = new List <CODEQBase>();
foreach (IObjetDeEasyQuery obj in table.Query.Childs)
{
CODEQBase t = obj as CODEQBase;
if (t != null)
{
lstTables.Add(t);
}
}
m_cmbTable.DataSource = lstTables;
m_cmbTable.DisplayMember = "NomFinal";
m_cmbTable.ValueMember = "Id";
m_cmbTable.SelectedValue = m_source.IdTable;
UpdateColonnes();
}
public CMenuTableDeRequete(CODEQBase objet)
: base(objet.NomFinal)
{
ObjetDeQuery = objet;
}
//-------------------------------------
public CResultAErreur FillFromSNMP(CInterrogateurSnmp agent)
{
CResultAErreur result = CResultAErreur.True;
try
{
agent.Connexion.Version = SnmpVersion;
agent.ConnexionIp = Ip;
agent.ConnexionPort = SnmpPort;
agent.ConnexionCommunity = Communaute;
CEasyQuerySource source = new CEasyQuerySource();
source.Connexion = new CSnmpConnexionForEasyQuery(agent);
if (TypeAgent != null)
{
foreach (CTypeEntiteSnmpPourSupervision typeEntite in TypeAgent.TypesEntites)
{
//Repere tous les existants
Dictionary <string, CEntiteSnmpPourSupervision> dicEntites = new Dictionary <string, CEntiteSnmpPourSupervision>();
foreach (CEntiteSnmpPourSupervision entite in GetEntites(typeEntite))
{
string strIndex = entite.Index;
if (strIndex != null)
{
dicEntites[strIndex] = entite;
}
}
//récupère les données de la table
CODEQBase objetDeQuery = typeEntite.GetObjetDeQuery(TypeAgent);
if (objetDeQuery != null)
{
CEasyQueryFromEasyQueryASourcesSpecifique query = new CEasyQueryFromEasyQueryASourcesSpecifique(objetDeQuery.Query, source);
DataTable table = query.GetTable(objetDeQuery.NomFinal);
if (table != null)
{
foreach (DataRow row in table.Rows)
{
CEntiteSnmpPourSupervision entite = new CEntiteSnmpPourSupervision(Database);
entite.CreateNew();
entite.AgentSnmp = this;
entite.TypeEntite = typeEntite;
entite.FillFromSource(row);
entite.UpdateIndexEtLibelle();
string strIndex = entite.Index;
//Si l'entité existe déjà
CEntiteSnmpPourSupervision oldEntite = Entites.FirstOrDefault(
e => e.Index == strIndex &&
e.TypeEntite.Id == typeEntite.Id &&
e.Id != entite.Id);
if (oldEntite != null)
{
oldEntite.FillFromSource(row);
entite.Delete();
}
}
}
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//--------------------------------------------------
public static void Autoexec()
{
CODEQBase.RegisterTypeDerivePossible(typeof(IODEQTableFromFramework), typeof(CODEQTableFilleFromFramework));
}
//-----------------------------------------------------------------
protected override void AfficherMenuAdditonnel(System.Windows.Forms.ContextMenuStrip menu)
{
base.AfficherMenuAdditonnel(menu);
//Ajoute les menus
foreach (ToolStripItem item in new ArrayList(m_menuActionsSurTables.Items))
{
menu.Items.Add(item);
}
m_menuProperties.Visible = Selection.Count == 1 && CanEditeProprietes(Selection[0]);
//Menu add
m_menuAddSousElement.DropDownItems.Clear();
if (Selection.Count >= 1)
{
CheckState? expandedState = null;
Dictionary <Type, int> lstType = new Dictionary <Type, int>();
foreach (I2iObjetGraphique obj in Selection)
{
CODEQBase objet = obj as CODEQBase;
if (objet != null)
{
if (expandedState == null)
{
if (objet.IsExpanded)
{
expandedState = CheckState.Checked;
}
else
{
expandedState = CheckState.Unchecked;
}
}
else
{
if (expandedState.Value == CheckState.Checked && !objet.IsExpanded ||
expandedState.Value == CheckState.Unchecked && objet.IsExpanded)
{
expandedState = CheckState.Indeterminate;
}
}
foreach (Type tp in objet.TypesDerivesPossibles)
{
int nNb = 0;
if (lstType.ContainsKey(tp))
{
nNb = lstType[tp];
}
nNb++;
lstType[tp] = nNb;
}
}
}
m_menuExpandTable.CheckState = expandedState != null ? expandedState.Value : CheckState.Unchecked;
foreach (KeyValuePair <Type, int> kv in lstType)
{
if (kv.Value == Selection.Count)
{
CODEQFromObjetsSource sousElement = Activator.CreateInstance(kv.Key) as CODEQFromObjetsSource;
if (sousElement != null && sousElement.NbSourceRequired == Selection.Count)
{
CMenuAddSousElement subMenu = new CMenuAddSousElement(sousElement);
subMenu.Click += new EventHandler(menuAddSousElement_Click);
m_menuAddSousElement.DropDownItems.Add(subMenu);
}
}
}
}
m_menuAddSousElement.Visible = m_menuAddSousElement.DropDownItems.Count != 0;
//Menu RemplaceSource
m_menuRemplaceSource.DropDownItems.Clear();
if (Selection.Count == 1)
{
CODEQFromObjetsSource tableFromSource = Selection[0] as CODEQFromObjetsSource;
if (tableFromSource == null)
{
m_menuRemplaceSource.Visible = false;
}
else
{
m_menuRemplaceSource.Visible = true;
IEnumerable <string> nomsParametres = tableFromSource.NomsSources;
IObjetDeEasyQuery[] sources = tableFromSource.ElementsSource;
for (int n = 0; n < tableFromSource.NbSourceRequired; n++)
{
ToolStripMenuItem itemSource = new ToolStripMenuItem();
string strText = n < nomsParametres.Count() ? nomsParametres.ElementAt(n) : (n + 1).ToString();
if (sources.Length > n)
{
strText += " (" + sources[n].NomFinal + ")";
}
itemSource.Text = strText;
itemSource.Tag = n;
itemSource.DropDownItems.Add(new ToolStripMenuItem(""));
itemSource.DropDownOpening += itemSource_DropDownOpening;
m_menuRemplaceSource.DropDownItems.Add(itemSource);
}
}
}
}
