1105 lines
20 KiB
C
1105 lines
20 KiB
C
/******************************************************************************
|
||
* @file task_panel.c
|
||
* @brief Implémentation du panneau GTK affichant les tâches.
|
||
******************************************************************************/
|
||
|
||
#include "widgets/task_panel.h"
|
||
|
||
/**
|
||
* @brief Intervalle de rafraîchissement du panneau, en millisecondes.
|
||
*/
|
||
#define TASK_PANEL_REFRESH_INTERVAL_MS 250
|
||
|
||
/**
|
||
* @brief Texte affiché lorsqu’aucune tâche n’est suivie.
|
||
*/
|
||
#define TASK_PANEL_EMPTY_TEXT \
|
||
"Aucune tâche en cours ou terminée"
|
||
|
||
/**
|
||
* @struct TaskPanelRow
|
||
* @brief Widgets persistants associés à une tâche.
|
||
*
|
||
* Les widgets sont créés une seule fois. Le rafraîchissement périodique
|
||
* modifie seulement leur contenu.
|
||
*/
|
||
typedef struct
|
||
{
|
||
BackgroundTask *task;
|
||
|
||
GtkWidget *frame;
|
||
GtkWidget *state_label;
|
||
GtkWidget *progress_bar;
|
||
GtkWidget *detail_label;
|
||
GtkWidget *cancel_button;
|
||
} TaskPanelRow;
|
||
|
||
/**
|
||
* @struct TaskPanel
|
||
* @brief État interne du panneau d’activité.
|
||
*
|
||
* TaskManager est emprunté et doit rester valide pendant toute la durée
|
||
* de vie du panneau.
|
||
*/
|
||
struct TaskPanel
|
||
{
|
||
TaskManager *task_manager;
|
||
|
||
GtkWidget *root_box;
|
||
GtkWidget *header_box;
|
||
GtkWidget *title_label;
|
||
GtkWidget *clear_button;
|
||
|
||
GtkWidget *scrolled_window;
|
||
GtkWidget *task_list_box;
|
||
|
||
GPtrArray *rows;
|
||
|
||
guint refresh_source_id;
|
||
};
|
||
|
||
/**
|
||
* @brief Retourne le libellé correspondant à l’état d’une tâche.
|
||
*
|
||
* @param state État de la tâche.
|
||
*
|
||
* @return Libellé statique.
|
||
*/
|
||
static const char *task_panel_get_state_label(
|
||
BackgroundTaskState state
|
||
)
|
||
{
|
||
switch (state)
|
||
{
|
||
case BACKGROUND_TASK_STATE_PENDING:
|
||
return "En attente";
|
||
|
||
case BACKGROUND_TASK_STATE_RUNNING:
|
||
return "En cours";
|
||
|
||
case BACKGROUND_TASK_STATE_COMPLETED:
|
||
return "Terminée";
|
||
|
||
case BACKGROUND_TASK_STATE_FAILED:
|
||
return "Échouée";
|
||
|
||
case BACKGROUND_TASK_STATE_CANCELLED:
|
||
return "Annulée";
|
||
|
||
default:
|
||
return "État inconnu";
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief Supprime tous les widgets enfants d’une boîte GTK.
|
||
*
|
||
* @param box Boîte à vider.
|
||
*/
|
||
static void task_panel_clear_box(
|
||
GtkWidget *box
|
||
)
|
||
{
|
||
GtkWidget *child = NULL;
|
||
|
||
if (box == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
child = gtk_widget_get_first_child(
|
||
box
|
||
);
|
||
|
||
while (child != NULL)
|
||
{
|
||
gtk_box_remove(
|
||
GTK_BOX(box),
|
||
child
|
||
);
|
||
|
||
child = gtk_widget_get_first_child(
|
||
box
|
||
);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief Demande l’annulation d’une tâche.
|
||
*
|
||
* La tâche est conservée dans les données du bouton avec une référence
|
||
* indépendante.
|
||
*
|
||
* @param button Bouton ayant reçu le clic.
|
||
* @param user_data Pointeur vers TaskPanel.
|
||
*/
|
||
static void task_panel_on_cancel_clicked(
|
||
GtkButton *button,
|
||
gpointer user_data
|
||
)
|
||
{
|
||
TaskPanel *task_panel = user_data;
|
||
BackgroundTask *task = NULL;
|
||
|
||
if (button == NULL ||
|
||
task_panel == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
task = g_object_get_data(
|
||
G_OBJECT(button),
|
||
"labfy-background-task"
|
||
);
|
||
|
||
if (task == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
background_task_cancel(
|
||
task
|
||
);
|
||
}
|
||
|
||
/**
|
||
* @brief Retire les tâches terminées du gestionnaire.
|
||
*
|
||
* @param button Bouton ayant reçu le clic.
|
||
* @param user_data Pointeur vers TaskPanel.
|
||
*/
|
||
static void task_panel_on_clear_clicked(
|
||
GtkButton *button,
|
||
gpointer user_data
|
||
)
|
||
{
|
||
TaskPanel *task_panel = user_data;
|
||
|
||
(void) button;
|
||
|
||
if (task_panel == NULL ||
|
||
task_panel->task_manager == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
task_manager_remove_finished(
|
||
task_panel->task_manager
|
||
);
|
||
}
|
||
|
||
/**
|
||
* @brief Réagit aux changements structurels du gestionnaire.
|
||
*
|
||
* @param task_manager Gestionnaire ayant changé.
|
||
* @param user_data Pointeur vers TaskPanel.
|
||
*/
|
||
static void task_panel_on_manager_changed(
|
||
TaskManager *task_manager,
|
||
gpointer user_data
|
||
)
|
||
{
|
||
TaskPanel *task_panel = user_data;
|
||
|
||
if (task_panel == NULL ||
|
||
task_manager == NULL ||
|
||
task_panel->task_manager != task_manager)
|
||
{
|
||
return;
|
||
}
|
||
|
||
task_panel_refresh(
|
||
task_panel
|
||
);
|
||
}
|
||
|
||
/**
|
||
* @brief Met à jour les lignes existantes sans reconstruire la liste.
|
||
*
|
||
* @param task_panel Panneau à mettre à jour.
|
||
*/
|
||
static void task_panel_update_rows(
|
||
TaskPanel *task_panel
|
||
);
|
||
|
||
/**
|
||
* @brief Rafraîchit périodiquement les progressions.
|
||
*
|
||
* @param user_data Pointeur vers TaskPanel.
|
||
*
|
||
* @return G_SOURCE_CONTINUE.
|
||
*/
|
||
static gboolean task_panel_on_refresh_timeout(
|
||
gpointer user_data
|
||
)
|
||
{
|
||
TaskPanel *task_panel = user_data;
|
||
|
||
if (task_panel == NULL)
|
||
{
|
||
return G_SOURCE_REMOVE;
|
||
}
|
||
|
||
task_panel_update_rows(
|
||
task_panel
|
||
);
|
||
|
||
return G_SOURCE_CONTINUE;
|
||
}
|
||
|
||
/**
|
||
* @brief Crée le texte secondaire d’une tâche.
|
||
*
|
||
* @param task Tâche concernée.
|
||
* @param state État courant.
|
||
* @param progress Progression courante.
|
||
* @param status_message Message de progression facultatif.
|
||
* @param error Erreur finale facultative.
|
||
*
|
||
* @return Nouvelle chaîne à libérer avec g_free().
|
||
*/
|
||
static char *task_panel_create_detail_text(
|
||
const BackgroundTask *task,
|
||
BackgroundTaskState state,
|
||
double progress,
|
||
const char *status_message,
|
||
const GError *error
|
||
)
|
||
{
|
||
const char *state_label = NULL;
|
||
|
||
if (task == NULL)
|
||
{
|
||
return g_strdup(
|
||
"Tâche invalide"
|
||
);
|
||
}
|
||
|
||
state_label = task_panel_get_state_label(
|
||
state
|
||
);
|
||
|
||
if (state == BACKGROUND_TASK_STATE_RUNNING)
|
||
{
|
||
if (status_message != NULL &&
|
||
status_message[0] != '\0')
|
||
{
|
||
return g_strdup_printf(
|
||
"%s — %.0f %% — %s",
|
||
state_label,
|
||
progress * 100.0,
|
||
status_message
|
||
);
|
||
}
|
||
|
||
return g_strdup_printf(
|
||
"%s — %.0f %%",
|
||
state_label,
|
||
progress * 100.0
|
||
);
|
||
}
|
||
|
||
if (state == BACKGROUND_TASK_STATE_FAILED &&
|
||
error != NULL)
|
||
{
|
||
return g_strdup_printf(
|
||
"%s — %s",
|
||
state_label,
|
||
error->message
|
||
);
|
||
}
|
||
|
||
if (status_message != NULL &&
|
||
status_message[0] != '\0')
|
||
{
|
||
return g_strdup_printf(
|
||
"%s — %s",
|
||
state_label,
|
||
status_message
|
||
);
|
||
}
|
||
|
||
return g_strdup(
|
||
state_label
|
||
);
|
||
}
|
||
|
||
/**
|
||
* @brief Libère les données privées d'une ligne.
|
||
*
|
||
* @param user_data Pointeur vers TaskPanelRow.
|
||
*/
|
||
static void task_panel_row_free(
|
||
gpointer user_data
|
||
)
|
||
{
|
||
TaskPanelRow *task_row = user_data;
|
||
|
||
if (task_row == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
background_task_unref(
|
||
task_row->task
|
||
);
|
||
|
||
task_row->task = NULL;
|
||
|
||
g_free(
|
||
task_row
|
||
);
|
||
}
|
||
|
||
/**
|
||
* @brief Met à jour l'affichage d'une ligne existante.
|
||
*
|
||
* Aucun widget n'est détruit ici.
|
||
*
|
||
* @param task_row Ligne à mettre à jour.
|
||
*/
|
||
static void task_panel_row_update(
|
||
TaskPanelRow *task_row
|
||
)
|
||
{
|
||
BackgroundTaskState state;
|
||
double progress = 0.0;
|
||
|
||
char *status_message = NULL;
|
||
char *detail_text = NULL;
|
||
|
||
GError *error = NULL;
|
||
|
||
if (task_row == NULL ||
|
||
task_row->task == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
state = background_task_get_state(
|
||
task_row->task
|
||
);
|
||
|
||
progress = background_task_get_progress(
|
||
task_row->task
|
||
);
|
||
|
||
status_message =
|
||
background_task_dup_status_message(
|
||
task_row->task
|
||
);
|
||
|
||
error = background_task_dup_error(
|
||
task_row->task
|
||
);
|
||
|
||
detail_text = task_panel_create_detail_text(
|
||
task_row->task,
|
||
state,
|
||
progress,
|
||
status_message,
|
||
error
|
||
);
|
||
|
||
gtk_label_set_text(
|
||
GTK_LABEL(task_row->state_label),
|
||
task_panel_get_state_label(
|
||
state
|
||
)
|
||
);
|
||
|
||
gtk_progress_bar_set_fraction(
|
||
GTK_PROGRESS_BAR(
|
||
task_row->progress_bar
|
||
),
|
||
state == BACKGROUND_TASK_STATE_COMPLETED
|
||
? 1.0
|
||
: progress
|
||
);
|
||
|
||
gtk_label_set_text(
|
||
GTK_LABEL(task_row->detail_label),
|
||
detail_text != NULL
|
||
? detail_text
|
||
: ""
|
||
);
|
||
|
||
/*
|
||
* Le bouton existe en permanence, mais n'est visible que lorsque
|
||
* la tâche peut être annulée.
|
||
*/
|
||
gtk_widget_set_visible(
|
||
task_row->cancel_button,
|
||
state == BACKGROUND_TASK_STATE_RUNNING
|
||
);
|
||
|
||
gtk_widget_set_sensitive(
|
||
task_row->cancel_button,
|
||
state == BACKGROUND_TASK_STATE_RUNNING
|
||
);
|
||
|
||
g_clear_error(
|
||
&error
|
||
);
|
||
|
||
g_free(
|
||
detail_text
|
||
);
|
||
|
||
g_free(
|
||
status_message
|
||
);
|
||
}
|
||
|
||
/**
|
||
* @brief Crée une ligne GTK persistante pour une tâche.
|
||
*
|
||
* @param task_panel Panneau propriétaire.
|
||
* @param task Tâche à afficher.
|
||
*
|
||
* @return Nouvelle ligne, ou NULL.
|
||
*/
|
||
static TaskPanelRow *task_panel_create_task_row(
|
||
TaskPanel *task_panel,
|
||
BackgroundTask *task
|
||
)
|
||
{
|
||
TaskPanelRow *task_row = NULL;
|
||
|
||
GtkWidget *row_box = NULL;
|
||
GtkWidget *header_box = NULL;
|
||
GtkWidget *title_label = NULL;
|
||
|
||
const char *title = NULL;
|
||
|
||
if (task_panel == NULL ||
|
||
task == NULL)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
task_row = g_new0(
|
||
TaskPanelRow,
|
||
1
|
||
);
|
||
|
||
task_row->task = background_task_ref(
|
||
task
|
||
);
|
||
|
||
task_row->frame = gtk_frame_new(
|
||
NULL
|
||
);
|
||
|
||
row_box = gtk_box_new(
|
||
GTK_ORIENTATION_VERTICAL,
|
||
6
|
||
);
|
||
|
||
gtk_widget_set_margin_start(
|
||
row_box,
|
||
10
|
||
);
|
||
|
||
gtk_widget_set_margin_end(
|
||
row_box,
|
||
10
|
||
);
|
||
|
||
gtk_widget_set_margin_top(
|
||
row_box,
|
||
8
|
||
);
|
||
|
||
gtk_widget_set_margin_bottom(
|
||
row_box,
|
||
8
|
||
);
|
||
|
||
header_box = gtk_box_new(
|
||
GTK_ORIENTATION_HORIZONTAL,
|
||
8
|
||
);
|
||
|
||
title = background_task_get_title(
|
||
task
|
||
);
|
||
|
||
title_label = gtk_label_new(
|
||
title != NULL
|
||
? title
|
||
: "Tâche sans titre"
|
||
);
|
||
|
||
gtk_widget_set_hexpand(
|
||
title_label,
|
||
TRUE
|
||
);
|
||
|
||
gtk_widget_set_halign(
|
||
title_label,
|
||
GTK_ALIGN_START
|
||
);
|
||
|
||
gtk_label_set_xalign(
|
||
GTK_LABEL(title_label),
|
||
0.0F
|
||
);
|
||
|
||
gtk_label_set_ellipsize(
|
||
GTK_LABEL(title_label),
|
||
PANGO_ELLIPSIZE_END
|
||
);
|
||
|
||
task_row->state_label = gtk_label_new(
|
||
NULL
|
||
);
|
||
|
||
gtk_widget_set_halign(
|
||
task_row->state_label,
|
||
GTK_ALIGN_END
|
||
);
|
||
|
||
task_row->cancel_button =
|
||
gtk_button_new_with_label(
|
||
"Annuler"
|
||
);
|
||
|
||
gtk_widget_set_halign(
|
||
task_row->cancel_button,
|
||
GTK_ALIGN_END
|
||
);
|
||
|
||
gtk_widget_set_valign(
|
||
task_row->cancel_button,
|
||
GTK_ALIGN_CENTER
|
||
);
|
||
|
||
/*
|
||
* TaskPanelRow conserve déjà une référence sur la tâche.
|
||
* Le bouton emprunte donc simplement ce pointeur.
|
||
*/
|
||
g_object_set_data(
|
||
G_OBJECT(task_row->cancel_button),
|
||
"labfy-background-task",
|
||
task_row->task
|
||
);
|
||
|
||
g_signal_connect(
|
||
task_row->cancel_button,
|
||
"clicked",
|
||
G_CALLBACK(
|
||
task_panel_on_cancel_clicked
|
||
),
|
||
task_panel
|
||
);
|
||
|
||
gtk_box_append(
|
||
GTK_BOX(header_box),
|
||
title_label
|
||
);
|
||
|
||
gtk_box_append(
|
||
GTK_BOX(header_box),
|
||
task_row->state_label
|
||
);
|
||
|
||
gtk_box_append(
|
||
GTK_BOX(header_box),
|
||
task_row->cancel_button
|
||
);
|
||
|
||
task_row->progress_bar =
|
||
gtk_progress_bar_new();
|
||
|
||
gtk_progress_bar_set_show_text(
|
||
GTK_PROGRESS_BAR(
|
||
task_row->progress_bar
|
||
),
|
||
TRUE
|
||
);
|
||
|
||
task_row->detail_label = gtk_label_new(
|
||
NULL
|
||
);
|
||
|
||
gtk_widget_set_halign(
|
||
task_row->detail_label,
|
||
GTK_ALIGN_START
|
||
);
|
||
|
||
gtk_label_set_xalign(
|
||
GTK_LABEL(task_row->detail_label),
|
||
0.0F
|
||
);
|
||
|
||
gtk_label_set_wrap(
|
||
GTK_LABEL(task_row->detail_label),
|
||
TRUE
|
||
);
|
||
|
||
gtk_label_set_wrap_mode(
|
||
GTK_LABEL(task_row->detail_label),
|
||
PANGO_WRAP_WORD_CHAR
|
||
);
|
||
|
||
gtk_label_set_selectable(
|
||
GTK_LABEL(task_row->detail_label),
|
||
TRUE
|
||
);
|
||
|
||
gtk_box_append(
|
||
GTK_BOX(row_box),
|
||
header_box
|
||
);
|
||
|
||
gtk_box_append(
|
||
GTK_BOX(row_box),
|
||
task_row->progress_bar
|
||
);
|
||
|
||
gtk_box_append(
|
||
GTK_BOX(row_box),
|
||
task_row->detail_label
|
||
);
|
||
|
||
gtk_frame_set_child(
|
||
GTK_FRAME(task_row->frame),
|
||
row_box
|
||
);
|
||
|
||
task_panel_row_update(
|
||
task_row
|
||
);
|
||
|
||
return task_row;
|
||
}
|
||
|
||
/**
|
||
* @brief Supprime les widgets et les données de toutes les lignes.
|
||
*
|
||
* @param task_panel Panneau à vider.
|
||
*/
|
||
static void task_panel_clear_rows(
|
||
TaskPanel *task_panel
|
||
)
|
||
{
|
||
if (task_panel == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
task_panel_clear_box(
|
||
task_panel->task_list_box
|
||
);
|
||
|
||
if (task_panel->rows != NULL)
|
||
{
|
||
g_ptr_array_set_size(
|
||
task_panel->rows,
|
||
0
|
||
);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief Met à jour toutes les lignes persistantes.
|
||
*
|
||
* @param task_panel Panneau concerné.
|
||
*/
|
||
static void task_panel_update_rows(
|
||
TaskPanel *task_panel
|
||
)
|
||
{
|
||
guint index = 0;
|
||
|
||
if (task_panel == NULL ||
|
||
task_panel->rows == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
for (index = 0;
|
||
index < task_panel->rows->len;
|
||
index++)
|
||
{
|
||
TaskPanelRow *task_row = NULL;
|
||
|
||
task_row = g_ptr_array_index(
|
||
task_panel->rows,
|
||
index
|
||
);
|
||
|
||
task_panel_row_update(
|
||
task_row
|
||
);
|
||
}
|
||
}
|
||
|
||
TaskPanel *task_panel_new(
|
||
TaskManager *task_manager
|
||
)
|
||
{
|
||
TaskPanel *task_panel = NULL;
|
||
|
||
if (task_manager == NULL)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
task_panel = g_new0(
|
||
TaskPanel,
|
||
1
|
||
);
|
||
|
||
task_panel->task_manager =
|
||
task_manager;
|
||
|
||
task_panel->rows =
|
||
g_ptr_array_new_with_free_func(
|
||
task_panel_row_free
|
||
);
|
||
|
||
task_panel->root_box = gtk_box_new(
|
||
GTK_ORIENTATION_VERTICAL,
|
||
8
|
||
);
|
||
|
||
task_panel->header_box = gtk_box_new(
|
||
GTK_ORIENTATION_HORIZONTAL,
|
||
8
|
||
);
|
||
|
||
gtk_widget_set_margin_start(
|
||
task_panel->header_box,
|
||
8
|
||
);
|
||
|
||
gtk_widget_set_margin_end(
|
||
task_panel->header_box,
|
||
8
|
||
);
|
||
|
||
gtk_widget_set_margin_top(
|
||
task_panel->header_box,
|
||
8
|
||
);
|
||
|
||
task_panel->title_label = gtk_label_new(
|
||
"Activité"
|
||
);
|
||
|
||
gtk_widget_set_hexpand(
|
||
task_panel->title_label,
|
||
TRUE
|
||
);
|
||
|
||
gtk_widget_set_halign(
|
||
task_panel->title_label,
|
||
GTK_ALIGN_START
|
||
);
|
||
|
||
gtk_label_set_xalign(
|
||
GTK_LABEL(task_panel->title_label),
|
||
0.0F
|
||
);
|
||
|
||
task_panel->clear_button =
|
||
gtk_button_new_with_label(
|
||
"Nettoyer"
|
||
);
|
||
|
||
g_signal_connect(
|
||
task_panel->clear_button,
|
||
"clicked",
|
||
G_CALLBACK(
|
||
task_panel_on_clear_clicked
|
||
),
|
||
task_panel
|
||
);
|
||
|
||
gtk_box_append(
|
||
GTK_BOX(task_panel->header_box),
|
||
task_panel->title_label
|
||
);
|
||
|
||
gtk_box_append(
|
||
GTK_BOX(task_panel->header_box),
|
||
task_panel->clear_button
|
||
);
|
||
|
||
task_panel->task_list_box = gtk_box_new(
|
||
GTK_ORIENTATION_VERTICAL,
|
||
8
|
||
);
|
||
|
||
gtk_widget_set_margin_start(
|
||
task_panel->task_list_box,
|
||
8
|
||
);
|
||
|
||
gtk_widget_set_margin_end(
|
||
task_panel->task_list_box,
|
||
8
|
||
);
|
||
|
||
gtk_widget_set_margin_bottom(
|
||
task_panel->task_list_box,
|
||
8
|
||
);
|
||
|
||
task_panel->scrolled_window =
|
||
gtk_scrolled_window_new();
|
||
|
||
gtk_scrolled_window_set_policy(
|
||
GTK_SCROLLED_WINDOW(
|
||
task_panel->scrolled_window
|
||
),
|
||
GTK_POLICY_AUTOMATIC,
|
||
GTK_POLICY_AUTOMATIC
|
||
);
|
||
|
||
gtk_scrolled_window_set_child(
|
||
GTK_SCROLLED_WINDOW(
|
||
task_panel->scrolled_window
|
||
),
|
||
task_panel->task_list_box
|
||
);
|
||
|
||
gtk_widget_set_vexpand(
|
||
task_panel->scrolled_window,
|
||
TRUE
|
||
);
|
||
|
||
gtk_box_append(
|
||
GTK_BOX(task_panel->root_box),
|
||
task_panel->header_box
|
||
);
|
||
|
||
gtk_box_append(
|
||
GTK_BOX(task_panel->root_box),
|
||
task_panel->scrolled_window
|
||
);
|
||
|
||
task_manager_set_changed_callback(
|
||
task_manager,
|
||
task_panel_on_manager_changed,
|
||
task_panel,
|
||
NULL
|
||
);
|
||
|
||
task_panel->refresh_source_id =
|
||
g_timeout_add(
|
||
TASK_PANEL_REFRESH_INTERVAL_MS,
|
||
task_panel_on_refresh_timeout,
|
||
task_panel
|
||
);
|
||
|
||
if (task_panel->refresh_source_id == 0)
|
||
{
|
||
task_manager_set_changed_callback(
|
||
task_manager,
|
||
NULL,
|
||
NULL,
|
||
NULL
|
||
);
|
||
|
||
g_ptr_array_unref(
|
||
task_panel->rows
|
||
);
|
||
|
||
task_panel->rows = NULL;
|
||
|
||
g_free(
|
||
task_panel
|
||
);
|
||
|
||
return NULL;
|
||
}
|
||
|
||
task_panel_refresh(
|
||
task_panel
|
||
);
|
||
|
||
return task_panel;
|
||
}
|
||
|
||
GtkWidget *task_panel_get_widget(
|
||
const TaskPanel *task_panel
|
||
)
|
||
{
|
||
if (task_panel == NULL)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
return task_panel->root_box;
|
||
}
|
||
|
||
void task_panel_refresh(
|
||
TaskPanel *task_panel
|
||
)
|
||
{
|
||
gsize task_count = 0;
|
||
gsize index = 0;
|
||
|
||
if (task_panel == NULL ||
|
||
task_panel->task_manager == NULL ||
|
||
task_panel->task_list_box == NULL ||
|
||
task_panel->rows == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
/*
|
||
* La liste n'est reconstruite que lorsque TaskManager signale
|
||
* un ajout ou une suppression.
|
||
*/
|
||
task_panel_clear_rows(
|
||
task_panel
|
||
);
|
||
|
||
task_count = task_manager_get_count(
|
||
task_panel->task_manager
|
||
);
|
||
|
||
gtk_widget_set_sensitive(
|
||
task_panel->clear_button,
|
||
task_count > 0
|
||
);
|
||
|
||
if (task_count == 0)
|
||
{
|
||
GtkWidget *empty_label = NULL;
|
||
|
||
empty_label = gtk_label_new(
|
||
TASK_PANEL_EMPTY_TEXT
|
||
);
|
||
|
||
gtk_widget_set_margin_top(
|
||
empty_label,
|
||
16
|
||
);
|
||
|
||
gtk_widget_set_margin_bottom(
|
||
empty_label,
|
||
16
|
||
);
|
||
|
||
gtk_widget_set_halign(
|
||
empty_label,
|
||
GTK_ALIGN_CENTER
|
||
);
|
||
|
||
gtk_box_append(
|
||
GTK_BOX(task_panel->task_list_box),
|
||
empty_label
|
||
);
|
||
|
||
return;
|
||
}
|
||
|
||
for (index = 0;
|
||
index < task_count;
|
||
index++)
|
||
{
|
||
BackgroundTask *task = NULL;
|
||
TaskPanelRow *task_row = NULL;
|
||
|
||
task = task_manager_get_task(
|
||
task_panel->task_manager,
|
||
index
|
||
);
|
||
|
||
if (task == NULL)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
task_row = task_panel_create_task_row(
|
||
task_panel,
|
||
task
|
||
);
|
||
|
||
if (task_row != NULL)
|
||
{
|
||
gtk_box_append(
|
||
GTK_BOX(
|
||
task_panel->task_list_box
|
||
),
|
||
task_row->frame
|
||
);
|
||
|
||
g_ptr_array_add(
|
||
task_panel->rows,
|
||
task_row
|
||
);
|
||
}
|
||
|
||
background_task_unref(
|
||
task
|
||
);
|
||
}
|
||
}
|
||
|
||
void task_panel_free(
|
||
TaskPanel *task_panel
|
||
)
|
||
{
|
||
if (task_panel == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
/*
|
||
* Le callback du manager ne doit plus pouvoir utiliser TaskPanel.
|
||
*/
|
||
if (task_panel->task_manager != NULL)
|
||
{
|
||
task_manager_set_changed_callback(
|
||
task_panel->task_manager,
|
||
NULL,
|
||
NULL,
|
||
NULL
|
||
);
|
||
}
|
||
|
||
/*
|
||
* Arrêt du rafraîchissement périodique.
|
||
*/
|
||
if (task_panel->refresh_source_id != 0)
|
||
{
|
||
g_source_remove(
|
||
task_panel->refresh_source_id
|
||
);
|
||
|
||
task_panel->refresh_source_id = 0;
|
||
}
|
||
|
||
if (task_panel->clear_button != NULL)
|
||
{
|
||
g_signal_handlers_disconnect_by_data(
|
||
task_panel->clear_button,
|
||
task_panel
|
||
);
|
||
}
|
||
|
||
task_panel_clear_rows(
|
||
task_panel
|
||
);
|
||
|
||
if (task_panel->rows != NULL)
|
||
{
|
||
g_ptr_array_unref(
|
||
task_panel->rows
|
||
);
|
||
|
||
task_panel->rows = NULL;
|
||
}
|
||
|
||
task_panel->task_manager = NULL;
|
||
|
||
g_free(
|
||
task_panel
|
||
);
|
||
}
|