/// ////////////////////////////////////////////////////////////
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;
}
//-----------------------------------------------------------------
public static string GetDonneeDynamiqueString(object obj, string strPropriete, string strValeurSiNull)
{
string strSuite = "";
CDefinitionProprieteDynamique defProp = GetDefinitionProprieteDynamique(strPropriete, ref strSuite);
if (defProp != null)
{
try
{
object retour = CInterpreteurProprieteDynamique.GetValue(obj, defProp).Data;
if (retour == null)
{
return(strValeurSiNull);
}
if (strSuite != "")
{
return(GetDonneeDynamiqueString(retour, strSuite, strValeurSiNull));
}
return(retour.ToString());
}
catch
{
return(strValeurSiNull);
}
}
try
{
return(CInterpreteurTextePropriete.GetStringValue(obj, strPropriete, strValeurSiNull));
}
catch
{
return(strValeurSiNull);
}
}
//---------------------------------------------------------------------------
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();
}
}
public CResultAErreur SetValue(object objet, string strPropriete, object valeur)
{
CResultAErreur result = CResultAErreur.True;
if (!CInterpreteurTextePropriete.SetValue(objet, strPropriete, valeur))
{
result.EmpileErreur(I.T("Error while affecting value|20003"));
}
return(result);
}
//------------------------------------------------------------------
private void SynchroniseTextEtObjet()
{
if (m_selectedObject == null)
{
Text = TextNull;
}
else
{
Text = CInterpreteurTextePropriete.GetStringValue(m_selectedObject, m_strPropriete, "");
}
m_strOldText = Text;
}
/// //////////////////////////////////////////////////
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);
}
private void SelectionMultiples()
{
CListeObjetsDonnees liste = ListeRelations;
CObjetDonneeAIdNumerique[] elts = (CObjetDonneeAIdNumerique[])CInterpreteurTextePropriete.CreateListeFrom(
liste, "ElementLie", typeof(CObjetDonneeAIdNumerique));
elts = CFormSelectElementsMultiples.GetListeElements(
m_typeRelation.TypeElements,
m_typeRelation.FiltreDataAssocie,
elts);
if (elts != null)
{
using (CWaitCursor waiter = new CWaitCursor())
{
//Table Entite->Vrai si existe dans les deux liste
// ->Faux si existe uniquement dans l'ancienne liste (à supprimer)
// ->Null si existe uniquement dans la nouvelle liste (à créer)
Hashtable tableExistants = new Hashtable();
foreach (CRelationEntreeAgenda_ElementAAgenda rel in ListeRelations)
{
tableExistants[rel.ElementLie] = false;
}
foreach (CObjetDonneeAIdNumerique objet in elts)
{
if (tableExistants[objet] == null) //création
{
CRelationEntreeAgenda_ElementAAgenda rel = new CRelationEntreeAgenda_ElementAAgenda(m_entreeAgenda.ContexteDonnee);
rel.CreateNewInCurrentContexte();
rel.ElementLie = objet;
rel.EntreeAgenda = m_entreeAgenda;
rel.RelationTypeEntree_TypeElement = m_typeRelation;
}
else
{
tableExistants[objet] = true;
}
}
//Supprime ceux qui doivent être supprimés
foreach (CRelationEntreeAgenda_ElementAAgenda rel in ListeRelations.ToArrayList())
{
object val = tableExistants[rel.ElementLie];
if (val is bool && ((bool)val) == false)
{
rel.Delete();
}
}
}
}
RefreshText();
}
private void m_btnOk_Click(object sender, System.EventArgs e)
{
int nIndice = m_numUpStart.IntValue;
int nPas = m_numUpPas.IntValue;
foreach (ListViewItem item in m_wndListeEntites.Items)
{
CInterpreteurTextePropriete.SetValue(
item.Tag, m_strProprieteOrdre, nIndice);
nIndice += nPas;
}
DialogResult = DialogResult.OK;
Close();
}
//------------------------------------------------------------
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);
}
//-------------------------------------------------------------------
public void ApplyModifs()
{
if (LockEdition)
{
return;
}
foreach (ListViewItem item in m_listView.Items)
{
CObjetDonneeAIdNumeriqueAuto objet = (CObjetDonneeAIdNumeriqueAuto)item.Tag;
bool bCreate = item.Checked;
if (ExclusionParException)
{
bCreate = !bCreate;
}
if (bCreate)
{
CObjetDonnee relation = (CObjetDonnee)m_hashtableObjets[objet];
if (relation == null)
{
relation = (CObjetDonnee)Activator.CreateInstance(m_listeRelationsSelectionnees.TypeObjets, new object[] { m_contexte });
relation.CreateNewInCurrentContexte(null);
CInterpreteurTextePropriete.SetValue(relation, m_strPropObjetConcerne, m_objetConcerne);
CInterpreteurTextePropriete.SetValue(relation, m_strProprieteRetournantObjetSecondaire, objet);
m_hashtableObjets[objet] = relation;
}
if (OnValideRelation != null)
{
object data = GetDataAssocie(objet);
if (OnSelectionChanged != null)
{
OnSelectionChanged(objet, data);
}
data = GetDataAssocie(objet);
OnValideRelation(objet, relation, ref data);
SetDataAssocie(objet, data);
}
}
else
{
if (m_hashtableObjets[objet] != null)
{
((CObjetDonnee)m_hashtableObjets[objet]).Delete();
m_hashtableObjets[objet] = null;
}
}
}
}
/// ///////////////////////////////////////////////////////
/// <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 Init(CObjetDonneeAIdNumerique[] elements)
{
m_elementsAAgenda = elements;
if (elements.Length == 0)
{
m_filtrePrincipal = new CFiltreDataImpossible();
}
else
{
//Type->id à voir
Hashtable tableTypeToIds = new Hashtable();
Type tp = m_elementsAAgenda[0].GetType();
foreach (CObjetDonneeAIdNumerique objet in m_elementsAAgenda)
{
AddElementAVoir(objet, tableTypeToIds);
if (objet is IElementAAgenda)
{
foreach (string strProp in ((IElementAAgenda)objet).GetProprietesAccessSousElementsAgenda())
{
ArrayList lst = CInterpreteurTextePropriete.CreateListePlateFrom(objet, strProp);
foreach (CObjetDonneeAIdNumerique objFils in lst)
{
AddElementAVoir(objFils, tableTypeToIds);
}
}
}
}
m_filtrePrincipal = new CFiltreData( );
string strFiltre = "";
int nVariable = 1;
foreach (DictionaryEntry dic in tableTypeToIds)
{
if (strFiltre != "")
{
strFiltre += " or ";
}
strFiltre += "(" + CRelationEntreeAgenda_ElementAAgenda.c_champTypeElementAAgenda + "=@" + nVariable.ToString() + " and " +
CRelationEntreeAgenda_ElementAAgenda.c_champIdElementAAgenda + " in (" + dic.Value.ToString() + "))";
m_filtrePrincipal.Parametres.Add(dic.Key.ToString());
nVariable++;
}
m_filtrePrincipal.Filtre = strFiltre;
}
}
//------------------------------------------------------------------------------
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 SynchroniseTextEtObjet()
{
if (m_selectedEntity == null)
{
Text = TextNull;
}
else
{
foreach (CConfigTextBoxSelectMemoryDb config in m_listeConfigs)
{
if (config.TypeObjets != null && config.TypeObjets.IsAssignableFrom(m_selectedEntity.GetType()))
{
Text = CInterpreteurTextePropriete.GetStringValue(m_selectedEntity, config.ProprieteAffichee, "");
break;
}
}
}
m_strOldText = Text;
UpdateImage();
}
//------------------------------------------------------------------------------
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;
}
/// ////////////////////////////////////////////////////////
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));
}
/// ////////////////////////////////////////////////////////
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);
}
/// <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();
}
}
}
}
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);
}
private void InitIntellisense()
{
if (m_dicIntellisense == null)
{
m_dicIntellisense = new Dictionary <string, HashSet <CReferenceEntiteMemoryDb> >();
HashSet <string> setMots = new HashSet <string>();
try
{
if (m_listeConfigs != null && m_bUseIntellisense)
{
foreach (CConfigTextBoxSelectMemoryDb config in m_listeConfigs)
{
try
{
CListeEntitesDeMemoryDbBase lstObjs = new CListeEntitesDeMemoryDbBase(m_currentMemoryDb, config.TypeObjets);
CFiltreMemoryDb filtre = config.FiltreDeBase;
lstObjs.Filtre = filtre;
if (lstObjs.Count() < 4000)
{
foreach (CEntiteDeMemoryDb obj in lstObjs)
{
string strText = CInterpreteurTextePropriete.GetStringValue(obj, config.ProprieteAffichee, "");
if (strText.Trim().Length > 0)
{
strText = strText.Trim();
HashSet <string> lstStrings = new HashSet <string>();
lstStrings.Add(strText);
int nIndex = strText.IndexOf(' ');
while (nIndex >= 0)
{
strText = strText.Substring(nIndex + 1).Trim();
lstStrings.Add(strText);
nIndex = strText.IndexOf(' ');
}
foreach (string strMotTmp in strText.Split(' '))
{
if (strMotTmp.Length > 2)
{
if (strMotTmp.Trim().Length > 0)
{
lstStrings.Add(strMotTmp);
}
}
}
CReferenceEntiteMemoryDb refObj = new CReferenceEntiteMemoryDb(obj);
foreach (string strMot in lstStrings)
{
HashSet <CReferenceEntiteMemoryDb> lst = null;
foreach (string strMotToutSeul in strMot.Split(' '))
{
if (!m_dicIntellisense.TryGetValue(strMotToutSeul.ToUpper(), out lst))
{
lst = new HashSet <CReferenceEntiteMemoryDb>();
m_dicIntellisense[strMotToutSeul.ToUpper()] = lst;
}
lst.Add(refObj);
}
if (!m_dicIntellisense.TryGetValue(strMot.ToUpper(), out lst))
{
lst = new HashSet <CReferenceEntiteMemoryDb>();
m_dicIntellisense[strMot.ToUpper()] = lst;
}
lst.Add(refObj);
setMots.Add(strMot);
}
}
}
}
}
catch { }
}
}
m_textBox.AutoCompleteSource = AutoCompleteSource.CustomSource;
m_textBox.AutoCompleteMode = AutoCompleteMode.Suggest;
m_textBox.AutoCompleteCustomSource.Clear();
m_textBox.AutoCompleteCustomSource.AddRange(setMots.ToArray());
}
catch { }
}
}
private void InitIntellisense()
{
if (m_dicIntellisense == null)
{
m_dicIntellisense = new Dictionary <string, HashSet <CReferenceObjetDonnee> >();
HashSet <string> setMots = new HashSet <string>();
try
{
if (m_listeConfigs != null && m_bUseIntellisense)
{
foreach (CConfigTextBoxFiltreRapide config in m_listeConfigs)
{
try
{
/*if (!typeof(IObjetALectureTableComplete).IsAssignableFrom(config.TypeObjets))
* continue;//Ne met en intellisense que ce qui est en lectutre table complète*/
CListeObjetsDonnees lstObjs = new CListeObjetsDonnees(CSc2iWin32DataClient.ContexteCourant, config.TypeObjets);
CFiltreData filtre = config.FiltreDeBase;
lstObjs.Filtre = filtre;
if (lstObjs.CountNoLoad < 4000)
{
foreach (CObjetDonnee obj in lstObjs)
{
string strText = CInterpreteurTextePropriete.GetStringValue(obj, config.ProprieteAffichee, "");
if (strText.Trim().Length > 0)
{
strText = strText.Trim();
HashSet <string> lstStrings = new HashSet <string>();
lstStrings.Add(strText);
int nIndex = GetIndexSeparateurNextWord(strText);
// strText.IndexOf(' ');
while (nIndex >= 0)
{
strText = strText.Substring(nIndex + 1).Trim();
lstStrings.Add(strText);
nIndex = GetIndexSeparateurNextWord(strText);
//nIndex = strText.IndexOf(' ');
}
foreach (string strMotTmp in strText.Split(' '))
{
if (strMotTmp.Length > 2)
{
if (strMotTmp.Trim().Length > 0)
{
lstStrings.Add(strMotTmp);
}
}
}
CReferenceObjetDonnee refObj = new CReferenceObjetDonnee(obj);
foreach (string strMot in lstStrings)
{
HashSet <CReferenceObjetDonnee> lst = null;
foreach (string strMotToutSeul in strMot.Split(' '))
{
if (!m_dicIntellisense.TryGetValue(strMotToutSeul.ToUpper(), out lst))
{
lst = new HashSet <CReferenceObjetDonnee>();
m_dicIntellisense[strMotToutSeul.ToUpper()] = lst;
}
lst.Add(refObj);
}
if (!m_dicIntellisense.TryGetValue(strMot.ToUpper(), out lst))
{
lst = new HashSet <CReferenceObjetDonnee>();
m_dicIntellisense[strMot.ToUpper()] = lst;
}
lst.Add(refObj);
setMots.Add(strMot);
}
}
}
}
}
catch { }
}
}
m_textBox.AutoCompleteSource = AutoCompleteSource.CustomSource;
m_textBox.AutoCompleteMode = AutoCompleteMode.Suggest;
m_textBox.AutoCompleteCustomSource.Clear();
m_textBox.AutoCompleteCustomSource.AddRange(setMots.ToArray());
}
catch { }
}
}
/// ///////////////////////////////////////////////////////
/// <summary>
/// Passe la cellule en édition grâce au contrôle correspondant
/// </summary>
protected override void Edit(
CurrencyManager cur,
int nLigne,
Rectangle bounds,
bool bReadOnly,
string strValue,
bool bCellIsVisible)
{
if (m_control == null)
{
return;
}
if (this.DataGridTableStyle.DataGrid.ReadOnly)
{
m_control.Hide();
return;
}
m_bEnEdition = true;
try
{
object valeur = GetColumnValueAtRow(cur, nLigne);
m_control.Parent = this.DataGridTableStyle.DataGrid;
m_control.Bounds = bounds;
if (BackColor.A == 255)
{
m_control.BackColor = BackColor;
}
else
{
m_control.BackColor = this.DataGridTableStyle.DataGrid.BackColor;
}
if (ForeColor.A == 255)
{
m_control.ForeColor = ForeColor;
}
else
{
m_control.ForeColor = this.DataGridTableStyle.DataGrid.ForeColor;
}
if (m_font != null)
{
m_control.Font = Font;
}
m_control.Show();
try
{
CInterpreteurTextePropriete.SetValue(m_control, m_strProprieteControl, valeur);
}
catch
{
try
{
//Tente en texte !
CInterpreteurTextePropriete.SetValue(m_control, m_strProprieteControl, GetString(cur.Current, valeur));
}
catch
{
//Rien à faire, on n'y arrive pas. Tant pis
}
}
m_control.Focus();
//Définit le controle qui doit éditer la valeur de la cellule
ColumnStartedEditing(m_control);
}
catch {}
}
