/// /////////////////////////////////////////////////////////
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
CResultAErreur result = CResultAErreur.True;
int nVersion = GetNumVersion();
result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.MySerialize(serializer);
if (!result)
{
return(result);
}
I2iSerializable objet = m_formuleMessage;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formuleMessage = (C2iExpression)objet;
result = serializer.TraiteArrayListOf2iSerializable(m_listeFormulesDestinataires);
if (!result)
{
return(result);
}
return(result);
}
/*
* class CLockerFichier { }
* private CResultAErreur WriteSaveFile()
* {
* CResultAErreur result = CResultAErreur.True;
*
* lock (typeof(CLockerFichier))
* {
*
* ///Sérialize l'objet en mémoire
* MemoryStream stream = new MemoryStream();
* BinaryWriter writer = new BinaryWriter(stream);
* CSerializerSaveBinaire serializer = new CSerializerSaveBinaire(writer);
* I2iSerializable iTmp = this;
* result = serializer.SerializeObjet(ref iTmp);
* if (!result)
* return result;
* writer.Close();
*
* //Ecrit le fichier crypté
* byte[] buffer = stream.GetBuffer();
*
* try
* {
* byte[] encrypted = Cryptage.Encrypt(buffer, defPassword);
* FileStream fileStream = new FileStream(m_stSaveFileFullName, FileMode.Truncate);
* writer = new BinaryWriter(fileStream);
* writer.Write(encrypted, 0, encrypted.Length);
* writer.Close();
*
* WriteCRC(m_stSaveFileFullName);
* fileStream.Close();
* }
* catch (Exception e)
* {
* result.EmpileErreur(new CErreurException(e));
* }
* stream.Close();
* }
*
* return result;
* }*/
//---------------------------------------------------------------------------------------
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
ArrayList lst = new ArrayList(m_listRecords);
result = serializer.TraiteArrayListOf2iSerializable(lst);
if (!result)
{
return(result);
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_listRecords.Clear();
foreach (CNombreUtilisePourTypeLicence record in lst)
{
m_listRecords.Add(record);
}
}
return(result);
}
//--------------------------------------
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strNumLicense);
serializer.TraiteString(ref m_strNomClient);
ArrayList lst = new ArrayList(m_listeLimitationsEntites);
result = serializer.TraiteArrayListOf2iSerializable(lst, new object[0]);
if (!result)
{
return(result);
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_listeLimitationsEntites.Clear();
foreach (CLimitationEntites lim in lst)
{
m_listeLimitationsEntites.Add(lim);
}
}
return(result);
}
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strID);
serializer.TraiteString(ref m_strNom);
serializer.TraiteString(ref m_strDescrip);
serializer.TraiteString(ref m_strHelpId);
ArrayList lst = new ArrayList(m_listeMenusItems);
result = serializer.TraiteArrayListOf2iSerializable(lst, this);
if (!result)
{
return(result);
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_listeMenusItems.Clear();
foreach (CMenuItem item in lst)
{
m_listeMenusItems.Add(item);
}
}
return(result);
}
//----------------------------------------------------------------------------------
public CResultAErreur Serialize(C2iSerializer serialiser)
{
int nVersion = GetNumVersion();
CResultAErreur result = serialiser.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serialiser.TraiteString(ref m_strTableInterrogee);
if (result)
{
result = serialiser.TraiteArrayListOf2iSerializable(m_listeChamps);
}
I2iSerializable obj = m_filtreAAppliquer;
result = serialiser.TraiteObject(ref obj);
m_filtreAAppliquer = (CFiltreData)obj;
if (nVersion >= 1)
{
bool bHasVersion = m_nIdVersion != null;
serialiser.TraiteBool(ref bHasVersion);
if (bHasVersion)
{
int nVersionDeBase = m_nIdVersion == null?0:(int)m_nIdVersion;
serialiser.TraiteInt(ref nVersionDeBase);
m_nIdVersion = nVersionDeBase;
}
}
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);
}
int nType = (int)m_typeDonnee.TypeDonnee;
serializer.TraiteInt(ref nType);
m_typeDonnee = new C2iTypeDonnee((sc2i.data.dynamic.TypeDonnee)nType);
I2iSerializable obj = m_expressionValidation;
result = serializer.TraiteObject(ref obj);
if (!result)
{
return(result);
}
m_expressionValidation = (C2iExpression)obj;
serializer.TraiteString(ref m_strDescriptionFormat);
if (nVersion >= 1)
{
result = serializer.TraiteArrayListOf2iSerializable(m_listeValeurs);
}
else
{
m_listeValeurs.Clear();
}
if (!result)
{
return(result);
}
//Version 2 : Ajout de la valeur par défaut
if (nVersion >= 2)
{
obj = m_expressionValeurParDefaut;
result = serializer.TraiteObject(ref obj);
m_expressionValeurParDefaut = (C2iExpression)obj;
}
else
{
m_expressionValeurParDefaut = null;
}
return(result);
}
//------------------------------------------------------------
public virtual CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strNomChampFinal);
int nOp = (int)m_operationAgregation;
serializer.TraiteInt(ref nOp);
m_operationAgregation = (OperationsAgregation)nOp;
if (nVersion < 2)
{
string strTmp = "";
serializer.TraiteString(ref strTmp);
CSourceDeChampDeRequete source = new CSourceDeChampDeRequete(strTmp);
serializer.TraiteString(ref strTmp);
source.ChampDeTable = strTmp;
serializer.TraiteString(ref strTmp);
source.Alias = strTmp;
m_listeSources = new ArrayList();
m_listeSources.Add(source);
}
else
{
result = serializer.TraiteArrayListOf2iSerializable(m_listeSources);
if (!result)
{
return(result);
}
}
serializer.TraiteBool(ref m_bGroupBy);
serializer.TraiteType(ref m_typeDonneeAvantAgregation);
if (nVersion >= 1)
{
serializer.TraiteString(ref m_strFonctionSql);
}
if (nVersion >= 3)
{
serializer.TraiteType(ref m_typeDonneeFinalForce);
}
else
{
m_typeDonneeFinalForce = null;
}
return(result);
}
//---------------------------------
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.AttacheObjet(typeof(IElementAVariablesDynamiquesBase), this);
result = serializer.TraiteArrayListOf2iSerializable(m_listeVariables);
if (!result)
{
return(result);
}
result = serializer.TraiteArrayListOf2iSerializable(m_listeDefinitionsJeux, this);
if (!result)
{
return(result);
}
I2iSerializable objet = m_formulaireEdition;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formulaireEdition = (C2iWndFenetre)objet;
serializer.TraiteInt(ref m_nNextIdVariable);
serializer.DetacheObjet(typeof(IElementAVariablesDynamiquesBase), this);
return(result);
}
/// ///////////////////////////////////////////////
public override CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = serializer.TraiteArrayListOf2iSerializable(m_listeComposantsFils);
return(result);
}
////////////////////////////////////////////////////////////////////////
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strNomTable);
I2iSerializable objet = m_filtreDynamique;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_filtreDynamique = (CFiltreDynamique)objet;
objet = m_relationToParent;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_relationToParent = (CInfoRelation)objet;
serializer.TraiteBool(ref m_bTouteLaTable);
result = serializer.TraiteArrayListOf2iSerializable(m_listeFils);
if (!result)
{
return(result);
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
NettoieFiltresFils();
foreach (CFiltreSynchronisation filtre in m_listeFils)
{
filtre.DefinitParent(this, filtre.RelationToParent);
}
}
if (nVersion >= 1)
{
serializer.TraiteBool(ref m_bIsAutoAdd);
}
return(result);
}
/// //////////////////////////////////////////////////////////
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = serializer.TraiteArrayListOf2iSerializable(m_lstPlanifications);
return(result);
}
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
string strName = Name;
serializer.TraiteString(ref strName);
Name = strName;
int nSens = (int)m_direction;
serializer.TraiteInt(ref nSens);
m_direction = (DirectionSerialisation)nSens;
serializer.TraiteType(ref m_type);
//Fils
ArrayList lst = new ArrayList(m_fils);
serializer.TraiteArrayListOf2iSerializable(lst);
ReconstruireFils(lst);
//Parent
if (m_direction != DirectionSerialisation.VersEnfants)
{
I2iSerializable father = (I2iSerializable)Parent;
serializer.SerializeObjet(ref father);
Parent = (CtrlPartiel)father;
}
////Control
//List<string> lstlignes = Serialise;
//ArrayList lignes = new ArrayList();
//foreach (string l in lstlignes)
// lignes.Add(l);
//IList lst = new ArrayList(lignes);
//serializer.TraiteArrayListOf2iSerializable(ref lst);
//lignes = new ArrayList(lst);
return(result);
}
//-------------------------------------------------
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.AttacheObjet(typeof(IElementAVariablesDynamiquesBase), this);
serializer.TraiteInt(ref m_nNextIdVariable);
ArrayList lstVariables = new ArrayList(m_listeVariables);
result = serializer.TraiteArrayListOf2iSerializable(lstVariables);
if (!result)
{
return(result);
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_listeVariables.Clear();
foreach (IVariableDynamique variable in lstVariables)
{
m_listeVariables.Add(variable);
}
}
result = serializer.TraiteObject <C2iWndFenetre>(ref m_formulaireEdition);
if (!result)
{
return(result);
}
serializer.AttacheObjet(typeof(IElementAVariablesDynamiquesBase), this);
serializer.TraiteType(ref m_typeSource);
result = serializer.TraiteListe <IMapItemGenerator>(m_listeGenerateurs, new object[] { this });
if (!result)
{
return(result);
}
return(result);
}
////////////////////////////////////////////////////////////////////////
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = serializer.TraiteArrayListOf2iSerializable(m_listefiltresSynchronisation);
if (!result)
{
return(result);
}
return(result);
}
//------------------------------------------------
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
ArrayList lst = new ArrayList(m_listeRemplissage);
result = serializer.TraiteArrayListOf2iSerializable(lst);
if (!result)
{
return(result);
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_listeRemplissage.Clear();
foreach (CRemplisssageChampActiviteActeur r in lst)
{
m_listeRemplissage.Add(r);
}
}
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);
}
/// //////////////////////////////////////////////
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 CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteType(ref m_typeSource);
if (serializer.Mode == ModeSerialisation.Ecriture && !m_bIsStructureComplexe)
{
RenommeNomTablesSimples();
}
I2iSerializable obj = m_table;
result = serializer.TraiteObject(ref obj);
if (!result)
{
return(result);
}
m_table = (ITableExport)obj;
if (m_table != null)
{
m_table.TypeSource = TypeSource;
}
if (nVersion > 0)
{
serializer.TraiteBool(ref m_bIsStructureComplexe);
}
else
{
m_bIsStructureComplexe = true;
}
if (nVersion > 1)
{
serializer.TraiteBool(ref m_bTraitementSurServeur);
}
else
{
m_bTraitementSurServeur = true;
}
if (nVersion > 2)
{
result = serializer.TraiteArrayListOf2iSerializable(m_listeTablesAutonomes);
}
if (nVersion < 4 && serializer.Mode == ModeSerialisation.Lecture)
{
RenommeNomTablesSimples();
}
return(result);
}
public override CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
result = base.Serialize(serializer);
if (!result)
{
return(result);
}
result = serializer.TraiteArrayListOf2iSerializable(m_listeFils);
if (!result)
{
return(result);
}
foreach (C2iSymbole wnd in m_listeFils)
{
wnd.Parent = this;
}
serializer.TraiteString(ref m_strName);
serializer.TraiteBool(ref m_bAnchorBottom);
serializer.TraiteBool(ref m_bAnchorLeft);
serializer.TraiteBool(ref m_bAnchorRight);
serializer.TraiteBool(ref m_bAnchorTop);
int nTmp = (int)DockStyle;
serializer.TraiteInt(ref nTmp);
DockStyle = (EDockStyle)nTmp;
DockChilds();
nTmp = m_backColor.ToArgb();
serializer.TraiteInt(ref nTmp);
m_backColor = Color.FromArgb(nTmp);
nTmp = m_foreColor.ToArgb();
serializer.TraiteInt(ref nTmp);
m_foreColor = Color.FromArgb(nTmp);
if (nVersion >= 1)
{
serializer.TraiteInt(ref m_nTabOrder);
}
if (nVersion >= 2)
{
serializer.TraiteBool(ref m_bCouleurFondAutomatique);
}
if (nVersion >= 2)
{
bool bHasType = m_targetType != null;
serializer.TraiteBool(ref bHasType);
if (bHasType)
{
serializer.TraiteType(ref m_targetType);
}
}
else
{
m_targetType = null;
}
if (nVersion >= 3)
{
serializer.TraiteBool(ref m_bLockElementASymbole);
}
if (nVersion >= 4)
{
serializer.TraiteBool(ref m_bVisible);
}
return(CResultAErreur.True);
}
//----------------------------------------------------------------------------------
#region SerializeAvantC2iTableExportATableFille
private CResultAErreur SerializeAvantC2iTableExportATableFille(C2iSerializer serialiser, int nOldVersion)
{
CResultAErreur result = CResultAErreur.True;
if (serialiser.Mode == ModeSerialisation.Ecriture)
{
//Pas la peine de traduire, ça n'arrive jamais
result.EmpileErreur("Cannot write the old version of C2iTableExport");
return(result);
}
string strTmp = NomTable;
serialiser.TraiteString(ref strTmp);
NomTable = strTmp;
I2iSerializable obj = ChampOrigine;
result = serialiser.TraiteObject(ref obj);
if (!result)
{
return(result);
}
ChampOrigine = (CDefinitionProprieteDynamique)obj;
serialiser.AttacheObjet(typeof(ITableExport), this);
ArrayList lstTables = new ArrayList();
result = serialiser.TraiteArrayListOf2iSerializable(lstTables);
serialiser.DetacheObjet(typeof(ITableExport), this);
if (!result)
{
return(result);
}
ClearTablesFilles();
foreach (ITableExport table in lstTables)
{
AddTableFille(table);
}
ArrayList lstChamps = new ArrayList();
result = serialiser.TraiteArrayListOf2iSerializable(lstChamps);
if (!result)
{
return(result);
}
m_listeChamps.Clear();
foreach (C2iChampExport champ in lstChamps)
{
AddChamp(champ);
}
if (nOldVersion >= 1)
{
obj = m_filtreAAppliquer;
result = serialiser.TraiteObject(ref obj);
m_filtreAAppliquer = (CFiltreDynamique)obj;
}
return(result);
}
/// /////////////////////////////////////
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
//TESTDBKEYOK
if (nVersion < 3)
{
serializer.ReadDbKeyFromOldId(ref m_keyUtilisateur, null);
}
else
{
serializer.TraiteDbKey(ref m_keyUtilisateur);
}
serializer.TraiteInt(ref m_nIdActionEnCours);
//Sérialize les données des actions
int nNb = m_tableDataAction.Count;
serializer.TraiteInt(ref nNb);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (int nIdAction in m_tableDataAction.Keys)
{
int nIdActionPourRef = nIdAction;
serializer.TraiteInt(ref nIdActionPourRef);
I2iSerializable donnee = (I2iSerializable)m_tableDataAction[nIdAction];
result = serializer.TraiteObject(ref donnee);
if (!result)
{
return(result);
}
}
break;
case ModeSerialisation.Lecture:
m_tableDataAction.Clear();
for (int nData = 0; nData < nNb; nData++)
{
int nIdAction = 0;
serializer.TraiteInt(ref nIdAction);
I2iSerializable donnee = null;
result = serializer.TraiteObject(ref donnee);
if (!result)
{
return(result);
}
m_tableDataAction[nIdAction] = donnee;
}
break;
}
//Sérialize le process
I2iSerializable objet = m_process;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_process = (CProcess)objet;
//Serialize la trace
result = serializer.TraiteArrayListOf2iSerializable(m_pile);
if (!result)
{
return(result);
}
if (nVersion >= 1)
{
objet = m_configurationImpression;
serializer.TraiteObject(ref objet);
m_configurationImpression = (CConfigurationsImpression)objet;
}
else
{
m_configurationImpression = new CConfigurationsImpression();
}
if (nVersion >= 2)
{
serializer.TraiteBool(ref m_bExecutionSurContexteClient);
}
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);
}
// Traite la formule retournant l'objet source
I2iSerializable objet = m_expressionEntiteSource;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_expressionEntiteSource = (C2iExpression)objet;
// Traite la formule retournant l'objet destination
objet = m_expressionEntiteDestination;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_expressionEntiteDestination = (C2iExpression)objet;
if (nVersion < 2)
{
serializer.ReadDbKeyFromOldId(ref m_dbKeyDefinisseurChampsCustomEntiteDestination, null);
}
else
{
serializer.TraiteDbKey(ref m_dbKeyDefinisseurChampsCustomEntiteDestination);
}
// Traite la liste des propriétés à copier
ArrayList lst = new ArrayList(m_lstProprietesDynamiquesACopier);
result = serializer.TraiteArrayListOf2iSerializable(lst);
if (!result)
{
return(result);
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_lstProprietesDynamiquesACopier = (CDefinitionProprieteDynamique[])lst.ToArray(typeof(CDefinitionProprieteDynamique));
}
if (nVersion >= 1)
{
serializer.TraiteBool(ref m_bCopieComplete);
}
else
{
m_bCopieComplete = false;
}
return(result);
}
/// /////////////////////////////////////////////////////////
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
CResultAErreur result = CResultAErreur.True;
int nVersion = GetNumVersion();
result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.MySerialize(serializer);
if (!result)
{
return(result);
}
I2iSerializable objet = m_formuleAdresseExpediteur;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formuleAdresseExpediteur = (C2iExpression)objet;
objet = m_formuleSujet;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formuleSujet = (C2iExpression)objet;
objet = m_formuleMessage;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formuleMessage = (C2iExpression)objet;
result = serializer.TraiteArrayListOf2iSerializable(m_listeFormulesMailsDestinatairesTo);
if (!result)
{
return(result);
}
result = serializer.TraiteArrayListOf2iSerializable(m_listeFormulesPiecesJointes);
if (!result)
{
return(result);
}
if (nVersion >= 1)
{
result = serializer.TraiteArrayListOf2iSerializable(m_listeFormulesMailsDestinatairesCC);
if (!result)
{
return(result);
}
result = serializer.TraiteArrayListOf2iSerializable(m_listeFormulesMailsDestinatairesBCC);
if (!result)
{
return(result);
}
}
if (nVersion >= 2)
{
serializer.TraiteBool(ref m_bFormatHTML);
}
if (nVersion >= 3)
{
serializer.TraiteBool(ref m_bUseDocLabelAsFileName);
}
if (nVersion >= 4)
{
serializer.TraiteString(ref m_strSMTPServer);
serializer.TraiteInt(ref m_nSMTPPort);
serializer.TraiteString(ref m_strSMTPUser);
serializer.TraiteString(ref m_strSMTPPassword);
}
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);
}
/// /////////////////////////////////////////////
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
try
{
serializer.AttacheObjet(typeof(IElementAVariablesDynamiquesBase), this);
serializer.TraiteType(ref m_typeElementsFiltres);
result = serializer.TraiteArrayListOf2iSerializable(m_listeVariables);
I2iSerializable obj = m_composantFiltre;
result = serializer.TraiteObject(ref obj);
m_composantFiltre = (CComposantFiltreDynamique)obj;
serializer.TraiteInt(ref m_nNextIdVariable);
obj = m_formulaireEdition;
result = serializer.TraiteObject(ref obj);
if (!result)
{
return(result);
}
m_formulaireEdition = (C2iWnd)obj;
if (nVersion >= 1)
{
//Serialize les valeurs des variables
foreach (CVariableDynamique variable in m_listeVariables)
{
if (variable.IsChoixUtilisateur())
{
object valeur = m_tableValeursChamps[variable.IdVariable];
if (valeur != null && variable.TypeDonnee.IsArrayOfTypeNatif)
{
IList lst = (IList)valeur;
result = serializer.TraiteListeObjetsSimples(ref lst);
valeur = lst;
}
else
{
result = serializer.TraiteObjetSimple(ref valeur);
}
if (!result)
{
return(result);
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
SetValeurChamp(variable, valeur);
}
}
}
}
if (nVersion >= 2 && nVersion < 4)
{
bool bTmp = false;
serializer.TraiteBool(ref bTmp);
if (bTmp)
{
FormuleIntegrerParentsHierarchiques = new C2iExpressionConstante(true);
}
else
{
FormuleIntegrerParentsHierarchiques = new C2iExpressionConstante(false);
}
serializer.TraiteBool(ref bTmp);
if (bTmp)
{
FormuleNeConserverQueLesRacines = new C2iExpressionConstante(true);
}
else
{
FormuleNeConserverQueLesRacines = new C2iExpressionConstante(false);
}
}
if (nVersion >= 3 && nVersion < 4)
{
bool bTmp = false;
serializer.TraiteBool(ref bTmp);
if (bTmp)
{
FormuleIntegrerFilsHierarchiques = new C2iExpressionConstante(true);
}
else
{
FormuleIntegrerFilsHierarchiques = new C2iExpressionConstante(false);
}
}
if (nVersion >= 4)
{
serializer.TraiteObject <C2iExpression>(ref m_formuleIntegrerParentsHierarchiques);
serializer.TraiteObject <C2iExpression>(ref m_formuleNeConserverQueLesRacines);
serializer.TraiteObject <C2iExpression>(ref m_formuleIntegrerFilsHierarchiques);
}
serializer.DetacheObjet(typeof(IElementAVariablesDynamiquesBase), this);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error while reading dynamic filter|172"));
}
return(result);
}
/// ///////////////////////////////////////
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
string strFormule = C2iExpression.GetPseudoCode(m_formuleSourceDonnees);
serializer.TraiteString(ref strFormule);
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_formuleSourceDonnees = C2iExpression.FromPseudoCode(strFormule);
}
ArrayList lst = new ArrayList(m_colonnes);
serializer.TraiteArrayListOf2iSerializable(lst, null);
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_colonnes = new List <CColonne>();
foreach (CColonne col in lst)
{
if (col != null)
{
m_colonnes.Add(col);
}
}
}
serializer.TraiteBool(ref m_bRemplirSurDemande);
if (nVersion >= 1)
{
int nVal;
if (nVersion < 2)
{
nVal = 0;
serializer.TraiteInt(ref nVal); //Ancienne version
}
nVal = (int)m_lineStyle;
serializer.TraiteInt(ref nVal);
if (nVal >= Enum.GetValues(typeof(GLGridStyles)).Length)
{
nVal = (int)GLGridStyles.gridSolid;
}
m_lineStyle = (GLGridStyles)nVal;
serializer.TraiteBool(ref m_bHeaderVisible);
nVal = m_colorGridColor.ToArgb();
serializer.TraiteInt(ref nVal);
m_colorGridColor = Color.FromArgb(nVal);
nVal = m_colorSelectionColor.ToArgb();
serializer.TraiteInt(ref nVal);
m_colorSelectionColor = Color.FromArgb(nVal);
nVal = m_colorHeaderText.ToArgb();
serializer.TraiteInt(ref nVal);
m_colorHeaderText = Color.FromArgb(nVal);
nVal = m_colorHeaderBack.ToArgb();
serializer.TraiteInt(ref nVal);
m_colorHeaderBack = Color.FromArgb(nVal);
if (nVersion < 2)
{
nVal = 0;
serializer.TraiteInt(ref nVal);
}
serializer.TraiteInt(ref m_nItemHeight);
serializer.TraiteBool(ref m_bShowBorder);
if (nVersion >= 2)
{
nVal = m_lineBackColor1.ToArgb();
serializer.TraiteInt(ref nVal);
m_lineBackColor1 = Color.FromArgb(nVal);
result = SerializeFont(serializer, ref m_fontHeader);
if (!result)
{
return(result);
}
}
}
if (nVersion >= 3)
{
int nVal = m_lineBackColor2.ToArgb();
serializer.TraiteInt(ref nVal);
m_lineBackColor2 = Color.FromArgb(nVal);
}
if (nVersion >= 4)
{
serializer.TraiteBool(ref m_bTotalGlobal);
}
if (nVersion >= 5)
{
int nVal = TotalBackColor.ToArgb();
serializer.TraiteInt(ref nVal);
TotalBackColor = Color.FromArgb(nVal);
nVal = TotalTextColor.ToArgb();
serializer.TraiteInt(ref nVal);
TotalTextColor = Color.FromArgb(nVal);
}
if (nVersion >= 6)
{
strFormule = C2iExpression.GetPseudoCode(m_formuleCodeInitialisation);
serializer.TraiteString(ref strFormule);
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_formuleCodeInitialisation = C2iExpression.FromPseudoCode(strFormule);
}
}
if (nVersion >= 7)
{
serializer.TraiteBool(ref m_bOptimizeRefresh);
}
return(result);
}