gantt — u_pbt_gantt #

← Référence des composants · Sommaire du guide

gantt planifie un projet : à gauche une grille de tâches (nom, début, fin, durée, avancement), à droite leurs barres sur une échelle de temps — jour, semaine, mois ou trimestre — avec la ligne d'aujourd'hui (à l'accent du thème) et les jours chômés grisés. Une tâche qui en contient d'autres est un récapitulatif dont les dates et l'avancement se calculent ; un jalon est un losange d'un jour ; une flèche relie une tâche à celle qui l'attend, et le chemin critique se dessine en rouge. L'utilisateur glisse une barre pour la déplacer, son bord de fin pour changer sa fin, le petit triangle dessous pour son avancement ; ue_task_moved, ue_task_resized et ue_progress_changed vous le disent. Le plan se remplit à la main ou depuis un DataStore, qui reçoit les changements.

▶ Le voir en vrai — Application de démonstration, tuile Gantt chart : l'aperçu, le code qui le produit et cette page, côte à côte.

En bref #

Démarrage rapide #

// A phase : the task that holds others becomes a summary
uo_plan.of_add_task(/*keys*/ "build", /*label*/ "Build", /*start*/ "2026-11-02", /*end*/ "2026-11-20")
uo_plan.of_add_task(/*keys*/ "build/design", /*label*/ "Design", /*start*/ "2026-11-02", /*end*/ "2026-11-06")
uo_plan.of_add_task(/*keys*/ "build/code", /*label*/ "Code", /*start*/ "2026-11-09", /*end*/ "2026-11-20")

// A milestone : an instant at the end of its day, here the day the code ends
uo_plan.of_add_milestone(/*keys*/ "golive", /*label*/ "Go-live", /*date*/ "2026-11-20")

// The links : a task starts once the one before it is finished
uo_plan.of_add_dependency(/*from_keys*/ "build/design", /*to_keys*/ "build/code")
uo_plan.of_add_dependency(/*from_keys*/ "build/code", /*to_keys*/ "golive")

// What is done already
uo_plan.of_task(/*keys*/ "build/design").id_progress = 100

// event ue_task_moved of uo_plan : (string as_keys, string as_start, string as_end, string as_old_start, string as_old_end)
// Local variables
string ls_code

// The code of the task : the LAST level of its address ("build/design" -> "design")
ls_code = this.of_task(/*keys*/ as_keys).of_key()

// Save the new dates of the task
UPDATE tasks SET start_date = :as_start, end_date = :as_end WHERE code = :ls_code;

Tâches, récapitulatifs et jalons #

Une tâche se désigne par son adresse : sa clé sous son parent, les niveaux joints par / — "build" en haut, "build/design" dans la tâche "build", ajoutée d'abord. Une tâche qui en contient d'autres devient un récapitulatif : une barre fine, ses dates vont du premier début au dernier jour de ce qu'elle contient, son avancement est leur moyenne pondérée par les durées. Ni l'utilisateur ni votre code n'écrivent ses dates ou son avancement : ils se calculent. Son chevron, un double-clic sur sa ligne ou ib_collapsed la replient ; ue_task_toggled suit.

Les dates sont des jours entiers, aaaa-mm-jj, la fin comprise : une tâche du 6 au 10 dure cinq jours, comptés au calendrier. of_add_task et of_add_milestone acceptent aussi deux date de PowerBuilder. Un jalon n'a pas de durée : un jour, un losange, aucun avancement. Par la poignée d'une tâche (of_task(adresse)), écrire is_start la déplace (sa durée reste), is_end change sa fin, id_progress son avancement ; une valeur écrite par votre code ne lève rien, comme SetItem. La même poignée lit ce que la tâche est maintenant : ses dates, sa durée (of_duration), sa place parmi ses sœurs à partir de 1 (of_position), son niveau (of_level).

// The test starts three days later : it moves, its length stays
uo_plan.of_task(/*keys*/ "test").is_start = "2026-11-26"

// Read back what the summary computed
MessageBox("Build", uo_plan.of_task(/*keys*/ "build").is_end + " - " + String(uo_plan.of_task(/*keys*/ "build").id_progress) + " %")

Liens et chemin critique #

of_add_dependency relie deux tâches par une flèche. Le type par défaut est fin à début (DEP_FS : la suivante commence une fois la précédente finie) ; DEP_SS (début à début), DEP_FF (fin à fin) et DEP_SF (début à fin) se donnent en troisième argument. Un lien que les dates cassent — la suivante commence trop tôt — est dessiné en pointillé dans la couleur du danger. Un lien vers soi-même, entre une tâche et ce qu'elle contient, un lien déjà là ou un lien qui fermerait une boucle est refusé (-5). of_dependency_type lit le type d'un lien, of_predecessors et of_successors de la poignée les tâches liées.

Avec ib_critical_path = true, le chemin critique se dessine dans la couleur du danger : les tâches et les liens sans marge, ceux qui repoussent la fin du projet s'ils glissent d'un jour. of_is_critical de la poignée le lit, que le chemin soit dessiné ou non. Avec ib_link_by_mouse = true, deux points apparaissent de part et d'autre de la barre sous le pointeur : l'utilisateur en glisse un sur une autre tâche, et ue_link_requested dit le lien demandé — son type suit le point de départ et la moitié de la barre visée. Le diagramme n'ajoute rien de lui-même : of_add_dependency une fois votre application d'accord. Un clic sur une flèche lève ue_dependency_clicked. La marge se compte en jours ouvrés (is_work_days) : une tâche qui finit un vendredi suivie d'une tâche qui commence le lundi n'en a aucune. Un jalon est un instant à la fin de son jour : posé le jour où finit la tâche qu'il suit, le lien est tenu, et la tâche qui le suit commence le lendemain. Un lien qui touche un récapitulatif engage les tâches qu'il contient ; un récapitulatif n'est jamais marqué, et une flèche n'est rouge qu'entre deux barres rouges. Une tâche terminée (100 %) n'est jamais marquée : elle ne pilote plus rien. is_project_end compte la marge jusqu'à une échéance au lieu de la dernière fin.

Calendrier : jours fériés, décalages, marqueurs et retards #

Un projet suit un calendrier. is_work_days dit les jours ouvrés de la semaine ; of_add_holiday ajoute un jour férié, un par un — grisé comme un week-end, nommé dans l'info-bulle de son jour à l'échelle jour, il ne compte ni dans la marge du chemin critique ni dans un décalage. Un lien peut porter un décalage en jours ouvrés : of_add_dependency("design", "build", DEP_FS, 2) laisse deux jours ouvrés entre la fin de l'une et le début de l'autre (un séchage, une livraison) ; négatif, c'est une avance. La règle de la flèche et le chemin critique le comptent, of_dependency_lag le relit, un DataStore l'écrit après le type ("12:fs+2"). of_add_marker trace un marqueur vertical à la fin d'un jour — une échéance contractuelle, une fin de sprint — avec son libellé en haut. Enfin, avec ib_show_late = true, une tâche en retard — son dernier jour est passé (is_today) et elle n'est pas finie — se dessine en ambre hachuré ; of_is_late() de sa poignée et le champ {late} des modèles le disent dans tous les cas.

// The public holidays of the year : days off, never float
uo_plan.of_add_holiday(/*date*/ "2026-11-11", /*label*/ "Armistice Day")
uo_plan.of_add_holiday(/*date*/ "2026-12-25", /*label*/ "Christmas")

// The paint dries two working days before the second coat
uo_plan.of_add_dependency(/*from_keys*/ "paint", /*to_keys*/ "second_coat", /*type*/ u_pbt_gantt.DEP_FS, /*lag*/ 2)

// The contractual deadline, in red
uo_plan.of_add_marker(/*key*/ "deadline", /*date*/ "2026-12-18", /*label*/ "Contract", /*color*/ RGB(/*red*/ 196, /*green*/ 43, /*blue*/ 28))

// The tasks behind schedule, in amber
uo_plan.ib_show_late = true

Ce que l'utilisateur change #

L'utilisateur glisse une barre pour déplacer la tâche, par jours entiers (ue_task_moved), son bord de fin pour changer sa fin (ue_task_resized), le petit triangle sous la barre pour son avancement (ue_progress_changed) ; une bulle dit les dates ou le pourcentage pendant le glisser, Échap annule. Au clavier, Ctrl + Gauche / Droite déplace la tâche sélectionnée d'un jour et Ctrl + Maj + Gauche / Droite change sa fin. Les événements arrivent la tâche déjà en place. Seul un geste les lève : une date écrite par votre code est muette, comme SetItem. Un récapitulatif ne se glisse pas, une tâche ou un diagramme ib_read_only non plus.

Avec ib_veto_changes = true, ue_task_changing est posé avant chacun de ces trois changements, avec les dates et l'avancement que la tâche prendrait : renvoyer FALSE la laisse comme elle était. Suppr sur la tâche sélectionnée lève ue_delete_requested : le diagramme ne retire rien, of_remove_task une fois votre application d'accord.

Échelle, grille et disposition #

L'échelle (is_scale) se choisit dans la barre d'outils (ib_toolbar, avec le bouton Aujourd'hui), par Ctrl + molette — le jour sous le pointeur reste sous le pointeur — ou par votre code ; ue_scale_changed suit. Aux échelles jour et semaine, les jours chômés (is_work_days) sont grisés. La grille montre les colonnes de is_columns, dans leur ordre, ses dates écrites par is_date_format ; l'utilisateur glisse la ligne entre grille et diagramme (ii_grid_width) et le bord d'un en-tête de colonne pour sa largeur. Ce qu'il a arrangé — l'échelle, les largeurs, les récapitulatifs repliés — se lit par of_get_layout, se rend par of_set_layout, et chaque changement lève ue_layout_changed avec la disposition entière : enregistrez-la, rendez-la au prochain lancement.

Le texte des barres et des info-bulles #

Le texte à côté de chaque barre s'écrit par un modèle, is_bar_template ("{label}" par défaut, vide pour aucun), et l'info-bulle d'une barre par is_tooltip_title_template et is_tooltip_template : du balisage riche où {owner} est un champ de la tâche — un des vôtres (of_set_field), une colonne du DataStore d'où elle vient, ou un champ intégré (label, key, keys, start, end, duration, days, progress, percent, milestone, summary, critical, late, level, parent). {end:d mmm} écrit une date avec les jetons d dd ddd dddd m mm mmm mmmm yy yyyy, {?owner}…{/owner} garde un morceau quand le champ dit quelque chose, {!owner}…{/owner} quand il ne dit rien, {x:raw} garde une valeur comme balisage, {{ }} sont des accolades. {label} et {parent} sont du balisage, comme dans la grille ; toute autre valeur est affichée telle quelle, jamais lue comme balisage. Un nom de champ intégré n'est jamais le vôtre : of_set_field le refuse, et une colonne du DataStore qui porte ce nom est masquée par lui. Une tâche qui a sa propre info-bulle (is_tooltip de sa poignée) montre celle-là.

// Who does what : a field of our own on a task
uo_plan.of_set_field(/*keys*/ "build/design", /*field*/ "owner", /*value*/ "Ada")

// Beside each bar : the label, the owner when there is one, the end day
uo_plan.is_bar_template = "{label}{?owner} - [b]{owner}[/b]{/owner} [symbol=calendar] {end:d mmm}"

Depuis un DataStore #

of_from_datastore fait une tâche de chaque ligne. Sa clé est la valeur de la colonne ROLE_KEY — un identifiant — ou, sans elle, le RowID de la ligne ; la colonne ROLE_PARENT nomme la clé de la tâche qui la contient (vide : en haut ; un parent introuvable ou une boucle met la ligne en haut). Une colonne joue un rôle quand elle en porte le nom (key, parent, label, start, end, progress, milestone, color, predecessors) ou quand of_map le dit. ROLE_MILESTONE fait un jalon de toute valeur qui dit oui ; ROLE_COLOR colore la barre (un RGB() de PowerBuilder ou #rrggbb) ; ROLE_PREDECESSORS liste les tâches attendues, leurs clés séparées par des virgules, le type après : quand ce n'est pas fin à début : "12, 14:ss". Les dates sont lues dans l'ordre régional du poste. Toutes les colonnes sont des champs des modèles. Les tâches d'un chargement précédent partent (leurs poignées sont libérées), celles ajoutées à la main restent. Deux lignes de même clé : la seconde devient key~RowID ; une clé qui contient un / ou un | prend le RowID, et ses enfants la retrouvent par sa valeur ; une clé qu'une tâche ajoutée à la main porte déjà devient key~RowID, sous le même parent — aucune ligne n'est jamais écartée. Une ligne dont le début est vide est une tâche non planifiée : la grille le dit, elle n'a pas de barre et aucun geste ne la déplace. Dates et décimaux sont lus quels que soient les réglages régionaux (12,5 vaut 12.5). of_from_datastore prend aussi un DataWindow ou un DataWindowChild : les lignes que l'utilisateur voit à côté du diagramme, réécrites là. Après un Reset ou un Retrieve du DataStore, redonnez-le : ses RowID repartent de zéro.

Avec ib_write_back = true, un geste écrit dans la ligne avant son événement : les dates de début et de fin pour un déplacement ou une nouvelle fin, l'avancement pour le triangle — chaque valeur dans le type de sa colonne. L'événement lit le DataStore à jour, l'Update reste à vous. Une valeur que le DataStore refuse remet la tâche comme elle était, ce qui était déjà écrit aussi, et lève ue_write_back_failed à la place de l'événement du geste. Après avoir changé une ligne vous-même, of_reload_row la renvoie au diagramme ; une ligne insérée depuis arrive aussi. Une tâche que vous retirez (of_remove_task) reste dehors jusqu'au prochain of_from_datastore : of_map et le rechargement d'une autre ligne ne la ramènent pas, of_reload_row de sa propre ligne la ramène. Après of_clear, of_reload_row refuse (-5) jusqu'à un nouveau chargement.

// Which column of the DataStore plays which role
uo_plan.of_map(/*role*/ u_pbt_gantt.ROLE_KEY, /*column*/ "id")
uo_plan.of_map(/*role*/ u_pbt_gantt.ROLE_PARENT, /*column*/ "parent_id")
uo_plan.of_map(/*role*/ u_pbt_gantt.ROLE_START, /*column*/ "start_date")
uo_plan.of_map(/*role*/ u_pbt_gantt.ROLE_END, /*column*/ "end_date")
uo_plan.of_map(/*role*/ u_pbt_gantt.ROLE_PREDECESSORS, /*column*/ "after")

// A change goes into the DataStore, then the rows become tasks
uo_plan.ib_write_back = true
uo_plan.of_from_datastore(/*ads*/ ids_tasks)

Propriétés #

Propriétés d'une tâche — n_pbt_gantt_task #

Sa poignée, par of_task(adresse). Une lecture demande au diagramme ce qu'est la tâche maintenant ; une valeur écrite est muette, comme SetItem ; ib_collapsed est un ordre et lève ue_task_toggled. Son of_count() compte les tâches qu'elle contient et son of_keys_at(n) rend l'adresse de la n-ième.

Constantes #

Méthodes #

Événements #

Clavier et souris #

• Glisser une barre la déplace par jours entiers, son bord de fin change sa fin, le petit triangle dessous son avancement ; une bulle dit les dates ou le pourcentage, Échap annule.
• Haut / Bas : la tâche au-dessus, au-dessous ; Début / Fin : la première, la dernière ; Page préc. / Page suiv. : une page plus haut, plus bas. La vue suit la tâche sélectionnée.
• Droite ouvre un récapitulatif replié, puis descend sur sa première tâche ; Gauche replie un récapitulatif ouvert, puis remonte à son parent. Lu de droite à gauche, Gauche et Droite s'inversent.
• Ctrl + Gauche / Droite déplace la tâche d'un jour, Ctrl + Maj + Gauche / Droite change sa fin d'un jour.
• Entrée ou double-clic ouvre la tâche, Suppr demande sa suppression, clic droit ou touche Menu (Maj + F10) : ue_task_rclicked. Un double-clic sur la ligne d'un récapitulatif le replie ou l'ouvre.
• Ctrl + molette change d'échelle, le jour sous le pointeur restant en place ; la molette sur la grille fait défiler le diagramme.
• Glisser la ligne entre grille et diagramme change la largeur de la grille, glisser le bord d'un en-tête celle de sa colonne.
• Le diagramme est un arrêt de Tab, la ligne entre grille et diagramme un second : Gauche / Droite la déplacent de 10 px (Maj : 50), Début masque la grille.
• Alt + Gauche / Droite fait défiler le temps, la sélection reste ; un clic dans la partie vide d'une ligne du diagramme sélectionne sa tâche.
• Près d'un bord, pendant un glisser, le diagramme défile de lui-même : le long du temps pour une barre, vers le haut ou le bas pour un lien.
• La barre d'outils est un arrêt de Tab : Gauche / Droite passent d'un bouton à l'autre, Entrée ou Espace le presse. Dans le diagramme, Ctrl + Plus / Moins change d'échelle, Ctrl + Début ramène aujourd'hui à l'écran, Ctrl + Haut / Bas change l'avancement de la tâche de 10 points.
• Pendant le tracé d'un lien, la barre visée est entourée, avec un bord épais du côté qu'elle tiendrait ; un lien déjà là ou qui fermerait une boucle s'entoure de gris et n'est pas demandé.

Exemples #

Des règles de planning #

// Once, after the plan is built : ask before each change of the user
uo_plan.ib_veto_changes = true

// event ue_task_changing of uo_plan : nothing ends after the go-live
if as_keys <> "golive" and as_end > this.of_task(/*keys*/ "golive").is_start then return false

// and nothing moves into the past : a task already started keeps its start
if as_start < String(Today(), "yyyy-mm-dd") and as_start < this.of_task(/*keys*/ as_keys).is_start then return false
return true

Des liens tracés à la souris #

// Once : two dots beside the bar under the pointer, the critical path in red
uo_plan.ib_link_by_mouse = true
uo_plan.ib_critical_path = true

// event ue_link_requested of uo_plan : the chart adds nothing by itself
if this.of_add_dependency(/*from_keys*/ as_from_keys, /*to_keys*/ as_to_keys, /*type*/ as_type) = -5 then
	MessageBox("Plan", "This link cannot be added.")
end if

// event ue_dependency_clicked of uo_plan : a click on an arrow removes it
this.of_remove_dependency(/*from_keys*/ as_from_keys, /*to_keys*/ as_to_keys)

Retrouver sa disposition au prochain lancement #

// The layout stored at the last start, if any
uo_plan.of_set_layout(/*layout_json*/ ProfileString(gs_ini, "plan", "layout", ""))

// event ue_layout_changed of uo_plan : store every change
SetProfileString(gs_ini, "plan", "layout", as_layout_json)

Ouvrir une tâche dans votre fenêtre #

// event ue_task_opened of uo_plan
// Local variables
long ll_row

// The row of the task in the DataStore, whatever key the task had to take
ll_row = this.of_task(/*keys*/ as_keys).of_row()

// A task added by hand has no row
if ll_row = 0 then return

// Edited in your window, then the task follows its row
OpenWithParm(w_task_edit, ll_row)
this.of_reload_row(/*row*/ ll_row)

Bonnes pratiques #

• Des phases en récapitulatifs : deux ou trois niveaux suffisent, l'utilisateur replie ce qu'il ne suit pas.
• Des liens plutôt que des dates recopiées : un lien que les dates cassent se voit, une date recopiée se trompe en silence.
• Le chemin critique allumé quand il faut tenir une date : il montre où un jour de retard coûte un jour au projet.
• Enregistrez dans ue_task_moved (ou laissez ib_write_back écrire le DataStore) : le diagramme montre le nouveau planning avant que la base ne le sache.
• Rendez la disposition (ue_layout_changed, of_set_layout) : l'échelle et les largeurs que l'utilisateur a choisies sont les siennes.

Hérité du socle commun #

Ces membres existent sur tous les composants visuels — ils ne sont pas propres à celui-ci. Ils sont détaillés une seule fois, dans les chapitres transverses ; cette table dit seulement où les lire.

Deux aides ne sont pas héritées : of_icon et of_escape_markup vivent sur n_pbt_utils. Déclarez-en une — n_pbt_utils lnv_utils, rien à créer — et appelez-les dessus.

← Référence des composants · Sommaire du guide