/// <summary>
/// Met à jour la position de la timeline.
/// </summary>
private void UpdateTimelinePosition()
{
if (DesignMode.IsInDesignMode)
{
return;
}
var timeService = IoC.Resolve <IServiceBus>().Get <ITimeTicksFormatService>();
var position = base.GetPosition(this.CurrentTimelinePosition);
if (position < 0)
{
position = 0;
}
if (_timelineThumb != null && _timelineLine != null)
{
var nextLeft = position - _timelineThumb.ActualWidth / 2.0;
if (Canvas.GetLeft(_timelineThumb) != nextLeft)
{
Canvas.SetLeft(_timelineThumb, nextLeft);
Canvas.SetLeft(_timelineLine, position);
if (_timelineTime != null)
{
_timelineTime.Content = timeService.TicksToString(GanttDates.ToTicks(this.CurrentTimelinePosition));
ShowTimelinePopup();
}
}
}
}
/// <summary>
/// Initialise une nouvelle instance de la classe <see cref="ActionGanttItem"/>.
/// </summary>
/// <param name="action">L'action.</param>
/// <param name="level">Le niveau d'indentation.</param>
public ActionGanttItem(KAction action, int level)
{
Action = action;
Indentation = level;
Start = GanttDates.ToDateTime(action.BuildStart);
Finish = GanttDates.ToDateTime(action.BuildFinish);
UpdateContent();
}
/// <summary>
/// Appelé lorsque la valeur de le propriété <see cref="BuildActionFinish"/> a changé.
/// </summary>
/// <param name="action">The action.</param>
protected override void OnBuildActionFinishChanged(KAction action)
{
foreach (var item in this.ItemsOfTypeAction.Where(i => i.Action == action))
{
_updatingitem = item;
item.Finish = GanttDates.ToDateTime(action.BuildFinish);
_updatingitem = null;
}
}
/// <summary>
/// Obtient la fin process d'une action.
/// </summary>
/// <param name="action">L'action.</param>
/// <returns>La fin</returns>
protected override long GetBuildFinish(KAction action)
{
if (_useGanttItemsTimingsOnly)
{
var first = this.ItemsOfTypeAction.First(i => i.Action == action);
return(GanttDates.ToTicks(first.Finish));
}
else
{
return(action.BuildFinish);
}
}
private void SetBuildFinish(KAction action, long value)
{
if (_useGanttItemsTimingsOnly)
{
foreach (var item in this.ItemsOfTypeAction.Where(i => i.Action == action))
{
item.Finish = GanttDates.ToDateTime(value);
}
}
else
{
action.BuildFinish = value;
}
}
/// <summary>
/// Calcule les intervales en fonction du zoom, de la timeline affichée et de la largeur du chart.
/// </summary>
/// <param name="zoom">Le zoom appliqué.</param>
public void CalculateInitialIntervals(double zoom)
{
var timeService = IoC.Resolve <IServiceBus>().Get <ITimeTicksFormatService>();
var start = this.GanttChartView.TimelinePageStart;
var finish = GanttDates.ToDateTime((this.GanttChartView.TimelinePageFinish - start).Ticks / 5);
var overallFinish = this.GanttChartView.TimelinePageFinish;
this.Intervals.Clear();
var total = finish - start;
var maxIntervalsCount = this.ChartWidth / 70;
var timeSpanMinIncrement = TimeSpan.FromHours(total.TotalHours / maxIntervalsCount);
long realIncrementTicks;
if (timeSpanMinIncrement.TotalSeconds < 1)
{
realIncrementTicks = timeSpanMinIncrement.Ticks;
}
else if (timeSpanMinIncrement.TotalMinutes < 1)
{
realIncrementTicks = TimeSpan.FromSeconds(Math.Ceiling(timeSpanMinIncrement.TotalSeconds)).Ticks;
}
else if (timeSpanMinIncrement.TotalHours < 1)
{
realIncrementTicks = TimeSpan.FromMinutes(Math.Ceiling(timeSpanMinIncrement.TotalMinutes)).Ticks;
}
else
{
realIncrementTicks = TimeSpan.FromHours(Math.Ceiling(timeSpanMinIncrement.TotalHours)).Ticks;
}
var currentDate = start;
while (currentDate < overallFinish)
{
var nextDate = currentDate.AddTicks(Convert.ToInt64(realIncrementTicks / zoom));
var interval = new CustomScaleInterval(currentDate, nextDate);
var timeSpan = currentDate - start;
interval.HeaderContent = timeService.TicksToString(timeSpan.Ticks);
this.Intervals.Add(interval);
currentDate = nextDate;
}
}
private void OnItemTimingChanged(object sender, EventArgs e)
{
var item = (ActionGanttItem)sender;
if (_updatingitem == item)
{
return;
}
if (_useGanttItemsTimingsOnly)
{
return;
}
if (!SetActionBuildTiming(item.Action, GanttDates.ToTicks(item.Start), GanttDates.ToTicks(item.Finish)))
{
item.Start = GanttDates.ToDateTime(item.Action.BuildStart);
item.Finish = GanttDates.ToDateTime(item.Action.BuildFinish);
}
}
/// <summary>
/// Applique un auto scale sur un ou plusieurs Gantts.
/// </summary>
/// <param name="updateTimelineRange"><c>true</c> pour mettre également à jour les ranges de la Timeline.</param>
/// <param name="charts">Les différents Gantts.</param>
private void AutoScale(bool updateTimelineRange, double zoomX, double zoomY, IEnumerable <IZoomableGanttTarget> charts)
{
var timeService = IoC.Resolve <IServiceBus>().Get <ITimeTicksFormatService>();
var chartsChart = new Dictionary <IZoomableGanttTarget, GanttChartView>();
if (!charts.Any(c => c.IsReadyForAutoScale))
{
return;
}
foreach (var chart in charts)
{
var grid = chart as GanttChartDataGrid;
if (grid != null && grid.GanttChartView != null)
{
chartsChart[chart] = grid.GanttChartView;
}
else
{
var v = chart as GanttChartView;
if (v != null)
{
chartsChart[chart] = v;
}
}
}
IEnumerable <GanttChartItem> tasks = null;
foreach (var chart in charts)
{
if (tasks == null)
{
tasks = chartsChart[chart].ManagedItems;
}
else
{
tasks = tasks.Concat(chartsChart[chart].ManagedItems);
}
}
if (tasks == null || !tasks.Any())
{
if (updateTimelineRange)
{
foreach (var zoomable in charts)
{
var chart = chartsChart[zoomable];
chart.TimelinePageStart = GanttDates.StartDate;
chart.TimelinePageFinish = GanttDates.DefaultEndDate;
if (chart.ScrollContentPresenter != null)
{
chart.UpdateScaleInterval = TimeSpan.FromTicks(timeService.CurrentTimeScale);
}
}
}
}
else
{
var start = GanttDates.StartDate;
var end = tasks.Max(t => t.Finish);
if (updateTimelineRange)
{
foreach (var zoomable in charts)
{
var chart = chartsChart[zoomable];
chart.TimelinePageStart = GanttDates.StartDate;
double finish = (end - start).Ticks * 5;
chart.TimelinePageFinish = GanttDates.ToDateTime(Convert.ToInt64(finish));
if (chart.ScrollContentPresenter != null)
{
chart.UpdateScaleInterval = TimeSpan.FromTicks(timeService.CurrentTimeScale);
}
}
var total = end - start;
double minWidth = double.PositiveInfinity;
foreach (var zoomable in charts)
{
var chart = chartsChart[zoomable];
if (chart.ScrollContentPresenter != null)
{
minWidth = Math.Min(minWidth, GetVisibleWidth(chart));
}
}
foreach (var zoomable in charts)
{
var chart = chartsChart[zoomable];
if (minWidth / total.TotalHours > 0.0)
{
chart.HourWidth = minWidth * zoomX / total.TotalHours;
}
}
foreach (var zoomable in charts)
{
var chart = chartsChart[zoomable];
var zoomableScale = (ZoomableScale)chart.Scales[0];
zoomableScale.ChartWidth = minWidth;
zoomableScale.CalculateInitialIntervals(zoomX);
}
}
// Application du zoom Y
foreach (var zoomable in charts)
{
var chart = chartsChart[zoomable];
var grid = zoomable as KGanttChartDataGrid;
if (grid == null)
{
grid = ((KGanttChartView)chart).ParentKDataGrid;
}
if (zoomable.ZoomYInitialValues == null)
{
zoomable.ZoomYInitialValues = new ZoomYInitialValues
{
BarHeightRatio = grid.BarHeight / grid.ItemHeight,
ItemHeight = grid.ItemHeight,
FontSize = grid.FontSize,
DataGridRowsPresenter = grid.FindFirstChild <System.Windows.Controls.Primitives.DataGridRowsPresenter>(),
};
}
// Arrondir au pixel près car autrement le LayoutRounding risque de causer des décalages entre la grille et les barres
grid.ItemHeight = Math.Round(zoomable.ZoomYInitialValues.ItemHeight * zoomY, 0);
grid.BarHeight = zoomable.ZoomYInitialValues.BarHeightRatio * grid.ItemHeight;
double fontSize = zoomable.ZoomYInitialValues.FontSize * zoomY;
System.Windows.Documents.TextElement.SetFontSize(zoomable.ZoomYInitialValues.DataGridRowsPresenter, fontSize);
System.Windows.Documents.TextElement.SetFontSize(chart.ScrollContentPresenter, fontSize);
}
}
SaveZoom(zoomX, zoomY);
}
public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
var dateTime = System.Convert.ToDateTime(value);
return(GanttDates.ToTicks(dateTime));
}
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
var ticks = System.Convert.ToInt64(value);
return(GanttDates.ToDateTime(ticks));
}
/// <summary>
/// Enregistre des actions déjà existantes et construit les éléments.
/// </summary>
/// <param name="allActions">Toutes les actions.</param>
/// <param name="filter">Les filtre I/E/S.</param>
public void RegisterInitialActions(IEnumerable <KAction> allActions, IESFilterValue filter)
{
Func <ActionsDisplayResults> displayedActions;
bool isCriticalPathEnabled;
bool useManagedPredSucc;
bool useGanttItemsTimingsOnly;
bool fixPredSuccTimings;
bool refreshTimings;
foreach (var action in allActions)
{
action.IsGroup = WBSHelper.HasChildren(action, allActions);
action.IsLinkToProcess = action.LinkedProcessId != null;
}
switch (filter)
{
case IESFilterValue.IES:
useManagedPredSucc = false;
isCriticalPathEnabled = true;
displayedActions = () => new ActionsDisplayResults {
Actions = allActions
};
useGanttItemsTimingsOnly = false;
fixPredSuccTimings = true;
refreshTimings = true;
break;
case IESFilterValue.I:
useManagedPredSucc = true;
isCriticalPathEnabled = true;
displayedActions = () => FilterActionsUpdatePredSuccManaged(allActions,
a => ActionsTimingsMoveManagement.IsActionExternal(a) || ActionsTimingsMoveManagement.IsActionDeleted(a),
a => ActionsTimingsMoveManagement.IsActionInternal(a));
useGanttItemsTimingsOnly = true;
fixPredSuccTimings = true;
refreshTimings = false;
break;
case IESFilterValue.IE:
useManagedPredSucc = true;
isCriticalPathEnabled = false;
displayedActions = () => FilterActionsUpdatePredSuccManaged(allActions,
a => ActionsTimingsMoveManagement.IsActionDeleted(a),
a => ActionsTimingsMoveManagement.IsActionExternal(a) || ActionsTimingsMoveManagement.IsActionInternal(a));
useGanttItemsTimingsOnly = true;
fixPredSuccTimings = true;
refreshTimings = false;
break;
default:
throw new ArgumentOutOfRangeException("filter");
}
_useGanttItemsTimingsOnly = useGanttItemsTimingsOnly;
this.IsCriticalPathEnabled = isCriticalPathEnabled;
var results = displayedActions();
this.UseManagedPredecessorsSuccessors = useManagedPredSucc;
if (filter == IESFilterValue.IES && useManagedPredSucc)
{
ActionsTimingsMoveManagement.DebugCheckAllWBS(results.Actions);
}
this.RegisterInitialActionsImpl(results.Actions);
if (results.NewTimings != null)
{
foreach (var timing in results.NewTimings)
{
SetBuildStart(timing.Action, timing.Start);
SetBuildFinish(timing.Action, timing.Finish);
}
}
if (refreshTimings)
{
foreach (var item in this.ItemsOfTypeAction)
{
_updatingitem = item;
item.Start = GanttDates.ToDateTime(item.Action.BuildStart);
item.Finish = GanttDates.ToDateTime(item.Action.BuildFinish);
_updatingitem = null;
}
}
if (fixPredSuccTimings)
{
this.FixPredecessorsSuccessorsTimings();
this.UpdateResourcesLoad();
}
}
