/// <summary>
/// ////////////////////////////////////////////
/// </summary>
/// <param name="dt"></param>
private void SetDateStart(DateTime dt)
{
m_dtFirstCellDate = dt;
CreateControlsJour();
for (int nJour = 0; nJour < 7; nJour++)
{
CControlJourAgendaModeMois jour = (CControlJourAgendaModeMois)m_listeControlsJours[nJour];
jour.SetJour(dt);
if (dt.Month % 2 == 0)
{
jour.CouleurFond = m_couleursMoisPairs;
}
else
{
jour.CouleurFond = m_couleurMoisImpairs;
}
dt = dt.AddDays(1);
}
m_labelTitre.Text = I.T("Week |121 ") + CUtilDate.GetWeekNum(m_dtFirstCellDate).ToString().PadLeft(2, '0') + "/" +
CUtilDate.GetYearOfWeek(m_dtFirstCellDate).ToString();
m_scrollBar.Enabled = false;
m_scrollBar.Minimum = -100;
m_scrollBar.Value = 0;
m_scrollBar.Maximum = 100;
m_scrollBar.Enabled = true;
UpdateItems();
}
/// <summary>
/// ////////////////////////////////////////////
/// </summary>
/// <param name="dt"></param>
private void SetDateStart(DateTime dt)
{
m_dtFirstCellDate = dt;
CreateControlsJour();
bool bOnlyOnMonth = false;
int nMonthAvec1 = dt.Month;
int nYearAvec1 = dt.Year;
for (int nJour = 0; nJour < 35; nJour++)
{
if ((nJour % 7) == 0)
{
Label labelSemaine = (Label)m_listeLabelsSemaines[(int)(nJour / 7)];
labelSemaine.Text = CUtilDate.GetWeekNum(dt).ToString();
}
CControlJourAgendaModeMois jour = (CControlJourAgendaModeMois)m_listeControlsJours[nJour];
if (dt.Day == 1 && nJour < 7)
{
bOnlyOnMonth = true;
nMonthAvec1 = dt.Month;
nYearAvec1 = dt.Year;
}
jour.SetJour(dt);
//jour.SetCalendrier ( m_calendrierAssocie );
if (dt.Month % 2 == 0)
{
jour.CouleurFond = m_couleursMoisPairs;
}
else
{
jour.CouleurFond = m_couleurMoisImpairs;
}
if (dt == m_dateEnCours)
{
jour.Focus();
}
dt = dt.AddDays(1);
}
if (bOnlyOnMonth)
{
m_labelTitre.Text = CUtilDate.GetNomMois(nMonthAvec1, false) + " " + nYearAvec1.ToString();
}
else
{
m_labelTitre.Text = CUtilDate.GetNomMois(m_dtFirstCellDate.Month, false) + " ";
if (m_dtFirstCellDate.Year != m_dtFirstCellDate.AddDays(35).Year)
{
m_labelTitre.Text += m_dtFirstCellDate.Year.ToString() + " ";
}
m_labelTitre.Text += "- ";
m_labelTitre.Text += CUtilDate.GetNomMois(m_dtFirstCellDate.AddDays(35).Month, false) + " ";
m_labelTitre.Text += m_dtFirstCellDate.AddDays(35).Year.ToString() + " ";
}
m_scrollBar.Enabled = false;
m_scrollBar.Minimum = -100;
m_scrollBar.Value = 0;
m_scrollBar.Maximum = 100;
m_scrollBar.Enabled = true;
UpdateItems();
}
public override CResultAErreur MajChamps()
{
CResultAErreur result = base.MajChamps();
if (!result)
{
return(result);
}
JoursBinaires jrs = JoursBinaires.Aucun;
for (int n = 0; n < 7; n++)
{
if (m_wndListeJours.Items[n].Checked)
{
jrs |= CUtilDate.GetJourBinaireForBaseLundi(n);
}
}
CPlanificationTacheFrequente plFreq = (CPlanificationTacheFrequente)Planification;
plFreq.JoursExecution = jrs;
if (m_wndHeureFin.ValeurHeure == null)
{
m_wndHeureFin.ValeurHeure = 23;
}
plFreq.HeureFin = (double)m_wndHeureFin.ValeurHeure;
plFreq.Ecart = m_wndEcart.IntValue;
plFreq.Unite = (CPlanificationTacheFrequente.EUniteTemps)m_cmbUnite.SelectedValue;
return(result);
}
/// /////////////////////////////////////////////////////////////////
private void CFormParametresEntreeAgendaCyclique_Load(object sender, System.EventArgs e)
{
CPlanificationTache planif = m_entree.PlanificationCyclique;
if (planif == null)
{
CPlanificationTacheHebdomadaire ph = new CPlanificationTacheHebdomadaire();
planif = ph;
ph.JoursExecution = CUtilDate.GetJourBinaireFor(m_entree.DateDebut.DayOfWeek);
ph.Heure = m_entree.DateDebut.Hour;
ph.EcartSemaine = 1;
}
m_panelPlanif.Init(planif);
m_dateDebut.Value = m_entree.DateDebut;
m_dateFin.Value = m_entree.DateFinCyclique;
TimeSpan sp = m_entree.DateFin - m_entree.DateDebut;
m_chkSansHoraire.Checked = m_entree.SansHoraire;
if (!m_entree.SansHoraire)
{
m_nDureeJours.Value = (int)sp.TotalDays;
}
else
{
m_nDureeJours.Value = (int)(sp.TotalDays + .999999999);
}
m_nDureeHeures.Value = (int)sp.Hours;
m_nDureeMinutes.Value = (int)sp.Minutes;
m_wndListeExclusions.ListeSource = m_entree.Desactivations;
}
//Retourne toutes les clés concernant une date donnée dans l'ordre de priorité
public static string[] GetAllKeysConcernant(DateTime dt)
{
return(new string[]
{
CCalendrier_JourParticulier.GetKeyForJourMoisAnnee(dt.Day, dt.Month, dt.Year),
CCalendrier_JourParticulier.GetKeyForJourMois(dt.Day, dt.Month),
CCalendrier_JourParticulier.GetKeyForJourDuMois(dt.Day),
CCalendrier_JourParticulier.GetKeyJoursDeSemaine(CUtilDate.GetJourBinaireFor(dt.DayOfWeek))
});
}
/// /////////////////////////////////////////////////////////
public static object StringToType(ETypeChampBasique type, string strTexte)
{
if (strTexte.ToUpper() == c_ConstanteNull)
{
return(null);
}
switch (type)
{
case ETypeChampBasique.Bool:
return(strTexte.ToString() == "1" || strTexte.ToUpper() == "TRUE");
case ETypeChampBasique.Date:
try
{
return(Convert.ChangeType(strTexte, typeof(DateTime), null));
}
catch
{
//Tente le format sc2i de date chaine
try
{
return(CUtilDate.FromUniversalString(strTexte));
}
catch
{
return(null);
}
}
case ETypeChampBasique.Decimal:
try
{
return(CUtilDouble.DoubleFromString(strTexte));
}
catch
{
return(null);
}
case ETypeChampBasique.Int:
try
{
return(Convert.ChangeType(strTexte, typeof(int), null));
}
catch
{
return(null);
}
case ETypeChampBasique.String:
return(strTexte);
}
return(null);
}
/// ///////////////////////////////////////////
protected CDateTimeEx GetMyNextOccurence(DateTime dtDateExecutionPrecedente, bool bPremiereExecution, bool bSuperieur)
{
DateTime dtVal = dtDateExecutionPrecedente;
if (JoursExecution == JoursBinaires.Aucun)
{
JoursExecution = JoursBinaires.Lundi;
}
JoursBinaires jour = CUtilDate.GetJourBinaireFor(dtVal.DayOfWeek);
int nInc = 0;
if (bPremiereExecution)
{
while (((jour & JoursExecution) != jour) && nInc < 7)
{
nInc++;
dtVal = dtVal.AddDays(1);
jour = CUtilDate.GetJourBinaireFor(dtVal.DayOfWeek);
}
}
else
{
if (bSuperieur)
{
if (dtVal.DayOfWeek == DayOfWeek.Sunday)
{
dtVal = dtVal.AddDays(7 * (m_nEcartSemaine - 1) + 1);
}
else
{
dtVal = dtVal.AddDays(1);
}
}
jour = CUtilDate.GetJourBinaireFor(dtVal.DayOfWeek);
//Regarde les jours suivants de la même semaine
while ((jour & JoursExecution) != jour && dtVal.DayOfWeek != DayOfWeek.Sunday)
{
dtVal = dtVal.AddDays(1);
jour = CUtilDate.GetJourBinaireFor(dtVal.DayOfWeek);
}
if ((jour & JoursExecution) != jour)
{
//Il faut passer à la semaine d'après
return(GetMyNextOccurence(CUtilDate.LundiDeSemaine(dtDateExecutionPrecedente.AddDays(7 * m_nEcartSemaine)), false, false));
}
}
int nHeure = (int)Heure;
int nMinute = (int)Math.Round((Heure - nHeure) * 60, 0);
dtVal = new DateTime(dtVal.Year, dtVal.Month, dtVal.Day, nHeure, nMinute, 0);
return(new CDateTimeEx(dtVal));
}
////////////////////////////////////
private void UpdateItemText(ListViewItem item)
{
if (!(item.Tag is CVisuEntreeAgenda))
{
return;
}
CVisuEntreeAgenda entree = (CVisuEntreeAgenda)item.Tag;
string strText = "";
if (!entree.Entree.SansHoraire && CUtilDate.SetTime0(entree.DateDebut) == CUtilDate.SetTime0(m_date))
{
if (Width > 68)
{
strText = GetHeure(entree.DateDebut);
}
if (m_bModeSemaine)
{
if (entree.DateFin.Date == m_date.Date)
{
strText += "-" + GetHeure(entree.DateFin) + " ";
}
else
{
strText += "...";
}
}
else
{
strText += " ";
}
}
if (CUtilDate.SetTime0(entree.DateDebut) != CUtilDate.SetTime0(m_date))
{
strText += "...";
if (m_bModeSemaine && entree.DateFin.Date == m_date.Date)
{
strText += GetHeure(entree.DateFin) + " ";
}
}
if (m_bAvecInitiales)
{
if (entree.ElementLie is IElementAIdentificationCourteAgenda)
{
strText += ((IElementAIdentificationCourteAgenda)entree.ElementLie).IdentificationCourte + "-";
}
}
strText += entree.Entree.Libelle;
item.Text = strText;
}
/// ////////////////////////////////////////////
private void CreateControlsJour()
{
if (m_listeControlsJours.Count != 0)
{
return;
}
this.SuspendDrawing();
Visible = false;
int nWidth = m_panelJours.ClientRectangle.Width;
int nHeight = m_panelJours.ClientRectangle.Height;
int nWidthElt = nWidth / 2;
int nHeightElement = nHeight / 3;
CControlJourAgendaModeMois jour;
for (int nJour = 0; nJour < 7; nJour++)
{
jour = new CControlJourAgendaModeMois(this);
jour.AvecInitiales = m_elementsAAgenda != null && m_elementsAAgenda.Length > 0;
jour.ImageRoles = m_imagesRoles != null?m_imagesRoles.ImageList:null;
jour.OnDemandeAffichageEntree += new DemandeAffichageEntreeAgendaEventHandler(OnDemandeAffichageEntree);
jour.OnDemandeCreationEntreeAgenda += new EventHandler(jour_OnDemandeCreationEntreeAgenda);
jour.Parent = m_panelJours;
jour.Left = (nJour / 3) * (nWidthElt - 1);
jour.Top = (nJour % 3) * (nHeightElement - 1);
if (nJour == 6)
{
jour.Top = (nHeightElement - 1) * 2 + nHeightElement / 2;
jour.Left = (nWidthElt - 1);
}
jour.Width = nWidthElt;
jour.Height = nHeightElement;
if (nJour >= 5)
{
jour.Height = nHeightElement / 2;
}
jour.Visible = true;
jour.CreateControl();
jour.Enter += new EventHandler(jour_Enter);
jour.ModeSemaine = true;
m_listeControlsJours.Add(jour);
}
m_scrollBar.Left = m_panelJours.Left + 7 * (nWidthElt - 1);
m_scrollBar.Top = m_panelJours.Top;
m_scrollBar.Height = 5 * (nHeightElement - 1);
SetSemaineEnCours(CUtilDate.GetWeekNum(DateTime.Now), CUtilDate.GetYearOfWeek(DateTime.Now));
DateEnCours = m_dateEnCours;
this.ResumeDrawing();
Visible = true;
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
try
{
DateTime dt = Convert.ToDateTime(valeursParametres[0]);
result.Data = CUtilDate.GetYearOfWeek(dt);
}
catch
{
result.EmpileErreur(I.T("The parameters of the function 'YearOfWeek' are incorrect|190"));
}
return(result);
}
public override void InitChamps(CPlanificationTache planification)
{
base.InitChamps(planification);
CPlanificationTacheHebdomadaire plHe = (CPlanificationTacheHebdomadaire)planification;
for (int n = 0; n < 7; n++)
{
if ((plHe.JoursExecution & CUtilDate.GetJourBinaireForBaseLundi(n)) != 0)
{
m_wndListeJours.Items[n].Checked = true;
}
else
{
m_wndListeJours.Items[n].Checked = false;
}
}
}
//----------------------------------------------
public CControleEditePeriodeJoursSemaine()
{
InitializeComponent();
foreach (Control ctrl in Controls)
{
CheckBox chk = ctrl as CheckBox;
if (chk != null)
{
try
{
int nTag = Int32.Parse(chk.Tag.ToString());
JoursBinaires j = (JoursBinaires)nTag;
DayOfWeek d = CUtilDate.GetDayOfWeekFor(j);
chk.Text = CUtilDate.GetNomJour(d, false);
}
catch { }
}
}
}
public override CResultAErreur MajChamps()
{
CResultAErreur result = base.MajChamps();
if (!result)
{
return(result);
}
JoursBinaires jrs = JoursBinaires.Aucun;
for (int n = 0; n < 7; n++)
{
if (m_wndListeJours.Items[n].Checked)
{
jrs |= CUtilDate.GetJourBinaireForBaseLundi(n);
}
}
((CPlanificationTacheHebdomadaire)Planification).JoursExecution = jrs;
return(result);
}
////////////////////////////////////
private void UpdateAspect()
{
if (m_bModeSemaine)
{
m_lblJour.Text = m_date.ToString("dddd dd MMMM");
}
else
{
m_lblJour.Text = m_date.Day.ToString();
if (m_date.Day == 1)
{
m_lblJour.Text += " " + CUtilDate.GetNomMois(m_date.Month, Width < 50);
}
}
m_iconeFerme.Visible = !m_bIsOuvert;
foreach (ListViewItem item in m_wndListeEntrees.Items)
{
UpdateItemText(item);
}
}
/// ///////////////////////////////////////////
protected override CDateTimeEx GetMyNextOccurence(DateTime dtDateExecutionPrecedente, bool bPremiereExecution)
{
if (JoursExecution == JoursBinaires.Aucun)
{
return(null);
}
DateTime dtVal = dtDateExecutionPrecedente;
double fHeure = ((double)dtVal.Hour) + ((double)dtVal.Minute) / 60;
if (fHeure < Heure)
{
dtVal = dtVal.Date.AddHours(Heure);
}
else
{
switch (m_nUnite)
{
case EUniteTemps.Hour:
dtVal = dtVal.AddHours(m_nEcart);
break;
case EUniteTemps.Minute:
dtVal = dtVal.AddMinutes(m_nEcart);
break;
}
}
fHeure = ((double)dtVal.Hour) + ((double)dtVal.Minute) / 60;
if (fHeure > HeureFin || fHeure < Heure)
{
dtVal = dtDateExecutionPrecedente.Date.AddDays(1);
dtVal = dtVal.AddHours(Heure);
JoursBinaires jour = CUtilDate.GetJourBinaireFor(dtVal.DayOfWeek);
while ((jour & JoursExecution) != jour)
{
dtVal = dtVal.AddDays(1);
jour = CUtilDate.GetJourBinaireFor(dtVal.DayOfWeek);
}
}
dtVal = new DateTime(dtVal.Year, dtVal.Month, dtVal.Day, dtVal.Hour, dtVal.Minute, 0);
return(dtVal);
}
//-----------------------------------------------------------------
public void AppliquerFiltre()
{
CFiltreData filtre = null;
if (m_cmbCategorie.ElementSelectionne is CCategorieGED)
{
CCategorieGED cat = (CCategorieGED)m_cmbCategorie.ElementSelectionne;
filtre = new CFiltreDataAvance(CDocumentGED.c_nomTable,
CRelationDocumentGED_Categorie.c_nomTable + "." +
CCategorieGED.c_nomTable + "." +
CCategorieGED.c_champCodeSystemeComplet + " LIKE @1",
cat.CodeSystemeComplet + "%");
}
if (m_dateDebutCreation.Value != null)
{
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreData(CDocumentGED.c_champDateCreation + ">=@1",
m_dateDebutCreation.Value.DateTimeValue));
}
if (m_dateFinCreation.Value != null)
{
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreData(CDocumentGED.c_champDateCreation + "<@1",
CUtilDate.SetTime0(m_dateFinCreation.Value.DateTimeValue.AddDays(1))));
}
if (m_dateDebutModification.Value != null)
{
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreData(CDocumentGED.c_champDateMAJ + ">=@1",
m_dateDebutModification.Value.DateTimeValue));
}
if (m_dateFinModification.Value != null)
{
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreData(CDocumentGED.c_champDateMAJ + "<@1",
CUtilDate.SetTime0(m_dateFinModification.Value.DateTimeValue.AddDays(1))));
}
Filtre = filtre;
OnAppliqueFiltre(new object(), null);
}
public static DateTime Arrondire(DateTime date, EEchelleTemps periode)
{
switch (periode)
{
case EEchelleTemps.Heure:
return(new DateTime(date.Year, date.Month, date.Day, date.Hour, 0, 0));
case EEchelleTemps.Jour:
return(date.Date);
case EEchelleTemps.Mois:
return(new DateTime(date.Year, date.Month, 1));
case EEchelleTemps.Semaine:
return(CUtilDate.LundiDeSemaine(date));
case EEchelleTemps.Annee:
return(new DateTime(date.Year, 1, 1));
}
return(date);
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
try
{
if (valeursParametres.Length == 1)
{
DateTime dt = (DateTime)valeursParametres[0];
result.Data = CUtilDate.LundiDeSemaine(CUtilDate.GetWeekNum(dt), CUtilDate.GetYearOfWeek(dt));
return(result);
}
int nSemaine = Convert.ToInt32(valeursParametres[0]);
int nAnnee = Convert.ToInt32(valeursParametres[1]);
result.Data = CUtilDate.LundiDeSemaine(nSemaine, nAnnee);
}
catch
{
result.EmpileErreur(I.T("Error during the date conversion : '@1' is not convertible to a date|196", valeursParametres[0].ToString()));
}
return(result);
}
/// ///////////////////////////////////////////
protected override string GetMyLibelle()
{
if (JoursExecution == JoursBinaires.Aucun)
{
return(I.T("Never|30000"));
}
string strLib = " Every|30001 ";
if (EcartSemaine != 1)
{
strLib += EcartSemaine + " ";
}
for (int nTmp = 0; nTmp < 7; nTmp++)
{
if ((JoursExecution & CUtilDate.GetJourBinaireForBaseLundi(nTmp)) != 0)
{
strLib += CUtilDate.GetNomJour((DayOfWeek)((nTmp + 8) % 7), true) + ",";
}
}
strLib = strLib.Substring(0, strLib.Length - 1);
return(strLib);
}
public override void InitChamps(CPlanificationTache planification)
{
CUtilSurEnum.CCoupleEnumLibelle[] couples = CUtilSurEnum.GetCouplesFromEnum(typeof(CPlanificationTacheFrequente.EUniteTemps));
m_cmbUnite.DataSource = couples;
m_cmbUnite.DisplayMember = "Libelle";
m_cmbUnite.ValueMember = "Valeur";
base.InitChamps(planification);
CPlanificationTacheFrequente plFreq = (CPlanificationTacheFrequente)planification;
for (int n = 0; n < 7; n++)
{
if ((plFreq.JoursExecution & CUtilDate.GetJourBinaireForBaseLundi(n)) != 0)
{
m_wndListeJours.Items[n].Checked = true;
}
else
{
m_wndListeJours.Items[n].Checked = false;
}
}
int nIndex = 0;
foreach (CUtilSurEnum.CCoupleEnumLibelle couple in couples)
{
if (couple.Valeur == (int)plFreq.Unite)
{
m_cmbUnite.SelectedIndex = nIndex;
}
nIndex++;
}
m_wndHeureFin.ValeurHeure = plFreq.HeureFin;
m_wndEcart.DoubleValue = plFreq.Ecart;
foreach (ListViewItem item in m_wndListeJours.Items)
{
item.Text = I.TT(GetType(), item.Text);
}
}
/// ///////////////////////////////////////////
protected override string GetMyLibelle()
{
string strLib = I.T("Every|30001 ");
switch (NumeroJour)
{
case 1:
strLib += I.T("first|30004 ");
break;
case 2:
strLib += I.T("second|30005 ");
break;
case 3:
strLib += I.T("third|30006 ");
break;
case 4:
strLib += I.T("fourth|30007 ");
break;
case 5:
strLib += I.T("last|30008 ");
break;
}
strLib += CUtilDate.GetNomJour(JourSemaine, false) + "s ";
if (EcartMois == 1)
{
strLib += I.T("of the month|30002");
}
else
{
strLib += I.T("Every @1 months|30003", EcartMois.ToString());
}
return(strLib);
}
/// /////////////////////////////////////////////////////////
public static string TypeToString(object valeur)
{
if (valeur == null)
{
return("");
}
if (valeur.GetType() == typeof(bool))
{
return(((bool)valeur)?"1":"0");
}
else if (valeur.GetType() == typeof(double))
{
return(valeur.ToString());
}
else if (valeur.GetType() == typeof(int))
{
return(valeur.ToString());
}
else if (valeur.GetType() == typeof(DateTime))
{
return(CUtilDate.GetUniversalString((DateTime)valeur));
}
return(valeur.ToString());
}
/// /////////////////////////////////////////////////////////
public static object StringToType(TypeDonnee type, string strTexte, CContexteDonnee contexteDonnee)
{
if (strTexte.ToUpper() == c_ConstanteNull)
{
return(null);
}
switch (type)
{
case TypeDonnee.tBool:
return(strTexte.ToString() == "1" || strTexte.ToUpper() == "TRUE");
case TypeDonnee.tDate:
try
{
return(Convert.ChangeType(strTexte, typeof(DateTime), null));
}
catch
{
//Tente le format sc2i de date chaine
try
{
return(CUtilDate.FromUniversalString(strTexte));
}
catch
{
return(null);
}
}
case TypeDonnee.tDouble:
try
{
return(CUtilDouble.DoubleFromString(strTexte));
}
catch
{
return(null);
}
case TypeDonnee.tEntier:
try
{
return(Convert.ChangeType(strTexte, typeof(int), null));
}
catch
{
return(null);
}
case TypeDonnee.tString:
return(strTexte);
case TypeDonnee.tObjetDonneeAIdNumeriqueAuto:
try
{
if (contexteDonnee == null)
{
return(null);
}
//Syntaxe : classe|id
int nPos = strTexte.LastIndexOf("|");
if (nPos < 0)
{
return(null);
}
string strClasse = strTexte.Substring(0, nPos);
int nId = Int32.Parse(strTexte.Substring(nPos + 1));
Type tp = CActivatorSurChaine.GetType(strClasse, true);
if (tp != null)
{
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tp, new object[] { contexteDonnee });
if (objet.ReadIfExists(nId))
{
return(objet);
}
}
return(null);
}
catch
{
return(null);
}
}
return(null);
}
private void CTimeBar_Paint(object sender, PaintEventArgs e)
{
DateTime dateDebut = ParametreAffichage.DateDebut;
if (m_bIsDragging)
{
dateDebut = m_dateDragEnCours;
}
SolidBrush brFond = new SolidBrush(BackColor);
e.Graphics.FillRectangle(brFond, ClientRectangle);
//Divise en 2 verticalement
Pen pen = new Pen(ForeColor);
int nYSeparation = ClientSize.Height / 2;
e.Graphics.DrawLine(pen, 0, nYSeparation, ClientSize.Width, nYSeparation);
int nX = 0;
DateTime dt = dateDebut;
DateTime lastDateEntete = dateDebut;
Brush brTexte = new SolidBrush(ForeColor);
while (nX < ClientSize.Width)
{
Rectangle rct = new Rectangle(nX, nYSeparation + 1, nX + ParametreAffichage.CellWidth, ClientSize.Height - nYSeparation - 2);
e.Graphics.FillRectangle(brFond, rct);
e.Graphics.DrawRectangle(pen, rct);
string strTexteEntete = "";
string strTextCell = "";
DateTime oldDate = dt;
switch (ParametreAffichage.Unit)
{
case EGanttTimeUnit.Hour:
if (lastDateEntete.Day != dt.Day || nX == 0)
{
strTexteEntete = dt.ToShortDateString();
}
strTextCell = dt.Hour.ToString("00") + ":00";
break;
case EGanttTimeUnit.Day:
if (lastDateEntete.Month != dt.Month || nX == 0)
{
strTexteEntete = dt.ToString("MMM yy");
}
strTextCell = dt.ToString("ddd").Substring(0, 1).ToUpper() + " " + dt.ToString("dd");
break;
case EGanttTimeUnit.Semaine:
if (dt.Month != lastDateEntete.Month)
{
strTexteEntete = dt.ToString("MMM yyyy");
}
strTextCell = CUtilDate.GetWeekNum(dt).ToString();
break;
case EGanttTimeUnit.Mois:
if (dt.Year != lastDateEntete.Year)
{
strTexteEntete = dt.Year.ToString();
}
strTextCell = dt.ToString("MMM");
break;
}
if (strTexteEntete.Length > 0)
{
e.Graphics.FillRectangle(brFond, nX, 0, ClientSize.Width, nYSeparation - 1);
e.Graphics.DrawLine(pen, new Point(nX, 0), new Point(nX, nYSeparation));
e.Graphics.DrawString(strTexteEntete, Font, brTexte, new Point(nX, 1));
lastDateEntete = oldDate;
}
if (dt < DateTime.Now && ParametreAffichage.AddCells(dt, 1) > DateTime.Now)
{
Brush brFondCell = new SolidBrush(Color.LightGray);
e.Graphics.FillRectangle(brFondCell, new Rectangle(nX + 1, nYSeparation + 1, ParametreAffichage.CellWidth - 1, ClientSize.Height - 2));
brFondCell.Dispose();
}
e.Graphics.DrawString(strTextCell, Font, brTexte, new Point(nX, nYSeparation + 1));
nX += ParametreAffichage.CellWidth;
dt = ParametreAffichage.AddCells(dt, 1);
}
brTexte.Dispose();
pen.Dispose();
brFond.Dispose();
}
public void Draw(Graphics g, Rectangle rect)
{
//Cache valide
if (m_cacheDessin != null && rect.Size == CacheDessin.Size)
{
g.DrawImageUnscaled(m_cacheDessin, rect.Location);
}
else
{
Rectangle rcImage = rect;
rcImage.Offset(new Point(-rcImage.Left, -rcImage.Top));
Image img = new Bitmap(rect.Size.Width, rect.Size.Height);
Graphics gTmp = Graphics.FromImage(img);
SolidBrush brush = new SolidBrush(Color.Beige);
gTmp.FillRectangle(brush, rcImage);
//Calendar calendrier = CultureInfo.InvariantCulture.Calendar;
int nWeekD = CUtilDate.GetWeekNum(DateDebut);
//int nWeekD = calendrier.GetWeekOfYear(DateDebut, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
string strWeekD = nWeekD.ToString();
if (nWeekD < 10)
{
strWeekD = "0" + strWeekD;
}
string strMoisD = DateDebut.Month.ToString();
if (DateDebut.Month < 10)
{
strMoisD = "0" + strMoisD;
}
string strJourD = DateDebut.Day.ToString();
if (DateDebut.Day < 10)
{
strJourD = "0" + strJourD;
}
string strAnneeD = DateDebut.Year.ToString();
int nWeekF = CUtilDate.GetWeekNum(DateFin);
//int nWeekF = calendrier.GetWeekOfYear(DateFin, CalendarWeekRule.FirstDay, DayOfWeek.Monday);
string strWeekF = nWeekF.ToString();
if (nWeekF < 10)
{
strWeekF = "0" + strWeekF;
}
string strMoisF = DateFin.Month.ToString();
if (DateFin.Month < 10)
{
strMoisF = "0" + strMoisF;
}
string strJourF = DateFin.Day.ToString();
if (DateFin.Day < 10)
{
strJourF = "0" + strJourF;
}
string strAnneeF = DateFin.Year.ToString();
//string strWeekF2 = calendrier.GetWeekOfYear(DateFin, CalendarWeekRule.FirstDay, DayOfWeek.Monday).ToString();
string strDateD = "";
string strDateF = "";
switch (FormatDate)
{
default:
case EFormatDate.JourMoisAnnee:
strDateD = strJourD + "/" + strMoisD + "/" + strAnneeD;
strDateF = strJourF + "/" + strMoisF + "/" + strAnneeF;
break;
case EFormatDate.JourMois:
strDateD = strJourD + "/" + strMoisD;
strDateF = strJourF + "/" + strMoisF;
break;
case EFormatDate.MoisAnnee:
strDateD = strMoisD + "/" + strAnneeD;
strDateF = strMoisF + "/" + strAnneeF;
break;
case EFormatDate.Jour:
strDateD = strJourD;
strDateF = strJourF;
break;
case EFormatDate.Mois:
strDateD = strMoisD;
strDateF = strMoisF;
break;
case EFormatDate.Annee:
strDateD = strAnneeD;
strDateF = strAnneeF;
break;
case EFormatDate.Semaine:
strDateD = strWeekD;
strDateF = strWeekF;
break;
}
SizeF sDateD = gTmp.MeasureString(strDateD, Police);
SizeF sDateF = gTmp.MeasureString(strDateF, Police);
int nHDateD = 0;
int nYCadreDateD = 0;
int nWDateD = 0;
int nXCadreDateD = 0;
Rectangle rDateD = new Rectangle();
int nHDateF = 0;
int nYCadreDateF = 0;
int nWDateF = 0;
int nXCadreDateF = 0;
Rectangle rDateF = new Rectangle();
Pen crayonRouge = new Pen(Brushes.Red);
Brush brushBlack = new SolidBrush(Color.Black);
Brush brushPaleGoldenrod = new SolidBrush(Color.PaleGoldenrod);
switch (PositionTranche)
{
case EPositionDessinTranche.Fin:
CDessinEditeurPreventive.DessinerLigne(ECoteRectangle.Droite, System.Drawing.Drawing2D.DashStyle.Dash, Color.Black, 1, rcImage, gTmp);
Image imgEtqFin = new Bitmap(((int)sDateF.Width + 5), ((int)sDateF.Height + 5));
Graphics gEtqFin = Graphics.FromImage(imgEtqFin);
rDateF = new Rectangle(0, 0, (int)sDateF.Width + 4, (int)sDateF.Height + 4);
gEtqFin.FillRectangle(brushPaleGoldenrod, rDateF);
gEtqFin.DrawRectangle(crayonRouge, rDateF);
gEtqFin.DrawString(strDateF, Police, brushBlack, 2, 2);
imgEtqFin.RotateFlip(RotateFlipType.Rotate270FlipNone);
gTmp.DrawImageUnscaled(imgEtqFin, new Point(rcImage.Width - 1 - imgEtqFin.Width, (rcImage.Height / 2) - imgEtqFin.Height / 2));
if (PositionTranche != EPositionDessinTranche.Unique)
{
goto case EPositionDessinTranche.Intermediaire;
}
else
{
CDessinEditeurPreventive.DessinerLigne(ECoteRectangle.Gauche, System.Drawing.Drawing2D.DashStyle.Dash, Color.Black, 1, rcImage, gTmp);
break;
}
case EPositionDessinTranche.Debut:
Image imgEtqDebut = new Bitmap(((int)sDateD.Width + 5), ((int)sDateD.Height + 5));
Graphics gEtqDebut = Graphics.FromImage(imgEtqDebut);
rDateD = new Rectangle(0, 0, (int)sDateD.Width + 4, (int)sDateD.Height + 4);
gEtqDebut.FillRectangle(brushPaleGoldenrod, rDateD);
gEtqDebut.DrawRectangle(crayonRouge, rDateD);
gEtqDebut.DrawString(strDateD, Police, brushBlack, 2, 2);
imgEtqDebut.RotateFlip(RotateFlipType.Rotate270FlipNone);
gTmp.DrawImageUnscaled(imgEtqDebut, new Point(1, (rcImage.Height / 2) - imgEtqDebut.Height / 2));
if (PositionTranche != EPositionDessinTranche.Unique)
{
goto case EPositionDessinTranche.Intermediaire;
}
else
{
goto case EPositionDessinTranche.Fin;
}
case EPositionDessinTranche.Intermediaire:
CDessinEditeurPreventive.DessinerLigne(ECoteRectangle.Gauche, System.Drawing.Drawing2D.DashStyle.Dash, Color.Black, 1, rcImage, gTmp);
#region LABEL DROIT
if (PositionTranche != EPositionDessinTranche.Fin)
{
nHDateF = (int)sDateF.Height;
nYCadreDateF = ((rcImage.Height / 2) - (nHDateF / 2) - 2);
nWDateF = (int)sDateF.Width;
nXCadreDateF = (rcImage.Width - (nWDateF / 2) - 2);
if (nWDateF % 2 != 0)
{
nXCadreDateF--;
}
rDateF = new Rectangle(nXCadreDateF, nYCadreDateF, ((int)sDateF.Width + 4), ((int)sDateF.Height + 4));
gTmp.FillRectangle(brushPaleGoldenrod, rDateF);
gTmp.DrawRectangle(crayonRouge, rDateF);
int posXFont = nXCadreDateF + 3;
int posYFont = nYCadreDateF + 2;
if (FormatDate == EFormatDate.JourMoisAnnee ||
FormatDate == EFormatDate.Mois)
{
posXFont += 2;
}
gTmp.DrawString(strDateF, Police, brushBlack, posXFont, posYFont);
}
#endregion
#region LABEL GAUCHE
if (PositionTranche != EPositionDessinTranche.Debut)
{
nHDateD = (int)sDateD.Height;
nYCadreDateD = ((rcImage.Height / 2) - (nHDateD / 2) - 2);
nWDateD = (int)sDateD.Width;
nXCadreDateD = (-(nWDateD / 2) - 2);
if (nWDateD % 2 != 0)
{
nXCadreDateD++;
}
int posYFont = nYCadreDateD + 2;
int posXFont = nXCadreDateD + 3;
if (FormatDate == EFormatDate.Semaine)
{
posXFont--;
}
rDateD = new Rectangle(nXCadreDateD, nYCadreDateD, (int)sDateD.Width + 4, (int)sDateD.Height + 4);
gTmp.FillRectangle(brushPaleGoldenrod, rDateD);
gTmp.DrawRectangle(crayonRouge, rDateD);
gTmp.DrawString(strDateD, Police, brushBlack, posXFont, posYFont);
}
#endregion
break;
case EPositionDessinTranche.Unique:
goto case EPositionDessinTranche.Debut;
default:
break;
}
CDessinEditeurPreventive.DessinerLigne(ECoteRectangle.Bas, System.Drawing.Drawing2D.DashStyle.Solid, Color.Black, 1, rcImage, gTmp);
//Sauvegarde du cache
g.DrawImageUnscaled(img, rect.Location);
m_cacheDessin = img;
brush.Dispose();
crayonRouge.Dispose();
brushBlack.Dispose();
brushPaleGoldenrod.Dispose();
}
}
/// <summary>
/// Définit le mois à afficher
/// </summary>
/// <param name="nMois"></param>
/// <param name="nYear"></param>
public void SetSemaineEnCours(int nSemaine, int nYear)
{
DateTime dt = CUtilDate.LundiDeSemaine(nSemaine, nYear);
SetDateStart(dt);
}
//----------------------------------------------------------------------------------------
/// <summary>
/// Retourne tous les jours particuliers
/// </summary>
/// <param name="date"></param>
/// <returns></returns>
private CCalendrier_JourParticulier GetJourParticulierAvecHeritage(DateTime date, bool bAutoriseLectureEnBase)
{
CCalendrier_JourParticulier jourParticulier = new CCalendrier_JourParticulier(this.ContexteDonnee);
CCalendrier_JourParticulier jourParticulierHerite = new CCalendrier_JourParticulier(this.ContexteDonnee);
if (this.CalendrierDeBase != null)
{
jourParticulierHerite = this.CalendrierDeBase.GetJourParticulierAvecHeritage(date, bAutoriseLectureEnBase);
}
else
{
jourParticulierHerite = null;
}
// Vérifie s'il existe une exception "jour/mois/année" sur le jour du calendrier sélectionné
if (jourParticulier.ReadIfExists(new CFiltreData(
CCalendrier_JourParticulier.c_champAnnee + "=@1 and " +
CCalendrier_JourParticulier.c_champMois + "=@2 and " +
CCalendrier_JourParticulier.c_champJour + "=@3 and " +
CCalendrier.c_champId + "=@4",
date.Year,
date.Month,
date.Day,
this.Id), bAutoriseLectureEnBase))
{
return(jourParticulier);
}
// Vérifie s'il existe une exception "jour/mois/année" sur le jour du calendrier de base
if (jourParticulierHerite != null && jourParticulierHerite.Annee != null)
{
return(jourParticulierHerite);
}
// Vérifie s'il existe une exception "jour/mois" sur le jour du calendrier sélectionné
if (jourParticulier.ReadIfExists(new CFiltreData(
CCalendrier_JourParticulier.c_champAnnee + " is null and " +
CCalendrier_JourParticulier.c_champMois + "=@1 and " +
CCalendrier_JourParticulier.c_champJour + "=@2 and " +
CCalendrier.c_champId + "=@3",
date.Month,
date.Day,
this.Id), bAutoriseLectureEnBase))
{
return(jourParticulier);
}
// Vérifie s'il existe une exception "jour/mois" sur le jour du calendrier de base
if (jourParticulierHerite != null && jourParticulierHerite.Mois != null)
{
return(jourParticulierHerite);
}
// Vérifie s'il existe une exception "jour du mois" sur le jour du calendrier sélectionné
if (jourParticulier.ReadIfExists(new CFiltreData(
CCalendrier_JourParticulier.c_champAnnee + " is null and " +
CCalendrier_JourParticulier.c_champMois + " is null and " +
CCalendrier_JourParticulier.c_champJour + "=@1 and " +
CCalendrier.c_champId + "=@2",
date.Day,
this.Id), bAutoriseLectureEnBase))
{
return(jourParticulier);
}
// Vérifie s'il existe une exception "jour" sur le jour du calendrier de base
if (jourParticulierHerite != null && jourParticulierHerite.Jour != null)
{
return(jourParticulierHerite);
}
// Vérifie s'il existe une exception "jour de semaine" sur le jour du calendrier sélectionné
if (jourParticulier.ReadIfExists(new CFiltreData(
CCalendrier_JourParticulier.c_champAnnee + " is null and " +
CCalendrier_JourParticulier.c_champMois + " is null and " +
CCalendrier_JourParticulier.c_champJour + " is null and " +
CCalendrier_JourParticulier.c_champJourSemaine + "=@1 and " +
CCalendrier.c_champId + "=@2",
(int)CUtilDate.GetJourBinaireFor(date.DayOfWeek),
this.Id), bAutoriseLectureEnBase))
{
return(jourParticulier);
}
// Vérifie s'il existe une exception "jour de semaine" sur le jour du calendrier de base
if (jourParticulierHerite != null && jourParticulierHerite.JourSemaine != 0)
{
return(jourParticulierHerite);
}
return(null);
}
/// <summary>
/// Importe un fichier. Le data du result contient un datatable
/// </summary>
/// <param name="?"></param>
/// <returns></returns>
public CResultAErreur LectureFichier(string strFichier)
{
CResultAErreur result = CResultAErreur.True;
StreamReader reader = new StreamReader(strFichier, new CEncoding(m_encoding).GetEncoding());
DataTable table = new DataTable();
try
{
//string strLigne = reader.ReadLine();
string strLigne = GetCSVLine(reader);
string[] strDatas = strLigne.Split(m_strSeparateur);
int nCol = 1;
int nLigne = 1;
//Creation des colonnes
Dictionary <DataColumn, CColonneCSV> mappageCols = new Dictionary <DataColumn, CColonneCSV>();
foreach (string strData in strDatas)
{
//Nom Table
string strNom = "Column " + nCol.ToString();
CColonneCSV colCSV = (CColonneCSV)m_tableColonnes[nCol - 1];
if (NomChampsSurPremiereLigne)
{
strNom = strData;
}
if (colCSV != null && colCSV.Nom != "")
{
strNom = colCSV.Nom;
}
int nIndex = 0;
while (table.Columns[strNom] != null)
{
nIndex++;
strNom = strNom + "_" + nIndex.ToString();
}
Type tp = typeof(string);
if (colCSV != null && colCSV.DataType != null)
{
tp = colCSV.DataType;
}
DataColumn col = new DataColumn(strNom, tp);
mappageCols.Add(col, colCSV);
table.Columns.Add(col);
col.AllowDBNull = true;
nCol++;
}
if (NomChampsSurPremiereLigne)
{
//strLigne = reader.ReadLine();
strLigne = GetCSVLine(reader);
nLigne++;
}
//Lecture Table
while (strLigne != null)
{
if (strLigne.Trim().Length > 0)
{
strDatas = GetDatas(strLigne);
nCol = 0;
DataRow row = table.NewRow();
foreach (string strData in strDatas)
{
if (nCol < table.Columns.Count)
{
DataColumn col = table.Columns[nCol];
CColonneCSV colCSV = mappageCols[col];
try
{
if (colCSV != null)
{
if (colCSV.HasNullMapping)
{
if (colCSV.NullCaseSensitive)
{
if (strData == colCSV.NullMapping)
{
row[col] = DBNull.Value;
nCol++;
continue;
}
}
else if (strData.ToUpper() == colCSV.NullMapping.ToUpper())
{
row[col] = DBNull.Value;
nCol++;
continue;
}
}
}
if (col.DataType == typeof(string))
{
row[col] = strData;
}
else if (col.DataType == typeof(double) || col.DataType == typeof(int) ||
col.DataType == typeof(float))
{
double fVal = CUtilDouble.DoubleFromString(strData);
if (col.DataType == typeof(int))
{
row[col] = (int)fVal;
}
if (col.DataType == typeof(float))
{
row[col] = (float)fVal;
}
else
{
row[col] = fVal;
}
}
else if (col.DataType == typeof(DateTime))
{
DateTime dt = CUtilDate.DateFromString(strData);
row[col] = dt;
}
else if (col.DataType == typeof(bool))
{
string valBool = strData.ToUpper();
bool val = (valBool == "1" || valBool == "O" || valBool == "OUI" || valBool == "Y" || valBool == "YES" || valBool == "TRUE");
row[col] = val;
}
else
{
object val = Convert.ChangeType(strData, col.DataType);
row[col] = val;
}
}
catch
{
if (ValeurNullSiErreur)
{
row[col] = DBNull.Value;
}
else
{
result.EmpileErreur(I.T("Conversion error : line @1 column @2 : the value cannot be converted into @3|30003"
, nLigne.ToString(), col.ColumnName, DynamicClassAttribute.GetNomConvivial(col.DataType)));
return(result);
}
}
}
nCol++;
}
table.Rows.Add(row);
}
//strLigne = reader.ReadLine();
strLigne = GetCSVLine(reader);
nLigne++;
}
result.Data = table;
return(result);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
return(result);
}
finally
{
try
{
reader.Close();
}
catch { }
}
}
//--------------------------------------------
public bool IsInPeriode(DateTime dt)
{
JoursBinaires j = CUtilDate.GetJourBinaireFor(dt.DayOfWeek);
return((m_joursActivation & j) == j);
}
