//-----------------------------------------------
public void AddVariable(CDefinitionProprieteDynamiqueVariableFormule variable)
{
if (m_listeVariables.FirstOrDefault(v => v.Nom.ToUpper() == variable.Nom.ToUpper()) == null)
{
m_listeVariables.Add(variable);
}
}
public void SetValeurVariable(CDefinitionProprieteDynamique defProp, object valeur)
{
CDefinitionProprieteDynamiqueVariableFormule defFormule = defProp as CDefinitionProprieteDynamiqueVariableFormule;
if (defFormule != null)
{
m_tableValeursVariables[defFormule.Nom.ToUpper()] = valeur;
}
}
/// /////////////////////////////////////////////////////////
protected object GetValeurChamp(object source, CDefinitionProprieteDynamique propriete)
{
CDefinitionProprieteDynamiqueVariableFormule defFormule = propriete as CDefinitionProprieteDynamiqueVariableFormule;
if (defFormule != null)
{
return(GetValeurVariable(defFormule));
}
if (source != null && m_bUseOptimiseurs)
{
Type tp = source.GetType();
string strKey = tp.ToString() + "/" + propriete.NomPropriete;
IOptimiseurGetValueDynamic optimiseur = null;
bool bDejaCherche = false;
if (m_dicOptimiseurs.TryGetValue(strKey, out optimiseur))
{
bDejaCherche = true;
}
if (!bDejaCherche)
{
optimiseur = CInterpreteurProprieteDynamique.GetOptimiseur(tp, propriete.NomPropriete);
m_dicOptimiseurs[strKey] = optimiseur;
}
if (optimiseur != null)
{
return(optimiseur.GetValue(source));
}
}
CResultAErreur result = CInterpreteurProprieteDynamique.GetValue(source, propriete, m_cache);
if (result)
{
return(result.Data);
}
if (m_oldInterpreteur != null)
{
return(m_oldInterpreteur.GetValue(source, propriete));
}
return(null);
}
//-----------------------------------------------
public void ReplaceVariable(CDefinitionProprieteDynamiqueVariableFormule oldVar,
CDefinitionProprieteDynamiqueVariableFormule newVar)
{
int?nIndex = null;
if (oldVar != null)
{
nIndex = m_listeVariables.IndexOf(oldVar);
if (nIndex < 0)
{
nIndex = null;
}
m_listeVariables.Remove(oldVar);
}
if (nIndex == null || m_listeRepresentations.Count - 1 < nIndex.Value)
{
m_listeVariables.Add(newVar);
}
else
{
m_listeVariables.Insert(nIndex.Value, newVar);
}
}
public void AddVariable(CDefinitionProprieteDynamiqueVariableFormule def)
{
m_tableVariables[def.Nom.ToUpper()] = def;
m_cacheDefs.Clear();
}
/// //////////////////////////////////////////
public override CResultAErreur AfterAnalyse(CAnalyseurSyntaxique analyseur)
{
CResultAErreur result = CResultAErreur.True;
bool bIsTableau = false;
Type tp = null;
CAnalyseurSyntaxiqueExpression analyseurExpression = analyseur as CAnalyseurSyntaxiqueExpression;
if (analyseurExpression != null)
{
C2iExpressionChamp champ = Parametres2i[0] as C2iExpressionChamp;
//Vérifie que les paramètres sont bien des constantes string
bool bParamOk = false;
if (Parametres.Count >= 2)
{
if (Parametres[0] is C2iExpressionChamp &&
(Parametres[1] is C2iExpressionConstante || Parametres[1] is C2iExpressionTypesDynamics) &&
(Parametres.Count != 3 || Parametres[2] is C2iExpressionConstante || Parametres[2] is C2iExpressionVrai || Parametres[2] is C2iExpressionFaux))
{
if (Parametres[1] is C2iExpressionTypesDynamics)
{
tp = ((C2iExpressionTypesDynamics)Parametres[1]).TypeReprésenté;
}
else if (Parametres[1] is Type)
{
tp = Parametres[1] as Type;
}
else
{
string strType = ((C2iExpressionConstante)Parametres2i[1]).Valeur.ToString();
tp = CActivatorSurChaine.GetType(strType, true);
}
if (tp == null)
{
result.EmpileErreur(I.T("The @1 type doesn't exist|136", Parametres[1].ToString()));
return(result);
}
else
{
if (Parametres.Count == 3 &&
Parametres2i[2] is C2iExpressionConstante)
{
if (((C2iExpressionConstante)Parametres[2]).Valeur is int)
{
bIsTableau = (int)(((C2iExpressionConstante)Parametres[2]).Valeur) != 0;
}
if (((C2iExpressionConstante)Parametres[2]).Valeur is bool)
{
bIsTableau = (bool)((C2iExpressionConstante)Parametres[2]).Valeur;
}
}
if (Parametres.Count == 3 && Parametres[2] is C2iExpressionVrai)
{
bIsTableau = true;
}
if (Parametres.Count == 3 && Parametres[2] is C2iExpressionFaux)
{
bIsTableau = false;
}
bParamOk = true;
}
}
}
if (!bParamOk)
{
result.EmpileErreur(I.T("The Var function paramters are invalid (two constant string are awaited and possibly one Boolean for the table)|138"));
return(result);
}
CDefinitionProprieteDynamiqueVariableFormule def = new CDefinitionProprieteDynamiqueVariableFormule(
champ.DefinitionPropriete.Nom,
new CTypeResultatExpression(tp, bIsTableau),
false);
champ.DefinitionPropriete = def;
analyseurExpression.AddVariable(def);
}
return(base.AfterAnalyse(analyseur));
}
public object GetValeurVariable(CDefinitionProprieteDynamiqueVariableFormule def)
{
return(m_tableValeursVariables[def.Nom.ToUpper()]);
}
/// /////////////////////////////////////////////////
public void AddVariable(CDefinitionProprieteDynamiqueVariableFormule def)
{
m_contexteAnalyse.AddVariable(def);
}
/// //////////////////////////////////////////
protected override CResultAErreur ProtectedEval(CContexteEvaluationExpression ctx)
{
CResultAErreur result = CResultAErreur.True;
try
{
C2iExpressionChamp champFinal = null;
object objSource = ctx.ObjetSource;
result = GetSourceEtChampFinal(Parametres2i[0], ctx, ref objSource, ref champFinal);
if (!result)
{
return(result);
}
if (champFinal == null)
{
result.EmpileErreur(I.T("Impossible to affect a value to @1|133", Parametres2i[0].ToString()));
return(result);
}
result = Parametres2i[1].Eval(ctx);
if (!result)
{
return(result);
}
object valeur = result.Data;
CDefinitionProprieteDynamiqueVariableFormule propFormule = champFinal.DefinitionPropriete as CDefinitionProprieteDynamiqueVariableFormule;
if (propFormule != null)
{
ctx.SetValeurVariable(propFormule, valeur);
}
else
{
if (objSource == null)
{
return(result);
}
SynchronizationContext c = ctx.SynchronizationContext;
if (c != null)
{
c.Post(x => CInterpreteurProprieteDynamique.SetValue(objSource, champFinal.DefinitionPropriete.NomPropriete, valeur), null);
}
else
{
result = CInterpreteurProprieteDynamique.SetValue(objSource, champFinal.DefinitionPropriete.NomPropriete, valeur);
}
}
if (result)
{
result.Data = valeur;
if (objSource != null)
{
ctx.Cache.ResetCache(objSource);
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//--------------------------------------------------
/// <summary>
/// crée les éléments graphiques d'une formule
/// </summary>
/// <param name="formule"></param>
public void InitFromFormule(C2iExpression formule)
{
m_listeRepresentations.Clear();
m_listeVariables.Clear();
if (formule == null)
{
return;
}
ArrayList lst = formule.ExtractExpressionsType(typeof(C2iExpressionVariable));
foreach (C2iExpressionVariable variable in lst)
{
if (variable.Parametres.Count > 0)
{
C2iExpressionChamp champ = variable.Parametres[0] as C2iExpressionChamp;
if (champ != null)
{
CDefinitionProprieteDynamiqueVariableFormule def = champ.DefinitionPropriete as CDefinitionProprieteDynamiqueVariableFormule;
if (def != null)
{
m_listeVariables.Add(def);
}
}
}
}
C2iExpressionBegin begin = formule as C2iExpressionBegin;
m_strIdStartPoint = "";
int nX = 100;
int nY = 20;
if (begin != null)
{
CRepresentationExpressionGraphique previous = null;
foreach (C2iExpression action in begin.Parametres)
{
if (!(action is C2iExpressionVariable))
{
CRepresentationExpressionGraphique rep = new CRepresentationExpressionGraphique();
rep.Position = new Point(nX, nY);
AddChild(rep);
rep.Parent = this;
rep.Formule = action;
nY = rep.RectangleAbsolu.Bottom;
foreach (CRepresentationExpressionGraphique repTmp in m_listeRepresentations)
{
if (repTmp.RectangleAbsolu.Bottom > nY)
{
nY = rep.RectangleAbsolu.Bottom;
}
}
nY += 20;
if (previous == null)
{
StartPoint = rep;
}
else
{
previous.Next = rep;
}
previous = rep;
}
}
}
else
{
CRepresentationExpressionGraphique rep = new CRepresentationExpressionGraphique();
rep.Position = new Point(nX, nY);
AddChild(rep);
rep.Parent = this;
rep.Formule = formule;
StartPoint = rep;
}
}
//-----------------------------------------------
public void RemoveVariable(CDefinitionProprieteDynamiqueVariableFormule variable)
{
m_listeVariables.Remove(variable);
}
