//------------------------------------------------------------------------------------------------------
public static bool EditeFonction(
ref CFonctionDynamique fonction,
CObjetPourSousProprietes objetAnalyse,
params KeyValuePair <string, Type>[] variablesSpecifiques)
{
if (fonction == null)
{
return(false);
}
CFormEditionFonctionDynamique form = new CFormEditionFonctionDynamique();
CFonctionDynamique fTmp = CCloner2iSerializable.Clone(fonction) as CFonctionDynamique;
form.m_panelFonction.Init(fTmp, objetAnalyse, true);
foreach (KeyValuePair <string, Type> kv in variablesSpecifiques)
{
form.m_panelFonction.AddSpecificVariableTypes(kv.Key, kv.Value);
}
bool bResult = false;
if (form.ShowDialog() == DialogResult.OK)
{
fonction = fTmp;
bResult = true;
}
form.Dispose();
return(bResult);
}
/// /////////////////////////////////////////////////////////
public void AddFonctionDynamique(CFonctionDynamique fonction)
{
CFonctionDynamique existante = FonctionsDynamiquesList.FirstOrDefault(f => f.IdFonction == fonction.IdFonction);
if (existante != null)
{
FonctionsDynamiquesList.Remove(existante);
}
FonctionsDynamiquesList.Add(fonction);
CommitFonctionsDynamiques();
}
//---------------------------------------------------------------------
private void m_btnAdd_LinkClicked(object sender, EventArgs e)
{
CFonctionDynamique fonction = new CFonctionDynamique();
if (CFormEditionFonctionDynamique.EditeFonction(
ref fonction,
m_objetPourSousProprietes))
{
ListViewItem item = new ListViewItem();
FillItem(item, fonction);
m_wndListeFonctions.Items.Add(item);
}
}
private void m_btnOk_Click(object sender, EventArgs e)
{
m_fonctions = new List <CFonctionDynamique>();
foreach (ListViewItem item in m_wndListeFonctions.Items)
{
CFonctionDynamique fonction = item.Tag as CFonctionDynamique;
if (fonction != null)
{
((List <CFonctionDynamique>)m_fonctions).Add(fonction);
}
}
DialogResult = DialogResult.OK;
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
public void Init(
CFonctionDynamique fonction,
CObjetPourSousProprietes objetAnalyse,
bool bAvecName)
{
m_fonction = fonction;
m_objetPourSousProprietes = objetAnalyse;
FillListeParametres();
m_txtNomFonction.Text = fonction.Nom;
m_txtFormule.Init(fonction,
objetAnalyse);
m_txtFormule.Formule = fonction.Formule;
m_panelNom.Visible = bAvecName;
m_bAfficheNom = bAvecName;
}
//-------------------------------------------------------------------------
protected override CResultAErreur MyInitChamps()
{
CResultAErreur result = base.MyInitChamps();
AffecterTitre(I.T("Dynamic function @1|20841", FonctionDynamiqueInDb.Nom));
InitComboTypes(false);
InitComboCategories();
m_cmbCategorie.Text = FonctionDynamiqueInDb.Categorie;
m_fonctionEditee = new CFonctionDynamique();
if (FonctionDynamiqueInDb.Fonction != null)
{
m_fonctionEditee = CCloner2iSerializable.Clone(FonctionDynamiqueInDb.Fonction) as CFonctionDynamique;
}
m_panelFonction.Init(m_fonctionEditee, FonctionDynamiqueInDb.TypeObjets, false);
return(result);
}
//---------------------------------------------------------------
private void m_btnRemove_LinkClicked(object sender, EventArgs e)
{
if (m_wndListeFonctions.SelectedItems.Count == 1)
{
CFonctionDynamique fonction = m_wndListeFonctions.SelectedItems[0].Tag as CFonctionDynamique;
if (fonction != null)
{
if (CFormAlerte.Afficher(I.T("Delete function @1 ?|20036", fonction.Nom),
EFormAlerteBoutons.OuiNon,
EFormAlerteType.Question) == DialogResult.Yes)
{
m_wndListeFonctions.Items.Remove(m_wndListeFonctions.SelectedItems[0]);
}
}
}
}
//---------------------------------------------------------------
private void m_btnEdit_LinkClicked(object sender, EventArgs e)
{
if (m_wndListeFonctions.SelectedItems.Count == 1)
{
ListViewItem item = m_wndListeFonctions.SelectedItems[0];
CFonctionDynamique fonction = item.Tag as CFonctionDynamique;
if (fonction != null)
{
if (CFormEditionFonctionDynamique.EditeFonction(
ref fonction,
m_objetPourSousProprietes))
{
FillItem(item, fonction);
}
}
}
}
//-----------------------------------------------------------------------------------------------
public IEnumerable <CDefinitionProprieteDynamique> GetDefinitionsFonctionsSupplementaires(CObjetPourSousProprietes objet)
{
List <CDefinitionProprieteDynamique> lstProps = new List <CDefinitionProprieteDynamique>();
if (objet == null)
{
return(lstProps.ToArray());
}
Type tp = objet.TypeAnalyse;
if (tp == null)
{
return(lstProps.ToArray());
}
if (!C2iFactory.IsInit())
{
return(lstProps.ToArray());
}
CContexteDonnee contexte = CContexteDonneeSysteme.GetInstance();
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, typeof(CFonctionDynamiqueInDb));
liste.Filtre = new CFiltreData(CFonctionDynamiqueInDb.c_champTypeObjets + "=@1", tp.ToString());
foreach (CFonctionDynamiqueInDb fonctionInDb in liste)
{
CFonctionDynamique fonction = fonctionInDb.Fonction;
if (fonction != null)
{
CDefinitionFonctionDynamique def = new CDefinitionFonctionDynamique(fonction);
if (fonctionInDb.Categorie.Length == 0)
{
def.Rubrique = I.T("Methods|58");
}
else
{
def.Rubrique = fonctionInDb.Categorie;
}
lstProps.Add(def);
}
}
return(lstProps.ToArray());
}
/// ///////////////////////////////////////
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strTexte);
if (nVersion < 2)
{
int nTmp = 0;
serializer.TraiteInt(ref nTmp);
nTmp = 0;
serializer.TraiteInt(ref nTmp);
}
//MODIF FAB
if (nVersion > 0)
{
bool bHasImage = m_imageFond != null;
serializer.TraiteBool(ref bHasImage);
if (bHasImage)
{
switch (serializer.Mode)
{
case ModeSerialisation.Lecture:
Byte[] bt = null;
serializer.TraiteByteArray(ref bt);
if (m_imageFond != null)
{
m_imageFond.Dispose();
}
m_imageFond = null;
MemoryStream stream = new MemoryStream(bt);
try
{
Bitmap bmp = (Bitmap)Bitmap.FromStream(stream);
m_imageFond = bmp;
}
catch
{
m_imageFond = null;
}
stream.Close();
break;
case ModeSerialisation.Ecriture:
MemoryStream streamSave = new MemoryStream();
try
{
m_imageFond.Save(streamSave, System.Drawing.Imaging.ImageFormat.Png);
}
catch (Exception e)
{
string strVal = e.ToString();
}
Byte[] buf = streamSave.GetBuffer();
serializer.TraiteByteArray(ref buf);
streamSave.Close();
break;
}
}
}
if (nVersion >= 3)
{
serializer.TraiteDouble(ref m_fMinutesRefresh);
}
else
{
m_fMinutesRefresh = 0;
}
if (nVersion >= 4 && nVersion < 7 && serializer.Mode == ModeSerialisation.Lecture)
{
List <CFormuleNommee> lst = new List <CFormuleNommee>();
result = serializer.TraiteListe <CFormuleNommee>(lst);
m_listeFonctions.Clear();
foreach (CFormuleNommee formule in lst)
{
CFonctionDynamique fonction = new CFonctionDynamique(formule.Libelle);
fonction.Formule = formule.Formule;
fonction.Nom = formule.Libelle;
m_listeFonctions.Add(fonction);
}
}
if (!result)
{
return(result);
}
if (nVersion >= 5)
{
serializer.TraiteBool(ref m_bAutoSize);
}
if (nVersion >= 6)
{
result = serializer.TraiteListe <CFormuleNommee>(m_listeParametres);
}
if (result && nVersion >= 7)
{
result = serializer.TraiteListe <CFonctionDynamique>(m_listeFonctions);
}
if (!result)
{
return(result);
}
return(result);
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] listeParametres)
{
CResultAErreur result = CResultAErreur.True;
if (ctx.ObjetSource == null)
{
result.Data = null;
return(result);
}
try
{
if (ctx.ObjetSource is IElementAFonctionsDynamiques && m_definitionFonction != null)
{
CFonctionDynamique fTmp = ((IElementAFonctionsDynamiques)ctx.ObjetSource).GetFonctionDynamique(m_definitionFonction.IdFonction);
if (fTmp != null)
{
m_fonction = fTmp;
}
}
if (m_fonction == null && ctx.ObjetBase is IElementAFonctionsDynamiques && m_definitionFonction != null)
{
CFonctionDynamique fTmp = ((IElementAFonctionsDynamiques)ctx.ObjetBase).GetFonctionDynamique(m_definitionFonction.IdFonction);
if (fTmp != null)
{
m_fonction = fTmp;
}
}
if (FonctionDynamique != null)
{
result = FonctionDynamique.Eval(ctx, listeParametres);
}
else if (DefinitionMethode != null)
{
object source = ctx.ObjetSource;
//Compatiblité (remplacement de méthodes par fonctions
bool bHasEvalFonction = false;
if (source is IElementAFonctionsDynamiques)
{
CFonctionDynamique fTmp = ((IElementAFonctionsDynamiques)source).GetFonctionDynamique(DefinitionMethode.Nom);
if (fTmp != null)
{
result = fTmp.Eval(ctx, listeParametres);
bHasEvalFonction = true;
}
}
if (!bHasEvalFonction)
{
MethodInfo info = ctx.ObjetSource.GetType().GetMethod(DefinitionMethode.NomProprieteSansCleTypeChamp);
if (info == null)
{
IInterpreteurMethodeDynamique inter = source as IInterpreteurMethodeDynamique;
if (inter != null)
{
inter.GetMethodInfo(DefinitionMethode.NomProprieteSansCleTypeChamp, ref info, ref source);
}
}
if (info == null)
{
CMethodeSupplementaire method = CGestionnaireMethodesSupplementaires.GetMethod(ctx.ObjetSource.GetType(), DefinitionMethode.NomProprieteSansCleTypeChamp);
if (method != null)
{
result.Data = method.Invoke(source, listeParametres);
return(result);
}
result.EmpileErreur(I.T("Cannot find @1 method|124", DefinitionMethode.NomProprieteSansCleTypeChamp));
return(result);
}
result.Data = info.Invoke(source, listeParametres);
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error during @1 method evaluation|123",
DefinitionMethode != null?
DefinitionMethode.NomProprieteSansCleTypeChamp:
FonctionDynamique != null?
FonctionDynamique.Nom:
"?"));
}
return(result);
}
//---------------------------------------------------------------------
private void FillItem(ListViewItem item, CFonctionDynamique fonction)
{
item.Text = fonction.Nom;
item.Tag = fonction;
}
/// /////////////////////////////////////////////////////////
public void RemoveFonctionDynamique(CFonctionDynamique fonction)
{
FonctionsDynamiquesList.Remove(fonction);
CommitFonctionsDynamiques();
}