//--------------------------------------
/// <summary>
/// Retourne null si le format dynamique est égal au format
/// </summary>
/// <param name="eltAVariables"></param>
/// <returns></returns>
public CFormatChampTableauCroise GetFormatDynamique(CElementAVariablesDynamiques eltAVariables)
{
if (!IsDynamic)
{
return(null);
}
bool?bBold = GetBold(eltAVariables);
Color foreColor = GetForeColor(eltAVariables);
Color backColor = GetBackColor(eltAVariables);
int nSize = GetFontSize(eltAVariables);
if (bBold != Bold ||
foreColor != ForeColor ||
backColor != BackColor ||
nSize != FontSize)
{
CFormatChampTableauCroise format = new CFormatChampTableauCroise();
format.FontName = FontName;
format.FontSize = nSize;
format.Alignement = Alignement;
format.ForeColor = foreColor;
format.BackColor = backColor;
format.Bold = bBold;
return(format);
}
return(null);
}
public override void OnDesignSelect(Type typeEdite, object objetEdite, IFournisseurProprietesDynamiques fournisseurProprietes)
{
CDefinitionProprieteDynamiqueEditor.SetBAffectable(true);
CDefinitionProprieteDynamiqueEditor.SetFournisseur(fournisseurProprietes);
CDefinitionProprieteDynamiqueEditor.SetTypeAutorises(new Type[] { typeof(CObjetDonnee) });
CDefinitionProprieteDynamiqueEditor.SetObjetPourSousProprietes(GetObjetPourAnalyseThis(typeEdite).TypeAnalyse);
CElementAVariablesDynamiques element = new CElementAVariablesDynamiques();
CVariableDynamiqueStatique var = new CVariableDynamiqueStatique(element);
var.Nom = "EditedElement";
var.IdVariable = "0";//Compatiblité avant DbKey
var.SetTypeDonnee(new CTypeResultatExpression(GetObjetPourAnalyseThis(typeEdite).TypeAnalyse, false));
element.AddVariable(var);
CDefinitionFiltreDynamiqueEditor.SetElementAVariablesExternes(element);
I2iObjetGraphique parent = this;
while (parent.Parent != null)
{
parent = parent.Parent;
}
base.OnDesignSelect(typeEdite, objetEdite, fournisseurProprietes);
}
public IElementAVariablesDynamiquesAvecContexteDonnee GetElementAVariableSourceFromType(Type tp)
{
if (tp == null)
{
return(null);
}
CElementAVariablesDynamiques elt = CElementAVariablesDynamiques.GetElementAUneVariableType(tp, DynamicClassAttribute.GetNomConvivial(tp));
return(elt);
}
//-------------------------------------------------
public static CElementAVariablesDynamiques GetNewFrom(IElementAVariablesDynamiquesAvecContexteDonnee elt)
{
if (elt == null)
{
return(null);
}
CElementAVariablesDynamiques newElt = new CElementAVariablesDynamiques();
newElt.CopieStatique(elt);
return(newElt);
}
//--------------------------------------
public bool?GetBold(CElementAVariablesDynamiques elt)
{
if (FormuleBold != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(elt);
CResultAErreur result = FormuleBold.Eval(ctx);
if (result && result.Data is bool)
{
return((bool)result.Data);
}
}
return(Bold);
}
//--------------------------------------
public Color GetBackColor(CElementAVariablesDynamiques elt)
{
if (FormuleBackColor != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(elt);
CResultAErreur result = FormuleBackColor.Eval(ctx);
if (result && result.Data is Color)
{
return((Color)result.Data);
}
}
return(BackColor);
}
//--------------------------------------
public int GetFontSize(CElementAVariablesDynamiques elt)
{
if (FormuleFontSize != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(elt);
CResultAErreur result = FormuleFontSize.Eval(ctx);
if (result && result.Data is int)
{
return((int)result.Data);
}
}
return(FontSize);
}
//-------------------------------------------------
/// <summary>
/// Crée un élément à variable, contenant une seule variable du type demandé,
/// avec le nom demandé.
/// </summary>
/// <param name="tp"></param>
/// <param name="strNomVariable"></param>
/// <returns></returns>
public static CElementAVariablesDynamiques GetElementAUneVariableType(Type tp, string strNomVariable)
{
CElementAVariablesDynamiques elt = new CElementAVariablesDynamiques();
CVariableDynamiqueSysteme newVariable = new CVariableDynamiqueSysteme(elt);
newVariable.Nom = strNomVariable;
//TESTDBKEYOK (SC)
//Id doit être égal à 0 pour compatiblité
newVariable.IdVariable = "0";
newVariable.SetTypeDonnee(new CTypeResultatExpression(tp, false));
elt.AddVariable(newVariable);
return(elt);
}
/// <summary>
/// récupère un objet pour formule liée à la cellule
///
/// </summary>
/// <param name="paramVisu"></param>
/// <param name="row">Ligne contenant les données (peut être nul en design)</param>
/// <param name="nCol">Numéro de colonne où se trouve la donnée (peut être null en design)</param>
/// <returns></returns>
public CElementAVariablesDynamiques GetObjetPourFormuleCellule
(
CParametreVisuDonneePrecalculee paramVisu,
DataRow row,
int?nCol)
{
CElementAVariablesDynamiques eltAVariables = new CElementAVariablesDynamiques();
CTypeDonneeCumulee typeDonnee = paramVisu.GetTypeDonneeCumulee(CContexteDonneeSysteme.GetInstance());
if (typeDonnee == null)
{
return(null);
}
CParametreDonneeCumulee parametreDonnee = typeDonnee.Parametre;
//Ajoute les clés
CChampFinalDeTableauCroise[] champsFinaux = paramVisu.TableauCroise.ChampsFinaux;
int nIdVariable = 0;
foreach (CChampFinalDeTableauCroise champFinal in champsFinaux)
{
CChampFinalDeTableauCroiseCle champCle = champFinal as CChampFinalDeTableauCroiseCle;
if (champCle != null)
{
CCleDonneeCumulee cle = parametreDonnee.GetChampCle(champCle.NomChamp);
if (cle != null)
{
CVariableDynamiqueSysteme variable = new CVariableDynamiqueSysteme(eltAVariables);
variable.Nom = champCle.NomChamp;
variable.IdVariable = nIdVariable.ToString();
nIdVariable++;
if (cle.TypeLie != null)
{
variable.SetTypeDonnee(new CTypeResultatExpression(cle.TypeLie, false));
}
else
{
variable.SetTypeDonnee(new CTypeResultatExpression(typeof(int), false));
}
eltAVariables.AddVariable(variable);
if (row != null && row.Table.Columns.Contains(champCle.NomChamp))
{
object val = row[champCle.NomChamp];;
if (cle.TypeLie != null)
{
try
{
if (val != DBNull.Value)
{
val = paramVisu.GetFromCache(cle.TypeLie, Int32.Parse((val.ToString())));
}
}
catch { }
}
else
if (val != DBNull.Value)
{
val = val.ToString();
}
//TESTDBKEYOK (SC)
eltAVariables.SetValeurChamp(variable.IdVariable, val);
}
}
}
}
//Ajoute la valeur de colonne pivot (s'il y a lieu )
CChampFinalDeTableauCroiseDonnee champAvecPivot = ChampFinal as CChampFinalDeTableauCroiseDonnee;
if (champAvecPivot != null && champAvecPivot.Pivot != null)
{
CCleDonneeCumulee cle = parametreDonnee.GetChampCle(champAvecPivot.Pivot.NomChamp);
if (cle != null)
{
CVariableDynamiqueSysteme variable = new CVariableDynamiqueSysteme(eltAVariables);
variable.Nom = champAvecPivot.Pivot.NomChamp;
variable.IdVariable = nIdVariable.ToString();
nIdVariable++;
if (cle.TypeLie != null)
{
variable.SetTypeDonnee(new CTypeResultatExpression(cle.TypeLie, false));
}
else
{
variable.SetTypeDonnee(new CTypeResultatExpression(typeof(string), false));
}
eltAVariables.AddVariable(variable);
if (row != null && nCol != null)
{
DataColumn col = row.Table.Columns[nCol.Value];
CChampFinalDetableauCroiseDonneeAvecValeur cv = col.ExtendedProperties[CTableauCroise.c_ExtendedPropertyToColumnKey] as CChampFinalDetableauCroiseDonneeAvecValeur;
if (cv != null)
{
object val = cv.ValeurPivot;
if (cle.TypeLie != null)
{
try
{
if (val != null)
{
val = paramVisu.GetFromCache(cle.TypeLie, Int32.Parse(val.ToString()));
}
}
catch
{
}
}
else
if (val != null)
{
val = val.ToString();
}
eltAVariables.SetValeurChamp(variable.IdVariable, val);
}
}
}
}
//Ajoute la valeur de la colonne
CVariableDynamiqueSysteme variableValue = new CVariableDynamiqueSysteme(eltAVariables);
variableValue.Nom = c_nomVariableValue;
variableValue.IdVariable = nIdVariable.ToString();
nIdVariable++;
variableValue.SetTypeDonnee(new CTypeResultatExpression(typeof(double), false));
eltAVariables.AddVariable(variableValue);
try
{
eltAVariables.SetValeurChamp(variableValue.IdVariable, Convert.ToDouble(row[nCol.Value]));
}
catch
{
}
//Ajoute les variables de filtre
foreach (CFiltreDonneePrecalculee filtreDonnee in paramVisu.FiltresUtilisateur)
{
foreach (IVariableDynamique variable in filtreDonnee.Filtre.ListeVariables)
{
CVariableDeFiltreDeportee v = new CVariableDeFiltreDeportee(eltAVariables);
v.Nom = variable.Nom;
v.SetTypeDonnee(variable.TypeDonnee);
v.ChampAssocieAuFiltre = filtreDonnee.ChampAssocie;
eltAVariables.AddVariable(v);
eltAVariables.SetValeurChamp(v.IdVariable, filtreDonnee.Filtre.GetValeurChamp(variable.IdVariable));
}
}
return(eltAVariables);
}
/// <summary>
/// ///////////////////////////////////////////////////////////////////////////////////////
/// </summary>
/// <param name="typeDonnee"></param>
/// <returns></returns>
public static object GetNewForTypeDonnee(TypeDonnee typeDonnee, Type typeObjetDonnee, object valeur)
{
object objTest = null;
switch (typeDonnee)
{
case TypeDonnee.tBool:
if (valeur == null)
{
objTest = new CObjetForTestValeurChampCustomBool( );
}
else
{
objTest = new CObjetForTestValeurChampCustomBool((bool)Convert.ChangeType(valeur, typeof(bool), null));
}
break;
case TypeDonnee.tDate:
if (valeur == null)
{
objTest = new CObjetForTestValeurChampCustomDateTime( );
}
else
{
objTest = new CObjetForTestValeurChampCustomDateTime((DateTime)Convert.ChangeType(valeur, typeof(DateTime), null));
}
break;
case TypeDonnee.tDouble:
if (valeur == null)
{
objTest = new CObjetForTestValeurChampCustomDouble( );
}
else if (valeur is CValeurUnite)
{
objTest = new CObjetForTestValeurChampCustomDouble(((CValeurUnite)valeur).Valeur);
}
else
{
objTest = new CObjetForTestValeurChampCustomDouble((double)Convert.ChangeType(valeur, typeof(double), null));
}
break;
case TypeDonnee.tEntier:
if (valeur == null)
{
objTest = new CObjetForTestValeurChampCustomInt( );
}
else
{
objTest = new CObjetForTestValeurChampCustomInt((int)Convert.ChangeType(valeur, typeof(int), null));
}
break;
case TypeDonnee.tString:
if (valeur == null)
{
objTest = new CObjetForTestValeurChampCustomString();
}
else
{
objTest = new CObjetForTestValeurChampCustomString(valeur.ToString());
}
break;
case TypeDonnee.tObjetDonneeAIdNumeriqueAuto:
CElementAVariablesDynamiques element = CElementAVariablesDynamiques.GetElementAUneVariableType(typeObjetDonnee, "value");
element.SetValeurChamp((IVariableDynamique)element.ListeVariables[0], valeur);
objTest = element;
break;
default:
throw new Exception(I.T("The type @1 isn't implemented in the value tests|185", typeDonnee.ToString()));
}
return(objTest);
}
//--------------------------------------
public string GetFontName(CElementAVariablesDynamiques elt)
{
return(FontName);
}
