Project Management Library

{{ product.platformsDescription }}

{{ product.description }}


Gantt Charts

With GanttChartTaskListView control you may present hierarchically indented or flat data item collections using a timeline view. Items may be tasks of a project, but you can actually adapt and display any other type of timeline based information too.


ganttChartComponent.ItemSource = …;

With ScheduleChartResourceListView control you may present multiple bars per line in the timeline view.


scheduleChartComponent.ItemsSource = …;

Simple GanttChartView and ScheduleChartView controls are also available.

Screenshot Screenshot

You can synchronize data and changes between Schedule Chart and Gantt Chart controls by sharing a TaskManager source that is eventually binding to the actual data source.

ganttChartComponent.TaskManagerSource = new TaskManager(…); scheduleChartComponent.AssignableTaskManagerSource = ganttChartComponent.TaskManager;

Task items

To load and present task data with Gantt Chart controls, initialize the Items collection of the component or its ItemsSource property, setting up items representing timeline tasks identified by these main properties: Indentation, Content, Start, Effort, CompletedEffort, IsMilestone, Assignments, and Predecessors.

You may use either the built-in TaskItem class or a custom type to create data item objects. If item property names are different, they should be identified using MemberPath properties of the component. IndentationMemberPath, DisplayMemberPath, StartMemberPath, EffortMemberPath, CompletedEffortMemberPath, IsMilestoneMemberPath, AssignmentsMemberPath, PredecessorsMemberPath, etc.

Summary items are determined by checking Indentation levels of subsequent items, and can be expanded or collapsed. Standard items are presented as rectangular bars, and milestones as special diamond shapes in the view.

Optionally, you may initialize item effort and completion values based on Finish and Completion properties instead of using Effort and CompletedEffort by manually initializing EffortMemberPath, DurationMemberPath, and CompletedEffortMemberPath to null.

Assignments collection defines item assignments and are identified by these properties: ResourceItem, and AllocationUnits.

ResourceItem should be an object from the separate AssignableResourceItems collection. An optional allocation units value is also supported for item assignments. When appropriate, you may alternatively use AssignmentsString values that specify the resource assignments of the item with optional allocation units in classic format: Resource 1, Resource 2 [50%].

Predecessors collection defines item dependencies and are identified by these properties: Item, DependencyType, and Lag.

DependencyType may be finish-to-start, start-to-start, finish-to-finish, or start-to-finish. An optional lag time span is also supported for item dependencies. When appropriate, you may alternatively use PredecessorsString values that specify the dependencies of the item with optional dependency type (abbreviated) and lag (in hours) in classic format: 1, 2SS+3.

Multiple types of time constraints may also be defined for Start and Finish values of task items using special properties: MinStart, MaxStart, MinFinish, and MaxFinish.

ganttChartComponent.ItemsSource = …; ganttChartComponent.AssignableResourceItemsSource = …;

Resource items

To load and present resource data with Schedule Chart controls, initialize the Items collection of the component or its ItemsSource property, setting up items representing resources identified by these main properties: Content.

You may use either the built-in ResourceItem class or a custom type to create data item objects. If item property names are different, they should be identified using MemberPath properties of the component. DisplayMemberPath, etc.

To load and present assigned task data for the resource rows of the Schedule Chart controls, initialize the AssignableTaskItems collection of the component or its AssignableTaskItemsSource property, setting up items representing timeline tasks, initialized as for a Gantt Chart control (see previous section).

The actual links between resources and assigned tasks is performed behind the scenes, comparing Assignment.ResourceItem references (of Assignments lists of TaskItem objects within AssignableTaskItems collection) to the managed resource Items.

Load Charts

Besides displaying data with Gantt Chart and Schedule Chart controls, you may display automatically computed resource allocation information with the LoadChartView control, either for a single resource item, such as that being currently selected in an external drop down list, or for multiple resource items, within the LoadChartResourceListView control.

Screenshot Screenshot

loadChartComponent.AssignableTaskManagerSource = ganttChartComponent.TaskManager;

List views

Separate TaskListView and ResourceListView controls are also available for presenting and managing project data collections.

Screenshot Screenshot

listViewComponent.ItemsSource = …;

Schedule editor

Using ScheduleDefinitionView component you may present and allow end users to modify schedule definition objects by specifying working days of a week, working hours of a day, and working and nonworking time exceptions such as holidays or lunch breaks. The output Schedule object may then be set to Gantt Chart components or individual task and resource items.

We also have utilities that allow you to create schedule definition objects based using formatted string values.


scheduleDefinitionComponent.Content = …;

element.Schedule = scheduleDefinitionComponent.Schedule;

PERT Charts

Gantt Chart and Schedule Chart controls also allow converting the data into items that may be displayed with interactive PertChartView (displaying dependencies between events) or NetworkDiagramView controls.

Screenshot Screenshot

pertChartComponent.Items = ganttChartComponent.GetPertChartItems();

Gantt Chart Light Library provides a similar set of controls for WPF with higher performance!

It has been redesigned from scratch with performance in mind, and provides multiple project management features too.

Drag and drop

End users may use drag and drop operations to reschedule bars, update start, finish and completion values independently, and create dependencies between items directly from the Gantt Chart area, besides editing values in an attached data grid.

Schedule Chart bars may also be vertically dragged to update resource assignments. To execute this operation, the end user should hover the bottom of the assignment bar, and perform the vertical drag only when a dotted line appears indicating assignment selection. Designed this way, we ensure that mixing of horizontal and vertical drag operations is avoided.


You may configure timeline duration, working days and hours, whether or not to display nonworking days and hours, scales, update interval (for drag and drop operations), zoom level (width of an hour), and whether to display interruptions in the view.

When the end user horizontally scrolls to an end of the timeline viewport special buttons appear to allow updating the timeline page, increasing both start and finish ends synchronously.


component.SetTimelinePage(start, finish); component.Schedule = new Schedule(…); component.AreNonworkingDaysVisible = true; component.AreNonworkingHoursVisible = false;

component.AreUpdateTimelinePageButtonsVisible = true;

scale.TimeScale = TimeScale.Months; scale.HeaderTextFormat = TimeScaleTextFormat.YearMonth; component.UpdateScale = GanttChartViewUpdateScale.HourQuarter;

component.HourWidth = 2.5;

component.AreTaskInterruptionsVisible = true;

Custom scales

You can add built-in or completely custom scale objects to Scales collection of the component as needed.

Screenshot Screenshot

And you may switch to the continuous schedule instance if your planning is based on a 24/7 approach.


Nonworking intervals

Nonworking intervals, such as holidays or simple day breaks, result by negating the output returned by a delegate method of the Schedule object. In other words, the Schedule object has a delegate that returns working intervals of a specific parameter date.

var schedule = new Schedule("MySchedule", (Date date) => { return new TimeIntervalCollection(…); });

Item calendars

You can configure working and nonworking time for individual task and resource items, when needed, using Schedule objects.

An individual item may have more or less working time than configured at view level, and therefore they will behave differently when setting start and finish values, including when using drag and drop update operations.

Note that when one or more resources are assigned to a task, a working time intersection is automatically computed and used for scheduling. If the intersection is empty, the task or generic schedule overrides it, though.

item.Schedule = new Schedule(…);

Project management

Besides data visualization features, the components offer built-in computed properties such as Duration, Effort, CompletedEffort, Completion, etc., project management algorithms such as baseline visualization, auto scheduling, critical path enumeration, and resource leveling.

var task = component.GetTask(…); var effort = task.Effort; var percentCompleted = task.Completion * 100;

component.IsBaselineVisible = true; component.AreTaskDependencyConstraintsEnabled = true;

foreach (criticalTask in component.GetCriticalTasks())
{ … }



Microsoft Project® XML schema

Gantt Chart components support returning data in Microsoft Project® XML format with GetProjectXml method, allowing you to export Microsoft Project® files with ease.

Moreover, TaskManager.ProjectXmlSerializer offers support for further customizing the way actual saving operations occur, allowing you to inject custom code for XML generation with handler methods on specific events.


Our components are persistence layer independent, so you can bind them to data collections from virtually any data source, including but not limited to SQL Server® databases and XML files.

MVVM support

The controls provide standard item binding, selection, and activation features, and accept built-in and custom commands as appropriate.

Screenshot Screenshot

Change notifications

To be notified when items managed by the component change, handle the underlying ItemCollectionChanged and PropertyChanged events of the data source.

Grid columns

You may customize the column collection of the grid by adding or redesigning data bound and cell template based columns.



You may fully customize item appearance, either for the entire chart or for individual entries in the view, using attached properties such as GanttChartView.StandardBarFill, StandardBarStroke, SummaryBarFill, etc.

Screenshot Screenshot Screenshot

Bar templates

When you need to develop advanced features in your timeline based application, chart bars may be fully redesigned using XAML based templates for StandardTaskTemplate, SummaryTaskTemplate, and MilestoneTaskTemplate properties of the components.

Screenshot Screenshot

Pointer control

To further customize component interactions, you may handle mouse events and get information about the visually hit elements.

Printing, and image and document exporting

All components offer a Print method that may be called to initiate a direct print operation for their content.

Moreover, you can export scalable images of a component content by calling GetExportDrawingVisual and GetExportBitmapSource methods on the fly. For example, you may then encode an output image to an external file format such as PNG, include the image into an element displayed in a custom printed document, simply displaying it as read only content on the screen, or place an output DrawingVisual into an XPS document.

Styling and templating

You may fully customize styles and templates of the component and its inner parts using XAML. Optionally, adapt and reuse any parts of the default XAML definitions that we have made available for multiple themes including Aero, Aero2, and Classic, or for a Generic theme.


Core entity managers

You can use TaskManager and ResourceManager component instances to provide core collection management features behind the scenes, and optionally bind them to visual control instances later, as needed.

For each object in the custom data source, a manager object creates and manages synchronized domain entity counterparts, providing the actual functions required by the user interface component instances.

If you prefer to use the domain logic only, you can work with the project management entities separately, since they are encapsulated in a separate Core assembly.

var resourceManager = new ResourceManager(…); listComponent.ResourceManagerSource = resourceManager;

var taskManager = new TaskManager(…, resourceManager); chartComponent.TaskManagerSource = taskManager;

Why DlhSoft {{ product.title }}?