//---------------------------------------------------------------------------
private CFormEditionStandard NewCFormEdition(CObjetDonneeAIdNumeriqueAuto objet, CListeObjetsDonnees liste)
{
if (m_strProprieteObjetAEditer.Trim() != "")
{
objet = (CObjetDonneeAIdNumeriqueAuto)CInterpreteurTextePropriete.GetValue(objet, m_strProprieteObjetAEditer);
liste = liste.GetDependances(m_strProprieteObjetAEditer);
}
CFormEditionStandard frm = null;
// YK 20/02/09 : On utilise ici le nouveau CFormFinder
if (m_referenceForm == null)
{
m_referenceForm = CFormFinder.GetRefFormToEdit(m_typeObjet);
}
if (m_referenceForm != null)
{
frm = (CFormEditionStandard)m_referenceForm.GetForm(objet, liste);
}
if (frm != null)
{
if (AfterCreateFormEdition != null)
{
AfterCreateFormEdition(this, frm);
}
frm.AfterSuppression += new ObjetDonneeEventHandler(OnSuppressionDansFormEdition);
frm.AfterValideModification += new ObjetDonneeEventHandler(OnValidationDansFormEdition);
frm.AfterAnnulationModification += new ObjetDonneeEventHandler(OnAnnulationDansFormEdition);
}
return(frm);
}
/// //////////////////////////////////////////////
private void Refill(IEnumerable liste)
{
if (m_bIsFilling)
{
return;
}
m_bIsFilling = true;
try
{
this.SuspendDrawing();
BeginUpdate();
object oldValue = SelectedValue;
DataSource = null;
if (liste == null)
{
EndUpdate();
m_bIsFilling = false;
return;
}
ArrayList lst = new ArrayList();
if (NullAutorise)
{
lst.Add(new CBinome(DBNull.Value, TextNull));
}
foreach (object obj in liste)
{
object objRetour = obj;
object valeurProp = CInterpreteurTextePropriete.GetValue(obj, ProprieteAffichee);
lst.Add(new CBinome(objRetour, valeurProp != null? valeurProp.ToString():""));
}
if (m_bTrier)
{
lst.Sort();
}
ValueMember = "ReturnValue";
DisplayMember = "DisplayValue";
DataSource = lst;
ValueMember = "ReturnValue";
DisplayMember = "DisplayValue";
EndUpdate();
object lastSelection = m_lastObjetSelectionne;
SelectedValue = oldValue;
if (SelectedValue == null)
{
SelectedValue = lastSelection;
}
}
finally
{
m_bIsFilling = false;
this.ResumeDrawing();
}
}
/// //////////////////////////////////////////////////
private void CFormOrdonnerEntites_Load(object sender, System.EventArgs e)
{
ArrayList lst = new ArrayList(m_listeObjets);
lst.Sort(new CObjetTrieur(m_strProprieteOrdre));
m_wndListeEntites.Items.Clear();
foreach (object obj in lst)
{
ListViewItem item = new ListViewItem(CInterpreteurTextePropriete.GetValue(obj, m_strProprieteToDisplay).ToString());
item.Tag = obj;
m_wndListeEntites.Items.Add(item);
}
}
public int Compare(object x, object y)
{
try
{
int nVal1 = (int)(CInterpreteurTextePropriete.GetValue(x, m_strPropOrdre));
int nVal2 = (int)(CInterpreteurTextePropriete.GetValue(y, m_strPropOrdre));
return(nVal1.CompareTo(nVal2));
}
catch
{
}
return(0);
}
//------------------------------------------------------------
public CResultAErreur GetValue(object objet, string strPropriete)
{
CResultAErreur result = CResultAErreur.True;
try
{
object valeur = CInterpreteurTextePropriete.GetValue(objet, strPropriete);
result.Data = valeur;
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// ///////////////////////////////////////////////////////
/// <summary>
/// Valide les modifications apportées à la valeur de la source
/// </summary>
protected override bool Commit(
CurrencyManager dataSource,
int rowNum
)
{
if (m_control == null || !m_bEnEdition)
{
return(true);
}
if (this.DataGridTableStyle.DataGrid.ReadOnly)
{
m_control.Hide();
return(true);
}
if (this.DataGridTableStyle.DataGrid.DataSource == null)
{
return(true);
}
object valeur = CInterpreteurTextePropriete.GetValue(m_control, m_strProprieteControl);
try
{
SetColumnValueAtRow(dataSource, rowNum, valeur);
}
catch (Exception e)
{
Console.WriteLine("\n\n\n**************************\nOn ne devrait pas passer là : C2iDataGridColumnStyleAControle : Erreur CommitEdit\n*****************************");
Console.WriteLine(e.ToString());
if (dataSource.Position != rowNum)
{
dataSource.Refresh();
dataSource.Position = rowNum;
try
{
SetColumnValueAtRow(dataSource, rowNum, valeur);
}
catch
{
throw new Exception("Y a plus rien a faire !!!");
}
}
}
m_control.Hide();
m_bEnEdition = false;
return(true);
}
//------------------------------------------------------------------------------
public void OnLinkClicked(object sender, MouseEventArgs args)
{
if (m_bComportementLinkStandard)
{
object obj;
obj = (CObjetDonneeAIdNumerique)this.ElementSelectionne;
if (LinkProperty != "")
{
obj = CInterpreteurTextePropriete.GetValue(obj, LinkProperty);
}
if (m_typeFormEditionStandard != null && this.ElementSelectionne != null)
{
CFormEditionStandard form = (CFormEditionStandard)Activator.CreateInstance(m_typeFormEditionStandard,
new object[] { obj });
CSc2iWin32DataNavigation.Navigateur.AffichePage(form);
}
}
}
//-------------------------------------------------------------------
private void CopyListToHashtable()
{
m_hashtableObjets.Clear();
if (m_listeRelationsSelectionnees.Count < 1)
{
return;
}
foreach (CObjetDonnee rel in m_listeRelationsSelectionnees)
{
object obj = CInterpreteurTextePropriete.GetValue(rel, m_strProprieteRetournantObjetSecondaire);
m_hashtableObjets[obj] = rel;
if (OnAssocieData != null)
{
object data = null;
OnAssocieData((CObjetDonnee)obj, rel, ref data);
m_tableDataAssocie[obj] = data;
}
}
}
/// <summary>
/// Vérifie si les éléments utilisant ce paramétrage vérifient bien ses modifications
/// </summary>
/// <returns></returns>
public CResultAErreur IsModifValide()
{
CResultAErreur result = CResultAErreur.True;
string strProp = ((IObjetASystemeDeCoordonnee)ObjetASystemeDeCoordonnees).ProprieteVersObjetsAFilsACoordonneesUtilisantLeParametrage;
List <IObjetAFilsACoordonnees> lstToTest = new List <IObjetAFilsACoordonnees>();
if (strProp != "")
{
object val = CInterpreteurTextePropriete.GetValue(ObjetASystemeDeCoordonnees, strProp);
if (val == null)
{
return(result);
}
if (val is IObjetAFilsACoordonnees)
{
lstToTest.Add((IObjetAFilsACoordonnees)val);
}
else
if (val is IEnumerable)
{
foreach (IObjetAFilsACoordonnees obj in (IEnumerable)val)
{
lstToTest.Add(obj);
}
}
}
else
if (ObjetASystemeDeCoordonnees is IObjetAFilsACoordonnees)
{
lstToTest.Add((IObjetAFilsACoordonnees)ObjetASystemeDeCoordonnees);
}
string strLib = this.ObjetASystemeDeCoordonnees.DescriptionElement;
foreach (IObjetAFilsACoordonnees obj in lstToTest)
{
result = obj.VerifieCoordonneesFils();
if (!result)
{
return(result);
}
}
return(result);
}
//------------------------------------------------------------------------------
private void RemplirFromParent(object sender, EventArgs e)
{
if (DesignMode || SelectionneurParent.IsUpdating())
{
return;
}
CObjetDonnee obj = m_selectionneurParent.ElementSelectionne;
if (obj == null)
{
//this.NullAutorise = true;
this.SelectedValue = null;
this.Enabled = false;
return;
}
//this.NullAutorise = false;
this.Enabled = true;
if (m_lastObjetSelectionneDansParent != obj)
{
this.ListDonnees = (IEnumerable)CInterpreteurTextePropriete.GetValue(obj, m_strPropParentListeObjets);
this.SelectedValue = null;
}
m_lastObjetSelectionneDansParent = obj;
}
/// <summary>
/// ////////////////////////////////////////////////////////////
/// </summary>
/// <param name="nodes"></param>
/// <param name="objetParent"></param>
/// <param name="nNbSousNiveauToFill"></param>
protected virtual void FillNodes(TreeNode nodeParent, CObjetDonneeAIdNumeriqueAuto objetParent)
{
TreeNodeCollection nodes = null;
if (nodeParent == null)
{
nodes = Nodes;
}
else
{
if (((CInfoNode)nodeParent.Tag).AreChildsLoaded)
{
return;
}
nodes = nodeParent.Nodes;
((CInfoNode)nodeParent.Tag).AreChildsLoaded = true;
}
nodes.Clear();
CListeObjetsDonnees listeFils = null;
if (objetParent == null)
{
CContexteDonnee contexte = CSc2iWin32DataClient.ContexteCourant;
if (m_objetRoot != null)
{
contexte = m_objetRoot.ContexteDonnee;
}
listeFils = new CListeObjetsDonnees(contexte, m_typeObjets);
if (m_objetRoot != null)
{
listeFils.Filtre = new CFiltreData(m_objetRoot.GetChampId() + "=@1", m_objetRoot.Id);
}
else
{
listeFils.Filtre = CFiltreData.GetAndFiltre(m_filtreRacine, new CFiltreData(m_strChampParent + " is null"));
}
}
else
{
listeFils = (CListeObjetsDonnees)CInterpreteurTextePropriete.GetValue(objetParent, m_strProprieteListeFils);
if (!m_bAutoriserFilsDesAutorises || !IsInFiltre(objetParent))
{
listeFils.Filtre = CFiltreData.GetAndFiltre(listeFils.Filtre, m_filtreRacine);
}
}
foreach (CObjetDonneeAIdNumeriqueAuto objetFils in listeFils)
{
bool bVoir = IsVisible(objetFils);
/*if ( m_tableCodesVisibles != null && objetFils is IObjetHierarchiqueACodeHierarchique )
* bVoir = m_tableCodesVisibles.Contains(((IObjetHierarchiqueACodeHierarchique)objetFils).CodeSystemeComplet);*/
if (m_bAutoriserFilsDesAutorises && !bVoir)
{
if (objetParent != null && IsInFiltre(objetParent))
{
if (objetFils is IObjetHierarchiqueACodeHierarchique && m_tableCodesVisibles != null)
{
m_tableCodesVisibles.Add(((IObjetHierarchiqueACodeHierarchique)objetFils).CodeSystemeComplet, true);
}
bVoir = true;
}
}
if (bVoir)
{
TreeNode node = new TreeNode();
FillNode(node, objetFils);
nodes.Add(node);
node.Nodes.Add(new TreeNode("__")); //Noeud bidon
if (!IsInFiltre(objetFils))
{
node.ForeColor = ForeColorNonSelectionnable;
node.Expand();
}
}
}
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
// Evalue la formule de l'entité destination
result = ExpressionEntiteDestination.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during @1 formula evaluation|216", ExpressionEntiteDestination.ToString()));
return(result);
}
CObjetDonneeAIdNumeriqueAuto objetDestination = (CObjetDonneeAIdNumeriqueAuto)result.Data;
// Evalue la formule de l'entité source
result = ExpressionEntiteSource.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during @1 formula evaluation|216", ExpressionEntiteSource.ToString()));
return(result);
}
CObjetDonneeAIdNumeriqueAuto objetSource = (CObjetDonneeAIdNumeriqueAuto)result.Data;
if (m_bCopieComplete)
{
//Copie toutes les propriétés, sauf les champs
if (objetSource == null || objetDestination == null)
{
return(result);
}
Type tp = objetDestination.GetType();
DataTable table = objetDestination.Row.Table;
if (table == null)
{
return(result);
}
List <string> keys = new List <string>();
foreach (DataColumn col in table.PrimaryKey)
{
keys.Add(col.ColumnName);
}
objetDestination.ContexteDonnee.CopyRow(objetSource.Row, objetDestination.Row, keys.ToArray());
IElementAChamps eltChampsDest = objetDestination as IElementAChamps;
IElementAChamps eltChampsSource = objetSource as IElementAChamps;
if (eltChampsDest == null || eltChampsSource == null)
{
return(result);
}
foreach (CRelationElementAChamp_ChampCustom relation in eltChampsSource.RelationsChampsCustom)
{
eltChampsDest.SetValeurChamp(relation.ChampCustom, relation.Valeur);
}
}
else
{
// Faire la copie de l'objet
for (int i = 0; i < m_lstProprietesDynamiquesACopier.Length; i++)
{
CDefinitionProprieteDynamique definitionPropriete = m_lstProprietesDynamiquesACopier[i];
// Si c'est un champs custom
if (definitionPropriete is CDefinitionProprieteDynamiqueChampCustom)
{
if (!(objetSource is IElementAChamps))
{
result.EmpileErreur(I.T("@1 : Incorrect custom field of source object|298", definitionPropriete.Nom));
return(result);
}
if (!(objetDestination is IElementAChamps))
{
result.EmpileErreur(I.T("@1 : Incorrect custom field of destination object|299", definitionPropriete.Nom));
return(result);
}
// Get la valeur du champ custom de l'objet source
object valeurChamp = ((IElementAChamps)objetSource).GetValeurChamp(((CDefinitionProprieteDynamiqueChampCustom)definitionPropriete).DbKeyChamp.StringValue);
// Set la valeur du champ custom de l'objet destination
result = ((IElementAChamps)objetDestination).SetValeurChamp(
((CDefinitionProprieteDynamiqueChampCustom)definitionPropriete).DbKeyChamp.StringValue,
valeurChamp);
}
// Si c'est un champ normal de la base
else
{
string strProp = definitionPropriete.NomProprieteSansCleTypeChamp;
// Get la valeur de propriété de l'objet source
object valeurProp = CInterpreteurTextePropriete.GetValue(objetSource, strProp);
// Set la valeut de propriété de l'objet destination
if (!CInterpreteurTextePropriete.SetValue(objetDestination, strProp, valeurProp))
{
result.EmpileErreur(I.T("Property @1 : Failed to set the value|300", strProp));
return(result);
}
}
}
}
return(result);
}
/// ///////////////////////////////////////////////////////////
public object GetValue(object objetInterroge, CDefinitionProprieteDynamique propriete)
{
//Récupère l'objet à interroger
string strProp = propriete.NomPropriete;
object valeur = m_cache.GetValeurCache(objetInterroge, strProp);
if (valeur != null)
{
return(valeur);
}
CContexteDonnee contexteForObjets = ContexteDonneeCache;
if (objetInterroge is IObjetAContexteDonnee)
{
contexteForObjets = ((IObjetAContexteDonnee)objetInterroge).ContexteDonnee;
}
if (contexteForObjets == null)
{
contexteForObjets = ContexteDonneeCache;
}
object objetFinal = objetInterroge;
int nPos = strProp.LastIndexOf('.');
if (nPos > 0 && !(propriete is CDefinitionProprieteDynamiqueDonneeCumulee) &&
!(propriete is CDefinitionProprieteDynamiqueChampCustom) &&
!(propriete is CDefinitionProprieteDynamiqueChampCustomFils) &&
!(propriete is CDefinitionProprieteDynamiqueFormule))
{
string strPropDebut;
strPropDebut = strProp.Substring(0, nPos);
strProp = strProp.Substring(nPos + 1);
objetFinal = m_cache.GetValeurCache(objetInterroge, strPropDebut);
if (objetFinal == null)
{
objetFinal = GetValue(objetInterroge, strPropDebut);
/*object objetAInterroger = null;
* MemberInfo membre = null;
* CInterpreteurTexteProptVariete.GetObjetFinalEtMemberInfo ( objetInterroge, strPropDebut, ref objetAInterroger, ref membre );
* if ( membre != null )
* {
* objetFinal = CInterpreteurTextePropriete.GetValue ( objetAInterroger, membre );
* }
* else
* {
* //On n'a pas trouvé le membre, il s'agit donc d'autre chose, il faut donc décomposer
* //Le champ
* }*/
//objetFinal = CInterpreteurTextePropriete.GetValue(objetInterroge, strPropDebut);
m_cache.StockeValeurEnCache(objetInterroge, strPropDebut, objetFinal);
}
if (objetFinal == null)
{
return(null);
}
valeur = m_cache.GetValeurCache(objetFinal, strProp);
if (valeur != null)
{
return(valeur);
}
}
if (propriete is CDefinitionProprieteDynamiqueChampCustom)
{
if (!(objetFinal is IElementAChamps))
{
valeur = null;
}
else
{
//TESTDBKEYTODO qui ne peut pas marche
valeur = ((IElementAChamps)objetFinal).GetValeurChamp(((CDefinitionProprieteDynamiqueChampCustom)propriete).DbKeyChamp.InternalIdNumeriqueANeJamaisUtiliserSaufDansCDbKeyAddOn.Value, System.Data.DataRowVersion.Default);
/*if (m_bValeurAfficheeDeChampsCustom)
* {
* CChampCustom champ = new CChampCustom(ContexteDonneeCache);
* if (champ.ReadIfExists(((CDefinitionProprieteDynamiqueChampCustom)propriete).IdChamp))
* {
* object valTmp = champ.DisplayFromValue(valeur);
* if (valTmp != null)
* valeur = valTmp;
* }
* }*/
}
}
else if (propriete is CDefinitionProprieteDynamiqueChampCustomFils && objetInterroge is CObjetDonneeAIdNumerique)
{
CChampCustom champ = new CChampCustom(ContexteDonneeCache);
if (champ.ReadIfExists(((CDefinitionProprieteDynamiqueChampCustomFils)propriete).KeyChamp))
{
Type tp = champ.Role.TypeAssocie;
try
{
IObjetDonneeAChamps elt = (IObjetDonneeAChamps)Activator.CreateInstance(tp, new object[] { contexteForObjets });
CRelationElementAChamp_ChampCustom rel = elt.GetNewRelationToChamp();
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteForObjets, tp);
liste.Filtre = new CFiltreDataAvance(
elt.GetNomTable(),
rel.GetNomTable() + "." +
CRelationElementAChamp_ChampCustom.c_champValeurString + "=@1 and " +
rel.GetNomTable() + "." +
CRelationElementAChamp_ChampCustom.c_champValeurInt + "=@2 and " +
rel.GetNomTable() + "." +
CChampCustom.c_champId + "=@3",
objetInterroge.GetType().ToString(),
((CObjetDonneeAIdNumerique)objetInterroge).Id,
champ.Id);
valeur = liste.ToArray(tp);
}
catch
{
valeur = null;
}
}
}
else if (propriete is CDefinitionProprieteDynamiqueListeEntites)
{
CListeEntites liste = new CListeEntites(contexteForObjets);
try
{
if (liste.ReadIfExists(((CDefinitionProprieteDynamiqueListeEntites)propriete).DbKeyListeEntite))
{
CListeObjetsDonnees resultListe = liste.GetElementsLiesFor(objetInterroge);
if (resultListe != null)
{
valeur = resultListe.ToArray(liste.TypeElements);
}
}
}
catch
{
valeur = null;
}
}
else if (propriete is CDefinitionProprieteDynamiqueRelationTypeId)
{
if (!(objetFinal is CObjetDonneeAIdNumerique))
{
valeur = null;
}
else
{
CDefinitionProprieteDynamiqueRelationTypeId defRel = (CDefinitionProprieteDynamiqueRelationTypeId)propriete;
return(((CObjetDonneeAIdNumerique)objetFinal).GetDependancesRelationTypeId(
defRel.Relation.TableFille,
defRel.Relation.ChampType,
defRel.Relation.ChampId,
false));
}
}
else if (propriete is CDefinitionProprieteDynamiqueDonneeCumulee)
{
if (!(objetFinal is CObjetDonneeAIdNumerique))
{
valeur = null;
}
else
{
CDefinitionProprieteDynamiqueDonneeCumulee defType = (CDefinitionProprieteDynamiqueDonneeCumulee)propriete;
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)objetFinal;
CTypeDonneeCumulee type = new CTypeDonneeCumulee(contexteForObjets);
if (type.ReadIfExists(defType.DbKeyTypeDonnee))
{
valeur = type.GetDonneesCumuleesForObjet(objet);
}
else
{
valeur = null;
}
}
}
else if (propriete is CDefinitionProprieteDynamiqueChampCalcule)
{
CChampCalcule champ = new CChampCalcule(contexteForObjets);
if (champ.ReadIfExists(((CDefinitionProprieteDynamiqueChampCalcule)propriete).DbKeyChamp))
{
valeur = champ.Calcule(objetFinal, new CFournisseurPropDynStd(true));
}
else
{
valeur = null;
}
}
else if (propriete is CDefinitionProprieteDynamiqueFormule)
{
CContexteEvaluationExpression contexte = new CContexteEvaluationExpression(objetInterroge);
contexte.AttacheObjet(typeof(CContexteDonnee), contexteForObjets);
CResultAErreur result = ((CDefinitionProprieteDynamiqueFormule)propriete).Formule.Eval(contexte);
if (result)
{
return(result.Data);
}
}
else if (propriete is CDefinitionProprieteDynamiqueVariableDynamique && objetFinal is IElementAVariables)
{
valeur = ((IElementAVariables)objetFinal).GetValeurChamp(((CDefinitionProprieteDynamiqueVariableDynamique)propriete).IdChamp);
}
else
{
valeur = CInterpreteurTextePropriete.GetValue(objetFinal, strProp);
}
m_cache.StockeValeurEnCache(objetInterroge, propriete.Nom, valeur);
if (objetFinal != objetInterroge)
{
m_cache.StockeValeurEnCache(objetFinal, strProp, valeur);
}
return(valeur);
}
/// ///////////////////////////////////////////////////////////
public object GetValue(object objetInterroge, string strPropriete)
{
CFournisseurPropDynStd fournisseur = new CFournisseurPropDynStd(false);
if (objetInterroge == null)
{
return(null);
}
//Est-ce une propriété simple ?(majorité des cas )
object objetAInterroger = null;
MemberInfo membre = null;
if (CInterpreteurTextePropriete.GetObjetFinalEtMemberInfo(objetInterroge, strPropriete, ref objetAInterroger, ref membre) && membre != null)
{
return(CInterpreteurTextePropriete.GetValue(objetAInterroger, membre));
}
//Bon pas de bol, c'est autre chose, il faut donc chercher ce que c'est
Type tp = objetInterroge.GetType();
string strPropDebut = strPropriete.Split('.')[0];
object objetPremier = CInterpreteurTextePropriete.GetValue(objetInterroge, strPropDebut);
if (objetPremier == null)
{
string strIdChamp = CDefinitionProprieteDynamiqueChampCustom.GetIdPropriete(strPropDebut);
foreach (CDefinitionProprieteDynamique def in fournisseur.GetDefinitionsChamps(tp, 0))
{
if (def.NomPropriete == strPropDebut ||
(strIdChamp != "" && def is CDefinitionProprieteDynamiqueChampCustom) &&
((CDefinitionProprieteDynamiqueChampCustom)def).DbKeyChamp == CDbKey.CreateFromStringValue(strIdChamp))
{
objetPremier = GetValue(objetInterroge, def);
//Si la suite est une relation de la valeur champ vers l'objet, il ne faut pas
//traier la suite
if (strPropDebut != strPropriete)
{
string strSuiteTmp = strPropriete.Substring(strPropDebut.Length + 1);
if (CInfoRelationComposantFiltreChampToEntite.IsRelationFromChampToEntite(strSuiteTmp))
{
//On a déjà traité ce lien par GetValeurPropriété (qui retourne la valeur
//et nom pas le lien vers la valeur)
strPropDebut += "." + strPropriete.Split('.')[1];
}
}
break;
}
}
}
if (objetPremier == null)
{
return(null);
}
if (strPropDebut == strPropriete)
{
return(objetPremier);
}
string strSuite = strPropriete.Substring(strPropDebut.Length + 1);
return(GetValue(objetPremier, strSuite));
}
public CResultAErreur FillControl(Control ctrl, object obj)
{
CResultAErreur result = CResultAErreur.True;
string strPropAffichee = "";
try
{
CInfoControle info = GetInfo(ctrl, false);
if (info != null && info.AutoUpdate && info.Field.Length > 0)
{
string strProp = info.Field;
if (strProp.LastIndexOf(".") >= 0 && ctrl is ComboBox)
{
string strTemp = strProp;
strProp = strTemp.Substring(0, strTemp.LastIndexOf("."));
strPropAffichee = strTemp.Substring(strTemp.LastIndexOf(".") + 1);
}
if (strProp != null && strProp != "")
{
MemberInfo methodeAppellee = null;
object objetToInterroge = null;
object objValue = CInterpreteurTextePropriete.GetValue(obj, strProp, ref objetToInterroge, ref methodeAppellee);
if (objValue != null)
{
if (OnRemplitControle != null)
{
OnRemplitControle(strProp, objValue);
}
if (ctrl is NumericUpDown)
{
if (objValue is int)
{
((NumericUpDown)ctrl).Value = new Decimal((int)objValue);
}
else if (objValue is double)
{
((NumericUpDown)ctrl).Value = new Decimal((double)objValue);
}
else
{
((NumericUpDown)ctrl).Value = (decimal)objValue;
}
}
else if (ctrl is C2iTextBoxNumerique)
{
if (objValue is int?)
{
((C2iTextBoxNumerique)ctrl).IntValue = (int?)objValue;
}
else if (objValue is double?)
{
((C2iTextBoxNumerique)ctrl).DoubleValue = (double?)objValue;
}
else
{
((C2iTextBoxNumerique)ctrl).DoubleValue = Convert.ToDouble(objValue);
}
}
else if (ctrl is DateTimePicker)
{
((DateTimePicker)ctrl).Value = (DateTime)objValue;
}
else if (ctrl is CheckBox)
{
((CheckBox)ctrl).Checked = (bool)objValue;
}
else if (ctrl is C2iComboBox)
{
((C2iComboBox)ctrl).SelectedValue = objValue;
}
else if (ctrl is ComboBox)
{
((ComboBox)ctrl).DisplayMember = strPropAffichee;
try
{ ((ComboBox)ctrl).SelectedValue = objValue; }
catch
{ ((ComboBox)ctrl).SelectedValue = System.DBNull.Value; }
}
else if (ctrl is I2iControlEditObject)
{
((I2iControlEditObject)ctrl).ObjetEdite = objValue;
}
else if (!(ctrl is CheckBox))
{
ctrl.Text = CInterpreteurTextePropriete.GetStringValueFormatee(objValue, "", methodeAppellee);
}
}
else
{
if (ctrl is ComboBox)
{
((ComboBox)ctrl).SelectedValue = System.DBNull.Value;
}
else if (!(ctrl is CheckBox))
{
ctrl.Text = "";
}
}
if (ctrl is C2iDateTimeExPicker)
{
((C2iDateTimeExPicker)ctrl).Value = (CDateTimeEx)objValue;
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur("Error while loading control @1 by @2||30046", ctrl.Name.ToString(), obj.ToString());
return(result);
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
object elementToModif = Process.GetValeurChamp(VariableAModifier.IdVariable);
if (elementToModif is CObjetDonnee)
{
elementToModif = ((CObjetDonnee)elementToModif).GetObjetInContexte(contexte.ContexteDonnee);
}
if (elementToModif == null)
{
return(result);
}
object nouvelleValeur = null;
if (!(ExpressionValeur is C2iExpressionNull))
{
//Calcule la nouvelle valeur
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = ExpressionValeur.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during @1 formula evaluation|216", ExpressionValeur.ToString()));
return(result);
}
nouvelleValeur = result.Data;
}
if (m_definitionPropriete.NomPropriete.Length > 1 &&
m_definitionPropriete.NomPropriete[0] == CDefinitionProprieteDynamique.c_strCaractereStartCleType)
{
result = CInterpreteurProprieteDynamique.SetValue(elementToModif, m_definitionPropriete, nouvelleValeur);
}
else
{
//Ancienne méthode
//Si modif de champ custom
if (m_definitionPropriete is CDefinitionProprieteDynamiqueChampCustom)
{
if (!(elementToModif is IElementAChamps))
{
result.EmpileErreur(I.T("@1 : Incorrect custom field or invalid target|217", m_definitionPropriete.Nom));
return(result);
}
result = ((IElementAChamps)elementToModif).SetValeurChamp(((CDefinitionProprieteDynamiqueChampCustom)m_definitionPropriete).DbKeyChamp.StringValue, nouvelleValeur);
return(result);
}
//récupère les éléments à modifier
string[] strProps = m_definitionPropriete.NomPropriete.Split('.');
ArrayList lstElementsAModifier = new ArrayList();
lstElementsAModifier.Add(elementToModif);
for (int nProp = 0; nProp < strProps.Length - 1; nProp++)
{
string strProp = strProps[nProp];
string strTmp = "";
CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(strProp, ref strTmp, ref strProp);
ArrayList newListe = new ArrayList();
foreach (object objet in lstElementsAModifier)
{
object newToModif = CInterpreteurTextePropriete.GetValue(objet, strProp);
if (newToModif != null)
{
newListe.Add(newToModif);
}
}
lstElementsAModifier = newListe;
}
string strLastProp = strProps[strProps.Length - 1];
MethodInfo fonctionFinale = null;
//Modifie la valeur
foreach (object obj in lstElementsAModifier)
{
try
{
if (fonctionFinale == null)
{
object dummy = null;
MemberInfo membre = null;
string strTmp = "";
CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(strLastProp, ref strTmp, ref strLastProp);
CInterpreteurTextePropriete.GetObjetFinalEtMemberInfo(obj, strLastProp, ref dummy, ref membre);
if (membre == null || !(membre is PropertyInfo))
{
result.EmpileErreur(I.T("The @1 property cannot be find|218", strLastProp));
return(result);
}
fonctionFinale = ((PropertyInfo)membre).GetSetMethod(true);
if (fonctionFinale == null)
{
result.EmpileErreur(I.T("The @1 property is in reading only|219", strLastProp));
return(result);
}
}
fonctionFinale.Invoke(obj, new object[] { nouvelleValeur });
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
return(result);
}
}
}
return(result);
}
