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 CResultAErreur Serialize(C2iSerializer serialiser)
{
int nVersion = GetNumVersion();
CResultAErreur result = serialiser.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serialiser.TraiteString(ref m_strNomTable);
I2iSerializable obj = ChampOrigine;
result = serialiser.TraiteObject(ref obj);
if (!result)
{
return(result);
}
ChampOrigine = (CDefinitionProprieteDynamique)obj;
obj = m_requete;
result = serialiser.TraiteObject(ref obj);
if (!result)
{
return(result);
}
m_requete = (C2iRequeteAvancee)obj;
if (m_requete == null)
{
m_requete = new C2iRequeteAvancee(null);
}
obj = m_filtreAAppliquer;
result = serialiser.TraiteObject(ref obj);
if (!result)
{
return(result);
}
m_filtreAAppliquer = (CFiltreDynamique)obj;
if (nVersion >= 1)
{
obj = m_tableauCroise;
result = serialiser.TraiteObject(ref obj);
if (!result)
{
return(result);
}
m_tableauCroise = (CTableauCroise)obj;
}
if (nVersion >= 2)
{
serialiser.TraiteBool(ref m_bNePasCalculer);
}
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);
}
//-------------------------------------------------------------------------------
private void m_lnkTableauCroise_LinkClicked(object sender, System.Windows.Forms.LinkLabelLinkClickedEventArgs e)
{
if (!(m_tableExportCumulee is C2iTableExportCumulee))
{
return;
}
MajChamps();
C2iTableExportCumulee tableCumulee = (C2iTableExportCumulee)m_tableExportCumulee;
CTableauCroise tableau = tableCumulee.TableauCroise;
if (tableau == null)
{
tableau = new CTableauCroise();
}
DataTable table = new DataTable();
tableCumulee.TableauCroise = null;
m_tableExportCumulee.InsertColonnesInTable(table);
tableCumulee.TableauCroise = tableau;
CFormEditTableauCroise.EditeTableau(tableau, table);
}
//---------------------------------
/// <summary>
///
/// </summary>
/// <param name="serializer"></param>
/// <returns></returns>
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);
}
I2iSerializable obj = ChampOrigine;
result = serializer.TraiteObject(ref obj);
if (!result)
{
return(result);
}
ChampOrigine = (CDefinitionProprieteDynamique)obj;
serializer.TraiteBool(ref m_bSupprimerTablesTravail);
I2iSerializable objet = m_tableau;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_tableau = (CTableauCroise)objet;
return(result);
}
public void InitChamps(DataTable tableSource, CTableauCroise tableCroisee)
{
m_tableauCroise = tableCroisee;
m_tableSource = tableSource;
m_wndListeChampsOrigine.Items.Clear();
if (m_tableSource != null)
{
foreach (DataColumn col in m_tableSource.Columns)
{
if (m_tableauCroise.ChampsCle.Count(
champ => champ.NomChamp == col.ColumnName
) == 0)
{
bool bTrouve = false;
foreach (CColonneePivot pivot in m_tableauCroise.ChampsColonne)
{
if (pivot.NomChamp == col.ColumnName)
{
bTrouve = true;
break;
}
}
if (!bTrouve)
{
ListViewItem item = new ListViewItem( );
item.Text = col.ColumnName;
item.Tag = col;
m_wndListeChampsOrigine.Items.Add(item);
}
}
}
}
m_wndListeCles.Items.Clear();
foreach (CCleTableauCroise cle in m_tableauCroise.ChampsCle)
{
ListViewItem item = new ListViewItem();
item.Text = cle.NomChamp;
item.Tag = cle;
m_wndListeCles.Items.Add(item);
}
m_wndListeColonnes.Items.Clear();
foreach (CColonneePivot pivot in m_tableauCroise.ChampsColonne)
{
ListViewItem item = new ListViewItem();
item.Text = pivot.NomChamp;
item.SubItems.Add(pivot.Prefixe);
item.Tag = pivot;
m_wndListeColonnes.Items.Add(item);
}
m_wndListeCumuls.Items.Clear();
foreach (CCumulCroise cumul in m_tableauCroise.CumulsCroises)
{
ListViewItem item = new ListViewItem();
item.Text = cumul.NomChamp;
item.SubItems.Add(cumul.TypeCumul.ToString());
item.SubItems.Add(cumul.PrefixFinal);
item.Tag = cumul;
m_wndListeCumuls.Items.Add(item);
}
}
/// /////////////////////////////////////////////////////////
public CResultAErreur EndInsertData(DataSet ds)
{
CResultAErreur result = CResultAErreur.True;
if (m_bNePasCalculer)
{
return(result);
}
if (m_mapIdBaseParentToReadToIdTable == null || m_mapIdBaseParentToReadToIdTable.Count == 0)
{
return(result);
}
DataTable table = ds.Tables[NomTable];
if (table == null)
{
result.EmpileErreur(I.T("Table @1 doesn't exist|116", NomTable));
return(result);
}
DataColumn colFille = null;
if (m_tableParente != null)
{
foreach (Constraint constraint in table.Constraints)
{
if (constraint is ForeignKeyConstraint)
{
ForeignKeyConstraint fkConst = (ForeignKeyConstraint)constraint;
colFille = fkConst.Columns[0];
}
}
}
string strListe = "";
foreach (int nId in m_mapIdBaseParentToReadToIdTable.Keys)
{
strListe += nId.ToString() + ";";
}
strListe = strListe.Substring(0, strListe.Length - 1);
CFiltreData filtreDeBase = new CFiltreDataAvance(
m_requete.TableInterrogee,
m_strChampIdParent + " in {" + strListe + "}");
result = GetFiltreDataAAppliquer(m_elementAVariablePourFiltres);
if (!result)
{
result.EmpileErreur(I.T("Error in cumulated table @1 filter|126", NomTable));
return(result);
}
CFiltreData leFiltreComplet = CFiltreData.GetAndFiltre(
filtreDeBase, (CFiltreData)result.Data);
C2iRequeteAvancee requete = (C2iRequeteAvancee)CCloner2iSerializable.Clone(m_requete);
string strChampParent = m_strChampIdParent + "_CLE_DB";
C2iChampDeRequete champ = new C2iChampDeRequete(
strChampParent,
new CSourceDeChampDeRequete(m_strChampIdParent),
typeof(int),
OperationsAgregation.None,
true);
requete.ListeChamps.Add(champ);
requete.FiltreAAppliquer = leFiltreComplet;
result = requete.ExecuteRequete(m_nIdSession);
if (!result)
{
return(result);
}
if (result.Data == null)
{
return(null);
}
DataTable tableDonnees = (DataTable)result.Data;
if (m_tableauCroise != null)
{
CTableauCroise newTableau = (CTableauCroise)CCloner2iSerializable.Clone(m_tableauCroise);
newTableau.AddChampCle(new CCleTableauCroise(strChampParent, typeof(int)));
result = newTableau.CreateTableCroisee(tableDonnees);
if (!result)
{
result.EmpileErreur(I.T("Error in data crossing|130"));
return(result);
}
tableDonnees = (DataTable)result.Data;
foreach (DataColumn col in tableDonnees.Columns)
{
DataColumn laColonne = table.Columns[col.ColumnName];
if (laColonne == null)
{
table.Columns.Add(col.ColumnName, col.DataType);
}
//Stef le 5/5/2005 : Si la colonne n'est pas du bon type,
//son type est ajusté !
else if (laColonne.DataType != col.DataType)
{
laColonne.DataType = col.DataType;
}
}
}
else
{
//Ajuste le type des colonnes
foreach (DataColumn col in tableDonnees.Columns)
{
DataColumn laColonne = table.Columns[col.ColumnName];
if (laColonne != null && laColonne.DataType != col.DataType)
{
laColonne.DataType = col.DataType;
}
}
}
//Intègre les données dans la table
ArrayList lstNewRows = new ArrayList();
foreach (DataRow row in tableDonnees.Rows)
{
DataRow newRow = table.NewRow();
foreach (DataColumn col in row.Table.Columns)
{
if (newRow.Table.Columns[col.ColumnName] != null)
{
newRow[col.ColumnName] = row[col];
}
}
if (colFille != null)
{
newRow[colFille] = (int)m_mapIdBaseParentToReadToIdTable[row[strChampParent]];
}
table.Rows.Add(newRow);
}
return(result);
}
/// /////////////////////////////////////////////////////////
public CResultAErreur InsertDataInDataSet(
IEnumerable list,
DataSet ds,
ITableExport tableParente,
int[] nValeursCle,
RelationAttribute relationToObjetParent,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablePourFiltres,
CCacheValeursProprietes cacheValeurs,
ITableExport tableFilleANeParCharger,
bool bAvecOptimisation,
CConteneurIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
if (NePasCalculer)
{
return(result);
}
int nValeurIndicateur = 0;
indicateur.SetBornesSegment(0, m_tableauCroise == null?2:3);
if (list == null)
{
return(result);
}
if (!(list is CListeObjetsDonnees))
{
result.EmpileErreur(I.T("Attempt of cumulated table on something other that a data list|125"));
return(result);
}
CListeObjetsDonnees listeDonnees = (CListeObjetsDonnees)list;
if (relationToObjetParent == null)
{
//Principe de la lecture en une fois :
//Si la liste des une liste objets contenus, c'est que chaque élément
//est un composant d'un parent. On stock donc tous les parents
//Pour lesquels on veut les données,
//et elles seront lues dans le EndInsertTable.
//Par contre si la liste contenu a un filtre, on ne peut plus
//stocker juste ça, il faudrait en plus stocker le filtre et ça
//devient compliqué.
if (listeDonnees is CListeObjetsDonneesContenus &&
(listeDonnees.Filtre == null ||
!listeDonnees.Filtre.HasFiltre))
{
CListeObjetsDonneesContenus listeContenu = (CListeObjetsDonneesContenus)listeDonnees;
if (listeContenu.ObjetConteneur != null &&
typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(listeContenu.ObjetConteneur.GetType()))
{
if (m_mapIdBaseParentToReadToIdTable == null)
{
m_mapIdBaseParentToReadToIdTable = new Hashtable();
}
m_mapIdBaseParentToReadToIdTable[((CObjetDonneeAIdNumerique)listeContenu.ObjetConteneur).Id] = nValeursCle[0];
m_strChampIdParent = listeContenu.ChampsFille[0];
m_tableParente = tableParente;
listeContenu.GetFiltreForRead();
m_nIdSession = listeContenu.ContexteDonnee.IdSession;
m_elementAVariablePourFiltres = elementAVariablePourFiltres;
return(result);
}
}
}
DataTable table = ds.Tables[NomTable];
if (table == null)
{
result.EmpileErreur(I.T("Table @1 doesn't exist|116", NomTable));
return(result);
}
DataColumn colFille = null;
if (tableParente != null)
{
foreach (Constraint constraint in table.Constraints)
{
if (constraint is ForeignKeyConstraint)
{
ForeignKeyConstraint fkConst = (ForeignKeyConstraint)constraint;
colFille = fkConst.Columns[0];
}
}
}
CFiltreData filtreDeBase = listeDonnees.GetFiltreForRead();
result = GetFiltreDataAAppliquer(elementAVariablePourFiltres);
if (!result)
{
result.EmpileErreur(I.T("Error in cumulated table @1 filter|126", NomTable));
return(result);
}
CFiltreData leFiltreComplet = CFiltreData.GetAndFiltre(
filtreDeBase, (CFiltreData)result.Data);
C2iRequeteAvancee requete = m_requete;
CTableauCroise tableauCroise = m_tableauCroise;
string strChampParent = "";
if (relationToObjetParent != null)
{
requete = (C2iRequeteAvancee)CCloner2iSerializable.Clone(m_requete);
strChampParent = relationToObjetParent.ChampsParent[0] + "_CLE_DB";
Type typeChampParent = typeof(string);
IChampDeTable champParent = tableParente.Champs.FirstOrDefault(c => c.NomChamp == strChampParent);
if (champParent != null)
{
typeChampParent = champParent.TypeDonnee;
}
C2iChampDeRequete champ = new C2iChampDeRequete(
strChampParent,
new CSourceDeChampDeRequete(relationToObjetParent.ChampsFils[0]),
typeof(int),
OperationsAgregation.None,
true);
requete.ListeChamps.Add(champ);
string strListe = "";
foreach (int nId in nValeursCle)
{
strListe += nId.ToString() + ";";
}
strListe = strListe.Substring(0, strListe.Length - 1);
leFiltreComplet = CFiltreData.GetAndFiltre(leFiltreComplet, new CFiltreDataAvance(
requete.TableInterrogee,
relationToObjetParent.ChampsFils[0] + " in {" + strListe + "}"));
if (tableauCroise != null)
{
tableauCroise = (CTableauCroise)CCloner2iSerializable.Clone(m_tableauCroise);
tableauCroise.AddChampCle(new CCleTableauCroise(strChampParent, typeChampParent));
}
}
requete.FiltreAAppliquer = leFiltreComplet;
indicateur.SetInfo(I.T("Table @1 (request)|127", NomTable));
if (ChampOrigine == null)
{
requete.TableInterrogee = CContexteDonnee.GetNomTableForType(listeDonnees.TypeObjets);
}
result = requete.ExecuteRequete(listeDonnees.ContexteDonnee.IdSession);
indicateur.SetValue(nValeurIndicateur++);
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Execution cancelled by the user|118"));
return(result);
}
if (!result)
{
return(result);
}
if (result.Data == null)
{
return(null);
}
DataTable tableDonnees = (DataTable)result.Data;
if (tableauCroise != null)
{
indicateur.SetInfo(I.T("Table @1 (cross table)|128", NomTable));
result = tableauCroise.CreateTableCroisee(tableDonnees);
indicateur.SetValue(nValeurIndicateur++);
if (!result)
{
result.EmpileErreur(I.T("Error in data crossing|130"));
return(result);
}
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Execution cancelled by the user|118"));
return(result);
}
tableDonnees = (DataTable)result.Data;
foreach (DataColumn col in tableDonnees.Columns)
{
DataColumn laColonne = table.Columns[col.ColumnName];
if (laColonne == null)
{
table.Columns.Add(col.ColumnName, col.DataType);
}
//Stef le 5/5/2005 : Si la colonne n'est pas du bon type,
//son type est ajusté !
else if (laColonne.DataType != col.DataType)
{
laColonne.DataType = col.DataType;
}
}
}
else
{
//Ajuste le type des colonnes
foreach (DataColumn col in tableDonnees.Columns)
{
DataColumn laColonne = table.Columns[col.ColumnName];
if (laColonne != null && laColonne.DataType != col.DataType)
{
laColonne.DataType = col.DataType;
}
}
}
indicateur.SetInfo(I.T("Storage|129"));
indicateur.PushSegment(nValeurIndicateur, nValeurIndicateur + 1);
indicateur.SetBornesSegment(0, tableDonnees.Rows.Count);
int nFrequence = Math.Min(tableDonnees.Rows.Count / 20, 500) + 1;
//Intègre les données dans la table
ArrayList lstNewRows = new ArrayList();
int nCompteur = 0;
foreach (DataRow row in tableDonnees.Rows)
{
nCompteur++;
if (nCompteur % nFrequence == 0)
{
indicateur.SetValue(nCompteur);
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Execution cancelled by the user|118"));
return(result);
}
}
DataRow newRow = table.NewRow();
foreach (DataColumn col in row.Table.Columns)
{
if (newRow.Table.Columns[col.ColumnName] != null)
{
newRow[col.ColumnName] = row[col];
}
}
if (colFille != null)
{
if (relationToObjetParent == null)
{
newRow[colFille] = nValeursCle[0];
}
else
{
newRow[colFille] = row[strChampParent];
}
}
table.Rows.Add(newRow);
}
indicateur.PopSegment();
return(result);
}
//---------------------------------
public override CResultAErreur EndInsertData(System.Data.DataSet ds)
{
CResultAErreur result = base.EndInsertData(ds);
if (NePasCalculer)
{
return(result);
}
if (!result)
{
return(result);
}
try
{
//Renomme la table de lien
//Table qui a été créé et sur laquelle les tables filles ont un lien
DataTable tableDeLien = ds.Tables[NomTable];
tableDeLien.TableName = NomTable + "_WK";
if (TablesFilles.Length == 0)
{
return(result);
}
//Trouve la table fille
DataTable tableSource = ds.Tables[TablesFilles[0].NomTable];
if (tableSource == null)
{
result.EmpileErreur(I.T("Table @1 doesn't exist|20004", TablesFilles[0].NomTable));
return(result);
}
CTableauCroise tableau = new CTableauCroise();
tableau.CopieFrom(m_tableau);
//Trouve le lien entre la table de lien et la table source
DataColumn colDeLienSource = null;
if (tableDeLien.Rows.Count != 0) //Sinon, c'est qu'on est
//Surement table racine, ou que l'on n'a pas de données
{
foreach (Constraint contrainte in tableSource.Constraints)
{
ForeignKeyConstraint fk = contrainte as ForeignKeyConstraint;
if (fk != null &&
fk.RelatedTable == tableDeLien)
{
colDeLienSource = fk.Columns[0];
break;
}
}
}
/*if (colDeLienSource == null)
* {
* result.EmpileErreur(I.T("Cannot find a link between @1 and @2|20007",
* tableDeLien.TableName, tableSource.TableName));
* return result;
* }*/
//Ajoute la colonne de lien comme clé
if (colDeLienSource != null)
{
tableau.InsertChampCle(0,
new CCleTableauCroise(colDeLienSource.ColumnName, colDeLienSource.DataType));
}
result = tableau.CreateTableCroisee(tableSource);
if (!result)
{
return(result);
}
if (result)
{
DataTable tableFinale = (DataTable)result.Data;
tableFinale.TableName = NomTable;
ds.Tables.Add(tableFinale);
//Crée le champ de lien avec la table parente
//Recherche de la table parente
string strFK = "";
DataColumn colLienFinale = null;
foreach (Constraint contrainte in tableDeLien.Constraints)
{
ForeignKeyConstraint fk = contrainte as ForeignKeyConstraint;
if (fk != null)
{
if (fk.Table == tableDeLien)
{
strFK = fk.Columns[0].ColumnName;
colLienFinale = C2iStructureExport.CreateForeignKeyInTable(fk.RelatedColumns[0], tableFinale, 0);
break;
}
}
}
if (colLienFinale == null && ChampOrigine != null)
{
result.EmpileErreur(I.T("Cannot establish a link for Union table @1|20008", NomTable));
return(result);
}
//Met en cache les clés filles vers les clés parentes
Dictionary <int, int> dicIdsFillesToParent = new Dictionary <int, int>();
string strPrimKey = tableDeLien.PrimaryKey[0].ColumnName;
if (colLienFinale != null)
{
foreach (DataRow row in tableDeLien.Rows)
{
dicIdsFillesToParent[(int)row[strPrimKey]] = (int)row[strFK];
}
if (colDeLienSource != null)
{
foreach (DataRow row in tableFinale.Rows)
{
row[colLienFinale.ColumnName] = dicIdsFillesToParent[(int)row[colDeLienSource.ColumnName]];
}
}
}
}
if (SupprimerTablesTravail)
{
SupprimeTableEtDependances(ds, tableDeLien.TableName);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// //////////////////////////////////////////////////////
private void Init(CTableauCroise tableau, DataTable tableSource)
{
m_tableauCroise = tableau;
m_tableSource = tableSource;
}
/// //////////////////////////////////
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 CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
if (m_tableauCroise == null)
{
m_tableauCroise = new CTableauCroise();
}
result = serializer.TraiteObject <CTableauCroise>(ref m_tableauCroise);
int nValSafe = m_nIdTypeDonneeCumulee == null ? -1 : m_nIdTypeDonneeCumulee.Value;
serializer.TraiteInt(ref nValSafe);
if (nValSafe < 0)
{
m_nIdTypeDonneeCumulee = null;
}
else
{
m_nIdTypeDonneeCumulee = nValSafe;
}
if (nVersion > 0)
{
int nVal = (int)OperationCumul;
serializer.TraiteInt(ref nVal);
OperationCumul = (OperationsAgregation)nVal;
serializer.TraiteString(ref m_strLibelleTotal);
}
if (nVersion >= 2)
{
serializer.TraiteBool(ref m_bShowExportButton);
}
else
{
m_bShowExportButton = true;
}
if (nVersion >= 3)
{
serializer.TraiteBool(ref m_bShowHeader);
}
else
{
m_bShowHeader = true;
}
if (result)
{
result = serializer.TraiteListe <CParametreVisuChampTableauCroise>(m_listeParametresChamps);
}
if (result)
{
result = serializer.TraiteObject <CFormatChampTableauCroise>(ref m_formatRows);
}
if (result)
{
result = serializer.TraiteObject <CFormatChampTableauCroise>(ref m_formatHeader);
}
if (result)
{
result = serializer.TraiteListe <CFiltreDonneePrecalculee>(m_listeFiltresDeBase);
}
if (result)
{
result = serializer.TraiteListe <CFiltreDonneePrecalculee>(m_listeFiltresUser);
}
return(result);
}
