void itemMenuFiltre_Click(object sender, EventArgs e)
{
CMenuItemFiltre menuFiltre = sender as CMenuItemFiltre;
if (menuFiltre != null)
{
CFiltreDynamiqueInDb filtreInDb = menuFiltre.Filtre;
CFiltreDynamique filtre = filtreInDb.Filtre;
if (m_lastFiltreDynamique != null)
{
foreach (IVariableDynamique variable in m_lastFiltreDynamique.ListeVariables)
{
object val = m_lastFiltreDynamique.GetValeurChamp(variable.IdVariable);
IVariableDynamique var2 = filtre.GetVariable(variable.IdVariable);
if (var2 != null && var2.Nom == variable.Nom)
{
filtre.SetValeurChamp(var2, val);
}
}
}
m_lastFiltreDynamique = filtre;
if (filtre.FormulaireEdition.Childs.Count() > 0)
{
if (!CFormFormulairePopup.EditeElement(
filtre.FormulaireEdition, filtre, "Filter|20175"))
{
return;
}
}
ApplyFiltre(filtre);
}
}
/// ////////////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees()
{
CResultAErreur result = CResultAErreur.True;
CProcessInDb processInDB = new CProcessInDb(Process.ContexteDonnee);
if (!processInDB.ReadIfExists(m_dbKeyProcess))
{
result.EmpileErreur(I.T("Invalid action to start|192"));
return(result);
}
//Vérifie le type des variables
CProcess process = processInDB.Process;
foreach (string strIdVariable in m_mapVariablesProcessToFormule.Keys)
{
IVariableDynamique variable = process.GetVariable(strIdVariable);
if (variable != null)
{
CTypeResultatExpression typeVariable = variable.TypeDonnee;
C2iExpression expression = (C2iExpression)m_mapVariablesProcessToFormule[strIdVariable];
if (expression != null)
{
if (!expression.TypeDonnee.Equals(typeVariable))
{
result.EmpileErreur(I.T("The formula of '@1' variable value must return a @2 type|193", variable.Nom, typeVariable.ToStringConvivial()));
}
}
}
}
return(result);
}
/// /////////////////////////////////////////////
public object GetValeurChamp(IVariableDynamique variable)
{
if (m_elementAVariablesExterne != null && GetVariableLocaleAuFiltre(variable.IdVariable) == null)
{
return(m_elementAVariablesExterne.GetValeurChamp(variable));
}
if (variable == null)
{
return(null);
}
if (variable is CVariableDynamiqueCalculee)
{
CVariableDynamiqueCalculee variableCalculee = (CVariableDynamiqueCalculee)variable;
return(variableCalculee.GetValeur(this));
}
else if (variable is CVariableDynamiqueListeObjets)
{
CVariableDynamiqueListeObjets variableListe = (CVariableDynamiqueListeObjets)variable;
return(variableListe.GetValeur(this));
}
else
{
object valeur = m_tableValeursChamps[variable.IdVariable];
if (valeur == null && variable is CVariableDynamiqueSaisie)
{
return(((CVariableDynamiqueSaisie)variable).GetValeurParDefaut());
}
return(valeur);
}
}
private void UpdateListeVariables()
{
m_bListeVariablesRemplie = false;
m_variableEnCoursEdition = null;
m_txtFormuleVariable.Visible = false;
if (!(m_cmbProcess.SelectedValue is CProcessInDb))
{
m_wndListeVariables.Enabled = false;
m_txtFormuleVariable.Visible = false;
return;
}
m_wndListeVariables.Enabled = true;
m_txtFormuleVariable.Visible = true;
CProcessInDb processInDB = (CProcessInDb)m_cmbProcess.SelectedValue;
CProcess process = processInDB.Process;
if (process == null)
{
m_wndListeVariables.Enabled = false;
m_txtFormuleVariable.Visible = false;
return;
}
ArrayList lst = new ArrayList(process.ListeVariables);
m_wndListeVariables.Remplir(lst, false);
m_bListeVariablesRemplie = true;
}
//------------------------------------------------------------------------------
//Le data du result contient la valeur déserializée
public static CResultAErreur ReadValeur(
byte[] data,
IVariableDynamique variable,
CContexteDonnee contexteDonnee)
{
CResultAErreur result = CResultAErreur.True;
if (data == null)
{
return(result);
}
MemoryStream stream = new MemoryStream(data);
BinaryReader reader = new BinaryReader(stream);
CSerializerReadBinaire serializer = new CSerializerReadBinaire(reader);
object valeur = null;
result = CSerializerValeursVariables.SerializeValeurVariable(
ref valeur,
variable,
serializer,
contexteDonnee);
if (result)
{
result.Data = valeur;
}
reader.Close();
stream.Close();
return(result);
}
//-------------------------------------------------------------------------
void itemNewVariable_Click(object sender, EventArgs e)
{
ToolStripMenuItem item = sender as ToolStripMenuItem;
Type tp = item != null ? item.Tag as Type : null;
if (tp != null)
{
IVariableDynamique variable = null;
try
{
variable = Activator.CreateInstance(tp, new object[] { m_elementAVariables }) as IVariableDynamique;
}
catch (Exception ex)
{
CResultAErreur result = CResultAErreur.True;
result.EmpileErreur(new CErreurException(ex));
CFormAlerte.Afficher(result.Erreur);
return;
}
if (variable != null && EditeVariable(variable))
{
ListViewItem lvItem = new ListViewItem();
FillItem(lvItem, variable);
m_wndListeVariables.Items.Add(lvItem);
m_elementAVariables.AddVariable(variable);
}
}
}
//-------------------------------------------------------------------------
private bool EditeVariable(IVariableDynamique variable)
{
if (variable == null)
{
return(false);
}
Type typeEditeur = CGestionnaireEditeursVariablesDynamiques.GetTypeEditeur(variable.GetType());
if (typeEditeur == null)
{
return(false);
}
IFormEditVariableDynamique frm = Activator.CreateInstance(typeEditeur) as IFormEditVariableDynamique;
bool bResult = frm.EditeLaVariable(variable, m_elementAVariables);
if (bResult)
{
ListViewItem item = GetItemForVariable(variable);
if (item != null)
{
item.Text = variable.Nom;
}
}
return(bResult);
}
//-------------------------------------------------
public void RemoveVariable(IVariableDynamique variable)
{
if (!(variable is CVariableDynamiqueSysteme))
{
m_listeVariables.Remove(variable);
}
}
internal void OnChangeVariable(IVariableDynamique variable)
{
CDefinitionProprieteDynamique defProp = new CDefinitionProprieteDynamiqueVariableDynamique(variable as CVariableDynamique);
if (FormuleSelectionObjet != null)
{
foreach (C2iExpressionChamp expChamp in FormuleSelectionObjet.ExtractExpressionsType(typeof(C2iExpressionChamp)))
{
CDefinitionProprieteDynamiqueVariableDynamique defVar = expChamp.DefinitionPropriete as CDefinitionProprieteDynamiqueVariableDynamique;
if (defVar != null && defVar.IdChamp == variable.IdVariable)
{
expChamp.DefinitionPropriete = defProp;
}
}
}
if (FormuleCondition != null)
{
foreach (C2iExpressionChamp expChamp in FormuleCondition.ExtractExpressionsType(typeof(C2iExpressionChamp)))
{
CDefinitionProprieteDynamiqueVariableDynamique defVar = expChamp.DefinitionPropriete as CDefinitionProprieteDynamiqueVariableDynamique;
if (defVar != null && defVar.IdChamp == variable.IdVariable)
{
expChamp.DefinitionPropriete = defProp;
}
}
}
foreach (CMacroObjetValeur mv in Valeurs)
{
mv.OnChangeVariable(variable);
}
}
/// //////////////////////////////////////////
private void OnChangeVariable()
{
CResultAErreur result = CResultAErreur.True;
if (m_variableEnCoursEdition != null)
{
if (m_txtFormuleVariable.Text.Trim() != "")
{
result = GetFormule(m_txtFormuleVariable);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
m_tableIdVariableToFormule[m_variableEnCoursEdition.IdVariable] = result.Data;
}
else
{
m_tableIdVariableToFormule[m_variableEnCoursEdition.IdVariable] = null;
}
}
if (m_wndListeVariables.SelectedItems.Count != 1)
{
m_variableEnCoursEdition = null;
m_txtFormuleVariable.Visible = true;
return;
}
m_variableEnCoursEdition = (IVariableDynamique)m_wndListeVariables.SelectedItems[0].Tag;
m_lblNomVariable.Text = m_variableEnCoursEdition.Nom;
C2iExpression expression = (C2iExpression)m_tableIdVariableToFormule[m_variableEnCoursEdition.IdVariable];
m_txtFormuleVariable.Text = expression == null?"":expression.GetString();
}
//-------------------------------------------------
public virtual object GetValeurChamp(IVariableDynamique variable)
{
if (variable == null)
{
return(null);
}
if (variable is CVariableDynamiqueCalculee)
{
CVariableDynamiqueCalculee variableCalculee = (CVariableDynamiqueCalculee)variable;
return(variableCalculee.GetValeur(this));
}
else if (variable is CVariableDynamiqueListeObjets)
{
CVariableDynamiqueListeObjets variableListe = (CVariableDynamiqueListeObjets)variable;
return(variableListe.GetValeur(this));
}
else
{
object valeur = m_tableValeursChamps[variable.IdVariable];
if (valeur == null && variable is CVariableDynamiqueSaisie)
{
return(((CVariableDynamiqueSaisie)variable).GetValeurParDefaut());
}
return(valeur);
}
}
//--------------------------------
public void OnChangeVariable(IVariableDynamique variable)
{
foreach (CMacroObjet mo in Objets)
{
mo.OnChangeVariable(variable);
}
}
//---------------------------------------------------------------------------
public object GetValeurChamp(string strIdVariable)
{
if (m_elementAVariablesExternes != null)
{
return(m_elementAVariablesExternes.GetValeurChamp(strIdVariable));
}
object ret = null;
if (!m_dicValeursVariables.ContainsKey(strIdVariable))
{
IVariableDynamique variable = GetVariable(strIdVariable);
IVariableDynamiqueAValeurParDefaut variableADefaut = variable as IVariableDynamiqueAValeurParDefaut;
if (variableADefaut != null)
{
return(variableADefaut.GetValeurParDefaut());
}
IVariableDynamiqueCalculee variableCalculee = variable as IVariableDynamiqueCalculee;
if (variableCalculee != null && variableCalculee.FormuleDeCalcul != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(this);
CResultAErreur result = variableCalculee.FormuleDeCalcul.Eval(ctx);
if (result)
{
return(result.Data);
}
}
}
m_dicValeursVariables.TryGetValue(strIdVariable, out ret);
return(ret);
}
//-------------------------------------------------------
public object GetValeurChamp(IVariableDynamique variable)
{
object valeur = null;
m_dicValeursVariables.TryGetValue(variable, out valeur);
return(valeur);
}
//---------------------------------------------------------------------------------------
private IVariableDynamique AssureVariableElementCible(CFiltreDynamique filtre, Type typeElement)
{
IVariableDynamique variableASupprimer = null;
foreach (IVariableDynamique variable in filtre.ListeVariables)
{
if (variable.Nom == c_champElementSource)
{
if (variable.TypeDonnee.TypeDotNetNatif != typeElement)
{
variableASupprimer = variable;
}
else
{
return(variable);
}
}
}
if (variableASupprimer != null)
{
filtre.RemoveVariable(variableASupprimer);
}
CVariableDynamiqueSysteme newVariable = new CVariableDynamiqueSysteme(filtre);
newVariable.Nom = c_champElementSource;
newVariable.SetTypeDonnee(new sc2i.expression.CTypeResultatExpression(typeElement, false));
filtre.AddVariablePropreAuFiltre(newVariable);
return(newVariable);
}
/// ////////////////////////////////////////////////////////
public object GetValeurChamp(IVariableDynamique variable)
{
if (m_elementAVariablesExterne != null)
{
return(m_elementAVariablesExterne.GetValeurChamp(variable));
}
if (variable == null)
{
return(null);
}
if (variable is CVariableDynamiqueCalculee)
{
CVariableDynamiqueCalculee variableCalculee = (CVariableDynamiqueCalculee)variable;
return(variableCalculee.GetValeur(this));
}
else
{
object val = m_tableValeursChamps[variable.IdVariable];
if (val == null && variable is CVariableDynamiqueSaisie)
{
m_tableValeursChamps[variable.IdVariable] = ((CVariableDynamiqueSaisie)variable).GetValeurParDefaut();
}
return(m_tableValeursChamps[variable.IdVariable]);
}
}
//-------------------------------------------------
public object GetValeurChamp(string strIdVariable)
{
object val = null;
IVariableDynamique variable = GetVariable(strIdVariable);
if (variable is CVariableDynamiqueCalculee)
{
return(((CVariableDynamiqueCalculee)variable).GetValeur(this));
}
m_tableValeursChamps.TryGetValue(strIdVariable, out val);
if (val == null)
{
if (!m_tableValeursChamps.ContainsKey(strIdVariable))
{
foreach (IVariableDynamique v in ListeVariables)
{
if (v.IdVariable == strIdVariable)
{
IVariableDynamiqueAValeurParDefaut vAvecDef = v as IVariableDynamiqueAValeurParDefaut;
if (vAvecDef != null)
{
val = vAvecDef.GetValeurParDefaut();
}
break;
}
}
}
m_tableValeursChamps[strIdVariable] = val;
}
return(val);
}
public bool EditeLaVariable(IVariableDynamique variable, IElementAVariablesDynamiquesBase eltAVariables)
{
Init(variable as CVariableDynamiqueSaisie, eltAVariables);
bool bResult = ShowDialog() == DialogResult.OK;
Dispose();
return(bResult);
}
//-------------------------------------------------
public virtual bool IsVariableUtilisee(IVariableDynamique variable)
{
if (variable is CVariableDynamiqueSysteme)
{
return(true);
}
return(false);
}
//---------------------------------------------
public CResultAErreur SetValeurChamp(IVariableDynamique variable, object valeur)
{
if (variable == null)
{
return(CResultAErreur.True);
}
return(SetValeurChamp(variable.IdVariable, valeur));
}
/// /////////////////////////////////////////////
public void OnChangeVariable(IVariableDynamique variable)
{
if (m_elementAVariablesExterne != null)
{
m_elementAVariablesExterne.OnChangeVariable(variable);
}
// TODO : ajoutez l'implémentation de C2iRequete.OnChangeVariable
}
//-----------------------------------------------------------------------------
public object GetValeurChamp(IVariableDynamique variable)
{
if (variable == null)
{
return(null);
}
return(GetValeurChamp(variable.IdVariable));
}
//-------------------------------------------------
public virtual void RemoveVariable(IVariableDynamique variable)
{
if (m_elementAVariablesExterne != null)
{
m_elementAVariablesExterne.RemoveVariable(variable);
return;
}
m_listeVariables.Remove(variable);
}
//-------------------------------------------------
public virtual CResultAErreur SetValeurChamp(IVariableDynamique variable, object valeur)
{
if (variable != null)
{
SetValeurChamp(variable.IdVariable, valeur);
}
return(CResultAErreur.True);
}
//--------------------------------------------------------------
public void AddVariable(IVariableDynamique variable)
{
CVariableDynamique v = variable as CVariableDynamique;
if (v != null)
{
m_listeVariables.Add(v);
}
}
/// /////////////////////////////////////////////
public bool IsVariableUtilisee(IVariableDynamique variable)
{
if (m_elementAVariablesExterne != null)
{
return(m_elementAVariablesExterne.IsVariableUtilisee(variable));
}
// TODO : ajoutez l'implémentation de C2iRequete.IsVariableUtilisee
return(false);
}
//-------------------------------------------------
public bool IsVariableUtilisee(IVariableDynamique variable)
{
if (variable is CVariableDynamiqueSysteme)
{
return(true);
}
//A FAIRE
return(false);
}
/// //////////////////////////////////////////////////////////////////////
public CDefinitionProprieteDynamiqueVariableDynamique(IVariableDynamique variable, bool bHasSubProperties)
: base(
variable.Nom,
variable.IdVariable,
variable.TypeDonnee,
bHasSubProperties,
false)
{
m_variable = variable;
}
/// //////////////////////////////////////////////////////////////////////
public CDefinitionProprieteDynamiqueVariableDynamique(IVariableDynamique variable)
: base(
variable.Nom,
variable.IdVariable,
variable.TypeDonnee,
CFournisseurGeneriqueProprietesDynamiques.HasSubProperties(variable.TypeDonnee.TypeDotNetNatif),
false)
{
m_variable = variable;
}
//--------------------------------------------------------------
public CResultAErreur SetValeurChamp(IVariableDynamique variable, object valeur)
{
CResultAErreur result = CDistantElementAVariables.WriteValeur(valeur, variable, m_contexteDonneeLocal);
if (result)
{
return(m_distantElementAVariables.SetValeurChamp(variable, (byte[])result.Data));
}
return(result);
}