/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
CValeurUnite valeur = valeursParametres[0] as CValeurUnite;
if (valeur == null)
{
try
{
double fVal = Convert.ToDouble(valeursParametres[0]);
result.Data = new CValeurUnite(fVal, m_strUnitId);
return(result);
}
catch { }
}
try{
result.Data = valeur.ConvertTo(m_strUnitId);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error during unit conversion|20115"));
}
return(result);
}
//--------------------------------------------------------------
public void SetTypeConsommable(CTypeConsommable tp)
{
if (tp == null)
{
m_nIdTypeConsommable = null;
}
else
{
m_nIdTypeConsommable = tp.Id;
}
if (tp != null && tp.Unite != null && m_valeurQuantite != null)
{
if (m_valeurQuantite.IUnite == null ||
m_valeurQuantite.IUnite.Classe.GlobalId !=
tp.Unite.Classe.GlobalId)
{
m_valeurQuantite = new CValeurUnite(
m_valeurQuantite.Valeur,
tp.Unite.LibelleCourt);
}
}
if (m_bIsCoutTarif)
{
m_valeurCU = null;
}
}
//--------------------------------------------------------------
public void InitFrom(CBesoin besoin, IDonneeBesoin donnee)
{
CDonneeBesoinTypeEquipement dT = donnee as CDonneeBesoinTypeEquipement;
if (dT != null)
{
if (dT.Quantite != null)
{
Quantite = new CValeurUnite(dT.Quantite, "");
}
if (dT.CoutUnitaire != null)
{
CoutUnitaire = new CValeurUnite(dT.CoutUnitaire.Value, "");
}
return;
}
CDonneeBesoinQuantiteCU dQ = donnee as CDonneeBesoinQuantiteCU;
if (dQ != null)
{
Quantite = dQ.Quantite;
CoutUnitaire = dQ.CoutUnitaire;
return;
}
}
//----------------------------------------------------------------------------------------------
private void UpdateQuantite()
{
CTypeConsommable tpCons = m_selectTypeEquipement.ElementSelectionne as CTypeConsommable;
if (tpCons != null && CurrentItem != null)
{
CValorisationElement val = CurrentItem.Tag as CValorisationElement;
IUnite unite = tpCons.Unite;
if (unite != null)
{
m_txtQuantite.DefaultFormat = unite.LibelleCourt;
}
m_txtQuantite.UseValueFormat = true;
CValeurUnite v = val.QuantiteEtUnite;
if (v != null && unite != null)
{
if (v.IUnite == null || v.IUnite.Classe.GlobalId != unite.Classe.GlobalId)
{
v = null;
}
}
m_txtQuantite.UnitValue = v;
m_txtQuantite.LockEdition = LockEdition;
}
else
{
IUnite unite = CGestionnaireUnites.GetUnite(CClasseUniteUnite.c_idUnite);
m_txtQuantite.DefaultFormat = unite.LibelleCourt;
m_txtQuantite.UnitValue = new CValeurUnite(1, unite.LibelleCourt);
m_txtQuantite.LockEdition = true;
}
}
//-----------------------------------------------
private void ShowMenuUnites()
{
CValeurUnite v = m_txtQuantité.UnitValue;
if (v != null)
{
IUnite u = v.IUnite;
if (u != null)
{
List <IUnite> lst = new List <IUnite>(CGestionnaireUnites.GetUnites(u.Classe));
lst.Sort((x, y) => x.FacteurVersBase.CompareTo(y.FacteurVersBase));
m_menuUnites.Items.Clear();
foreach (IUnite unite in lst)
{
ToolStripMenuItem itemUnite = new ToolStripMenuItem(unite.LibelleCourt);
itemUnite.Tag = unite;
m_menuUnites.Items.Add(itemUnite);
if (unite.LibelleCourt == m_lblUniteCU.Text)
{
itemUnite.Checked = true;
}
itemUnite.Click += new EventHandler(itemUnite_Click);
}
m_menuUnites.Show(m_lblUniteCU, new Point(0, m_lblUniteCU.Height));
}
}
}
//---------------------------------------------------------------------------
void itemUnite_Click(object sender, EventArgs e)
{
CValeurUnite valeur = UnitValue;
ToolStripMenuItem item = sender as ToolStripMenuItem;
IUnite unite = item != null ? item.Tag as IUnite : null;
if (unite != null)
{
Text = valeur.ToString(unite.GlobalId);
/*valeur = valeur.ConvertTo(unite.GlobalId);
* valeur.Format = "";
* UnitValue = valeur;*/
}
}
//--------------------------------------------------------------
public double?CalculeCout(CBesoin besoin)
{
double?fValeur = null;
if (m_valeurQuantite != null && m_valeurCU != null)
{
try
{
CValeurUnite v = m_valeurQuantite * m_valeurCU;
fValeur = v.Valeur;
}
catch { }
}
return(fValeur);
}
//---------------------------------------------------------------------------
private void m_menu_Opening(object sender, System.ComponentModel.CancelEventArgs e)
{
m_menuCouper.Enabled = SelectionLength > 0;
m_menuCopier.Enabled = SelectionLength > 0;
m_menuColler.Enabled = Clipboard.GetData(DataFormats.Text) != null;
m_menuSupprimer.Enabled = SelectionLength > 0;
m_menuSelectAll.Enabled = Text.Length > 0;
foreach (IDisposable dis in new ArrayList(m_menuConvertir.DropDownItems))
{
dis.Dispose();
}
m_menuConvertir.DropDownItems.Clear();
IClasseUnite classe = null;
if (UniteRacine != null)
{
classe = UniteRacine.Classe;
}
else
{
CValeurUnite v = this.UnitValue;
if (v != null && v.Unite != null)
{
IUnite uTmp = CGestionnaireUnites.GetUnite(v.Unite);
if (uTmp != null)
{
classe = uTmp.Classe;
}
}
}
m_menuConvertir.Enabled = classe != null;
if (classe != null && UnitValue != null)
{
foreach (IUnite unite in CGestionnaireUnites.GetUnites(classe))
{
ToolStripMenuItem itemUnite = new ToolStripMenuItem(unite.LibelleLong);
itemUnite.Tag = unite;
itemUnite.Click += new EventHandler(itemUnite_Click);
m_menuConvertir.DropDownItems.Add(itemUnite);
}
ToolStripTextBox box = new ToolStripTextBox();
m_menuConvertir.DropDownItems.Add(box);
box.KeyDown += new KeyEventHandler(formatBox_KeyDown);
}
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
CValeurUnite valeur = valeursParametres[0] as CValeurUnite;
string strUnite = valeursParametres[1] as string;
try{
result.Data = valeur.ConvertTo(strUnite);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error during unit conversion|20115"));
}
return(result);
}
/// <summary>
/// Stocke une valeur unité
/// </summary>
/// <param name="valeur"></param>
/// <param name="objet"></param>
/// <param name="strChampValeur"></param>
/// <param name="strChampUnite"></param>
public static void SetValeur(CValeurUnite valeur,
CObjetDonnee objet,
string strChampValeur,
string strChampUnite)
{
if (valeur == null)
{
objet.Row[strChampValeur] = DBNull.Value;
objet.Row[strChampUnite] = "";
}
else
{
objet.Row[strChampValeur] = valeur.ConvertToBase();
objet.Row[strChampUnite] = valeur.Unite;
}
}
//------------------------------------------------------
public void SetElementEdite(IElementAVariables element)
{
m_elementAVariables = element;
if (m_variable != null && element != null)
{
object valeur = element.GetValeurChamp(m_variable.IdVariable);
CValeurUnite valU = valeur as CValeurUnite;
if (valU != null)
{
UnitValue = valU;
}
else
{
UnitValue = null;
}
}
}
//--------------------------------------------
protected override CResultAErreur MyMajChamps()
{
CResultAErreur result = base.MyMajChamps();
if (!result)
{
return(result);
}
COperation op = Operation;
if (op != null)
{
//Le type d'opération est déjà affecté
if (m_panelLieEquipement.Visible)
{
op.Equipement = m_txtSelectEquipementLie.ElementSelectionne as CEquipement;
}
if (m_dateDebut.Visible)
{
op.DateDebut = m_dateDebut.Value;
}
if (m_dateFin.Visible)
{
op.DateHeureFin = m_dateFin.Value;
}
if (m_txtDuree.Visible)
{
if (m_txtDuree.UnitValue != null)
{
CValeurUnite vu = m_txtDuree.UnitValue.ConvertTo(CClasseUniteTemps.c_idH);
op.Duree = vu.Valeur;
}
else
{
op.Duree = null;
}
}
op.Commentaires = m_txtCommentaire.Text;
if (m_panelFormulaireEnCours != null)
{
m_panelFormulaireEnCours.AffecteValeursToElement();
}
}
return(result);
}
private void C2iTextBoxNumeriqueAvecUnite_Validated(object sender, EventArgs e)
{
if (Text.Trim().Length > 0 && UnitValue == null)
{
IUnite unite = UniteRacine;
StringBuilder blUnites = new StringBuilder();
if (unite != null)
{
foreach (IUnite u in CGestionnaireUnites.GetUnites(unite.Classe))
{
blUnites.Append(u.LibelleCourt);
blUnites.Append(" ");
}
}
else
{
foreach (IClasseUnite classe in CGestionnaireUnites.Classes)
{
IEnumerable <IUnite> lstUnites = CGestionnaireUnites.GetUnites(classe);
if (lstUnites.Count() > 0)
{
blUnites.Append(Environment.NewLine);
blUnites.Append(classe.Libelle + " : ");
foreach (IUnite u in lstUnites)
{
blUnites.Append(u.LibelleCourt);
blUnites.Append(',');
}
blUnites.Remove(blUnites.Length - 1, 1);
}
}
}
m_error.SetError(this, I.T("Enter value using units @1|20014", blUnites.ToString()));
}
else
{
m_error.SetError(this, "");
CValeurUnite valeur = UnitValue;
if (valeur != null)
{
UnitValue = valeur;
}
}
}
//--------------------------------------------------------------
public void InitFrom(CBesoin besoin, IDonneeBesoin donnee)
{
CDonneeBesoinTypeEquipement dT = donnee as CDonneeBesoinTypeEquipement;
if (dT != null)
{
if (dT.Quantite != null)
{
Quantite = new CValeurUnite(dT.Quantite, "");
}
if (dT.CoutUnitaire != null)
{
CoutUnitaire = new CValeurUnite(dT.CoutUnitaire.Value, "");
}
}
else
{
}
}
//------------------------------------------------------------------------
private void m_txtQuantité_Validated(object sender, EventArgs e)
{
if (!m_bIsInitializing)
{
CValeurUnite v = m_txtQuantité.UnitValue;
m_lblUniteCU.Text = "";
if (v != null && v.IUnite != null && m_uniteCU != null)
{
if (m_uniteCU.Classe == v.IUnite.Classe)
{
m_lblUniteCU.Text = m_uniteCU.LibelleCourt;
}
}
else if (v != null && v.IUnite != null)
{
m_lblUniteCU.Text = v.IUnite.LibelleCourt;
}
MajChamps();
DeclencheOnCoutChanged();
}
}
//----------------------------------
private C2iExpression GetFormuleValeur(object valeur)
{
C2iExpression formule = null;
if (valeur is CObjetDonneeAIdNumerique)
{
formule = new C2iExpressionGetEntite();
formule.Parametres.Add(new C2iExpressionConstante(valeur.GetType().ToString()));
formule.Parametres.Add(new C2iExpressionConstante(((CObjetDonneeAIdNumerique)valeur).Id));
}
else if (valeur == null)
{
formule = new C2iExpressionNull();
}
else
{
if (valeur is CValeurUnite)
{
CValeurUnite vU = valeur as CValeurUnite;
formule = new C2iExpressionValeurUnite();
C2iExpressionConstante exp1 = new C2iExpressionConstante(vU.Valeur);
C2iExpressionConstante exp2 = new C2iExpressionConstante(vU.Unite);
formule.Parametres.Add(exp1);
formule.Parametres.Add(exp2);
}
else
{
if (valeur is CDateTimeEx)
{
valeur = ((CDateTimeEx)valeur).DateTimeValue;
}
if (C2iExpressionConstante.CanManage(valeur))
{
formule = new C2iExpressionConstante(valeur);
}
}
}
return(formule);
}
/// <summary>
/// Récupère une valeur unité
/// </summary>
/// <param name="objet"></param>
/// <param name="strChampValeur"></param>
/// <param name="strChampUnite"></param>
/// <returns></returns>
public static CValeurUnite GetValeur(CObjetDonnee objet,
string strChampValeur,
string strChampUnite)
{
if (objet == null)
{
return(null);
}
double?fValeur = objet.Row.Get <double?>(strChampValeur);
if (fValeur == null)
{
return(null);
}
string strUnite = objet.Row.Get <string>(strChampUnite);
if (strUnite != null)
{
CValeurUnite v = CValeurUnite.GetValeurFromValeurBase(fValeur.Value, strUnite);
return(v);
}
return(new CValeurUnite(fValeur.Value, ""));
}
//------------------------------------------------------------------------
public double GetValuationForDate(DateTime dt, CValeurUnite quantite)
{
CListeObjetsDonnees lstValEqpt = Valorisations;
CListeObjetsDonnees lstLot = lstValEqpt.GetDependances("LotValorisation");
double fQuantite = 1;
if (quantite != null && Unite != null)
{
if (quantite.IUnite == null)
{
fQuantite = quantite.Valeur;
}
else
{
fQuantite = quantite.ConvertTo(Unite.GlobalId).Valeur;
}
}
if (lstValEqpt.Count == 0)
{
return(0);
}
lstLot.Tri = CLotValorisation.c_champDateLot;
CLotValorisation lot = lstLot[0] as CLotValorisation;
if (lot != null && lot.DateLot.Date.AddMinutes(-1) > dt)//Premier plus récent->premier
{
CValorisationElement val = lot.GetValorisation(this);
if (val != null)
{
return(val.Valeur * fQuantite);
}
return(0);
}
lstLot.InterditLectureInDB = true;
lstLot.Filtre = new CFiltreData(CLotValorisation.c_champDateLot + "<@1",
dt.Date.AddDays(1));
lstLot.Tri = CLotValorisation.c_champDateLot;
if (lstLot.Count > 0)
{
lot = lstLot[lstLot.Count - 1] as CLotValorisation;
if (lot != null)
{
CValorisationElement val = lot.GetValorisation(this);
if (val != null)
{
CValeurUnite v = val.QuantiteEtUnite;
IUnite monUnite = Unite;
if (v != null && monUnite != null)
{
v = v.ConvertTo(monUnite.GlobalId);
if (v.Valeur != 0)
{
return(val.Valeur / v.Valeur * fQuantite);
}
}
return(val.Valeur * fQuantite);
}
}
}
return(0);
}
//----------------------------------------------------------
private bool OnKeyTab(bool bEnAvant)
{
List <CValeurUnite> valeurs = CValeurUnite.DecomposeChaineFormattée(Text);
int nIndexDansFormat = 0;
int nSel = SelectionStart;
StringBuilder bl = new StringBuilder();
List <int> nStartPos = new List <int>();
foreach (CValeurUnite valeur in valeurs)
{
nStartPos.Add(bl.Length);
bl.Append(valeur.ToString());
}
int nLastUnite = -1;
List <string> strFormatsDef = new List <string>();
strFormatsDef.AddRange(DefaultFormat.Split(' '));
//Navigation dedans
for (int nIndex = 0; nIndex < valeurs.Count; nIndex++)
{
string strTmp = valeurs[nIndex].ToString();
int nTmp = strFormatsDef.IndexOf(valeurs[nIndex].Unite);
if (nTmp > nLastUnite)
{
nLastUnite = nTmp;
}
if (nSel < strTmp.Length + nIndexDansFormat)
{
Text = bl.ToString();
if (bEnAvant)
{
SelectionStart = nIndexDansFormat + strTmp.Length;
if (nIndex < valeurs.Count - 1)
{
SelectionLength = valeurs[nIndex + 1].Valeur.ToString().Length;
}
return(true);
}
else
{
if (nIndex == 0)
{
return(false);
}
SelectionStart = nStartPos[nIndex - 1];
SelectionLength = valeurs[nIndex - 1].Valeur.ToString().Length;
return(true);
}
}
nIndexDansFormat += strTmp.Length;
}
if (bEnAvant)
{
if (nLastUnite + 1 < strFormatsDef.Count() && valeurs.Count > 0 && valeurs[valeurs.Count - 1].Unite.Trim() == "")
{
Text += strFormatsDef[nLastUnite + 1];
SelectionStart = Text.Length;
SelectionLength = 0;
return(true);
}
}
return(false);
}
