GanttChart

Creates a Gantt chart with an empty plan: empty Tasks, Links and Holidays lists of its own, a Monday-to-Friday week and Week zoom. To share a plan, give several charts the same lists.

Gets or sets the fill of a task bar and a milestone diamond that are not on the critical path.

Critical bars use CriticalBrush while ShowCriticalPath is on, and the finished part of every bar is darkened by ProgressBrush. Summaries are drawn in SummaryBrush. In Windows high contrast the system colours are used instead.

<pm:GanttChart BarBrush="#2E7D32" CriticalBrush="#C62828" ProgressBrush="#66000000"
               TodayBrush="#1565C0" NonWorkingBrush="#14000000" />

Gets or sets the fill of the thin baseline bar drawn under a task's bar while ShowBaselines is on.

In Windows high contrast the system colours are used instead.

Gets or sets which columns the task list shows beside the task's name.

The order is fixed – #, Task, Start, Finish, Days, % done, Assignee, Predecessors – and so are the English headings. Name, Start, Days, % done and Predecessors can be typed into with F2. For example GanttColumns.Wbs | GanttColumns.Name | GanttColumns.Assignee.

Gets or sets the colour of the bars, milestones and links on the critical path, while ShowCriticalPath is on.

It is also the colour of the border a cell editor shows when what was typed cannot be read. In Windows high contrast the system colours are used instead.

Gets or sets the colour of the lines between rows and columns, under the headers and beside the splitter.

In Windows high contrast the system colours are used instead.

Gets or sets the width of the task list, the left-hand pane; the timeline takes the rest.

It is never drawn wider than leaves room for the splitter and the vertical scroll bar. Dragging the splitter sets it, keeping both panes at least 48 units wide, without removing a binding; Esc during the drag puts it back.

Gets or sets the tint behind the column headings, the timeline's header rows and the splitter.

In Windows high contrast the system colours are used instead.

Gets or sets the dates that are not worked, beside the days WorkingWeek leaves out: bank holidays, a shutdown, a company day off.

A task that runs across a holiday is a day longer on the calendar, and the day is shaded at Day and Week zoom. An ObservableCollection is watched: gantt.Holidays.Add(new DateTime(2026, 12, 25)) reschedules at once.

Gets or sets whether the reader can only look at the plan, and not change it.

Selecting, scrolling, zooming, opening summaries and resizing the task list still work, and code can still change the plan. Turning it on cancels a drag and drops an open edit. To allow some edits only, cancel TaskChanging instead.

Gets or sets the colour of the arrows between bars that are not on the critical path.

Links on the critical path use CriticalBrush; the selected task's links are drawn in Foreground, heavier. In Windows high contrast the system colours are used instead.

Gets or sets the links between the tasks: which task waits for which, how, and with what lag.

A link that cannot be honoured – an unknown task, a repeat, a loop – is left out and reported in ProjectSchedule.Problems. Links the reader draws or types are added to and removed from this list, which therefore must not be read-only if links are to be edited. It is watched as Tasks is.

Gets the chart's logical children: the scroll bars and the cell editor, which therefore take the chart's resources and styles.

Gets or sets the tint behind the days that are not worked – weekends and Holidays – on the timeline and in its header.

The tint is drawn only at Day and Week Zoom, where a day is wide enough to see. In Windows high contrast the system colours are used instead.

Gets or sets what is painted over the finished part of a bar, from its start to its ProjectTask.Progress, and over the finished part of a summary's bracket.

A translucent brush keeps working whatever BarBrush and CriticalBrush are; an opaque one paints the finished part a colour of its own. In Windows high contrast the system colours are used instead.

Gets or sets the first day work on the plan can happen.

A date that is not worked is read as the next working day. No task is scheduled before it except one that TaskConstraintKind.MustStartOn an earlier date.

Gets or sets the height of every row, in the task list and on the timeline alike.

A bar is half the row high, never less than 6, so taller rows give bars and handles that are easier to grab.

Gets the plan as scheduled: every task's dates, float and outline number, the links that were honoured, the critical path, and what in the input could not be used.

A change only marks the schedule stale; it is worked out again when next needed, by a redraw or by reading this, so the value is always current. A chart that is not loaded schedules afresh on every read. ScheduledTask.Task leads back to your own task.

foreach (ScheduledTask task in gantt.Schedule.Tasks)
{
    if (task.IsCritical && !task.IsSummary)
        Console.WriteLine($"{task.Wbs} {task.Name}: {task.Start:d} to {task.Finish:d}");
}

Gets or sets the task the reader has chosen: the highlighted row and bar, and the row the keyboard works on.

Setting a task inside a closed summary opens the summaries above it and scrolls it into view. A task not in Tasks is not selected: the property is cleared once the plan is current, as it is when the selected task is removed. Closing the summary the selected task is in moves the selection to the summary. Bind it to a PertChart's or TaskBoard's SelectedTask to keep the views in step.

Gets or sets the fill behind the selected row in the task list; a fainter copy marks the row across the timeline.

Choose a light or translucent brush: the selected row's text is drawn over it in the ordinary text colour. In Windows high contrast the system colours are used instead.

Gets or sets whether each task's baseline – the dates first agreed – is drawn as a thin bar in BaselineBrush under its bar, so slippage shows at a glance.

A task has a baseline when ProjectTask.BaselineStart is set; it runs to ProjectTask.BaselineFinish, or covers one day without it.

// Freeze the plan as it stands as the baseline, then show it.
foreach (ScheduledTask scheduled in gantt.Schedule.Tasks)
{
    scheduled.Task.BaselineStart = scheduled.Start;
    scheduled.Task.BaselineFinish = scheduled.Finish;
}
gantt.ShowBaselines = true;

Gets or sets whether the critical path – the tasks with no float, which decide when the plan finishes – is drawn in CriticalBrush, links included.

Turning it off changes only the colours; the critical tasks are still in ProjectSchedule.CriticalPath.

Gets or sets whether the links between tasks are drawn as arrows between their bars.

Hiding them does not stop them deciding the dates. A link to a task inside a closed summary is not drawn, and the selected task's links are drawn heaviest.

Gets or sets whether a line in TodayBrush is drawn down the timeline through today, with a notch in the header.

Today is Today, or the computer's date. Nothing is drawn when today is outside the timeline.

Gets or sets the colour of a summary task's bracket: the bar with downward points at each end that spans its subtasks.

In Windows high contrast the system colours are used instead.

Gets or sets the tasks of the plan: a flat list in outline order, in which a subtask names its summary through ProjectTask.ParentId.

The list's order is the order of the rows within each summary. A task is a summary when another task names it as its parent. Tasks with no ProjectTask.Id are left out, and a repeated id is reported in ProjectSchedule.Problems.

While the chart is loaded an ObservableCollection or a BindingList<T> is watched, and so is every task in it. A plain List<T> is read when assigned; call Reschedule after changing one. Assigning a new list cancels a drag and drops an open cell edit.

gantt.Tasks.Add(new ProjectTask("qa", "Acceptance testing", 4) { ParentId = "build", Assignee = "Lena Fischer" });
gantt.Links.Add(new TaskLink("api", "qa"));   // scheduled and drawn with no further call

Gets or sets the date the today line is drawn on.

It moves the ShowToday line and the place ScrollToToday goes to, and no date in the schedule. Set it to show a plan as at a status date.

Gets or sets the colour of the today line, the notch above it, and today's date in the header.

The line is drawn while ShowToday is on. In Windows high contrast the system colours are used instead.

Gets the number of elements the chart is made of: its three drawing panes, its three scroll bars and its cell editor.

Gets or sets the day a week begins on in the timeline's headers.

At Week zoom each week is labelled by this day. Scheduling is unaffected; WorkingWeek decides that.

Gets or sets the days of the week on which work happens.

Durations and lags count working days, so a five-day task starting on a Thursday finishes the Wednesday after, and the weekend between is shaded. In XAML: WorkingWeek="Sunday, Monday, Tuesday, Wednesday, Thursday".

Gets or sets how much time the timeline shows: how wide a day is, and what its two header rows label.

A day is 32 logical units (1/96 inch) wide at Day, 14 at Week, 4 at Month, 1.6 at Quarter and 0.6 at Year; weekends and holidays are shaded at Day and Week. A change keeps the date in the middle of the timeline (or under the pointer, for Ctrl+wheel) where it is, and raises ZoomChanged.

Lays out the task list, the splitter, the timeline and the scroll bars in the size the chart has been given.

arrangeSize: the chart uses all of it.

Scrolls asked for before the first layout – by ZoomToFit, ScrollToTask and the rest – are carried out once this has run.

Closes every summary task, leaving the top level of the outline. Raises TaskToggled for each one closed; a selected subtask hands the selection to its summary.

Opens every summary task, so that every task has a row. Raises TaskToggled for each one opened.

Draws the whole chart as an image: every task, inside closed summaries too, beside the whole timeline, with the task list at its full width.

The image, frozen, so that it can be saved or handed to another thread.

Selection, focus and the scroll position are not drawn, and the image uses the chart's current Zoom, colours and font. The chart need not be on screen: one made only for exporting reads its plan afresh.

An image that would be wider or taller than 16,384 pixels, or larger than 128 megapixels, is made at the highest resolution below dpi that fits; its DpiX says which.

BitmapSource image = gantt.ExportImage(144);
var png = new PngBitmapEncoder();
png.Frames.Add(BitmapFrame.Create(image));
using (FileStream file = File.Create("Relaunch plan.png"))
    png.Save(file);

Returns one of the elements the chart is made of.

The element at that position.

Tells whether a summary task is open, showing its subtasks.

true for an open summary; false for a closed one, a task with no subtasks, null, or a task not in the plan.

Says how much room the chart wants: all it is given, up to 720 by 360 logical units.

The smaller of constraint and 720 by 360.

A chart shows as much of a plan as fits and scrolls the rest, so it has no natural size; give it a size, or put it where it is stretched (a Grid cell or a DockPanel's last child), rather than in a StackPanel.

Gives UI Automation the chart as a tree of rows, so that a screen reader can read and work the plan.

The chart's automation peer.

Each row is a tree item named with what its bar shows in pictures – its dates, length, progress, and its float or that it is critical – and can be selected, opened or closed, scrolled into view and invoked (which raises TaskActivated).

Redraws for a new display scale, so that grid lines stay one device pixel wide and text is sharp.

Shows or hides the focus rectangle round the current row, and on taking the focus tells a screen reader which row is current.

Carries out the chart's keys: the arrows and page keys to move between rows and cells, F2 to edit, Enter and Space to activate, Shift and Ctrl+Shift with the arrows to move and stretch a task, Ctrl with Plus, Minus and 0 to zoom, and Esc to cancel a drag.

The arrows are always taken, even at the first or last row, so they never move focus out of the chart by surprise. The class remarks list every key.

Raises LinksChanged. An override should call the base implementation, or handlers are not called.

Raises LinksChanging. An override should call the base implementation, or handlers are not called.

Cancels a drag, with no change, when something else takes the mouse – a dialog, or another window coming to the front.

Hides the bar handles and the tooltip when the pointer leaves the chart.

Acts on a click: selects the row or bar under the pointer, opens or closes a summary at its expander, and starts a drag on a bar, its end, its progress handle, its link dot or the splitter. A double-click raises TaskActivated.

A click while a cell is being edited first commits the edit; when the text cannot be read, the editor stays open and the click does nothing more. An override should call the base implementation.

Ends a drag and makes the change it describes, through TaskChanging or LinksChanging. A press that never moved far enough to be a drag changes nothing.

Follows the pointer: carries on a drag, scrolling when it passes the edge of the view, or shows the handles of the bar under the pointer and, after the hover time, a tooltip describing its task.

Selects the task under the pointer, so that a context menu acts on the task that was clicked.

<pm:GanttChart x:Name="gantt">
    <pm:GanttChart.ContextMenu>
        <ContextMenu>
            <MenuItem Header="Open task" Click="OnOpenTask" />   <!-- acts on gantt.SelectedTask -->
        </ContextMenu>
    </pm:GanttChart.ContextMenu>
</pm:GanttChart>

Scrolls the rows by the system's wheel setting; with Shift, scrolls the pane under the pointer sideways; with Ctrl, zooms about the pointer.

Redraws when a property the drawing reads from the control itself changes: the font, Foreground, Background or UIElement.IsEnabled.

An override should call the base implementation.

Shows what a press would do: a sideways arrow over the splitter, a bar's end or its progress handle, a cross over a link dot, and a hand over a bar that can be moved or an expander.

Draws the background, the splitter and the corner above the vertical scroll bar. The task list and the timeline are drawn by panes of their own, so that scrolling or a drag redraws only what changed.

Raises ScheduleChanged. An override should call the base implementation, or handlers are not called.

Raises SelectedTaskChanged. An override should call the base implementation, or handlers are not called.

Raises TaskActivated. An override should call the base implementation, or handlers are not called.

Raises TaskChanged. An override should call the base implementation, or handlers are not called.

Raises TaskChanging. An override should call the base implementation, or handlers are not called.

Raises TaskToggled. An override should call the base implementation, or handlers are not called.

Raises ZoomChanged. An override should call the base implementation, or handlers are not called.

Asks the reader for a printer and prints the whole chart on one page, as ExportImage draws it, shrunk to fit the printable area when it is larger.

Nothing is printed if the reader cancels the print dialog. A long plan at a fine zoom is shrunk a long way; choose a coarser Zoom first, or close summaries, for a readable page.

Schedules the plan again now and redraws.

Needed only after changing a plain List<T> or array, or a task in one; observable collections and their tasks are watched. Tasks newly added to a plain list are watched from here on. ScheduleChanged is raised before this returns.

Brings a task into view: opens the summaries above it, scrolls its row into view, and scrolls the timeline to its bar when any of the bar is out of sight.

The selection does not change; set SelectedTask as well to highlight it. Called before the chart has a size, it waits for the first layout.

ProjectTask late = gantt.Schedule.Tasks.First(t => t.TotalFloat < 0).Task;
gantt.SelectedTask = late;
gantt.ScrollToTask(late);

Scrolls the timeline sideways so that today is in view, a third of the way across the pane.

Today is Today, or the computer's date. The rows do not scroll. Called before the chart has a size, it waits for the first layout.

Opens or closes one summary task.

Raises TaskToggled when the summary changes. Closing one that holds the selected task moves the selection to it.

Shows less time in more detail: one step finer through Year, Quarter, Month, Week and Day.

The date in the middle of the timeline stays where it is. At Day zoom nothing changes. The reader's Ctrl+Plus does the same, and Ctrl with the wheel zooms about the pointer.

Shows more time in less detail: one step coarser through Day, Week, Month, Quarter and Year.

The date in the middle of the timeline stays where it is. At Year zoom nothing changes. The reader's Ctrl+Minus does the same.

Chooses the finest Zoom at which the whole plan, first day to last, fits the timeline pane, and scrolls to the plan's first day.

Called before the chart has a size – from a constructor, say – it waits for the first layout and then fits. An empty plan is left as it is. When even Year zoom is too fine the chart is set to Year. The reader's Ctrl+0 does the same.

gantt.Loaded += (sender, e) => gantt.ZoomToFit();

Occurs after an edit the reader made has added links to Links or removed them. Save the links here to keep the edit.

Occurs when the reader is about to change the links into a task – by drawing a link between two bars, or by typing into the Predecessors cell. Cancel it to refuse the edit.

Drawing adds one link; typing replaces the links into the task that differ from the ones typed, keeping those typed as they already are. A link the scheduler would refuse – a loop, a repeat, a summary linked to its own subtask – never gets this far: the reader is told why instead. When nobody cancels, the links are removed from and added to Links and LinksChanged is raised. When Links is read-only the reader is told so, and the event is not raised.

Occurs after the plan has been scheduled again: once the chart is loaded, and whenever a task, a link, one of the lists or a calendar setting has changed.

Changes that arrive together – a board re-ranking a column, a loop setting twenty properties – are scheduled once and announced once, from the dispatcher, so a handler sees the finished result and may change the plan again. Reschedule raises it before returning. A chart that is not loaded does not raise it.

gantt.ScheduleChanged += (sender, e) =>
{
    finishText.Text = gantt.Schedule.ProjectFinish.ToLongDateString();
    problemList.ItemsSource = gantt.Schedule.Problems;   // each one reads as a sentence
};

Occurs when SelectedTask changes, whether the reader chose another row or the application set the property.

Occurs when the reader asks to open a task: by double-clicking its row or bar, or by pressing Enter or Space on the selected row. The task is already selected.

gantt.TaskActivated += (sender, e) => MessageBox.Show($"{e.Task.Name}: {e.Task.Assignee}, {e.Task.Progress:0}% done");

Occurs after an edit the reader made has been written to a task: its start, length, progress or name.

Raised once per edit, before the plan is scheduled again; save the task here to keep the edit, and read the dates that follow from it in ScheduleChanged.

Occurs when the reader is about to change a task – by dragging its bar, by a key or by typing into a cell – before anything has changed. Cancel it to refuse the edit.

The event data names the task, how the edit was made and the new values (null for what is not changing). When nobody cancels, the chart writes the values to the ProjectTask, raises TaskChanged and schedules again. Every edit the chart makes comes through here, which makes it the one place for rules such as "a signed-off task cannot move"; setting a task's properties in code does not raise it.

gantt.TaskChanging += (sender, e) =>
{
    if (e.Task.Status == "Signed off")
    {
        e.Cancel = true;
        MessageBox.Show(e.Task.Name + " is signed off and cannot be changed.");
    }
};

Occurs when a summary task is opened or closed – by its expander, the arrow keys, SetExpanded, ExpandAll, CollapseAll, or because a task inside it was selected.

Raised once for each summary that changes. Which summaries are open belongs to the chart: ProjectTask.IsCollapsed only sets how a summary starts, and is not written back.

Occurs when Zoom changes, from code or from the reader's Ctrl+wheel, Ctrl+Plus, Ctrl+Minus or Ctrl+0.

Identifies the BarBrush dependency property.

Identifies the BaselineBrush dependency property.

Identifies the Columns dependency property.

Identifies the CriticalBrush dependency property.

Identifies the GridLineBrush dependency property.

Identifies the GridWidth dependency property.

Identifies the HeaderBrush dependency property.

Identifies the Holidays dependency property.

Identifies the IsReadOnly dependency property.

Identifies the LinkBrush dependency property.

Identifies the Links dependency property.

Identifies the NonWorkingBrush dependency property.

Identifies the ProgressBrush dependency property.

Identifies the ProjectStart dependency property.

Identifies the RowHeight dependency property.

Identifies the SelectedTask dependency property.

Identifies the SelectionBrush dependency property.

Identifies the ShowBaselines dependency property.

Identifies the ShowCriticalPath dependency property.

Identifies the ShowLinks dependency property.

Identifies the ShowToday dependency property.

Identifies the SummaryBrush dependency property.

Identifies the Tasks dependency property.

Identifies the TodayBrush dependency property.

Identifies the Today dependency property.

Identifies the WeekStart dependency property.

Identifies the WorkingWeek dependency property.

Identifies the Zoom dependency property.