/// //////////////////////////////////////////
protected override CResultAErreur ProtectedEval(CContexteEvaluationExpression ctx)
{
CResultAErreur result = CResultAErreur.True;
try
{
C2iExpression[] parametresFiltre = new C2iExpression[Parametres.Count - 2];
for (int nIndex = 2; nIndex < Parametres.Count; nIndex++)
{
parametresFiltre[nIndex - 2] = Parametres2i[nIndex];
}
result = GetFiltre(ctx, Parametres2i[0], Parametres2i[1], parametresFiltre);
if (!result)
{
return(result);
}
if (!(ctx.ObjetSource is CObjetDonnee))
{
result.EmpileErreur(I.T("SelectSql cannot be applied here|229"));
return(result);
}
CFiltreDataAvance filtre = (CFiltreDataAvance)result.Data;
CListeObjetsDonnees liste = new CListeObjetsDonnees(((CObjetDonnee)ctx.ObjetSource).ContexteDonnee,
CContexteDonnee.GetTypeForTable(filtre.TablePrincipale));
liste.Filtre = filtre;
result.Data = liste;
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error in SelectSql|228"));
}
return(result);
}
//--------------------------------------------------------
public CListeRestrictionsUtilisateurSurType GetRestrictions(CObjetDonnee objet)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(objet);
CListeRestrictionsUtilisateurSurType restrictions = new CListeRestrictionsUtilisateurSurType();
foreach (CCoupleFormuleToGroupeRestrictions couple in m_listeCouples)
{
if (couple.Formule != null)
{
CResultAErreur result = couple.Formule.Eval(ctx);
if (result && result.Data is bool)
{
if ((bool)result.Data)
{
CGroupeRestrictionSurType groupe = new CGroupeRestrictionSurType(objet.ContexteDonnee);
if (groupe.ReadIfExists(couple.IdGroupeRestriction))
{
restrictions.Combine(groupe.ListeRestrictions);
}
}
}
}
}
return(restrictions);
}
//-----------------------------------------------------------------------------------------
protected override void MyUpdateValeursCalculees()
{
CContexteEvaluationExpression ctx = CUtilControlesWnd.GetContexteEval(this, EditedElement);
if (WndSchemaReseau.ElementFormula != null)
{
CResultAErreur resultExpression = WndSchemaReseau.ElementFormula.Eval(ctx);
if (resultExpression)
{
// Schema de réseau
CSchemaReseau schema = resultExpression.Data as CSchemaReseau;
if (schema != null)
{
// Init ici
m_controleSchemaReseau.Init(schema.GetSchema(false), schema);
m_controleSchemaReseau.LockEdition = true;
m_controleSchemaReseau.ModeEdition = EModeEditeurSchema.Selection;
}
}
}
if (WndSchemaReseau.DynamicNetworkViewFormula != null)
{
CResultAErreur resultExpression = WndSchemaReseau.DynamicNetworkViewFormula.Eval(ctx);
if (resultExpression)
{
// Parametre de vue dynamique
CParametreVueSchemaDynamique parametre = resultExpression.Data as CParametreVueSchemaDynamique;
if (parametre != null)
{
m_controleSchemaReseau.ParametreDynamique = parametre.ParametreRepresentation;
}
}
}
}
//------------------------------------------------------------
/// <summary>
/// Récupère la valeur d'un paramètre
/// </summary>
/// <param name="strParametre"></param>
/// <returns></returns>
/// <remarks>
/// Chaque fenêtre peut posséder des paramètres.
/// La valeur par défaut du paramètre peut être défini via une formule,
/// cependant, en appellant "SetParameterValue" sur le C2iWnd, la valeur
/// par défaut peut être remplacée par une valeur spécifique.<BR></BR>
/// Si une fenêtre ne possède pas un paramètre, elle remonte sur les
/// fenêtre parentes pour tenter de trouver la valeur du paramètre
/// </remarks>
public object GetParameter(string strParametre)
{
C2iWndFenetre wndFenetre = m_controleWnd != null ? m_controleWnd.WndAssociee as C2iWndFenetre : null;
if (wndFenetre != null)
{
object val = wndFenetre.GetValeurForceeParametre(strParametre);
if (val != null)
{
return(val);
}
strParametre = strParametre.ToUpper();
foreach (CFormuleNommee f in wndFenetre.Parameters)
{
if (f.Libelle.ToUpper() == strParametre && f.Formule != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(m_controleWnd.EditedElement);
CResultAErreur result = f.Formule.Eval(ctx);
if (result)
{
return(result.Data);
}
}
}
}
CEncaspuleurControleWndForFormules ctrl = WndContainer as CEncaspuleurControleWndForFormules;
if (ctrl != null)
{
return(ctrl.GetParameter(strParametre));
}
return(null);
}
//---------------------------------------------------
public override CResultAErreur GetErreursManualEndEtape(CEtapeWorkflow etape)
{
CResultAErreur result = base.GetErreursManualEndEtape(etape);
if (result)
{
result = CResultAErreur.True;
//Vérifie toutes les conditions de fin
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(etape);
foreach (CFormuleNommee fn in FormulesConditionFin)
{
if (fn != null && fn.Formule != null)
{
CResultAErreur resTmp = fn.Formule.Eval(ctx);
if (!resTmp)
{
result.EmpileErreur(I.T("Error in formula '@1' for step @2|20082",
fn.Libelle, etape.LastError));
return(result);
}
bool bOk = resTmp.Data != null;
if (bOk)
{
bool?bConv = CUtilBool.BoolFromString(resTmp.Data.ToString());
bOk = bConv == true;
}
if (!bOk)
{
result.EmpileErreur(fn.Libelle);
}
}
}
}
return(result);
}
/// ///////////////////////
public Image GetImageToDisplay(CContexteEvaluationExpression contexte)
{
Image imgToCopy = null;
if (ImageFormula != null && contexte != null)
{
try
{
CResultAErreur result = ImageFormula.Eval(contexte);
if (result && result.Data is Bitmap)
{
imgToCopy = (Bitmap)result.Data;
}
}
catch
{
imgToCopy = null;
}
}
if (imgToCopy == null)
{
imgToCopy = DefaultImage;
}
if (imgToCopy != null)
{
return((Image)imgToCopy.Clone());
}
return(null);
}
//-----------------------------------------------------------------------------
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
CContexteDonnee ctxDonnee = null;
if (ctx.ObjetSource is IObjetAContexteDonnee)
{
ctxDonnee = ((IObjetAContexteDonnee)ctx.ObjetSource).ContexteDonnee;
}
if (ctxDonnee == null)
{
ctxDonnee = ctx.GetObjetAttache(typeof(CContexteDonnee)) as CContexteDonnee;
}
if (ctxDonnee == null)
{
ctxDonnee = CContexteDonneeSysteme.GetInstance();
}
CNommageEntite nommage = new CNommageEntite(ctxDonnee);
//TESTDBKEYOK
if (nommage.ReadIfExists(m_keyNommageEntite)) //&& nommage.NomFort == m_strNom)
{
result.Data = nommage.GetObjetNomme();
}
else if (nommage.ReadIfExists(new CFiltreData(CNommageEntite.c_champNomFort + "=@1",
m_strNom)))
{
result.Data = nommage.GetObjetNomme();
}
return(result);
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
if (valeursParametres[0] == null || !typeof(IEnumerable).IsAssignableFrom(valeursParametres[0].GetType()))
{
result.Data = new object[] { valeursParametres[0] };
return(result);
}
try
{
ArrayList newListe = new ArrayList();
IEnumerable lst = (IEnumerable)valeursParametres[0];
foreach (object elt in lst)
{
if (!newListe.Contains(elt))
{
newListe.Add(elt);
}
}
result.Data = newListe;
return(result);
}
catch
{
result.EmpileErreur(I.T("Error during the evaluation of 'distinct'|241"));
}
return(result);
}
//------------------------------------------------------------------------------------
public IEnumerable <CObjetDonneeAIdNumerique> GetListeAssociations(object sourceDeFormule)
{
List <CObjetDonneeAIdNumerique> lst = new List <CObjetDonneeAIdNumerique>();
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(sourceDeFormule);
foreach (C2iExpression formule in AssociationsFormulas)
{
CResultAErreur result = formule.Eval(ctx);
if (result)
{
object data = result.Data;
if (data is CObjetDonneeAIdNumerique)
{
lst.Add(data as CObjetDonneeAIdNumerique);
}
IEnumerable lstObjets = data as IEnumerable;
if (lstObjets != null)
{
foreach (object obj in lstObjets)
{
if (obj is CObjetDonneeAIdNumerique)
{
lst.Add(obj as CObjetDonneeAIdNumerique);
}
}
}
}
}
return(lst.AsReadOnly());
}
/// //////////////////////////////////////////
protected override CResultAErreur ProtectedEval(CContexteEvaluationExpression ctx)
{
CResultAErreur result = CResultAErreur.True;
if (!typeof(IEnumerable).IsAssignableFrom(ctx.ObjetSource.GetType()))
{
result.EmpileErreur(I.T("The function ListInText cannot apply to the @1 type|237", ctx.ObjetSource.GetType().ToString()));
return(result);
}
ArrayList lst = new ArrayList();
foreach (object obj in (IEnumerable)ctx.ObjetSource)
{
try
{
ctx.PushObjetSource(obj, true);
result = Parametres2i[0].Eval(ctx);
ctx.PopObjetSource(true);
if (!result)
{
return(result);
}
}
catch {}
}
return(result);
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
//Tente la conversion du second en int
string str1;
int n2;
try
{
str1 = valeursParametres[0].ToString();
n2 = (int)valeursParametres[1];
}
catch
{
result.EmpileErreur(I.T("No overload of the 'Left' function accepts the parameters indicated|299"));
return(result);
}
try
{
if (n2 >= str1.Length)
{
result.Data = str1;
}
else
{
result.Data = str1.Substring(0, n2);
}
}
catch
{
result.EmpileErreur(I.T("Error in the 'Left' function|300"));
}
return(result);
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
if (valeursParametres[0] == null || !typeof(IEnumerable).IsAssignableFrom(valeursParametres[0].GetType()))
{
result.Data = 0;
return(result);
}
IList lst = valeursParametres[0] as IList;
if (lst != null)
{
result.Data = lst.Count;
}
else
{
IEnumerable en = valeursParametres[0] as IEnumerable;
int nCount = 0;
foreach (object obj in en)
{
nCount++;
}
result.Data = nCount;
}
return(result);
}
//---------------------------------------------------------------------------
public bool GenereItem(
object obj,
double fLat,
double fLong, CMapLayer layer)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(this.m_mapItemGenerator);
if (FormuleCondition != null && !(FormuleCondition is C2iExpressionVrai))
{
result = FormuleCondition.Eval(ctx);
if (!result || result.Data == null)
{
return(false);
}
bool?bResult = CUtilBool.BoolFromString(result.Data.ToString());
if (bResult == null || !bResult.Value)
{
return(false);
}
}
string strLibelle = "";
if (FormuleToolTip != null)
{
result = FormuleToolTip.Eval(ctx);
if (result && result.Data != null)
{
strLibelle = result.Data.ToString();
}
}
IMapItem item = null;
if (MarkerType != EMapMarkerType.none)
{
item = new CMapItemSimple(layer, fLat, fLong, MarkerType);
}
else if (Image != null)
{
if (layer.Database.GetImage(m_strImageId) == null)
{
layer.Database.AddImage(m_strImageId, Image);
}
item = new CMapItemImage(layer, fLat, fLong, m_strImageId);
}
else
{
item = new CMapItemSimple(layer, fLat, fLong, EMapMarkerType.green);
}
item.Tag = obj;
item.ToolTip = strLibelle;
item.PermanentToolTip = PermanentToolTip;
if (ItemGenerator.ActionSurClick != null)
{
item.MouseClicked += new MapItemClickEventHandler(OnMouseClick);
}
return(true);
}
/// ////////////////////////////////////////////////////////////
public void FillNode(TreeNode node, CObjetDonneeAIdNumeriqueAuto objet)
{
if (objet != null)
{
string strText = "";
if (m_formuleLibelle != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(objet);
CResultAErreur result = m_formuleLibelle.Eval(ctx);
if (result && result.Data != null)
{
strText = result.Data.ToString();
}
}
if (strText.Length == 0)
{
strText = CInterpreteurTextePropriete.GetStringValue(objet, m_strProprieteAffichee, "Non def");
}
node.Text = strText;
}
CInfoNode info;
if (node.Tag is CInfoNode)
{
info = (CInfoNode)node.Tag;
}
else
{
info = new CInfoNode();
}
info.Objet = objet;
node.Tag = info;
}
/// //////////////////////////////////////////
protected override CResultAErreur ProtectedEval(CContexteEvaluationExpression ctx)
{
CResultAErreur result = CResultAErreur.True;
if (GetNbParametresNecessaires() >= 0 && Parametres.Count != GetNbParametresNecessaires())
{
result.EmpileErreur(I.T("The number of parameters isn't correct (@1 expected)|246", GetNbParametresNecessaires().ToString()));
return(result);
}
try
{
result = Parametres2i[0].Eval(ctx);
if (!result)
{
return(result);
}
bool b1 = Convert.ToBoolean(result.Data);
if (b1)
{
return(Parametres2i[1].Eval(ctx));
}
else
{
return(Parametres2i[2].Eval(ctx));
}
}
catch
{
}
result.EmpileErreur(I.T("No overload of the function 'IF' accept the indicated parameters|247"));
return(result);
}
//-----------------------------------
public IEnumerable <CCategorieGED> GetListeCategories(object sourceDeFormule)
{
List <CCategorieGED> lst = new List <CCategorieGED>();
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(sourceDeFormule);
foreach (C2iExpression formule in CategoriesFormulas)
{
CResultAErreur result = formule.Eval(ctx);
if (result)
{
object data = result.Data;
if (data is CCategorieGED)
{
lst.Add(data as CCategorieGED);
}
IEnumerable lstObjets = data as IEnumerable;
if (lstObjets != null)
{
foreach (object obj in lstObjets)
{
if (obj is CCategorieGED)
{
lst.Add(obj as CCategorieGED);
}
}
}
}
}
return(lst.AsReadOnly());
}
/// ///////////////////////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.False;
result.EmpileErreur(I.T("Impossible Error|248"));
return(result);
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
object v1 = valeursParametres[0];
object v2 = valeursParametres[1];
ArrayList lst = new ArrayList();
if (v1 is ICollection)
{
lst.AddRange((ICollection)v1);
}
else if (v1 != null)
{
lst.Add(v1);
}
if (v2 is ICollection)
{
lst.AddRange((ICollection)v2);
}
else if (v2 != null)
{
lst.Add(v2);
}
result.Data = lst;
return(result);
}
//------------------------------------------------------
public CResultAErreur MajChamps(bool bControlerValeur)
{
CResultAErreur result = CResultAErreur.True;
if (m_elementAVariables != null && m_variable != null)
{
object valeur = null;
if (m_control is ISelectionneurElementListeObjetsDonnees)
{
valeur = ((ISelectionneurElementListeObjetsDonnees)m_control).ElementSelectionne;
if (m_variable is CVariableDynamiqueSelectionObjetDonnee)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(valeur);
CResultAErreur resTmp = ((CVariableDynamiqueSelectionObjetDonnee)m_variable).ExpressionRetournee.Eval(ctx);
if (resTmp)
{
valeur = resTmp.Data;
}
}
}
m_elementAVariables.SetValeurChamp(m_variable.IdVariable, valeur);
if (bControlerValeur)
{
result = m_variable.VerifieValeur(valeur);
}
}
return(result);
}
//------------------------------------------------------------
public CResultAErreur GetValue(object objet, string strPropriete)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression contexte = new CContexteEvaluationExpression(objet);
if (objet is CObjetDonnee)
{
contexte.AttacheObjet(typeof(CContexteDonnee), ((CObjetDonnee)objet).ContexteDonnee);
}
Type tpAnalyse = null;
if (objet != null)
{
tpAnalyse = objet.GetType();
}
CContexteAnalyse2iExpression ctx = new CContexteAnalyse2iExpression(new CFournisseurPropDynStd(), tpAnalyse);
CAnalyseurSyntaxiqueExpression analyseur = new CAnalyseurSyntaxiqueExpression(ctx);
result = analyseur.AnalyseChaine(strPropriete);
if (!result)
{
return(result);
}
C2iExpression formule = (C2iExpression)result.Data;
result = formule.Eval(contexte);
if (result)
{
return(result);
}
return(result);
}
/// //////////////////////////////////////////////////
public override CResultAErreur GetComposantExpression(CFiltreDynamique filtreDynamique)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(filtreDynamique);
if (ConditionApplication != null)
{
result = ConditionApplication.Eval(ctx);
if (!result)
{
result.EmpileErreur(I.T("Error while evaluation of @1|143", ConditionApplication.GetString()));
return(result);
}
if (!((result.Data is bool && (bool)result.Data) || result.Data.ToString() == "1"))
{
result.Data = null;
return(result);
}
}
C2iExpressionChamp expChamp = new C2iExpressionChamp(m_champ);
C2iExpression expressionIsNull = new C2iExpressionEstNull();
expressionIsNull.Parametres.Add(expChamp);
result.Data = expressionIsNull;
if (!TestNull)
{
C2iExpression expNon = new C2iExpressionNon();
expNon.Parametres.Add(expressionIsNull);
result.Data = expNon;
}
return(result);
}
public object GetValue(object objet)
{
if (m_formule == null)
{
return(null);
}
if (m_contexteEval == null)
{
m_contexteEval = new CContexteEvaluationExpression(objet);
m_contexteEval.UseOptimiseurs = true;
}
else
{
m_contexteEval.ChangeSource(objet);
}
if (objet is CObjetDonnee)
{
m_contexteEval.AttacheObjet(typeof(CContexteDonnee), ((CObjetDonnee)objet).ContexteDonnee);
}
CResultAErreur result = m_formule.Eval(m_contexteEval);
if (result)
{
return(result.Data);
}
return(null);
}
private static CResultAErreur DeclencheEvenement(
IControleWndFor2iWnd ctrl,
CHandlerEvenementParFormule handler)
{
CResultAErreur result = CResultAErreur.True;
try
{
if (handler.FormuleEvenement != null)
{
IControleWndFor2iWnd ctrlParent = ctrl;
while (ctrlParent.WndContainer != null && !ctrlParent.IsRacineForEvenements)
{
ctrlParent = ctrlParent.WndContainer as IControleWndFor2iWnd;
}
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(new CEncaspuleurControleWndForFormules(ctrlParent));
result = handler.FormuleEvenement.Eval(ctx);
if (ctrl.Control != null)
{
ctrl.Control.Refresh();
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
if (valeursParametres[0] is String)
{
Type tp = DynamicClassAttribute.GetTypeFromNomConvivial((string)valeursParametres[0]);
if (tp != null)
{
result.Data = tp.ToString();
return(result);
}
tp = CActivatorSurChaine.GetType((string)valeursParametres[0]);
if (tp != null)
{
result.Data = tp.ToString();
return(result);
}
}
else
{
if (valeursParametres[0] != null)
{
result.Data = valeursParametres[0].GetType().ToString();
return(result);
}
}
result.Data = "";
return(result);
}
//----------------------------------------------------
public CIconeGantt GetIcone(IElementDeGantt element)
{
if (m_formuleCondition != null && Image != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(element);
CResultAErreur result = m_formuleCondition.Eval(ctx);
if (result)
{
if (result.Data is bool && (bool)result.Data)
{
string strTooltip = "";
if (Tooltip != null)
{
result = Tooltip.Eval(ctx);
if (result)
{
strTooltip = result.Data.ToString();
}
}
return(new CIconeGantt(Image, strTooltip));
}
}
}
return(null);
}
/// //////////////////////////////////////////
protected override CResultAErreur ProtectedEval(CContexteEvaluationExpression ctx)
{
CResultAErreur result = CResultAErreur.True;
try
{
foreach (C2iExpression parametre in Parametres2i)
{
result = parametre.Eval(ctx);
if (!result)
{
result.EmpileErreur(I.T("Error during the evaluation of the @1 expression|250", GetString()));
return(result);
}
bool bVal = Convert.ToBoolean(result.Data);
if (!bVal)
{
result.Data = false;
return(result);
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//---------------------------------------------------------------
protected override void MyUpdateValeursCalculees()
{
C2iWndWebBrowser wndBrowser = WndAssociee as C2iWndWebBrowser;
if (wndBrowser == null | m_browser == null)
{
return;
}
CContexteEvaluationExpression contexte = CUtilControlesWnd.GetContexteEval(this, EditedElement);
try
{
if (wndBrowser.UrlFormula != null)
{
CResultAErreur result = wndBrowser.UrlFormula.Eval(contexte);
string strUrl = null;
if (result)
{
strUrl = result.Data == null ? null : result.Data.ToString();
}
m_browser.Url = new Uri(strUrl);
}
}
catch { }
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.False;
result.EmpileErreur(I.T("MyEval of C2iExpresisonOu should never be called|251"));
return(result);
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
double fMoyenne = 0;
if (valeursParametres[0] == null || !typeof(IEnumerable).IsAssignableFrom(valeursParametres[0].GetType()))
{
result.Data = 0;
return(result);
}
foreach (object obj in (IEnumerable)valeursParametres[0])
{
object valeur = GetValeur(obj);
try
{
fMoyenne += Convert.ToDouble(valeur);
}
catch
{
}
}
if (((IList)valeursParametres[0]).Count != 0)
{
fMoyenne = fMoyenne / ((IList)valeursParametres[0]).Count;
}
result.Data = fMoyenne;
return(result);
}
/// //////////////////////////////////////////////////////
private void m_btnTester_Click(object sender, System.EventArgs e)
{
C2iExpression expression = GetExpression();
if (expression == null)
{
return;
}
if (m_cmbType.SelectedItem == null || !(m_cmbType.SelectedItem is C2iTypeDonnee))
{
CFormAlerte.Afficher(I.T("Select a data type|30026"), EFormAlerteType.Exclamation);
return;
}
TypeDonnee tp = ((C2iTypeDonnee)m_cmbType.SelectedItem).TypeDonnee;
object obj = CObjetForTestValeurChampCustom.GetNewForTypeDonnee(tp,
null, m_txtTest.Text);
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(obj);
CResultAErreur result = expression.Eval(ctx);
if (!result)
{
result.EmpileErreur(I.T("Error during validation formula evaluation|30027"));
CFormAlerte.Afficher(result);
return;
}
if ((result.Data is bool && (bool)result.Data) || result.Data.ToString() == "1")
{
CFormAlerte.Afficher(I.T("Accepted value|30028"));
}
else
{
CFormAlerte.Afficher(I.T("Rejected value|30029"), EFormAlerteType.Erreur);
}
}