//-------------------------------------------------------
public CParametreSourceChart GetCloneAvecMemeId()
{
CParametreSourceChart p = CCloner2iSerializable.Clone(this, null, new object[] { m_chartSetup }) as CParametreSourceChart;
p.m_strId = m_strId;
return(p);
}
//------------------------------------------------------------------------------------------------------
public static bool EditeFonction(
ref CFonctionDynamique fonction,
CObjetPourSousProprietes objetAnalyse,
params KeyValuePair <string, Type>[] variablesSpecifiques)
{
if (fonction == null)
{
return(false);
}
CFormEditionFonctionDynamique form = new CFormEditionFonctionDynamique();
CFonctionDynamique fTmp = CCloner2iSerializable.Clone(fonction) as CFonctionDynamique;
form.m_panelFonction.Init(fTmp, objetAnalyse, true);
foreach (KeyValuePair <string, Type> kv in variablesSpecifiques)
{
form.m_panelFonction.AddSpecificVariableTypes(kv.Key, kv.Value);
}
bool bResult = false;
if (form.ShowDialog() == DialogResult.OK)
{
fonction = fTmp;
bResult = true;
}
form.Dispose();
return(bResult);
}
//---------------------------------------------------
public void Init(C2iStructureImport structure)
{
m_structureImport = CCloner2iSerializable.Clone(structure) as C2iStructureImport;
//Remplit la liste des types
CInfoClasseDynamique[] classes = DynamicClassAttribute.GetAllDynamicClass();
ArrayList classesAIdAuto = new ArrayList();
foreach (CInfoClasseDynamique classe in classes)
{
if (typeof(CObjetDonneeAIdNumeriqueAuto).IsAssignableFrom(classe.Classe))
{
classesAIdAuto.Add(classe);
}
}
classesAIdAuto.Insert(0, new CInfoClasseDynamique(typeof(DBNull), I.T("None|19")));
m_cmbTypeEntite.DataSource = null;
m_cmbTypeEntite.DataSource = classesAIdAuto;
m_cmbTypeEntite.DisplayMember = "Nom";
m_cmbTypeEntite.ValueMember = "Classe";
m_cmbTypeEntite.SelectedValue = m_structureImport.TypeCible;
m_chkOptionCreate.Checked = ((m_structureImport.OptionImport & EOptionImport.Create) == EOptionImport.Create);
m_chkOptionUpdate.Checked = ((m_structureImport.OptionImport & EOptionImport.Update) == EOptionImport.Update);
m_chkPrechargerLaCible.Checked = m_structureImport.ChargerTouteLaCible;
FillControleMappage();
}
//-----------------------------------------------------------------------
public void Init(Type typeObjetPourForm, CReferenceTypeForm refTypeForm)
{
m_typeObjetPourForm = typeObjetPourForm;
m_refTypeFormAvecCondition = new CReferenceTypeFormAvecCondition();
if (refTypeForm is CReferenceTypeFormBuiltIn)
{
m_refTypeFormAvecCondition.DefaultTypeForm = refTypeForm;
}
if (refTypeForm is CReferenceTypeFormDynamic)
{
m_refTypeFormAvecCondition.DefaultTypeForm = refTypeForm;
}
if (refTypeForm is CReferenceTypeFormAvecCondition)
{
m_refTypeFormAvecCondition = CCloner2iSerializable.Clone(refTypeForm) as CReferenceTypeFormAvecCondition;
}
m_comboDefaultForm.Init(typeObjetPourForm);
m_comboDefaultForm.TypeSelectionne = m_refTypeFormAvecCondition.DefaultTypeForm;
List <CRefTypeFormAvecConditionItem> lst = new List <CRefTypeFormAvecConditionItem>();
foreach (CReferenceTypeFormAvecCondition.CParametreTypeForm p in m_refTypeFormAvecCondition.Parametres)
{
lst.Add(new CRefTypeFormAvecConditionItem(m_typeObjetPourForm, p));
}
m_wndListeForms.Items = lst.ToArray();
}
//------------------------------------------------------------------
public CChartSetup EditeParametreChart(CChartSetup parametre)
{
CChartSetup copie = CCloner2iSerializable.Clone(parametre) as CChartSetup;
copie.IContexteDonnee = parametre.IContexteDonnee;
copie.ElementAVariablesExternes = parametre.ElementAVariablesExternes;
CObjetPourSousProprietes oldTp = CProprieteExpressionEditor.ObjetPourSousProprietes;
IFournisseurProprietesDynamiques oldFournisseur = CProprieteExpressionEditor.FournisseurProprietes;
try
{
CProprieteExpressionEditor.ObjetPourSousProprietes = typeof(CChartSetup);
CProprieteExpressionEditor.FournisseurProprietes = new CFournisseurGeneriqueProprietesDynamiques();
if (CFormEditChartSetup.EditeSetup(copie))
{
return(copie);
}
}
catch { }
finally
{
CProprieteExpressionEditor.ObjetPourSousProprietes = oldTp;
CProprieteExpressionEditor.FournisseurProprietes = oldFournisseur;
}
return(parametre);
}
public void Init(CODEQTableauCroise objetTableauCroise)
{
m_txtNomTable.Text = objetTableauCroise.NomFinal;
m_chkUseCache.Checked = objetTableauCroise.UseCache;
m_objetTableauCroise = objetTableauCroise;
m_tableSource = new DataTable();
IObjetDeEasyQuery tableDef = m_objetTableauCroise.TableSource;
if (tableDef != null)
{
foreach (IColumnDeEasyQuery col in tableDef.Columns)
{
Type tp = col.DataType;
if (tp.IsGenericType && tp.GetGenericTypeDefinition() == typeof(Nullable <>))
{
tp = tp.GetGenericArguments()[0];
}
m_tableSource.Columns.Add(new DataColumn(col.ColumnName, tp));
}
}
CTableauCroise tableauCroise = CCloner2iSerializable.Clone(m_objetTableauCroise.TableauCroise) as CTableauCroise;
if (tableauCroise == null)
{
tableauCroise = new CTableauCroise();
}
m_panelTableauCroise.InitChamps(m_tableSource, tableauCroise);
}
//-----------------------------------------------------------------------
public CReferenceTypeForm GetReferenceTypeForm()
{
if (m_wndListeForms.Items.Count() == 0)
{
if (m_comboDefaultForm.TypeSelectionne != null)
{
return(m_comboDefaultForm.TypeSelectionne);
}
}
else
{
m_refTypeFormAvecCondition.DefaultTypeForm = m_comboDefaultForm.TypeSelectionne;
CResultAErreur result = m_wndListeForms.MajChamps();
if (result)
{
List <CReferenceTypeFormAvecCondition.CParametreTypeForm> lst = new List <CReferenceTypeFormAvecCondition.CParametreTypeForm>();
foreach (CRefTypeFormAvecConditionItem i in m_wndListeForms.Items)
{
lst.Add(i.Parametre);
}
m_refTypeFormAvecCondition.Parametres = lst.ToArray();
}
CReferenceTypeFormAvecCondition rt = CCloner2iSerializable.Clone(m_refTypeFormAvecCondition) as CReferenceTypeFormAvecCondition;
return(rt);
}
return(null);
}
public static CParametreRepresentationSymbole EditeParametre(
Type typeElements,
CParametreRepresentationSymbole parametre)
{
CFormEditCParametreRepresentationSymbole form = new CFormEditCParametreRepresentationSymbole();
if (parametre != null)
{
form.m_parametre = CCloner2iSerializable.Clone(parametre) as CParametreRepresentationSymbole;
if (form.m_parametre == null)
{
form.m_parametre = new CParametreRepresentationSymbole();
}
}
form.m_typeElements = typeElements;
DialogResult result = form.ShowDialog();
CParametreRepresentationSymbole newParametre = parametre;
if (result == DialogResult.OK)
{
newParametre = form.m_parametre;
}
form.Dispose();
return(newParametre);
}
//////////////////////////////////////////////////
protected void CopyTo(CFiltreDataAvance filtre)
{
base.CopyTo(filtre);
filtre.m_strTablePrincipale = m_strTablePrincipale;
if (m_composantPrincipal != null)
{
m_composantPrincipal = (CComposantFiltre)CCloner2iSerializable.Clone(m_composantPrincipal);
}
}
//-------------------------------------------------
public void Init(IObjetDeEasyQuery table1, IObjetDeEasyQuery table2, CParametreJointure parametre)
{
if (table1 == null || table2 == null)
{
Visible = false;
return;
}
Visible = true;
m_parametre = CCloner2iSerializable.Clone(parametre) as CParametreJointure;
m_cmbOperateur.Items.Clear();
if (table1 != null)
{
m_txtFormule1.Init(table1, table1.GetType());
}
if (table2 != null)
{
m_txtFormule2.Init(table2, table2.GetType());
}
foreach (EOperateurJointure operateur in Enum.GetValues(typeof(EOperateurJointure)))
{
switch (operateur)
{
case EOperateurJointure.Egal:
m_cmbOperateur.Items.Add("=");
break;
case EOperateurJointure.Superieur:
m_cmbOperateur.Items.Add(">");
break;
case EOperateurJointure.SuperieurEgal:
m_cmbOperateur.Items.Add(">=");
break;
case EOperateurJointure.Inferieur:
m_cmbOperateur.Items.Add("<");
break;
case EOperateurJointure.InferieurEgal:
m_cmbOperateur.Items.Add("<=");
break;
case EOperateurJointure.Different:
m_cmbOperateur.Items.Add("<>");
break;
default:
break;
}
m_txtFormule1.Formule = m_parametre.FormuleTable1;
m_txtFormule2.Formule = m_parametre.FormuleTable2;
m_cmbOperateur.SelectedIndex = (int)m_parametre.Operateur;
}
}
//-----------------------------------------
public CChampCustom GetChampInMemoryDb(CMemoryDb db)
{
CChampCustom copie = new CChampCustom(db);
if (!copie.ReadIfExist(Id))
{
copie = CCloner2iSerializable.Clone(this, null, new object[] { db }) as CChampCustom;
}
return(copie);
}
//----------------------------------------------------
public void Init(CObjetDonnee objetRacine)
{
m_entitesManager = new CEntitiesManager(objetRacine.ContexteDonnee.IdSession);
m_entitesManager.IndicateurProgression = m_lblProgression;
if (m_configParDefaut != null)
{
m_entitesManager.ConfigurationRecherche = CCloner2iSerializable.CloneGeneric <CConfigurationRechercheEntites>(m_configParDefaut);
}
m_objetRacine = objetRacine;
m_pileObjets.Push(objetRacine);
ShowObjetCourant();
}
//---------------------------------------------------------------
protected override void MyCreateControle(
CCreateur2iFormulaireV2 createur,
C2iWnd wnd,
Control parent,
IFournisseurProprietesDynamiques fournisseurProprietes)
{
m_createur = createur;
m_fournisseur = fournisseurProprietes;
C2iWndConteneurSousFormulaire conteneur = wnd as C2iWndConteneurSousFormulaire;
if (conteneur == null)
{
return;
}
m_panelSousFormulaire = new CPanelSousFormulaire();
//m_panelPourBorder = new Panel();
//m_panelPourBorder.Controls.Add(m_panelSousFormulaire);
//m_panelSousFormulaire.Dock = DockStyle.Fill;
switch (conteneur.BorderStyle)
{
case C2iWndPanel.PanelBorderStyle.Aucun:
m_panelSousFormulaire.BorderStyle = BorderStyle.None;
break;
case C2iWndPanel.PanelBorderStyle._3D:
m_panelSousFormulaire.BorderStyle = BorderStyle.Fixed3D;
break;
case C2iWndPanel.PanelBorderStyle.Plein:
m_panelSousFormulaire.BorderStyle = BorderStyle.FixedSingle;
break;
default:
break;
}
CCreateur2iFormulaireV2.AffecteProprietesCommunes(conteneur, m_panelSousFormulaire);
m_panelSousFormulaire.AutoScroll = true;
m_panelSousFormulaire.AdjustSizeToFormulaire = conteneur.Autosize;
//parent.Controls.Add(m_panelPourBorder);
parent.Controls.Add(m_panelSousFormulaire);
if (conteneur != null && conteneur.SubFormReference != null)
{
C2iWnd frm = sc2i.formulaire.subform.C2iWndProvider.GetForm(conteneur.SubFormReference);
if (frm != null)
{
SubForm = CCloner2iSerializable.Clone(frm) as C2iWnd;
}
}
}
//---------------------------------------------------------------------------
public static CConfigurationRechercheEntites EditeConfiguration(CConfigurationRechercheEntites configuration)
{
using (CFormParametresRecherche frm = new CFormParametresRecherche())
{
frm.m_configuration = CCloner2iSerializable.CloneGeneric <CConfigurationRechercheEntites>(configuration);
if (frm.ShowDialog() == DialogResult.OK)
{
return(frm.m_configuration);
}
}
return(null);
}
//----------------------------------------------------
public static void ShowListe(
string strTitre,
CListeObjetsDonnees listeAVoir,
CFormNavigateur navigateurAssocié,
GLColumnCollection columns,
string strContexteUtilisation)
{
if (listeAVoir == null)
{
return;
}
//Créer une nouvelle liste dans le contexte de base
CListeObjetsDonnees lst = new CListeObjetsDonnees(CSc2iWin32DataClient.ContexteCourant, listeAVoir.TypeObjets);
CFiltreData filtre = CFiltreData.GetAndFiltre(listeAVoir.FiltrePrincipal,
listeAVoir.Filtre);
lst.Filtre = filtre;
CFormListeExtraiteOld frm = new CFormListeExtraiteOld();
frm.Text = strTitre;
frm.m_navigateurAssocié = navigateurAssocié != null?navigateurAssocié:m_navigateurParDefaut;
Image img = CFormListeStandard.CalculeNewImage(lst.TypeObjets);
frm.m_listeObjets = lst;
if (columns != null)
{
frm.m_panelListe.AllowSerializePreferences = false;
foreach (GLColumn col in columns)
{
GLColumn copie = CCloner2iSerializable.Clone(col) as GLColumn;
frm.m_panelListe.Columns.Add(copie);
}
}
else
{
frm.m_panelListe.AllowSerializePreferences = true;
if (strContexteUtilisation != null)
{
frm.m_panelListe.ContexteUtilisation = strContexteUtilisation;
}
string strField = DescriptionFieldAttribute.GetDescriptionField(lst.TypeObjets, "DescriptionElement");
GLColumn col = new GLColumn("");
col.Propriete = strField;
col.Width = frm.m_panelListe.ClientSize.Width;
frm.m_panelListe.Columns.Add(col);
}
frm.Show();
}
public void Init(CParametreVisuDonneePrecalculee parametre)
{
if (parametre == null)
{
m_parametre = new CParametreVisuDonneePrecalculee();
}
else
{
m_parametre = CCloner2iSerializable.Clone(parametre) as CParametreVisuDonneePrecalculee;
}
InitComboTypeDonnee();
InitFromParametre();
}
public static CParametresInitialisationEtape EditeParametres(CParametresInitialisationEtape parametres)
{
CFormEditeParametresInitialisationEtape form = new CFormEditeParametresInitialisationEtape();
form.m_parametre = CCloner2iSerializable.Clone(parametres) as CParametresInitialisationEtape;
CParametresInitialisationEtape retour = parametres;
if (form.ShowDialog() == DialogResult.OK)
{
retour = form.m_parametre;
}
form.Dispose();
return(retour);
}
/// /////////////////////////////////////////////////
public static CResultAErreur AnalyseFormule(string strChaine, string strTableDeBase)
{
CResultAErreur result = CResultAErreur.True;
string strKey = strTableDeBase + "/" + strChaine;
CComposantFiltre composant = (CComposantFiltre)m_tableCache[strKey];
if (composant != null)
{
composant = (CComposantFiltre)CCloner2iSerializable.Clone(composant);
result.Data = composant;
return(result);
}
CAnalyseurSyntaxiqueFiltre analyseur = new CAnalyseurSyntaxiqueFiltre(strTableDeBase);
analyseur.SyntaxeSqlStandard = false;
string strCopie = strChaine;
//Permet de convertir un filtre data en filter data avancé
Regex exNotLike = new Regex("not like", RegexOptions.IgnoreCase);
Regex exNotIn = new Regex("not in", RegexOptions.IgnoreCase);
strCopie = exNotIn.Replace(strCopie, "NotIn");
strCopie = exNotLike.Replace(strCopie, "NotLike");
result = analyseur.AnalyseChaine(strCopie);
if (!result)
{
result.EmpileErreur(I.T("-------------SC2I Syntax-----------------|110"));
analyseur.SyntaxeSqlStandard = true;
CResultAErreur resultStd = analyseur.AnalyseChaine(strChaine);
if (!resultStd)
{
resultStd.EmpileErreur(I.T("-------------SQL Syntax--------------|111"));
result.Erreur += resultStd.Erreur;
}
else
{
result = resultStd;
}
}
if (result.Data is CComposantFiltre)
{
composant = (CComposantFiltre)result.Data;
composant = (CComposantFiltre)CCloner2iSerializable.Clone(composant);
m_tableCache.AddElement(strKey, composant);
}
return(result);
}
/// //////////////////////////////////////////////////////
public static bool EditeTableau(CTableauCroise tableau, DataTable tableSource)
{
CFormEditTableauCroise form = new CFormEditTableauCroise();
CTableauCroise copie = (CTableauCroise)CCloner2iSerializable.Clone(tableau);
form.Init(copie, tableSource);
Boolean bOk = form.ShowDialog() == DialogResult.OK;
if (bOk)
{
tableau.CopieFrom(copie);
}
form.Dispose();
return(bOk);
}
//---------------------------------------------------------
public void Init(CParametreEasyQueryConnexion parametre, CObjetPourSousProprietes source, IFournisseurProprietesDynamiques fournisseurProprietes)
{
if (parametre == null)
{
m_parametre = new CParametreEasyQueryConnexion();
}
else
{
m_parametre = CCloner2iSerializable.CloneGeneric <CParametreEasyQueryConnexion>(parametre);
}
m_txtNomConnexion.Text = m_parametre.NomConnexion;
FillComboTypesConnexions();
m_cmbTypeConnexion.SelectedValue = parametre.IdTypeConnexion;
m_txtNomConnexion.Text = parametre.NomConnexion;
m_wndFormulesParametres.Init(parametre.FormulesParametres.ToArray(), source, fournisseurProprietes);
}
//-------------------------------------------------------------------------
protected override CResultAErreur MyInitChamps()
{
CResultAErreur result = base.MyInitChamps();
AffecterTitre(I.T("Dynamic function @1|20841", FonctionDynamiqueInDb.Nom));
InitComboTypes(false);
InitComboCategories();
m_cmbCategorie.Text = FonctionDynamiqueInDb.Categorie;
m_fonctionEditee = new CFonctionDynamique();
if (FonctionDynamiqueInDb.Fonction != null)
{
m_fonctionEditee = CCloner2iSerializable.Clone(FonctionDynamiqueInDb.Fonction) as CFonctionDynamique;
}
m_panelFonction.Init(m_fonctionEditee, FonctionDynamiqueInDb.TypeObjets, false);
return(result);
}
public List <C2iWndListe.CColonne> EditeColonnes(List <C2iWndListe.CColonne> liste)
{
List <C2iWndListe.CColonne> lstCopie = new List <C2iWndListe.CColonne>();
foreach (C2iWndListe.CColonne col in liste)
{
lstCopie.Add((C2iWndListe.CColonne)CCloner2iSerializable.Clone(col));
}
m_listeColonnes = lstCopie;
if (ShowDialog() == DialogResult.OK)
{
return(m_listeColonnes);
}
return(m_listeColonnes);
}
public IEnumerable <string> GetInspiration(IParametreInspiration parametre)
{
IEnumerable <string> lstRetour = new List <string>();
CInspiration inspiration = null;
if (!m_dicInspirations.TryGetValue(parametre, out inspiration))
{
inspiration = new CInspiration(CCloner2iSerializable.Clone(parametre) as CParametreInspirationProprieteDeType);
m_dicInspirations[parametre] = inspiration;
}
if (inspiration != null)
{
lstRetour = inspiration.GetInspiration();
}
return(lstRetour);
}
//-----------------------------------------------------------------------------------
public void Init(
CEasyQuery easyQuery,
CCAMLQuery query,
IEnumerable <CCAMLItemField> fields)
{
m_easyQuery = easyQuery;
m_fields = fields;
if (query != null)
{
m_query = CCloner2iSerializable.Clone(query) as CCAMLQuery;
}
else
{
m_query = new CCAMLQuery();
}
InitArbre();
}
//--------------------------------------
public static bool EditeChamp(CChampEntiteFromQuery champ,
CTypeEntiteSnmpPourSupervision typeEntite)
{
CFormEditChampEntiteFromQuery form = new CFormEditChampEntiteFromQuery();
form.m_champEdite = champ;
form.m_typeEntite = CCloner2iSerializable.Clone(typeEntite) as CTypeEntiteSnmpPourSupervision;
bool bResult = false;
if (form.ShowDialog() == DialogResult.OK)
{
bResult = true;
CCloner2iSerializable.CopieTo(form.m_typeEntite, typeEntite);
}
form.Dispose();
return(bResult);
}
public static bool EditeTypeEntite(CTypeEntiteSnmpPourSupervision typeEntite,
CTypeAgentPourSupervision typeAgent)
{
CFormEditTypeEntiteSnmp form = new CFormEditTypeEntiteSnmp();
CTypeEntiteSnmpPourSupervision typeEdite = CCloner2iSerializable.Clone(typeEntite) as CTypeEntiteSnmpPourSupervision;
form.m_panelEdition.Init(typeEdite, typeAgent);
bool bResult = false;
if (form.ShowDialog() == DialogResult.OK)
{
CCloner2iSerializable.CopieTo(typeEdite, typeEntite);
bResult = true;
}
form.Dispose();
return(bResult);
}
//-----------------------------------------------------------------------------------
public void Init(CODEQFiltreCAML filtre)
{
m_objetFiltre = filtre;
m_txtNomTable.Text = filtre.NomFinal;
m_chkUseCache.Checked = filtre.UseCache;
m_ctrlFormulesNommees.TypeFormuleNomme = typeof(CColonneEQCalculee);
m_ctrlFormulesNommees.Init(m_objetFiltre.ColonnesCalculees.ToArray(), typeof(CDataRowForChampCalculeODEQ), m_objetFiltre);
if (filtre.CAMLQuery != null)
{
m_query = CCloner2iSerializable.Clone(filtre.CAMLQuery) as CCAMLQuery;
}
else
{
m_query = new CCAMLQuery();
}
m_panelCAML.Init(m_objetFiltre.Query, m_query, filtre.TableSource.CAMLFields);
m_panelPostFilter.Init(filtre);
}
//--------------------------------------------------------------------------------
private void InitChamps()
{
m_txtLibelleElement.Text = m_elementDeMultiStructure.Libelle;
m_txtPrefix.Text = m_elementDeMultiStructure.Prefixe;
m_query = CCloner2iSerializable.Clone(JeuQuery.EasyQueryAvecSource) as CEasyQuery;
m_query.ElementAVariablesExternes = JeuQuery.EasyQueryAvecSource.ElementAVariablesExternes;
m_query.IContexteDonnee = JeuQuery.EasyQueryAvecSource.IContexteDonnee;
foreach (CEasyQuerySource source in JeuQuery.EasyQueryAvecSource.Sources)
{
m_query.ListeSources.AddSource(source);
}
foreach (string strIdTable in JeuQuery.IdTablesARetourner)
{
m_setTablesARetourner.Add(strIdTable);
}
m_panelQuery.Init(m_query);
InitListeTables(false);
}
//-------------------------------------------------
private CResultAErreurType <C2iExpression> GetFormuleFinaleForEntite(CEntiteSnmp entite)
{
CResultAErreurType <C2iExpression> result = new CResultAErreurType <C2iExpression>();
if (m_formulePolling == null)
{
result.EmpileErreur(I.T("Can not apply formula to entity @1|20254",
entite.Libelle));
return(result);
}
C2iExpression formule = CCloner2iSerializable.Clone(m_formulePolling) as C2iExpression;
ArrayList lst = formule.ExtractExpressionsType(typeof(C2iExpressionChamp));
foreach (C2iExpressionChamp exp in lst)
{
CDefinitionProprieteDynamiqueChampCustom def = exp.DefinitionPropriete as CDefinitionProprieteDynamiqueChampCustom;
string strOID = null;
if (def != null)
{
CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
if (champ.ReadIfExists(def.DbKeyChamp))
{
strOID = entite.GetFieldOID(champ.Id);
if (strOID.Trim().Length == 0)
{
strOID = null;
}
else
{
exp.DefinitionPropriete = new CDefinitionProprieteDynamiqueOID(strOID);
}
}
}
if (strOID == null)
{
result.EmpileErreur(I.T("Can not find SNMP field for @1|20255", def.Nom));
return(result);
}
}
result.Data = formule;
return(result);
}
/// //////////////////////////////////////////////////
private void Init(CVariableDynamiqueSelectionObjetDonnee variable)
{
m_wndAideFormule.FournisseurProprietes = new CFournisseurPropDynStd(true);
m_variable = variable;
//Clone le filtre
m_filtreDynamique = (CFiltreDynamique)CCloner2iSerializable.Clone(m_variable.FiltreSelection);
if (m_filtreDynamique == null)
{
m_filtreDynamique = new CFiltreDynamique(CSc2iWin32DataClient.ContexteCourant);
}
if (m_variable.FiltreSelection != null)
{
m_filtreDynamique.ElementAVariablesExterne = m_variable.FiltreSelection.ElementAVariablesExterne;
}
m_wndAideFormule.ObjetInterroge = m_filtreDynamique.TypeElements;
m_txtValeurAffichee.Init(m_wndAideFormule.FournisseurProprietes, m_wndAideFormule.ObjetInterroge);
m_panelFiltre.InitSansVariables(m_filtreDynamique);
if (m_variable.ExpressionAffichee != null)
{
m_txtValeurAffichee.Text = m_variable.ExpressionAffichee.GetString();
}
else
{
m_txtValeurAffichee.Text = "";
}
if (m_variable.ExpressionRetournee != null)
{
m_txtValeurStockee.Text = m_variable.ExpressionRetournee.GetString();
}
else
{
m_txtValeurStockee.Text = "";
}
m_txtValeurStockee.Init(m_wndAideFormule.FournisseurProprietes, m_wndAideFormule.ObjetInterroge);
m_textBoxReceiveFormules = m_txtValeurAffichee;
m_txtValeurAffichee.BackColor = Color.LightGreen;
m_chkCanBeNull.Checked = m_variable.CanBeNull;
m_txtNullValue.Text = m_variable.TextNull;
m_txtNullValue.Visible = m_chkCanBeNull.Checked;
m_chkRechercheRapide.Checked = m_variable.UtiliserRechercheRapide;
}
