/// ///////////////////////////////////////
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
bool bHasImage = m_imageDefault != null;
serializer.TraiteBool(ref bHasImage);
if (bHasImage)
{
switch (serializer.Mode)
{
case ModeSerialisation.Lecture:
Byte[] bt = null;
serializer.TraiteByteArray(ref bt);
if (m_imageDefault != null)
{
m_imageDefault.Dispose();
}
m_imageDefault = null;
MemoryStream stream = new MemoryStream(bt);
try
{
Bitmap bmp = (Bitmap)Bitmap.FromStream(stream);
m_imageDefault = bmp;
}
catch
{
m_imageDefault = null;
}
stream.Close();
break;
case ModeSerialisation.Ecriture:
MemoryStream streamSave = new MemoryStream();
try
{
m_imageDefault.Save(streamSave, System.Drawing.Imaging.ImageFormat.Png);
}
catch (Exception e)
{
string strVal = e.ToString();
}
Byte[] buf = streamSave.GetBuffer();
serializer.TraiteByteArray(ref buf);
streamSave.Close();
break;
}
}
return(result);
}
//------------------------------------------
public virtual CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = serializer.TraiteObject <CParametreNiveauArbreGantt>(ref m_parametreFils);
if (nVersion >= 1)
{
bool bHasImage = m_image != null;
serializer.TraiteBool(ref bHasImage);
if (bHasImage)
{
byte[] data = null;
MemoryStream stream = null;
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
stream = new MemoryStream();
m_image.Save(stream, ImageFormat.Png);
data = stream.ToArray();
serializer.TraiteByteArray(ref data);
stream.Close();
break;
case ModeSerialisation.Lecture:
serializer.TraiteByteArray(ref data);
try
{
stream = new MemoryStream(data);
Image = (Bitmap)Bitmap.FromStream(stream);
}
catch
{
}
break;
}
}
}
return(result);
}
/// ///////////////////////////////////////
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
bool bHasImage = m_metafileDefault != null;
serializer.TraiteBool(ref bHasImage);
if (bHasImage)
{
switch (serializer.Mode)
{
case ModeSerialisation.Lecture:
Byte[] bt = null;
serializer.TraiteByteArray(ref bt);
if (m_metafileDefault != null)
{
m_metafileDefault.Dispose();
}
m_metafileDefault = null;
MemoryStream stream = new MemoryStream(bt);
try
{
Metafile meta = (Metafile)Metafile.FromStream(stream);
m_metafileDefault = meta;
}
catch
{
m_metafileDefault = null;
}
stream.Close();
break;
case ModeSerialisation.Ecriture:
try
{
int nHandle = m_metafileDefault.GetHenhmetafile().ToInt32();
int nBufSize = GetEnhMetaFileBits(nHandle, 0, null);
byte[] buffer = new byte[nBufSize];
if (GetEnhMetaFileBits(nHandle, nBufSize, buffer) > 0)
{
serializer.TraiteByteArray(ref buffer);
}
else
{
buffer = new byte[0];
serializer.TraiteByteArray(ref buffer);
}
}
catch (Exception e)
{
string strVal = e.ToString();
}
break;
}
}
return(result);
}
//-----------------------------------------------
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteInt(ref m_nIndex);
int nTmp = (int)m_markerType;
serializer.TraiteInt(ref nTmp);
m_markerType = (EMapMarkerType)nTmp;
result = serializer.TraiteObject <C2iExpression>(ref m_formuleCondition);
if (result)
{
result = serializer.TraiteObject <C2iExpression>(ref m_formuleToolTip);
}
if (!result)
{
return(result);
}
serializer.TraiteBool(ref m_bPermanentToolTip);
bool bHasImage = m_image != null;
serializer.TraiteBool(ref bHasImage);
if (bHasImage)
{
switch (serializer.Mode)
{
case ModeSerialisation.Lecture:
Byte[] bt = null;
serializer.TraiteByteArray(ref bt);
if (m_image != null)
{
m_image.Dispose();
}
m_image = null;
MemoryStream stream = new MemoryStream(bt);
try
{
Bitmap bmp = (Bitmap)Bitmap.FromStream(stream);
m_image = bmp;
}
catch
{
m_image = null;
}
stream.Close();
break;
case ModeSerialisation.Ecriture:
MemoryStream streamSave = new MemoryStream();
try
{
Bitmap copie = new Bitmap(m_image);
copie.Save(streamSave, System.Drawing.Imaging.ImageFormat.Png);
copie.Dispose();
}
catch (Exception e)
{
string strVal = e.ToString();
}
Byte[] buf = streamSave.GetBuffer();
serializer.TraiteByteArray(ref buf);
streamSave.Close();
break;
}
}
return(result);
}
/// ///////////////////////////////////////
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strTexte);
if (nVersion < 2)
{
int nTmp = 0;
serializer.TraiteInt(ref nTmp);
nTmp = 0;
serializer.TraiteInt(ref nTmp);
}
//MODIF FAB
if (nVersion > 0)
{
bool bHasImage = m_imageFond != null;
serializer.TraiteBool(ref bHasImage);
if (bHasImage)
{
switch (serializer.Mode)
{
case ModeSerialisation.Lecture:
Byte[] bt = null;
serializer.TraiteByteArray(ref bt);
if (m_imageFond != null)
{
m_imageFond.Dispose();
}
m_imageFond = null;
MemoryStream stream = new MemoryStream(bt);
try
{
Bitmap bmp = (Bitmap)Bitmap.FromStream(stream);
m_imageFond = bmp;
}
catch
{
m_imageFond = null;
}
stream.Close();
break;
case ModeSerialisation.Ecriture:
MemoryStream streamSave = new MemoryStream();
try
{
m_imageFond.Save(streamSave, System.Drawing.Imaging.ImageFormat.Png);
}
catch (Exception e)
{
string strVal = e.ToString();
}
Byte[] buf = streamSave.GetBuffer();
serializer.TraiteByteArray(ref buf);
streamSave.Close();
break;
}
}
}
if (nVersion >= 3)
{
serializer.TraiteDouble(ref m_fMinutesRefresh);
}
else
{
m_fMinutesRefresh = 0;
}
if (nVersion >= 4 && nVersion < 7 && serializer.Mode == ModeSerialisation.Lecture)
{
List <CFormuleNommee> lst = new List <CFormuleNommee>();
result = serializer.TraiteListe <CFormuleNommee>(lst);
m_listeFonctions.Clear();
foreach (CFormuleNommee formule in lst)
{
CFonctionDynamique fonction = new CFonctionDynamique(formule.Libelle);
fonction.Formule = formule.Formule;
fonction.Nom = formule.Libelle;
m_listeFonctions.Add(fonction);
}
}
if (!result)
{
return(result);
}
if (nVersion >= 5)
{
serializer.TraiteBool(ref m_bAutoSize);
}
if (nVersion >= 6)
{
result = serializer.TraiteListe <CFormuleNommee>(m_listeParametres);
}
if (result && nVersion >= 7)
{
result = serializer.TraiteListe <CFonctionDynamique>(m_listeFonctions);
}
if (!result)
{
return(result);
}
return(result);
}
//------------------------------------------------------
public sc2i.common.CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
//Serialisation de la table
bool bHasTable = m_tableDesDifferences != null;
serializer.TraiteBool(ref bHasTable);
if (bHasTable)
{
if (serializer.Mode == ModeSerialisation.Ecriture)
{
//Il faut sérialiser un dataset pour que
//Les rowState soient sauvegardés
DataSet ds = new DataSet();
ds.Tables.Add(m_tableDesDifferences);
//Serialise la table des différences
MemoryStream s = new MemoryStream();
GZipStream szip = new GZipStream(s, CompressionMode.Compress);
BinaryFormatter format = new BinaryFormatter();
format.Serialize(szip, ds);
szip.Close();
ds.Tables.Remove(m_tableDesDifferences);
byte[] data = s.GetBuffer();
serializer.TraiteByteArray(ref data);
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
byte[] data = null;
serializer.TraiteByteArray(ref data);
DataSet ds = new DataSet();
Stream s = new MemoryStream(data);
GZipStream szip = new GZipStream(s, CompressionMode.Decompress);
BinaryFormatter format = new BinaryFormatter();
try
{
ds = (DataSet)format.Deserialize(szip);
szip.Close();
m_tableDesDifferences = ds.Tables[0];
ds.Tables.Remove(m_tableDesDifferences);
}
catch
{
result.EmpileErreur(I.T("Error while reading datatable|545"));
}
}
}
if (nVersion > 0)
{
serializer.TraiteBool(ref m_bChangementClePrimaire);
serializer.TraiteBool(ref m_bChangementTypeTable);
}
if (nVersion > 1)
{
serializer.TraiteBool(ref m_bCreationTable);
serializer.TraiteBool(ref m_bSuppressionTable);
}
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_strLibelle);
result = serializer.TraiteListe <CFolderConsultationHierarchique>(m_listeSousFolders, this);
if (!result)
{
return(result);
}
result = serializer.TraiteObject <C2iExpression>(ref m_expressionLibelle);
if (!result)
{
return(result);
}
if (nVersion >= 1)
{
int nColor = m_couleur.ToArgb();
serializer.TraiteInt(ref nColor);
m_couleur = Color.FromArgb(nColor);
}
if (nVersion >= 2)
{
bool bHasImage = m_image != null;
serializer.TraiteBool(ref bHasImage);
if (bHasImage)
{
byte[] data = null;
MemoryStream stream = null;
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
stream = new MemoryStream();
m_image.Save(stream, ImageFormat.Png);
data = stream.ToArray();
serializer.TraiteByteArray(ref data);
stream.Close();
break;
case ModeSerialisation.Lecture:
serializer.TraiteByteArray(ref data);
try
{
stream = new MemoryStream(data);
Image = (Bitmap)Bitmap.FromStream(stream);
}
catch
{
}
break;
}
}
}
return(result);
}