Afficher plusieurs colonnes dans l'image du graphique Gantt rendu

Aperçu

Dans Microsoft Project, les données du projet peuvent être représentées à la fois sous forme textuelle et graphiquement sous forme de graphiques. Les types de graphiques les plus courants comprennent le graphique Gantt, l’utilisation des tâches et l’utilisation des ressources. Aspose.tasks pour .NET prend en charge le rendu des données de projet en tant que graphiques graphiques.

Cet article décrit deux approches pour la personnalisation des colonnes de projet affichées dans un graphique Gantt et montre comment rendre le graphique à une image.

Gantt Chart

Un graphique Gantt est une représentation graphique basée sur la chronologie des tâches du projet, segmentée par jours, semaines ou mois. Un projet se compose généralement de tâches affectées aux ressources. Une tâche individuelle peut être divisée en sous-tâches. Chaque tâche a une date de début et de fin qui définit sa durée. Un graphique Gantt dans le projet Microsoft donne un aperçu visuel de ces informations.

La capture d’écran suivante montre un graphique Gantt typique dans le projet Microsoft:

Image du graphique Gantt dans Aspose.tasks pour .net

Dans Aspose.tasks pour .NET, la classe «Project» est la classe principale pour travailler avec les fichiers de projet. Il expose plusieurs surcharges de la méthode «Enregistrer» pour exporter des données de projet vers divers formats.

Par exemple, la surcharge Save (String, SaveOptions) surcharge:

• Le premier paramètre spécifie le nom du fichier de sortie.
• Le deuxième paramètre accepte une instance d’une classe dérivée de «SaveOptions», telle que «PDFSaveOptions» pour le format PDF.

Type de sauvegarde

Le comportement de rendu peut être personnalisé à l’aide de propriétés de la classe «SaveOptions» ou de l’un de ses héritiers. Par exemple:

• Utilisez `SaveOptions.CustomPageSize ‘pour définir la taille de la page de sortie.
• Utilisez SaveOptions.legendonEachPage pour contrôler si une légende apparaît sur chaque 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.