/// //////////////////////////////////
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
I2iSerializable objet = m_definitionJeuDonnees;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_definitionJeuDonnees = (IDefinitionJeuDonnees)objet;
int nNbCles = c_nbChampsCle;
if (nVersion >= 1)
{
serializer.TraiteInt(ref nNbCles);
}
else
{
nNbCles = 10;
}
for (int n = 0; n < nNbCles; n++)
{
if (n < nNbCles)
{
if (nVersion < 3)
{
string strTmp = "";
serializer.TraiteString(ref strTmp);
m_cles[n] = new CCleDonneeCumulee(strTmp);
}
else
{
CCleDonneeCumulee cle = m_cles[n];
result = cle.Serialize(serializer);
if (!result)
{
return(result);
}
m_cles[n] = cle;
}
}
else if (n < c_nbChampsCle)
{
m_cles[n] = new CCleDonneeCumulee("");
}
}
int nNbValeurs = c_nbChampsValeur;
if (nVersion >= 1)
{
serializer.TraiteInt(ref nNbValeurs);
}
else
{
nNbValeurs = 10;
}
for (int n = 0; n < c_nbChampsValeur; n++)
{
if (n < nNbValeurs)
{
serializer.TraiteString(ref m_strChampsValeurs[n]);
}
else if (n < c_nbChampsValeur)
{
m_strChampsValeurs[n] = "";
}
}
if (nVersion >= 2)
{
serializer.TraiteBool(ref m_bViderAChaqueCalcul);
}
else
{
m_bViderAChaqueCalcul = false;
}
if (nVersion >= 3)
{
serializer.TraiteBool(ref m_bPasDeSuppression);
}
else
{
m_bPasDeSuppression = false;
}
if (nVersion >= 5)
{
serializer.TraiteString(ref m_strTableSourceDeDonnees);
}
if (nVersion >= 6)
{
int nNbDates = c_nbChampsDate;
serializer.TraiteInt(ref nNbDates);
for (int n = 0; n < c_nbChampsDate; n++)
{
if (n < nNbDates)
{
serializer.TraiteString(ref m_strChampsDates[n]);
}
else if (n < c_nbChampsDate)
{
m_strChampsDates[n] = "";
}
}
int nNbTextes = c_nbChampsTexte;
serializer.TraiteInt(ref nNbTextes);
for (int n = 0; n < c_nbChampsTexte; n++)
{
if (n < nNbTextes)
{
serializer.TraiteString(ref m_strChampsTextes[n]);
}
else if (n < c_nbChampsTexte)
{
m_strChampsTextes[n] = "";
}
}
}
return(result);
}
/// //////////////////////////////////////////////////////////////
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.MySerialize(serializer);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strCodeActionServeur);
if (nVersion >= 1)
{
bool bHasHadObjetContexte = false;
if (serializer.GetObjetAttache(typeof(CContexteDonnee)) == null)
{
bHasHadObjetContexte = true;
serializer.AttacheObjet(typeof(CContexteDonnee), Process.ContexteDonnee);
}
int nNbCouplesChampExpression = 0;
foreach (object valeur in m_tableValeursParametres.Values)
{
if (valeur != null)
{
nNbCouplesChampExpression++;
}
}
serializer.TraiteInt(ref nNbCouplesChampExpression);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (DictionaryEntry entry in m_tableValeursParametres)
{
if (entry.Value != null)
{
string str = (string)entry.Key;
serializer.TraiteString(ref str);
I2iSerializable ser = (I2iSerializable)entry.Value;
result = serializer.TraiteObject(ref ser, null);
if (!result)
{
return(result);
}
}
}
break;
case ModeSerialisation.Lecture:
m_tableValeursParametres.Clear();
for (int nVal = 0; nVal < nNbCouplesChampExpression; nVal++)
{
string strProp = "";
serializer.TraiteString(ref strProp);
I2iSerializable ser = null;
result = serializer.TraiteObject(ref ser);
if (!result)
{
return(result);
}
m_tableValeursParametres[strProp] = ser;
}
break;
}
if (bHasHadObjetContexte)
{
serializer.DetacheObjet(typeof(CContexteDonnee), Process.ContexteDonnee);
}
}
return(result);
}
/// /////////////////////////////////////////////////////////
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
int nNb = m_tableRestrictions.Count;
serializer.TraiteInt(ref nNb);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (Type tp in m_tableRestrictions.Keys)
{
Type tpTemp = tp;
I2iSerializable restriction = (I2iSerializable)m_tableRestrictions[tp];
serializer.TraiteType(ref tpTemp);
result = serializer.TraiteObject(ref restriction);
if (!result)
{
return(result);
}
}
break;
case ModeSerialisation.Lecture:
m_tableRestrictions.Clear();
for (int nType = 0; nType < nNb; nType++)
{
Type tp = null;
I2iSerializable rest = null;
serializer.TraiteType(ref tp);
result = serializer.TraiteObject(ref rest, tp);
if (!result)
{
return(result);
}
if (tp != null)
{
m_tableRestrictions[tp] = rest;
}
}
break;
}
if (nVersion >= 1)
{
serializer.TraiteBool(ref m_bIsAdministrateur);
}
if (nVersion >= 2)
{
bool bHasAnnulation = SeuilAnnulationPriorites != null;
serializer.TraiteBool(ref bHasAnnulation);
if (bHasAnnulation)
{
int nTmp = SeuilAnnulationPriorites == null ? 0 : (int)m_nSeuilAnnulationPriorites;
serializer.TraiteInt(ref nTmp);
SeuilAnnulationPriorites = nTmp;
}
}
return(result);
}
/// //////////////////////////////////////////////
public override CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (nVersion >= 2)
{
result = base.Serialize(serializer);
}
if (result)
{
result = PrivateSerialize(serializer, nVersion);
}
if (result && nVersion < 2)
{
result = MySerialize(serializer);
}
if (!result)
{
return(result);
}
result = serializer.TraiteArrayListOf2iSerializable(m_listeFils);
if (!result)
{
return(result);
}
foreach (C2iWnd wnd in m_listeFils)
{
wnd.Parent = this;
}
if (nVersion > 2)
{
I2iSerializable objet = m_expressionVisibilite;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_expressionVisibilite = (C2iExpression)objet;
}
else
{
m_expressionVisibilite = null;
}
if (nVersion >= 5)
{
I2iSerializable objet = m_expressionEnable;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_expressionEnable = (C2iExpression)objet;
}
else
{
m_expressionEnable = null;
}
if (nVersion >= 6)
{
serializer.TraiteBool(ref m_bAnchorBottom);
serializer.TraiteBool(ref m_bAnchorLeft);
serializer.TraiteBool(ref m_bAnchorRight);
serializer.TraiteBool(ref m_bAnchorTop);
}
if (nVersion >= 7)
{
serializer.TraiteString(ref m_strName);
}
else
{
m_strName = "";
}
if (nVersion >= 8)
{
int nTmp = (int)DockStyle;
serializer.TraiteInt(ref nTmp);
DockStyle = (EDockStyle)nTmp;
DockChilds();
}
if (nVersion >= 9)
{
result = serializer.TraiteListe <CHandlerEvenementParFormule>(m_listeHandlers);
if (!result)
{
return(result);
}
}
else
{
m_listeHandlers = new List <CHandlerEvenementParFormule>();
}
if (nVersion >= 10)
{
bool bHasType = m_typeEdite != null;
serializer.TraiteBool(ref bHasType);
if (bHasType)
{
serializer.TraiteType(ref m_typeEdite);
}
}
else
{
m_typeEdite = null;
}
if (nVersion >= 11)
{
int nTmp = (int)m_lockMode;
serializer.TraiteInt(ref nTmp);
m_lockMode = (ELockMode)nTmp;
}
if (nVersion >= 12)
{
serializer.TraiteString(ref m_strHelpText);
}
return(result);
}
public override CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.Serialize(serializer);
if (!result)
{
return(result);
}
serializer.TraiteInt(ref m_nBorderWidth);
int nTmp;
nTmp = (int)m_borderStyle;
serializer.TraiteInt(ref nTmp);
m_borderStyle = (ELabelBorderStyle)nTmp;
result = SerializeFont(serializer, ref m_font);
if (!result)
{
return(result);
}
nTmp = m_backColor.ToArgb();
serializer.TraiteInt(ref nTmp);
m_backColor = Color.FromArgb(nTmp);
nTmp = m_textColor.ToArgb();
serializer.TraiteInt(ref nTmp);
m_textColor = Color.FromArgb(nTmp);
nTmp = m_borderColor.ToArgb();
serializer.TraiteInt(ref nTmp);
m_borderColor = Color.FromArgb(nTmp);
serializer.TraiteInt(ref m_IdObjetAssocie);
I2iSerializable objet = m_expression;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_expression = (C2iExpression)objet;
if (nVersion > 1)
{
nTmp = (int)m_alignement;
serializer.TraiteInt(ref nTmp);
m_alignement = (ContentAlignment)nTmp;
}
if (nVersion >= 3)
{
serializer.TraiteBool(ref m_bDrawLine);
}
return(CResultAErreur.True);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.MySerialize(serializer);
if (!result)
{
return(result);
}
if (nVersion < 4 && serializer.Mode == ModeSerialisation.Lecture)
{
int nIdTemp = -1;
serializer.TraiteInt(ref nIdTemp);
m_strIdVariableElement = nIdTemp.ToString();
}
else
{
serializer.TraiteString(ref m_strIdVariableElement);
}
I2iSerializable objet = ParametreDeclencheur;
result = serializer.TraiteObject(ref objet);
ParametreDeclencheur = (CParametreDeclencheurEvenement)objet;
serializer.TraiteBool(ref m_bDeclenchementUnique);
if (nVersion >= 1)
{
serializer.TraiteString(ref m_strLibelleEvenement);
}
if (nVersion >= 3)
{
int nVal = (int)TypeDeGestionDuCodeEvenement;
serializer.TraiteInt(ref nVal);
TypeDeGestionDuCodeEvenement = (TypeGestionCode)nVal;
}
else if (nVersion >= 2)
{
//Avant, le type de gestion du code evenement était un boolean (NePasCreerSiExiste=true)
bool bTmp = TypeDeGestionDuCodeEvenement == TypeGestionCode.NePasCreerSiExiste;
serializer.TraiteBool(ref bTmp);
if (bTmp)
{
TypeDeGestionDuCodeEvenement = TypeGestionCode.NePasCreerSiExiste;
}
else
{
TypeDeGestionDuCodeEvenement = TypeGestionCode.PasDeGestionCode;
}
}
else
{
TypeDeGestionDuCodeEvenement = TypeGestionCode.RemplacerSiExiste;
}
return(result);
}
//-------------------------------------------------------------
public void TraiteApresClonage(I2iSerializable source)
{
m_strId = Guid.NewGuid().ToString();
}
public CResultAErreur Serialize(C2iSerializer serializer)
{
//VERSION
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
#region CLES PARTICULIERES
int nNbKeys = m_clesParticulieres.Count;
serializer.TraiteInt(ref nNbKeys);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (CAuditVersionCleParticuliere k in m_clesParticulieres)
{
result = k.Serialize(serializer);
if (!result)
{
return(result);
}
}
break;
case ModeSerialisation.Lecture:
m_clesParticulieres.Clear();
for (int nK = 0; nK < nNbKeys; nK++)
{
CAuditVersionCleParticuliere key = new CAuditVersionCleParticuliere();
CResultAErreur lecKey = key.Serialize(serializer);
if (!lecKey)
{
result.Erreur += lecKey.Erreur;
result.Result = false;
}
m_clesParticulieres.Add(key);
}
break;
}
#endregion
//FILTRE
I2iSerializable iFiltre = m_filtre;
result = serializer.SerializeObjet(ref iFiltre);
if (!result)
{
return(result);
}
if (iFiltre != null)
{
m_filtre = (CFiltreDynamique)iFiltre;
}
else
{
m_filtre = null;
}
//TYPE
bool bHasType = m_type != null;
serializer.TraiteBool(ref bHasType);
if (bHasType)
{
serializer.TraiteType(ref m_type);
}
else
{
m_type = null;
}
//FORMULE
I2iSerializable iFormuleCle = m_formuleCle;
result = serializer.SerializeObjet(ref iFormuleCle);
if (!result)
{
return(result);
}
if (iFormuleCle != null)
{
m_formuleCle = (C2iExpression)iFormuleCle;
}
else
{
m_formuleCle = null;
}
//FORMULE DE DESCRIPTION
if (nVersion > 0)
{
I2iSerializable iFormuleDescription = m_formuleDescription;
result = serializer.SerializeObjet(ref iFormuleDescription);
if (!result)
{
return(result);
}
if (iFormuleDescription != null)
{
m_formuleDescription = (C2iExpression)iFormuleDescription;
}
else
{
m_formuleDescription = null;
}
}
return(result);
}
/// //////////////////////////////////
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strRequete);
serializer.AttacheObjet(typeof(IElementAVariablesDynamiquesBase), this);
result = serializer.TraiteArrayListOf2iSerializable(m_listeVariables);
if (!result)
{
return(result);
}
I2iSerializable objet = m_formulaireEdition;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formulaireEdition = (C2iWnd)objet;
if (nVersion < 3)
{
//TESTDBKEYTODO
int nTmp = 0;
serializer.TraiteInt(ref nTmp);
}
serializer.DetacheObjet(typeof(IElementAVariablesDynamiquesBase), this);
if (serializer.GetObjetAttache(typeof(CContexteDonnee)) != null)
{
ContexteDonnee = (CContexteDonnee)serializer.GetObjetAttache(typeof(CContexteDonnee));
}
else
{
ContexteDonnee = CContexteDonneeSysteme.GetInstance();
}
if (nVersion >= 1)
{
objet = m_tableauCroise;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_tableauCroise = (CTableauCroise)objet;
}
else
{
m_tableauCroise = null;
}
if (nVersion >= 2)
{
bool bHasType = m_typeReferencePourConnexion != null;
serializer.TraiteBool(ref bHasType);
if (bHasType)
{
serializer.TraiteType(ref m_typeReferencePourConnexion);
}
}
return(result);
}
//----------------------------------------------------------
private CResultAErreur SerializeTable(C2iSerializer serializer, int nVersion, ref DataTable table)
{
Type tp = null;
int nNb = 0;
CResultAErreur result = CResultAErreur.True;
DateTime dt = DateTime.Now;
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
tp = GetTypeForTable(table.TableName);
serializer.TraiteType(ref tp);
nNb = table.Rows.Count;
serializer.TraiteInt(ref nNb);
foreach (DataRow row in table.Rows)
{
I2iSerializable entite = Activator.CreateInstance(tp, new object[] { row }) as I2iSerializable;
if (nVersion == 0)
{
result = serializer.TraiteObject(ref entite);
}
else
{
result = entite.Serialize(serializer);
}
if (!result)
{
return(result);
}
}
break;
case ModeSerialisation.Lecture:
tp = null;
serializer.TraiteType(ref tp);
table = GetTable(tp);
if (table == null)
{
result.EmpileErreur(I.T("Can not allocate table for type @1|20009", tp.ToString()));
return(result);
}
nNb = 0;
serializer.TraiteInt(ref nNb);
I2iSerializable ser = (I2iSerializable)Activator.CreateInstance(tp, new object[] { this });
for (int n = 0; n < nNb; n++)
{
if (nVersion == 0)
{
result = serializer.TraiteObject(ref ser, this);
}
else
{
if (!IsFullReadEnCours)
{
ser = (I2iSerializable)Activator.CreateInstance(tp, new object[] { this });
}
result = ser.Serialize(serializer);
}
if (!result)
{
return(result);
}
}
break;
}
/*TimeSpan sp = DateTime.Now - dt;
* Console.WriteLine("Serialize " + table.TableName + " : " + sp.TotalMilliseconds);*/
return(result);
}
private CResultAErreur SafeExecuteAction(C2iSponsor sponsor, ref CResultAErreur result, ref DialogResult dialogResult)
{
bool bBoucle = true;
while (bBoucle)
{
bBoucle = false;
CCreateur2iFormulaireV2 createur = new CCreateur2iFormulaireV2();
//Fait passer le formulaire par le réseau
byte[] dataFormulaire = m_actionFormulaire.GetDataSerialisationFormulairePourClient();
MemoryStream stream = new MemoryStream(dataFormulaire);
BinaryReader reader = new BinaryReader(stream);
CSerializerReadBinaire serializer = new CSerializerReadBinaire(reader);
serializer.AttacheObjet(typeof(IElementAVariablesDynamiquesBase), m_actionFormulaire.Process);
I2iSerializable formulaireSer = null;
result = serializer.TraiteObject(ref formulaireSer);
reader.Close();
stream.Close();
if (!result)
{
result.EmpileErreur(I.T("Error while retrieving the form|30253"));
return(result);
}
C2iWnd formulaire = (C2iWnd)formulaireSer;
createur.CreateControlePrincipalEtChilds(m_panelFormulaire, formulaire, m_actionFormulaire.Process);
createur.ControleValeursAvantValidation = true;
CProxyElementAVariables proxy = m_actionFormulaire.Process.GetProxyElementAVariables(sponsor);
proxy.ContexteDonneeLocal = sc2i.win32.data.CSc2iWin32DataClient.ContexteCourant;
createur.ElementEdite = proxy;
foreach (IVariableDynamique varDyn in m_actionFormulaire.Process.ListeVariables)
{
sponsor.Register(varDyn);
}
Size szFormulaire = formulaire.Size;
Size szOldPanel = m_panelFormulaire.Size;
Size newSizeThis = Size;
newSizeThis.Width = Size.Width - szOldPanel.Width + szFormulaire.Width;
newSizeThis.Height = Size.Height - szOldPanel.Height + szFormulaire.Height;
Size = newSizeThis;
m_panelFormulaire.Size = szFormulaire;
m_btnAnnuler.Visible = m_actionFormulaire.CanCancel;
this.Text = m_actionFormulaire.Descriptif;
dialogResult = ShowDialog(CTimosApp.Navigateur);
if (dialogResult == DialogResult.OK)
{
CResultAErreur resultTmp = createur.MAJ_Champs();
if (!resultTmp)
{
CFormAlerte.Afficher(resultTmp.Erreur);
bBoucle = true;
}
}
}
result.Data = C2iDialogResult.Get2iDialogResultFromDialogResult(dialogResult);
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
if (nVersion >= 1)
{
result = base.MySerialize(serializer);
}
else
{
result = base.BaseSerialize(serializer);
}
if (!result)
{
return(result);
}
if (nVersion < 5)
{
serializer.ReadDbKeyFromOldId(ref m_dbKeyProcess, typeof(CProcessInDb));
}
else
{
serializer.TraiteDbKey(ref m_dbKeyProcess);
}
serializer.TraiteBool(ref m_bModeAsynchrone);
I2iSerializable objet = null;
int nNbVariables = m_mapVariablesProcessToFormule.Count;
serializer.TraiteInt(ref nNbVariables);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (string strId in m_mapVariablesProcessToFormule.Keys)
{
string strTemp = strId;
serializer.TraiteString(ref strTemp);
objet = GetExpressionForVariableProcess(strId);
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
}
break;
case ModeSerialisation.Lecture:
m_mapVariablesProcessToFormule.Clear();
for (int nVar = 0; nVar < nNbVariables; nVar++)
{
int nIdVariableTemp = 0;
string strIdVariable = "0";
if (nVersion < 5)
{
serializer.TraiteInt(ref nIdVariableTemp);
strIdVariable = nIdVariableTemp.ToString();
}
else
{
serializer.TraiteString(ref strIdVariable);
}
objet = null;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
SetExpressionForVariableProcess(strIdVariable, (C2iExpression)objet);
}
break;
}
if (nVersion >= 2)
{
serializer.TraiteBool(ref m_bLancerDansContexteSepare);
}
if (nVersion >= 3)
{
serializer.TraiteInt(ref m_nIdPointEntree);
}
else
{
m_nIdPointEntree = -1;
}
if (nVersion >= 4)
{
serializer.TraiteBool(ref m_bSansTrace);
}
return(result);
}
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
NettoieFormulesLienEtChamps();
int nIdTypeEntree = -1;
if (TypeEntree != null)
{
nIdTypeEntree = TypeEntree.Id;
}
serializer.TraiteInt(ref nIdTypeEntree);
if (serializer.Mode == ModeSerialisation.Lecture)
{
if (nIdTypeEntree != -1)
{
CTypeEntreeAgenda typeEntree = new CTypeEntreeAgenda((CContexteDonnee)serializer.GetObjetAttache(typeof(CContexteDonnee)));
if (typeEntree.ReadIfExists(nIdTypeEntree))
{
m_typeEntree = typeEntree;
}
}
}
if (TypeEntree == null)
{
result.EmpileErreur(I.T("The entry type is incorrect|30081"));
return(result);
}
I2iSerializable objet = m_formuleCommentaires;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formuleCommentaires = (C2iExpression)objet;
objet = m_formuleDateDebut;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formuleDateDebut = (C2iExpression)objet;
objet = m_formuleDateFin;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formuleDateFin = (C2iExpression)objet;
objet = m_formuleLibelle;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formuleLibelle = (C2iExpression)objet;
serializer.TraiteBool(ref m_bSansHoraires);
serializer.TraiteBool(ref m_bEtatAuto);
int nEtat = m_etatInitial.EtatInt;
serializer.TraiteInt(ref nEtat);
m_etatInitial = new CEtatEntreeAgenda((EtatEntreeAgenda)nEtat);
serializer.AttacheObjet(typeof(CParametreEntreeAgenda), this);
result = serializer.TraiteArrayListOf2iSerializable(m_listeParametresRelationsChamps);
if (!result)
{
return(result);
}
result = serializer.TraiteArrayListOf2iSerializable(m_listeParametresRelationsTypesElements);
if (!result)
{
return(result);
}
foreach (CParametreRelationEntreeAgenda_TypeElement parametre in m_listeParametresRelationsTypesElements.ToArray())
{
if (parametre.Relation == null)
{
m_listeParametresRelationsChamps.Remove(parametre);
}
}
serializer.DetacheObjet(typeof(CParametreEntreeAgenda), this);
//Supprime les relations à type éléments invalides
foreach (CParametreRelationEntreeAgenda_TypeElement rel in (IEnumerable)m_listeParametresRelationsChamps.Clone())
{
if (rel.Relation == null)
{
m_listeParametresRelationsChamps.Remove(rel);
}
}
if (nVersion == 1)
{
//Ancienne référence de la date
objet = null;
result = serializer.TraiteObject(ref objet);
string strDummy = "";
serializer.TraiteString(ref strDummy);
}
if (nVersion >= 3)
{
objet = (I2iSerializable)m_formuleCle;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formuleCle = (C2iExpression)objet;
}
if (nVersion >= 4)
{
serializer.TraiteInt(ref m_nMinutesRappel);
}
return(result);
}
