Display Multiple Columns in Rendered Gantt Chart Image

Overview

In Microsoft Project, project data can be represented both in textual form and graphically as charts. The most common chart types include Gantt Chart, Task Usage, and Resource Usage. Aspose.Tasks for .NET supports rendering project data as graphical charts.

This article describes two approaches for customizing project columns displayed in a Gantt chart and demonstrates how to render the chart to an image.

Gantt Chart

A Gantt chart is a timeline-based graphical representation of project tasks, segmented by days, weeks, or months. A project typically consists of tasks assigned to resources. An individual task may be divided into subtasks. Each task has a start and end date that defines its duration. A Gantt chart in Microsoft Project provides a visual overview of this information.

The following screenshot shows a typical Gantt chart in Microsoft Project:

Gantt Chart Image in Aspose.Tasks for .NET

In Aspose.Tasks for .NET, the Project class is the primary class for working with project files. It exposes multiple overloads of the Save method to export project data to various formats.

For example, the Save(string, SaveOptions) overload:

• The first parameter specifies the output file name.
• The second parameter accepts an instance of a class derived from SaveOptions, such as PdfSaveOptions for PDF format.

SaveOptions Type

Rendering behavior can be customized using properties of the SaveOptions class or one of its inheritors. For example:

• Use SaveOptions.CustomPageSize to define the output page size.
• Use SaveOptions.LegendOnEachPage to control whether a legend appears on each page.

PdfSaveOptions saveOptions = new PdfSaveOptions()
{
    CustomPageSize = new SizeF(800, 600),
    LegendOnEachPage = false
};

There are at least two approaches to customize the appearance of the rendered Gantt chart.

Customize Gantt Chart Columns Using ProjectView

This approach is considered obsolete and is unlikely to be extended in future releases. The ProjectView class provides limited functionality and allows specifying a set of columns to be included in the output image.

To use it, create a list of GanttChartColumn instances and pass them to the ProjectView constructor. Then assign this view to the SaveOptions.View property.

// Create the view columns
var columns = new List<GanttChartColumn>();
columns.Add(new GanttChartColumn("Name", 100, new TaskToColumnTextConverter(TaskName)));
columns.Add(new GanttChartColumn("Notes", 100, new TaskToColumnTextConverter(TaskNotes)));
columns.Add(new GanttChartColumn("Resources", 200, new TaskToColumnTextConverter(TaskResources)));

// Create the view
ProjectView projectView = new ProjectView(columns);

// Create SaveOptions
PdfSaveOptions saveOptions = new PdfSaveOptions()
{
    CustomPageSize = new SizeF(800, 600),
    View = projectView
};

// Save the project to PDF
project.Save("output.pdf", saveOptions);

The GanttChartColumn constructor accepts three arguments: the column name, column width, and a TaskToColumnTextConverter delegate that converts task data to display text. Example implementations:

private string TaskName(Task task)
{
    StringBuilder res = new StringBuilder();
    for (int i = 1; i < task.OutlineLevel; i++)
    {
        res.Append("  ");
    }

    res.AppendFormat("{0}. {1}", task.Id, task.Name);
    return res.ToString();
}

private string TaskNameHtml(Task task)
{
    StringBuilder res = new StringBuilder();
    for (int i = 1; i < task.OutlineLevel; i++)
    {
        res.Append("&nbsp;&nbsp;");
    }

    res.AppendFormat("{0}. {1}", task.Id, task.Name);
    return res.ToString();
}

private string TaskNotes(Task task)
{
    return task.NotesText ?? string.Empty;
}

private string TaskResources(Task task)
{
    StringBuilder res = new StringBuilder();
    Project project = task.ParentProject;
    bool bFirst = true;
    foreach (ResourceAssignment assignment in project.GetResourceAssignmentsByTask(task))
    {
        if (assignment.Resource != null)
        {
            if (!bFirst)
            {
                res.Append(", ");
            }

            res.Append(assignment.Resource.Name);
            bFirst = false;
        }
    }

    return res.ToString();
}

Below are examples of resulting images exported using the above code:

Customize Gantt Chart Columns Using View

Using the View class and its inheritors is the recommended approach for customizing chart output. The View class corresponds to the view settings in Microsoft Project and provides a richer API compared to ProjectView.

An existing view can be retrieved from the Views collection (for MPP files), customized, and passed to the Project.Save method via the SaveOptions.ViewSettings property.

The following example demonstrates how to retrieve an existing view from an MPP file, insert a new column into it, and use this view for rendering the Gantt chart.

Project project = new Project("input.mpp");

// Get existing view
var view = (GanttChartView) project.Views.GetByName("&Gantt Chart");

// Define and insert new column
TableField field = new TableField()
{
    AlignData = StringAlignment.Far,
    Width = 50,
    Field = Field.TaskName,
    Title = "Task name"
};

view.Table.TableFields.Insert(1, field);

PdfSaveOptions saveOptions = new PdfSaveOptions()
{
    ViewSettings = view
};

project.Save("output.pdf", saveOptions);

Conclusion

Aspose.Tasks for .NET provides multiple options for customizing Gantt chart rendering. Although ProjectView allows basic configuration, its functionality is limited and it is considered deprecated.

For more advanced control and alignment with Microsoft Project’s visual structure, the use of View and its associated classes is recommended. This approach provides better flexibility and is suitable for working with views defined in MPP files or for programmatically configuring new view layouts.