fy59/lardon3d
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

chore: normalize user-facing language and repair v25 fixtures

Browse source
This commit is contained in:
fy59 2026-09-03 06:28:56 +02:00
parent b8c5dc8eb1
commit e3c0dc1e2c
13 changed files with 293 additions and 284 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

44
src/image_catalog.c
View file

@ -162,22 +162,22 @@ validate_file(
{
char *path = join_path(originals_path, filename);
if (!path) {
set_error(error_message, error_message_size, "Erreur : chemin d'image trop long.");
set_error(error_message, error_message_size, "Error: image path is too long.");
return false;
}
struct stat info;
if (lstat(path, &info) != 0) {
free(path);
set_error(error_message, error_message_size, "Erreur : image du manifeste absente.");
set_error(error_message, error_message_size, "Error: manifest image is missing.");
return false;
}
free(path);
if (S_ISLNK(info.st_mode) || !S_ISREG(info.st_mode)) {
set_error(error_message, error_message_size, "Erreur : image du manifeste non régulière.");
set_error(error_message, error_message_size, "Error: manifest image is not a regular file.");
return false;
}
if (info.st_size < 0 || (uintmax_t)info.st_size != (uintmax_t)expected_size) {
set_error(error_message, error_message_size, "Erreur : taille d'image incohérente.");
set_error(error_message, error_message_size, "Error: inconsistent image size.");
return false;
}
return true;
@ -195,7 +195,7 @@ parse_line(
char *first_tab = strchr(line, '\t');
char *second_tab = first_tab ? strchr(first_tab + 1, '\t') : NULL;
if (!first_tab || !second_tab || strchr(second_tab + 1, '\t')) {
set_error(error_message, error_message_size, "Erreur : ligne de manifeste invalide.");
set_error(error_message, error_message_size, "Error: invalid manifest line.");
return false;
}
*first_tab = '\0';
@ -206,23 +206,23 @@ parse_line(
uint64_t size_bytes;
if (!valid_filename(filename)) {
set_error(error_message, error_message_size, "Erreur : nom d'image invalide dans le manifeste.");
set_error(error_message, error_message_size, "Error: invalid image name in manifest.");
return false;
}
if (!source_path[0]) {
set_error(error_message, error_message_size, "Erreur : chemin source vide dans le manifeste.");
set_error(error_message, error_message_size, "Error: empty source path in manifest.");
return false;
}
if (!parse_size(size_text, &size_bytes)) {
set_error(error_message, error_message_size, "Erreur : taille invalide dans le manifeste.");
set_error(error_message, error_message_size, "Error: invalid size in manifest.");
return false;
}
if (filename_exists(catalog, filename)) {
set_error(error_message, error_message_size, "Erreur : image dupliquée dans le manifeste.");
set_error(error_message, error_message_size, "Error: duplicate image in manifest.");
return false;
}
if (catalog->total_size > UINT64_MAX - size_bytes) {
set_error(error_message, error_message_size, "Erreur : taille totale du catalogue trop grande.");
set_error(error_message, error_message_size, "Error: total catalog size is too large.");
return false;
}
if (!validate_file(
@ -235,7 +235,7 @@ parse_line(
return false;
}
if (!append_entry(catalog, filename, source_path, size_bytes)) {
set_error(error_message, error_message_size, "Erreur : mémoire insuffisante pour le catalogue.");
set_error(error_message, error_message_size, "Error: insufficient memory for the catalog.");
return false;
}
return true;
@ -250,45 +250,45 @@ lardon3d_image_catalog_load(
{
set_error(error_message, error_message_size, "");
if (!state || !state->project_loaded || !state->project_path[0]) {
set_error(error_message, error_message_size, "Aucun projet chargé.");
set_error(error_message, error_message_size, "No project loaded.");
return NULL;
}
Lardon3DImageCatalog *catalog = calloc(1, sizeof(*catalog));
if (!catalog) {
set_error(error_message, error_message_size, "Erreur : mémoire insuffisante pour le catalogue.");
set_error(error_message, error_message_size, "Error: insufficient memory for the catalog.");
return NULL;
}
char *images_path = join_path(state->project_path, "images");
char *originals_path = images_path ? join_path(images_path, "originals") : NULL;
char *manifest_path = images_path ? join_path(images_path, "manifest.tsv") : NULL;
if (!images_path || !originals_path || !manifest_path) {
set_error(error_message, error_message_size, "Erreur : chemin du catalogue trop long.");
set_error(error_message, error_message_size, "Error: catalog path is too long.");
goto failure;
}
int descriptor = open(manifest_path, O_RDONLY | O_NOFOLLOW);
if (descriptor < 0) {
if (errno == ENOENT) {
set_error(error_message, error_message_size, "Aucune image importée.");
set_error(error_message, error_message_size, "No imported image.");
free(images_path);
free(originals_path);
free(manifest_path);
return catalog;
}
set_error(error_message, error_message_size, "Erreur : impossible d'ouvrir manifest.tsv.");
set_error(error_message, error_message_size, "Error: unable to open manifest.tsv.");
goto failure;
}
struct stat manifest_info;
if (fstat(descriptor, &manifest_info) != 0 || !S_ISREG(manifest_info.st_mode)) {
(void)close(descriptor);
set_error(error_message, error_message_size, "Erreur : manifest.tsv n'est pas régulier.");
set_error(error_message, error_message_size, "Error: manifest.tsv is not a regular file.");
goto failure;
}
FILE *file = fdopen(descriptor, "r");
if (!file) {
(void)close(descriptor);
set_error(error_message, error_message_size, "Erreur : impossible de lire manifest.tsv.");
set_error(error_message, error_message_size, "Error: unable to read manifest.tsv.");
goto failure;
}
@ -298,11 +298,11 @@ lardon3d_image_catalog_load(
bool valid = length >= 0
&& strcmp(line, "filename\tsize_bytes\tsource_path\n") == 0;
if (!valid) {
set_error(error_message, error_message_size, "Erreur : en-tête de manifest.tsv invalide.");
set_error(error_message, error_message_size, "Error: invalid manifest.tsv header.");
}
while (valid && (length = getline(&line, &capacity, file)) >= 0) {
if (length == 0 || line[(size_t)length - 1] != '\n') {
set_error(error_message, error_message_size, "Erreur : ligne tronquée dans manifest.tsv.");
set_error(error_message, error_message_size, "Error: truncated line in manifest.tsv.");
valid = false;
break;
}
@ -316,13 +316,13 @@ lardon3d_image_catalog_load(
error_message_size
)) {
if (!error_message || !error_message_size || !error_message[0]) {
set_error(error_message, error_message_size, "Erreur : ligne de manifeste invalide.");
set_error(error_message, error_message_size, "Error: invalid manifest line.");
}
valid = false;
}
}
if (ferror(file) || fclose(file) != 0) {
set_error(error_message, error_message_size, "Erreur : lecture de manifest.tsv impossible.");
set_error(error_message, error_message_size, "Error: unable to read manifest.tsv.");
valid = false;
}
free(line);

16
src/image_view.c
View file

@ -279,7 +279,7 @@ lardon3d_image_view_set_filter(
(void)snprintf(
error_message,
error_message_size,
"Erreur : filtre invalide."
"Error: invalid filter."
);
}
return false;
@ -290,7 +290,7 @@ lardon3d_image_view_set_filter(
(void)snprintf(
error_message,
error_message_size,
"Erreur : filtre trop long."
"Error: filter is too long."
);
}
return false;
@ -300,7 +300,7 @@ lardon3d_image_view_set_filter(
(void)snprintf(
error_message,
error_message_size,
"Erreur : mémoire insuffisante pour la vue."
"Error: insufficient memory for the view."
);
}
return false;
@ -368,16 +368,16 @@ lardon3d_image_view_sort_name(Lardon3DImageSort sort)
{
switch (sort) {
case LARDON3D_IMAGE_SORT_NAME_ASC:
return "Nom croissant";
return "Name ascending";
case LARDON3D_IMAGE_SORT_NAME_DESC:
return "Nom décroissant";
return "Name descending";
case LARDON3D_IMAGE_SORT_SIZE_ASC:
return "Taille croissante";
return "Size ascending";
case LARDON3D_IMAGE_SORT_SIZE_DESC:
return "Taille décroissante";
return "Size descending";
case LARDON3D_IMAGE_SORT_IMPORT_ORDER:
default:
return "Ordre d'import";
return "Import order";
}
}

108
src/import.c
View file

@ -106,7 +106,7 @@ trim_source_path(
)
{
if (!input) {
set_status(state, "Erreur : dossier source vide.");
set_status(state, "Error: source directory is empty.");
return false;
}
@ -121,11 +121,11 @@ trim_source_path(
size_t length = (size_t)(end - start);
if (length == 0) {
set_status(state, "Erreur : dossier source vide.");
set_status(state, "Error: source directory is empty.");
return false;
}
if (length >= PATH_MAX) {
set_status(state, "Erreur : chemin source trop long.");
set_status(state, "Error: source path is too long.");
return false;
}
(void)memcpy(output, start, length);
@ -153,7 +153,7 @@ resolve_source_path(
}
}
set_status(state, "Erreur : chemin source trop long ou inaccessible.");
set_status(state, "Error: source path is too long or inaccessible.");
return false;
}
@ -192,7 +192,7 @@ candidate_list_append(
: candidates->capacity * 2;
if (capacity < candidates->capacity
|| capacity > SIZE_MAX / sizeof(*candidates->items)) {
set_status(state, "Erreur : trop de fichiers à importer.");
set_status(state, "Error: too many files to import.");
return false;
}
void *items = realloc(
@ -200,7 +200,7 @@ candidate_list_append(
capacity * sizeof(*candidates->items)
);
if (!items) {
set_status(state, "Erreur : mémoire insuffisante pour l'import.");
set_status(state, "Error: insufficient memory for import.");
return false;
}
candidates->items = items;
@ -215,7 +215,7 @@ candidate_list_append(
filename
);
if (written < 0 || (size_t)written >= sizeof(candidate->filename)) {
set_status(state, "Erreur : nom de fichier trop long.");
set_status(state, "Error: filename is too long.");
return false;
}
candidate->created = false;
@ -232,24 +232,24 @@ ensure_originals_directory(
{
if (!join_path(images_path, state->project_path, "images")
|| !join_path(originals_path, images_path, "originals")) {
set_status(state, "Erreur : chemin du projet trop long.");
set_status(state, "Error: project path is too long.");
return false;
}
struct stat info;
if (lstat(images_path, &info) != 0 || !S_ISDIR(info.st_mode)) {
set_status(state, "Erreur : dossier images absent ou invalide.");
set_status(state, "Error: images directory is missing or invalid.");
return false;
}
if (lstat(originals_path, &info) == 0) {
if (!S_ISDIR(info.st_mode)) {
set_status(state, "Erreur : images/originals n'est pas un dossier.");
set_status(state, "Error: images/originals is not a directory.");
return false;
}
return true;
}
if (errno != ENOENT || mkdir(originals_path, 0755) != 0) {
set_status(state, "Erreur : impossible de créer images/originals.");
set_status(state, "Error: unable to create images/originals.");
return false;
}
return true;
@ -303,7 +303,7 @@ manifest_begin(
images_path,
".manifest.tsv.tmp.XXXXXX"
)) {
set_status(state, "Erreur : chemin du manifeste trop long.");
set_status(state, "Error: manifest path is too long.");
return false;
}
@ -316,18 +316,18 @@ manifest_begin(
struct stat info;
if (fstat(previous_descriptor, &info) != 0 || !S_ISREG(info.st_mode)) {
(void)close(previous_descriptor);
set_status(state, "Erreur : manifest.tsv invalide.");
set_status(state, "Error: invalid manifest.tsv.");
return false;
}
previous = fdopen(previous_descriptor, "r");
if (!previous) {
(void)close(previous_descriptor);
set_status(state, "Erreur : impossible de lire manifest.tsv.");
set_status(state, "Error: unable to read manifest.tsv.");
return false;
}
writer->previous_exists = true;
} else if (errno != ENOENT) {
set_status(state, "Erreur : impossible de lire manifest.tsv.");
set_status(state, "Error: unable to read manifest.tsv.");
return false;
}
@ -336,7 +336,7 @@ manifest_begin(
if (previous) {
(void)fclose(previous);
}
set_status(state, "Erreur : impossible de préparer manifest.tsv.");
set_status(state, "Error: unable to prepare manifest.tsv.");
return false;
}
writer->file = fdopen(descriptor, "w");
@ -346,7 +346,7 @@ manifest_begin(
(void)fclose(previous);
}
manifest_abort(writer);
set_status(state, "Erreur : impossible d'écrire manifest.tsv.");
set_status(state, "Error: unable to write manifest.tsv.");
return false;
}
@ -373,7 +373,7 @@ manifest_begin(
if (!success) {
manifest_abort(writer);
set_status(state, "Erreur : manifest.tsv invalide ou illisible.");
set_status(state, "Error: manifest.tsv is invalid or unreadable.");
}
return success;
}
@ -446,7 +446,7 @@ manifest_commit(Lardon3DAppState *state, ManifestWriter *writer)
}
if (!success) {
(void)unlink(writer->temporary_path);
set_status(state, "Erreur : impossible de mettre à jour manifest.tsv.");
set_status(state, "Error: unable to update manifest.tsv.");
}
return success;
}
@ -602,7 +602,7 @@ analyze_source_directory(
{
DIR *directory = opendir(absolute_source);
if (!directory) {
set_status(state, "Erreur : impossible d'ouvrir le dossier source.");
set_status(state, "Error: unable to open source directory.");
return false;
}
@ -616,7 +616,7 @@ analyze_source_directory(
struct dirent *entry = readdir(directory);
if (!entry) {
if (errno != 0) {
set_status(state, "Erreur : lecture du dossier source impossible.");
set_status(state, "Error: unable to read source directory.");
success = false;
}
break;
@ -628,7 +628,7 @@ analyze_source_directory(
char source_path[PATH_MAX];
if (!join_path(source_path, absolute_source, entry->d_name)) {
set_status(state, "Erreur : chemin source trop long.");
set_status(state, "Error: source path is too long.");
success = false;
break;
}
@ -645,7 +645,7 @@ analyze_source_directory(
if (has_forbidden_manifest_character(entry->d_name)) {
set_status(
state,
"Erreur : nom de fichier incompatible avec le manifeste."
"Error: filename is incompatible with the manifest."
);
success = false;
break;
@ -653,7 +653,7 @@ analyze_source_directory(
char destination_path[PATH_MAX];
if (!join_path(destination_path, originals_path, entry->d_name)) {
set_status(state, "Erreur : chemin destination trop long.");
set_status(state, "Error: destination path is too long.");
success = false;
break;
}
@ -664,7 +664,7 @@ analyze_source_directory(
}
if (closedir(directory) != 0) {
set_status(state, "Erreur : fermeture du dossier source impossible.");
set_status(state, "Error: unable to close source directory.");
success = false;
}
return success;
@ -711,27 +711,25 @@ fail_import(
(void)snprintf(
state->status_message,
sizeof(state->status_message),
"Import annulé : %zu copie%s retirée%s après erreur (%s).",
"Import cancelled: %zu %s removed after error (%s).",
removed,
removed == 1 ? "" : "s",
removed == 1 ? "" : "s",
removed == 1 ? "copy" : "copies",
reason
);
} else if (result->copied > 0) {
(void)snprintf(
state->status_message,
sizeof(state->status_message),
"Erreur critique : %zu copie%s conservée%s sans manifeste (%s).",
"Critical error: %zu %s retained without manifest (%s).",
result->copied,
result->copied == 1 ? "" : "s",
result->copied == 1 ? "" : "s",
result->copied == 1 ? "copy" : "copies",
reason
);
} else {
(void)snprintf(
state->status_message,
sizeof(state->status_message),
"Erreur d'import : %s.",
"Import error: %s.",
reason
);
}
@ -754,7 +752,7 @@ cancel_import(
(void)snprintf(
state->status_message,
sizeof(state->status_message),
"Import annulé : %zu sur %zu fichiers traités.",
"Import cancelled: %zu of %zu files processed.",
processed,
result->admissible_found
);
@ -788,7 +786,7 @@ lardon3d_import_directory_batch(
struct stat source_info;
if (lstat(absolute_source, &source_info) != 0
|| !S_ISDIR(source_info.st_mode)) {
set_status(state, "Erreur : dossier source absent ou invalide.");
set_status(state, "Error: source directory is missing or invalid.");
return LARDON3D_IMPORT_FAILED;
}
char images_path[PATH_MAX], originals_path[PATH_MAX];
@ -804,7 +802,7 @@ lardon3d_import_directory_batch(
DIR *directory = opendir(absolute_source);
if (!directory) {
manifest_abort(&manifest);
set_status(state, "Erreur : impossible d'ouvrir le dossier source.");
set_status(state, "Error: unable to open source directory.");
return LARDON3D_IMPORT_FAILED;
}
CandidateList created = {0};
@ -888,8 +886,8 @@ lardon3d_import_directory_batch(
manifest_abort(&manifest);
(void)rollback_created_files(&created, originals_path);
free(created.items);
set_status(state, cancelled ? "Import annulé à une frontière sûre."
: "Erreur pendant un lot d'import.");
set_status(state, cancelled ? "Import cancelled at a safe boundary."
: "Error during an import batch.");
return cancelled ? LARDON3D_IMPORT_CANCELLED : LARDON3D_IMPORT_FAILED;
}
if (!manifest_commit(state, &manifest)) {
@ -899,7 +897,7 @@ lardon3d_import_directory_batch(
}
free(created.items);
*complete = result->processed == result->admissible_found;
set_status(state, *complete ? "Import terminé." : "Lot d'import publié.");
set_status(state, *complete ? "Import completed." : "Import batch published.");
publish_progress(control, result, result->processed, state->status_message);
return LARDON3D_IMPORT_SUCCEEDED;
}
@ -919,7 +917,7 @@ lardon3d_import_directory_controlled(
publish_progress(control, result, 0, "Analyse du dossier source...");
if (!state->project_loaded) {
set_status(state, "Aucun projet chargé.");
set_status(state, "No project loaded.");
publish_progress(control, result, 0, state->status_message);
return LARDON3D_IMPORT_FAILED;
}
@ -935,19 +933,19 @@ lardon3d_import_directory_controlled(
return LARDON3D_IMPORT_FAILED;
}
if (has_forbidden_manifest_character(absolute_source)) {
set_status(state, "Erreur : chemin source incompatible avec le manifeste.");
set_status(state, "Error: source path is incompatible with the manifest.");
publish_progress(control, result, 0, state->status_message);
return LARDON3D_IMPORT_FAILED;
}
struct stat source_directory_info;
if (lstat(absolute_source, &source_directory_info) != 0) {
set_status(state, "Erreur : dossier source inexistant.");
set_status(state, "Error: source directory does not exist.");
publish_progress(control, result, 0, state->status_message);
return LARDON3D_IMPORT_FAILED;
}
if (!S_ISDIR(source_directory_info.st_mode)) {
set_status(state, "Erreur : la source n'est pas un dossier.");
set_status(state, "Error: source is not a directory.");
publish_progress(control, result, 0, state->status_message);
return LARDON3D_IMPORT_FAILED;
}
@ -956,7 +954,7 @@ lardon3d_import_directory_controlled(
char originals_path[PATH_MAX];
if (!join_path(images_path, state->project_path, "images")
|| !join_path(originals_path, images_path, "originals")) {
set_status(state, "Erreur : chemin du projet trop long.");
set_status(state, "Error: project path is too long.");
publish_progress(control, result, 0, state->status_message);
return LARDON3D_IMPORT_FAILED;
}
@ -978,7 +976,7 @@ lardon3d_import_directory_controlled(
}
if (analysis_cancelled) {
free(candidates.items);
set_status(state, "Import annulé : 0 fichier traité.");
set_status(state, "Import cancelled: 0 files processed.");
publish_progress(control, result, 0, state->status_message);
return LARDON3D_IMPORT_CANCELLED;
}
@ -986,7 +984,7 @@ lardon3d_import_directory_controlled(
if (import_is_cancelled(control)) {
free(candidates.items);
set_status(state, "Import annulé : 0 fichier traité.");
set_status(state, "Import cancelled: 0 files processed.");
publish_progress(control, result, 0, state->status_message);
return LARDON3D_IMPORT_CANCELLED;
}
@ -1079,7 +1077,7 @@ lardon3d_import_directory_controlled(
source_path
)) {
success = false;
failure_reason = "écriture du manifeste impossible";
failure_reason = "unable to write manifest";
break;
}
++processed;
@ -1129,7 +1127,7 @@ lardon3d_import_directory_controlled(
state,
result,
removed,
"mise à jour du manifeste impossible"
"unable to update manifest"
);
publish_progress(control, result, processed, state->status_message);
return LARDON3D_IMPORT_FAILED;
@ -1139,13 +1137,11 @@ lardon3d_import_directory_controlled(
(void)snprintf(
state->status_message,
sizeof(state->status_message),
"Import terminé : %zu copiée%s, %zu déjà présente%s.",
"Import completed: %zu copied, %zu already present.",
result->copied,
result->copied == 1 ? "" : "s",
result->already_present,
result->already_present == 1 ? "" : "s"
result->already_present
);
publish_progress(control, result, processed, "Import terminé.");
publish_progress(control, result, processed, "Import completed.");
return LARDON3D_IMPORT_SUCCEEDED;
}
@ -1187,7 +1183,7 @@ lardon3d_import_directory_batch_to_scanset(
struct stat directory_info;
if (lstat(source, &directory_info) != 0 || !S_ISDIR(directory_info.st_mode)
|| S_ISLNK(directory_info.st_mode)) {
set_status(state, "Erreur : dossier source absent ou invalide.");
set_status(state, "Error: source directory is missing or invalid.");
return LARDON3D_IMPORT_FAILED;
}
DIR *directory = opendir(source);
@ -1254,15 +1250,15 @@ lardon3d_import_directory_batch_to_scanset(
legacy_manifest_active = false;
}
if (cancelled) {
set_status(state, "Import annulé à une frontière sûre.");
set_status(state, "Import cancelled at a safe boundary.");
return LARDON3D_IMPORT_CANCELLED;
}
if (!success) {
set_status(state, "Erreur pendant un lot d'import.");
set_status(state, "Error during an import batch.");
return LARDON3D_IMPORT_FAILED;
}
*complete = !remaining;
set_status(state, *complete ? "Import terminé." : "Lot d'import publié.");
set_status(state, *complete ? "Import completed." : "Import batch published.");
publish_progress(control, result, result->processed, state->status_message);
return LARDON3D_IMPORT_SUCCEEDED;
}

204
src/layout.c
View file

@ -60,7 +60,7 @@ draw_text(int row, int column, int available, const char *text)
static void
draw_too_small(int rows, int columns)
{
static const char message[] = "Terminal trop petit";
static const char message[] = "Terminal too small";
int row = rows > 0 ? rows / 2 : 0;
int column = columns > (int)(sizeof(message) - 1)
? (columns - (int)(sizeof(message) - 1)) / 2
@ -86,24 +86,24 @@ screen_title(Lardon3DScreen screen)
{
switch (screen) {
case LARDON3D_SCREEN_PROJECTS:
return "Projets";
return "Projects";
case LARDON3D_SCREEN_IMPORT:
return "Import";
case LARDON3D_SCREEN_VIEWER:
return "Viewer";
case LARDON3D_SCREEN_HELP:
return "Aide / contrats runtime";
return "Help / runtime contracts";
case LARDON3D_SCREEN_TASKS:
return "Tâches";
return "Tasks";
case LARDON3D_SCREEN_RESOURCES:
return "Ressources / Governor";
return "Resources / Governor";
case LARDON3D_SCREEN_OPTICS:
return "Profils optiques immuables";
return "Immutable optical profiles";
case LARDON3D_SCREEN_SSD:
return "SSD externe";
return "External SSD";
case LARDON3D_SCREEN_HOME:
default:
return "Observatoire Lardon3D";
return "Lardon3D Observatory";
}
}
@ -116,26 +116,26 @@ screen_footer(
Lardon3DTuiKeyContract keys = lardon3d_tui_key_contract(
interaction_mode);
if (keys.enter && keys.escape && keys.f10) {
return "F10 SSD | Enter valider | ESC annuler";
return "F10 SSD | Enter confirm | ESC cancel";
}
if (keys.cancel_import && keys.f10) {
return "F10 SSD | X annuler l'import | Q/ESC désactivés";
return "F10 SSD | X cancel import | Q/ESC disabled";
}
switch (screen) {
case LARDON3D_SCREEN_PROJECTS:
return "F10 SSD | N Nouveau O Ouvrir C Fermer | ESC Accueil F7 Optique Q";
return "F10 SSD | N New O Open C Close | ESC Home F7 Optics Q";
case LARDON3D_SCREEN_IMPORT:
return "F10 SSD | I Importer R Recharger S Tri/Filtre X Effacer | ESC Q";
return "F10 SSD | I Import R Reload S Sort/Filter X Clear | ESC Q";
case LARDON3D_SCREEN_TASKS:
return "F10 SSD | ↑/↓ P pause R reprise C annuler | ESC F6 Ressources Q";
return "F10 SSD | ↑/↓ P pause R resume C cancel | ESC F6 Resources Q";
case LARDON3D_SCREEN_RESOURCES:
return "F10 SSD | Observation seule: CPU/GPU/batch par Governor | ESC Q";
return "F10 SSD | Observation only: CPU/GPU/batch by Governor | ESC Q";
case LARDON3D_SCREEN_OPTICS:
return "F10 SSD | TAB ↑/↓ [ première ] suivante B/L/C V/A/G/K/E R retry ESC Q";
return "F10 SSD | TAB ↑/↓ [ first ] next B/L/C V/A/G/K/E R retry ESC Q";
case LARDON3D_SCREEN_SSD:
return "F10 SSD | activer/drainer/annuler drain (asynchrone) | ESC Q";
return "F10 SSD | enable/drain/cancel drain (asynchronous) | ESC Q";
default:
return "F10 SSD | F1 Aide F2 Projets F3 Import F4 Viewer F5 Tâches F6 Ressources Q";
return "F10 SSD | F1 Help F2 Projects F3 Import F4 Viewer F5 Tasks F6 Resources Q";
}
}
@ -233,8 +233,8 @@ static void
draw_project_line(const Lardon3DAppState *state, int row, int columns)
{
char line[512];
(void)snprintf(line, sizeof(line), "Projet: %.120s%s%.370s",
state->project_loaded ? state->project_name : "aucun",
(void)snprintf(line, sizeof(line), "Project: %.120s%s%.370s",
state->project_loaded ? state->project_name : "none",
state->project_loaded ? " " : "",
state->project_loaded ? state->project_path : "");
draw_text(row, 2, columns - 4, line);
@ -267,7 +267,7 @@ draw_home(
int active_row = start + 6;
if (!runtime->active_task_known) {
draw_text_style(active_row, 2, columns - 4,
"Tâche active: aucune", LARDON3D_TUI_SEMANTIC_DIM, palette);
"Active task: none", LARDON3D_TUI_SEMANTIC_DIM, palette);
return;
}
const Lardon3DTaskObservation *task =
@ -302,7 +302,7 @@ draw_home(
(unsigned long long)task->id, task->name);
} else {
(void)snprintf(line, sizeof(line),
"scientifique indéterminé | #%llu %.18s",
"scientific unknown | #%llu %.18s",
(unsigned long long)task->id, task->name);
}
} else {
@ -337,15 +337,15 @@ draw_home(
if (runtime->active_progress.throughput_known) {
(void)snprintf(throughput, sizeof(throughput),
runtime->active_progress.runtime_percentage
? "%.1f%%/s" : "%.1f unité/s",
? "%.1f%%/s" : "%.1f unit/s",
runtime->active_progress.units_per_second);
} else {
(void)snprintf(throughput, sizeof(throughput), "UNKNOWN");
}
(void)snprintf(line, sizeof(line),
"Durée %s | ETA %s | débit %s%s", elapsed, eta, throughput,
"Elapsed %s | ETA %s | throughput %s%s", elapsed, eta, throughput,
runtime->active_progress.resumed_prefix_excluded
? " | préfixe repris exclu" : "");
? " | resumed prefix excluded" : "");
draw_text(active_row + 2, 2, columns - 4, line);
}
}
@ -353,9 +353,9 @@ draw_home(
static void
draw_projects(const char *input_text, const char *input_label, int columns)
{
draw_text(5, 4, columns - 6, "N : Nouveau projet");
draw_text(6, 4, columns - 6, "O : Ouvrir un projet");
draw_text(7, 4, columns - 6, "C : Fermer le projet");
draw_text(5, 4, columns - 6, "N: New project");
draw_text(6, 4, columns - 6, "O: Open a project");
draw_text(7, 4, columns - 6, "C: Close project");
draw_input_field(input_text, input_label, 9, columns);
}
@ -363,19 +363,19 @@ static void
draw_catalog(const Lardon3DAppState *state, int rows, int columns)
{
if (!state->project_loaded || !state->image_view || !state->image_catalog) {
draw_text(5, 4, columns - 6, "Aucun projet chargé.");
draw_text(5, 4, columns - 6, "No project loaded.");
return;
}
size_t count = lardon3d_image_view_count(state->image_view);
size_t total = lardon3d_image_catalog_count(state->image_catalog);
char line[512];
(void)snprintf(line, sizeof(line), "Images visibles: %zu / %zu | Tri: %s",
(void)snprintf(line, sizeof(line), "Visible images: %zu / %zu | Sort: %s",
count, total, lardon3d_image_view_sort_name(
lardon3d_image_view_sort(state->image_view)));
draw_text(4, 2, columns - 4, line);
const char *filter = lardon3d_image_view_filter(state->image_view);
(void)snprintf(line, sizeof(line), "Filtre: %s",
filter[0] ? filter : "aucun");
(void)snprintf(line, sizeof(line), "Filter: %s",
filter[0] ? filter : "none");
draw_text(5, 2, columns - 4, line);
size_t visible = rows > 12 ? (size_t)(rows - 12) : 1;
size_t offset = lardon3d_image_view_offset(state->image_view);
@ -407,7 +407,7 @@ draw_import(
if (snapshot && snapshot->status == LARDON3D_IMPORT_TASK_RUNNING) {
char line[256];
(void)snprintf(line, sizeof(line),
"Import: %zu/%zu | copiés %zu | présents %zu | ignorés %zu",
"Import: %zu/%zu | copied %zu | present %zu | skipped %zu",
snapshot->processed, snapshot->total, snapshot->copied,
snapshot->already_present, snapshot->ignored);
draw_text_style(5, 2, columns - 4, line,
@ -427,7 +427,7 @@ draw_import(
}
if (percent > 100) percent = 100;
draw_progress_bar(7, 2, columns - 4, percent, palette);
draw_text(9, 2, columns - 4, "X : annuler l'import");
draw_text(9, 2, columns - 4, "X: cancel import");
} else if (input_text) {
draw_input_field(input_text, input_label, 5, columns);
} else {
@ -446,18 +446,18 @@ draw_tasks(
{
char line[512];
(void)snprintf(line, sizeof(line),
"Total %zu | running %zu | pending %zu | terminal cumulées %zu",
"Total %zu | running %zu | pending %zu | terminal cumulative %zu",
runtime->task_summary.total, runtime->task_summary.running,
runtime->task_summary.pending, runtime->task_summary.completed);
draw_text(4, 2, columns - 4, line);
if (runtime->task_count == 0) {
draw_text_style(6, 4, columns - 6, "Aucune tâche retenue.",
draw_text_style(6, 4, columns - 6, "No retained task.",
LARDON3D_TUI_SEMANTIC_DIM, palette);
return;
}
if (selected >= runtime->task_count) selected = runtime->task_count - 1;
const Lardon3DTaskObservation *chosen = &runtime->tasks[selected];
(void)snprintf(line, sizeof(line), "Sélection #%llu %s | %s | %s",
(void)snprintf(line, sizeof(line), "Selection #%llu %s | %s | %s",
(unsigned long long)chosen->id, chosen->name,
chosen->has_task_kind ? chosen->task_kind : "untyped",
lardon3d_task_state_name(chosen->state));
@ -472,7 +472,7 @@ draw_tasks(
: LARDON3D_TUI_SEMANTIC_CPU), palette);
if (chosen->durable_progress_known) {
(void)snprintf(line, sizeof(line),
"Progression durable: %llu/%llu%s",
"Durable progress: %llu/%llu%s",
(unsigned long long)chosen->durable_completed,
(unsigned long long)chosen->durable_total,
chosen->state == TASK_COMPLETED
@ -485,10 +485,10 @@ draw_tasks(
: LARDON3D_TUI_SEMANTIC_NORMAL, palette);
} else if (chosen->has_task_kind) {
draw_text_style(7, 2, columns - 4,
"Progression scientifique: indéterminée",
"Scientific progress: unknown",
LARDON3D_TUI_SEMANTIC_WARNING, palette);
} else {
(void)snprintf(line, sizeof(line), "Progression runtime: %u%%",
(void)snprintf(line, sizeof(line), "Runtime progress: %u%%",
chosen->progress);
draw_text(7, 2, columns - 4, line);
}
@ -576,7 +576,7 @@ format_external_storage_summary(
(void)snprintf(line, capacity,
"Governor SSD %s | alloc %s | scratch total/free %s/%s | leases %zu",
status,
resource->scratch_new_allocations_allowed ? "oui" : "non",
resource->scratch_new_allocations_allowed ? "yes" : "no",
scratch_total, scratch_free, resource->scratch_leases);
}
@ -590,7 +590,7 @@ draw_resources(
{
if (!resource->valid) {
draw_text_style(5, 4, columns - 6,
"Ressources système indisponibles (UNKNOWN).",
"System resources unavailable (UNKNOWN).",
LARDON3D_TUI_SEMANTIC_WARNING, palette);
char external[512];
format_external_storage_summary(
@ -615,22 +615,22 @@ draw_resources(
resource->cpu_admitted);
}
(void)snprintf(line, sizeof(line),
"CPU active/admis/disponible: %u/%s/%u (hôte %u) | utilisation %s",
"CPU active/admitted/available: %u/%s/%u (host %u) | utilization %s",
resource->cpu_active, admitted, resource->cpu_available,
resource->cpu_logical_total,
resource->cpu_utilization_known ? "connue" : "UNKNOWN");
resource->cpu_utilization_known ? "known" : "UNKNOWN");
draw_text_style(6, 2, columns - 4, line,
LARDON3D_TUI_SEMANTIC_CPU, palette);
if (viewport == LARDON3D_TUI_VIEWPORT_FULL) {
if (resource->cpu_utilization_known) {
(void)snprintf(line, sizeof(line),
"CPU raison: %s | utilisation %u.%02u%%",
"CPU reason: %s | utilization %u.%02u%%",
resource->cpu_reason,
resource->cpu_utilization_basis_points / 100U,
resource->cpu_utilization_basis_points % 100U);
} else {
(void)snprintf(line, sizeof(line),
"CPU raison: %s | utilisation UNKNOWN",
"CPU reason: %s | utilization UNKNOWN",
resource->cpu_reason);
}
draw_text(7, 4, columns - 6, line);
@ -645,14 +645,14 @@ draw_resources(
}
(void)snprintf(line, sizeof(line),
"GPU %s | slots active/dispo %u/%u | busy %s | backend %s",
resource->gpu_present ? "présent" : "absent",
resource->gpu_present ? "present" : "absent",
resource->gpu_slots_active, resource->gpu_slots_available,
gpu_busy,
lardon3d_tui_gpu_backend_name(resource->gpu_backend));
draw_text_style(viewport == LARDON3D_TUI_VIEWPORT_FULL ? 9 : 7,
2, columns - 4, line, LARDON3D_TUI_SEMANTIC_GPU, palette);
if (viewport == LARDON3D_TUI_VIEWPORT_FULL) {
(void)snprintf(line, sizeof(line), "GPU raison: %s",
(void)snprintf(line, sizeof(line), "GPU reason: %s",
resource->gpu_backend_reason);
draw_text(10, 4, columns - 6, line);
}
@ -662,7 +662,7 @@ draw_resources(
format_bytes(resource->ram_reserve_bytes, reserve);
format_bytes(resource->ram_reserved_bytes, reserved);
(void)snprintf(line, sizeof(line),
"RAM total %s | MemAvailable %s | réserve %s | réservée Task %s",
"RAM total %s | MemAvailable %s | reserve %s | Task reserved %s",
total, available, reserve, reserved);
draw_text(viewport == LARDON3D_TUI_VIEWPORT_FULL ? 11 : 8,
2, columns - 4, line);
@ -672,13 +672,13 @@ draw_resources(
format_bytes(resource->swap_used_bytes, swap_used);
if (resource->swap_delta_known) {
(void)snprintf(line, sizeof(line),
"Swap total %s | utilisé %s | delta in/out %llu/%llu pages",
"Swap total %s | used %s | delta in/out %llu/%llu pages",
swap_total, swap_used,
(unsigned long long)resource->swap_pages_in_delta,
(unsigned long long)resource->swap_pages_out_delta);
} else {
(void)snprintf(line, sizeof(line),
"Swap total %s | utilisé %s | delta in/out UNKNOWN",
"Swap total %s | used %s | delta in/out UNKNOWN",
swap_total, swap_used);
}
} else {
@ -702,7 +702,7 @@ draw_resources(
resource->helper_limit);
}
(void)snprintf(line, sizeof(line),
"Contrat: batch %s | inflight %s | helpers %s | I/O active/dispo %u/%u",
"Contract: batch %s | inflight %s | helpers %s | I/O active/available %u/%u",
batch, inflight, helpers, resource->io_active,
resource->io_available);
draw_text(14, 2, columns - 4, line);
@ -737,17 +737,17 @@ draw_resources(
external_swap_used);
}
(void)snprintf(line, sizeof(line),
"Governor SSD swap total/used %s/%s | identité %.120s",
"Governor SSD swap total/used %s/%s | identity %.120s",
external_swap_total, external_swap_used,
resource->external_storage_registered
? resource->external_storage_identity : "UNKNOWN");
draw_text(17, 2, columns - 4, line);
(void)snprintf(line, sizeof(line), "SSD raison: %.220s",
(void)snprintf(line, sizeof(line), "SSD reason: %.220s",
resource->external_storage_registered
? resource->external_storage_reason : "UNREGISTERED");
draw_text(18, 2, columns - 4, line);
draw_text(20, 2, columns - 4,
"Les choix CPU/GPU/batch sont observés; aucun réglage utilisateur normal.");
"CPU/GPU/batch choices are observed; no normal user tuning.");
}
}
@ -775,17 +775,17 @@ draw_ssd(
const Lardon3DSsdSnapshot *ssd = &runtime->ssd;
char line[640];
if (!runtime->ssd_controller_available) {
draw_text_style(4, 2, columns - 4, "Etat: UNKNOWN",
draw_text_style(4, 2, columns - 4, "State: UNKNOWN",
LARDON3D_TUI_SEMANTIC_WARNING, palette);
if (operation && operation->running) {
(void)snprintf(line, sizeof(line),
"Opération asynchrone: %s (ncurses reste réactif)",
"Asynchronous operation: %s (ncurses remains responsive)",
lardon3d_tui_ssd_action_name(operation->action));
draw_text_style(5, 2, columns - 4, line,
LARDON3D_TUI_SEMANTIC_WARNING, palette);
}
draw_text(7, 2, columns - 4,
"Contrôleur/télémétrie SSD indisponible; identité, swap, scratch et usage UNKNOWN.");
"SSD controller/telemetry unavailable; identity, swap, scratch and usage UNKNOWN.");
return;
}
bool telemetry_actionable = !operation
@ -802,7 +802,7 @@ draw_ssd(
/* The async owner is exact operation state, not inferred device state. It
* is the only way ENABLING can remain visible while the synchronous
* controller holds its mutex through bounded side-effect verification. */
(void)snprintf(line, sizeof(line), "Etat: %s%s",
(void)snprintf(line, sizeof(line), "State: %s%s",
lardon3d_ssd_state_name(displayed_state),
displayed_state == LARDON3D_SSD_SAFE_TO_UNPLUG
? " — SAFE TO UNPLUG" : "");
@ -810,7 +810,7 @@ draw_ssd(
ssd_semantic(displayed_state), palette);
if (operation && operation->running) {
(void)snprintf(line, sizeof(line),
"Opération asynchrone: %s (ncurses reste réactif)",
"Asynchronous operation: %s (ncurses remains responsive)",
lardon3d_tui_ssd_action_name(operation->action));
draw_text_style(5, 2, columns - 4, line,
LARDON3D_TUI_SEMANTIC_WARNING, palette);
@ -822,10 +822,10 @@ draw_ssd(
* booleans are observations. Rendering them as inactive/unmounted
* would turn validation failure into guessed physical state. */
draw_text_style(7, 2, columns - 4,
"UNKNOWN — télémétrie invalide: identité, lien, swap, scratch, mount et usage.",
"UNKNOWN — invalid telemetry: identity, link, swap, scratch, mount and usage.",
LARDON3D_TUI_SEMANTIC_ERROR, palette);
draw_text(9, 2, columns - 4,
"Contrôle F10 désactivé jusqu'à une observation bornée valide.");
"F10 control disabled until a valid bounded observation is available.");
return;
}
char link_speed[64];
@ -836,17 +836,17 @@ draw_ssd(
(void)snprintf(link_speed, sizeof(link_speed), "UNKNOWN");
}
(void)snprintf(line, sizeof(line),
"Modèle: %s | série: %s | lien: %s",
"Model: %s | serial: %s | link: %s",
ssd->model_known ? ssd->model : "UNKNOWN",
ssd->serial_known ? ssd->serial : "UNKNOWN",
link_speed);
draw_text_style(7, 2, columns - 4, line,
LARDON3D_TUI_SEMANTIC_SSD, palette);
(void)snprintf(line, sizeof(line), "Identité stable Drive: %s",
(void)snprintf(line, sizeof(line), "Stable Drive identity: %s",
ssd->drive_identity[0] ? ssd->drive_identity : "UNKNOWN");
draw_text(8, 2, columns - 4, line);
(void)snprintf(line, sizeof(line),
"Paire exacte: %s | swap UUID %s | scratch UUID %s",
"Exact pair: %s | swap UUID %s | scratch UUID %s",
ssd->pairing_valid ? "VALID" : "INVALID/UNKNOWN",
ssd->swap_uuid[0] ? ssd->swap_uuid : "UNKNOWN",
ssd->scratch_uuid[0] ? ssd->scratch_uuid : "UNKNOWN");
@ -861,7 +861,7 @@ draw_ssd(
format_bytes(ssd->swap_used_bytes, swap_used);
}
(void)snprintf(line, sizeof(line),
"Swap: %s | total %s | utilisé %s",
"Swap: %s | total %s | used %s",
ssd->swap_active ? "ACTIVE" : "INACTIVE",
swap_total, swap_used);
draw_text(10, 2, columns - 4, line);
@ -881,19 +881,19 @@ draw_ssd(
ssd->scratch_lease_count, ssd->scratch_lease_capacity);
draw_text(11, 2, columns - 4, line);
(void)snprintf(line, sizeof(line),
"Drain demandé: %s | raison: %s",
ssd->drain_requested ? "oui" : "non",
"Drain requested: %s | reason: %s",
ssd->drain_requested ? "yes" : "no",
ssd->reason[0] ? ssd->reason : "UNKNOWN");
draw_text_style(12, 2, columns - 4, line,
ssd->state == LARDON3D_SSD_ERROR
? LARDON3D_TUI_SEMANTIC_ERROR
: LARDON3D_TUI_SEMANTIC_NORMAL, palette);
draw_text(14, 2, columns - 4,
"F10 agit uniquement sur la paire Drive/UUID validée; jamais de format/repair/poweroff.");
"F10 acts only on the validated Drive/UUID pair; never format/repair/poweroff.");
draw_text(15, 2, columns - 4,
"Le swap/SSD reste une sécurité/scratch physique, jamais de la RAM scientifique.");
"Swap/SSD remains safety/physical scratch, never scientific RAM.");
} else {
(void)snprintf(line, sizeof(line), "Raison: %s",
(void)snprintf(line, sizeof(line), "Reason: %s",
ssd->reason[0] ? ssd->reason : "UNKNOWN");
draw_text_style(6, 2, columns - 4, line,
ssd->state == LARDON3D_SSD_ERROR
@ -904,7 +904,7 @@ draw_ssd(
ssd->swap_active ? "ACTIVE" : "INACTIVE",
ssd->scratch_mounted ? "MOUNTED" : "UNMOUNTED",
ssd->scratch_lease_count,
ssd->drain_requested ? "oui" : "non");
ssd->drain_requested ? "yes" : "no");
draw_text(10, 2, columns - 4, line);
}
}
@ -950,14 +950,14 @@ draw_optics(
if (!optics || !optics->project_bound) {
const char *message = optics && optics->message[0]
? optics->message
: "Aucun Project DB lié; aucun profil ou assignation n'est deviné.";
: "No Project DB bound; no profile or assignment is guessed.";
draw_text_style(5, 4, columns - 6, message,
optics && optics->message[0]
? LARDON3D_TUI_SEMANTIC_ERROR
: LARDON3D_TUI_SEMANTIC_WARNING, palette);
if (optics && optics->message[0]) {
draw_text(7, 4, columns - 6,
"R : réessayer explicitement la liaison Project DB.");
"R: explicitly retry Project DB binding.");
}
return;
}
@ -972,20 +972,20 @@ draw_optics(
? (optics->selected_configuration < optics->configuration_count
? optics->selected_configuration : 0) : 0;
(void)snprintf(line, sizeof(line),
"Body [%zu/%zu affichés%s]: %s %s — %s",
"Body [%zu/%zu shown%s]: %s %s — %s",
optics->body_count ? body + 1 : 0, optics->body_count,
optics->bodies_have_next ? ", suite" : "",
optics->bodies_have_next ? ", more" : "",
optics->body_count ? optics->bodies[body].manufacturer : "UNKNOWN",
optics->body_count ? optics->bodies[body].model : "",
optics->body_count ? optics->bodies[body].name : "aucun");
optics->body_count ? optics->bodies[body].name : "none");
draw_text(4, 2, columns - 4, line);
(void)snprintf(line, sizeof(line),
"Lens [%zu/%zu affichés%s]: %s %s — %s (%s)",
"Lens [%zu/%zu shown%s]: %s %s — %s (%s)",
optics->lens_count ? lens + 1 : 0, optics->lens_count,
optics->lenses_have_next ? ", suite" : "",
optics->lenses_have_next ? ", more" : "",
optics->lens_count ? optics->lenses[lens].manufacturer : "UNKNOWN",
optics->lens_count ? optics->lenses[lens].model : "",
optics->lens_count ? optics->lenses[lens].name : "aucun",
optics->lens_count ? optics->lenses[lens].name : "none",
optics->lens_count
? lens_interface_name(optics->lenses[lens].interface_kind)
: "UNKNOWN");
@ -999,24 +999,24 @@ draw_optics(
&optics->configurations[configuration];
if (selected->has_focal_length) {
(void)snprintf(line, sizeof(line),
"Config [%zu/%zu affichés%s] #%llu body #%llu lens #%llu focal %u µm",
"Config [%zu/%zu shown%s] #%llu body #%llu lens #%llu focal %u µm",
configuration + 1, optics->configuration_count,
optics->configurations_have_next ? ", suite" : "",
optics->configurations_have_next ? ", more" : "",
(unsigned long long)selected->optical_configuration_id,
(unsigned long long)selected->camera_body_profile_id,
(unsigned long long)selected->lens_profile_id,
selected->focal_length_um);
} else {
(void)snprintf(line, sizeof(line),
"Config [%zu/%zu affichés%s] #%llu body #%llu lens #%llu focal ABSENT",
"Config [%zu/%zu shown%s] #%llu body #%llu lens #%llu focal ABSENT",
configuration + 1, optics->configuration_count,
optics->configurations_have_next ? ", suite" : "",
optics->configurations_have_next ? ", more" : "",
(unsigned long long)selected->optical_configuration_id,
(unsigned long long)selected->camera_body_profile_id,
(unsigned long long)selected->lens_profile_id);
}
} else {
(void)snprintf(line, sizeof(line), "Config: aucune");
(void)snprintf(line, sizeof(line), "Config: none");
}
draw_text(6, 2, columns - 4, line);
if (optics->calibration_count > 0) {
@ -1026,15 +1026,15 @@ draw_optics(
const Lardon3DOpticalCalibrationProfile *calibration =
&optics->calibrations[selected];
(void)snprintf(line, sizeof(line),
"Pane %s | calibration [%zu/%zu affichées%s] #%llu %.28s v%u",
"Pane %s | calibration [%zu/%zu shown%s] #%llu %.28s v%u",
optics_pane_name(optics->active_pane), selected + 1,
optics->calibration_count,
optics->calibrations_have_next ? ", suite" : "",
optics->calibrations_have_next ? ", more" : "",
(unsigned long long)calibration->calibration_profile_id,
calibration->name, calibration->profile_version);
} else {
(void)snprintf(line, sizeof(line),
"Pane %s | calibration candidate: aucune",
"Pane %s | calibration candidate: none",
optics_pane_name(optics->active_pane));
}
draw_text(7, 2, columns - 4, line);
@ -1056,17 +1056,17 @@ draw_optics(
draw_text_style(8, 2, columns - 4, line, semantic, palette);
} else {
draw_text_style(8, 2, columns - 4,
"Capture: non inspecté (V); unresolved reste absence d'assignation.",
"Capture: not inspected (V); unresolved remains no assignment.",
LARDON3D_TUI_SEMANTIC_DIM, palette);
}
(void)snprintf(line, sizeof(line),
"Calibrations compatibles: %zu | sélection: %s",
"Compatible calibrations: %zu | selection: %s",
optics->calibration_count,
optics->capture_selection_found ? "explicite" : "aucune/ambiguë");
optics->capture_selection_found ? "explicit" : "none/ambiguous");
draw_text(9, 2, columns - 4, line);
if (optics->metadata_lookup_performed) {
(void)snprintf(line, sizeof(line),
"Métadonnées exactes: body %s | lens %s",
"Exact metadata: body %s | lens %s",
optics->metadata_body_found ? "MATCH" : "UNRESOLVED",
optics->metadata_lens_found ? "MATCH" : "UNRESOLVED");
draw_text(10, 2, columns - 4, line);
@ -1077,9 +1077,9 @@ draw_optics(
draw_text(13, 2, columns - 4,
"C config focal mm/? V inspect capture A assign capture G task:group");
draw_text(14, 2, columns - 4,
"K sélection calibration E metadata exact [ première page ] page suivante R retry");
"K select calibration E exact metadata [ first page ] next page R retry");
draw_text_style(16, 2, columns - 4,
"Immutable: modifier = créer une nouvelle version/configuration.",
"Immutable: modify = create a new version/configuration.",
LARDON3D_TUI_SEMANTIC_WARNING, palette);
}
}
@ -1092,24 +1092,24 @@ draw_help(
)
{
draw_text(4, 2, columns - 4,
"F1 aide, F2 projets, F3 import, F4 viewer futur, F5 tâches, F6 ressources,");
"F1 help, F2 projects, F3 import, F4 future viewer, F5 tasks, F6 resources,");
draw_text(5, 2, columns - 4,
"F7 profils optiques, F10 SSD; ESC accueil; Q quitter.");
"F7 optical profiles, F10 SSD; ESC home; Q quit.");
draw_text_style(7, 2, columns - 4,
"Vert=healthy, jaune=warning/throttled, rouge=error, cyan=GPU, bleu=CPU, magenta=SSD.",
"Green=healthy, yellow=warning/throttled, red=error, cyan=GPU, blue=CPU, magenta=SSD.",
LARDON3D_TUI_SEMANTIC_HEALTHY, palette);
draw_text(8, 2, columns - 4,
"Sans couleur/peu de paires, les libellés et bold/dim conservent le sens.");
"Without color/few color pairs, labels and bold/dim preserve meaning.");
if (viewport == LARDON3D_TUI_VIEWPORT_FULL) {
draw_text(10, 2, columns - 4,
"La TUI observe des snapshots bornés >=1s; aucun worker ne touche ncurses.");
"The TUI observes bounded snapshots >=1s; no worker touches ncurses.");
draw_text(11, 2, columns - 4,
"Le Governor choisit CPU/GPU/batch. La TUI ne modifie ni admission ni science.");
"The Governor selects CPU/GPU/batch. The TUI changes neither admission nor science.");
draw_text(12, 2, columns - 4,
"Dense (future) reste NOT_APPLICABLE; aucune étape future n'est RUNNING.");
"Dense (future) remains NOT_APPLICABLE; no future stage is RUNNING.");
} else {
draw_text(10, 2, columns - 4,
"Governor choisit les ressources; Dense future reste NOT_APPLICABLE.");
"Governor selects resources; future Dense remains NOT_APPLICABLE.");
}
}
@ -1170,7 +1170,7 @@ lardon3d_layout_draw_runtime(
break;
case LARDON3D_SCREEN_VIEWER:
draw_text_style(6, 4, columns - 8,
"Viewer Vulkan: PLANNED, aucun travail scientifique actif.",
"Vulkan viewer: PLANNED, no active scientific work.",
LARDON3D_TUI_SEMANTIC_DIM, palette);
break;
case LARDON3D_SCREEN_HOME:

80
src/project.c
View file

@ -58,7 +58,7 @@ static void set_database_status(Lardon3DAppState *state, Lardon3DProjectDb *data
} else if (open_error) {
(void)snprintf(detail, sizeof(detail), "%s", open_error);
}
(void)snprintf(state->status_message, sizeof(state->status_message), "Erreur project.db : %.220s",
(void)snprintf(state->status_message, sizeof(state->status_message), "project.db error: %.220s",
detail[0] ? detail : fallback);
}
@ -72,7 +72,7 @@ static void clear_catalog(Lardon3DAppState *state) {
static bool normalize_name(Lardon3DAppState *state, const char *input, char *output,
size_t output_size) {
if (!input) {
set_status(state, "Erreur : le nom du projet est vide.");
set_status(state, "Error: project name is empty.");
return false;
}
@ -88,21 +88,21 @@ static bool normalize_name(Lardon3DAppState *state, const char *input, char *out
size_t length = (size_t)(end - start);
if (length == 0) {
set_status(state, "Erreur : le nom du projet est vide.");
set_status(state, "Error: project name is empty.");
return false;
}
if (length >= output_size) {
set_status(state, "Erreur : le nom du projet est trop long.");
set_status(state, "Error: project name is too long.");
return false;
}
if ((length == 1 && start[0] == '.') || (length == 2 && start[0] == '.' && start[1] == '.')) {
set_status(state, "Erreur : nom de projet interdit.");
set_status(state, "Error: forbidden project name.");
return false;
}
for (const char *character = start; character < end; ++character) {
if (*character == '/' || *character == '\\' || iscntrl((unsigned char)*character)) {
set_status(state, "Erreur : nom de projet interdit.");
set_status(state, "Error: forbidden project name.");
return false;
}
}
@ -153,19 +153,19 @@ static bool resolve_projects_root(Lardon3DAppState *state, char root[PATH_MAX])
const char *configured = getenv("LARDON3D_PROJECTS_ROOT");
if (configured && configured[0]) {
if (configured[0] != '/' || !copy_path(root, PATH_MAX, configured)) {
set_status(state, "Erreur : répertoire racine invalide.");
set_status(state, "Error: invalid project root directory.");
return false;
}
} else {
const char *home = getenv("HOME");
if (!home || home[0] != '/') {
set_status(state, "Erreur : HOME est absent ou invalide.");
set_status(state, "Error: HOME is missing or invalid.");
return false;
}
int written = snprintf(root, PATH_MAX, "%s/Documents/Lardon/Projets3D", home);
if (written < 0 || (size_t)written >= PATH_MAX) {
set_status(state, "Erreur : chemin racine trop long.");
set_status(state, "Error: root path is too long.");
return false;
}
}
@ -189,22 +189,22 @@ static bool ensure_directory(Lardon3DAppState *state, const char *path,
struct stat info;
if (lstat(path, &info) == 0) {
if (!S_ISDIR(info.st_mode)) {
set_status(state, "Erreur : un élément du chemin n'est pas un dossier.");
set_status(state, "Error: a path component is not a directory.");
return false;
}
return true;
}
if (errno != ENOENT || created->count >= MAX_CREATED_DIRECTORIES) {
set_status(state, "Erreur : impossible de préparer le répertoire racine.");
set_status(state, "Error: unable to prepare the root directory.");
return false;
}
if (mkdir(path, 0755) != 0) {
set_status(state, "Erreur : impossible de créer un dossier.");
set_status(state, "Error: unable to create a directory.");
return false;
}
if (!copy_path(created->paths[created->count], sizeof(created->paths[created->count]), path)) {
(void)rmdir(path);
set_status(state, "Erreur : chemin de dossier trop long.");
set_status(state, "Error: directory path is too long.");
return false;
}
++created->count;
@ -215,7 +215,7 @@ static bool ensure_directory_tree(Lardon3DAppState *state, const char *path,
CreatedDirectories *created) {
char partial[PATH_MAX];
if (!copy_path(partial, sizeof(partial), path)) {
set_status(state, "Erreur : chemin racine trop long.");
set_status(state, "Error: root path is too long.");
return false;
}
@ -239,13 +239,13 @@ static bool write_project_ini(Lardon3DAppState *state, const char *project_path,
char final_path[PATH_MAX];
if (!join_path(final_path, sizeof(final_path), project_path, "project.ini") ||
!join_path(temporary_path, sizeof(temporary_path), project_path, ".project.ini.tmp.XXXXXX")) {
set_status(state, "Erreur : chemin de project.ini trop long.");
set_status(state, "Error: project.ini path is too long.");
return false;
}
int descriptor = mkstemp(temporary_path);
if (descriptor < 0) {
set_status(state, "Erreur : impossible de créer project.ini.");
set_status(state, "Error: unable to create project.ini.");
return false;
}
@ -253,7 +253,7 @@ static bool write_project_ini(Lardon3DAppState *state, const char *project_path,
if (!file) {
(void)close(descriptor);
(void)unlink(temporary_path);
set_status(state, "Erreur : impossible d'écrire project.ini.");
set_status(state, "Error: unable to write project.ini.");
return false;
}
@ -273,7 +273,7 @@ static bool write_project_ini(Lardon3DAppState *state, const char *project_path,
}
if (!success) {
(void)unlink(temporary_path);
set_status(state, "Erreur : impossible d'écrire project.ini.");
set_status(state, "Error: unable to write project.ini.");
}
return success;
}
@ -283,7 +283,7 @@ bool lardon3d_project_create(Lardon3DAppState *state, const char *name) {
return false;
}
if (state->project_loaded || state->project_db) {
set_status(state, "Erreur : un projet est déjà ouvert.");
set_status(state, "Error: a project is already open.");
return false;
}
@ -298,11 +298,11 @@ bool lardon3d_project_create(Lardon3DAppState *state, const char *name) {
return false;
}
if (!generate_stable_id(stable_id)) {
set_status(state, "Erreur : impossible de créer l'identité du projet.");
set_status(state, "Error: unable to create project identity.");
return false;
}
if (!join_path(project_path, sizeof(project_path), root, normalized_name)) {
set_status(state, "Erreur : chemin du projet trop long.");
set_status(state, "Error: project path is too long.");
return false;
}
@ -315,7 +315,7 @@ bool lardon3d_project_create(Lardon3DAppState *state, const char *name) {
struct stat info;
if (lstat(project_path, &info) == 0 || errno != ENOENT) {
cleanup_directories(&created);
set_status(state, "Erreur : ce projet existe déjà.");
set_status(state, "Error: this project already exists.");
return false;
}
if (!ensure_directory(state, project_path, &created)) {
@ -329,7 +329,7 @@ bool lardon3d_project_create(Lardon3DAppState *state, const char *name) {
for (size_t index = 0; index < sizeof(subdirectories) / sizeof(subdirectories[0]); ++index) {
char path[PATH_MAX];
if (!join_path(path, sizeof(path), project_path, subdirectories[index])) {
set_status(state, "Erreur : chemin de dossier trop long.");
set_status(state, "Error: directory path is too long.");
cleanup_directories(&created);
return false;
}
@ -349,7 +349,7 @@ bool lardon3d_project_create(Lardon3DAppState *state, const char *name) {
if (!join_path(database_path, sizeof(database_path), project_path, "project.db") ||
!join_path(ini_path, sizeof(ini_path), project_path, "project.ini")) {
cleanup_directories(&created);
set_status(state, "Erreur : chemin de base projet trop long.");
set_status(state, "Error: project database path is too long.");
return false;
}
Lardon3DProjectDb *database = NULL;
@ -384,7 +384,7 @@ bool lardon3d_project_create(Lardon3DAppState *state, const char *name) {
(void)copy_path(state->project_name, sizeof(state->project_name), normalized_name);
(void)copy_path(state->project_path, sizeof(state->project_path), project_path);
(void)snprintf(state->project_stable_id, sizeof(state->project_stable_id), "%s", stable_id);
(void)snprintf(state->status_message, sizeof(state->status_message), "Projet créé : %s",
(void)snprintf(state->status_message, sizeof(state->status_message), "Project created: %s",
state->project_name);
return true;
}
@ -392,21 +392,21 @@ bool lardon3d_project_create(Lardon3DAppState *state, const char *name) {
static bool read_project_ini(Lardon3DAppState *state, const char *path, ProjectMetadata *metadata) {
int descriptor = open(path, O_RDONLY | O_NOFOLLOW);
if (descriptor < 0) {
set_status(state, "Erreur : project.ini est absent ou inaccessible.");
set_status(state, "Error: project.ini is missing or inaccessible.");
return false;
}
struct stat info;
if (fstat(descriptor, &info) != 0 || !S_ISREG(info.st_mode)) {
(void)close(descriptor);
set_status(state, "Erreur : project.ini n'est pas un fichier régulier.");
set_status(state, "Error: project.ini is not a regular file.");
return false;
}
FILE *file = fdopen(descriptor, "r");
if (!file) {
(void)close(descriptor);
set_status(state, "Erreur : impossible de lire project.ini.");
set_status(state, "Error: unable to read project.ini.");
return false;
}
@ -483,7 +483,7 @@ static bool read_project_ini(Lardon3DAppState *state, const char *path, ProjectM
}
if (!valid || !section_found || !name_found || !version_found ||
(metadata->version == 2 && !stable_id_found) || (metadata->version == 1 && stable_id_found)) {
set_status(state, "Erreur : project.ini invalide.");
set_status(state, "Error: invalid project.ini.");
return false;
}
return true;
@ -494,7 +494,7 @@ bool lardon3d_project_open(Lardon3DAppState *state, const char *directory_name)
return false;
}
if (state->project_loaded || state->project_db) {
set_status(state, "Erreur : un projet est déjà ouvert.");
set_status(state, "Error: a project is already open.");
return false;
}
@ -512,13 +512,13 @@ bool lardon3d_project_open(Lardon3DAppState *state, const char *directory_name)
if (!join_path(project_path, sizeof(project_path), root, normalized_directory) ||
!join_path(ini_path, sizeof(ini_path), project_path, "project.ini") ||
!join_path(database_path, sizeof(database_path), project_path, "project.db")) {
set_status(state, "Erreur : chemin du projet trop long.");
set_status(state, "Error: project path is too long.");
return false;
}
struct stat info;
if (lstat(project_path, &info) != 0 || !S_ISDIR(info.st_mode)) {
set_status(state, "Erreur : dossier projet absent ou invalide.");
set_status(state, "Error: project directory is missing or invalid.");
return false;
}
@ -530,12 +530,12 @@ bool lardon3d_project_open(Lardon3DAppState *state, const char *directory_name)
bool database_existed = false;
if (lstat(database_path, &info) == 0) {
if (!S_ISREG(info.st_mode)) {
set_status(state, "Erreur : project.db n'est pas un fichier régulier.");
set_status(state, "Error: project.db is not a regular file.");
return false;
}
database_existed = true;
} else if (errno != ENOENT) {
set_status(state, "Erreur : project.db est inaccessible.");
set_status(state, "Error: project.db is inaccessible.");
return false;
}
@ -606,7 +606,7 @@ bool lardon3d_project_open(Lardon3DAppState *state, const char *directory_name)
}
if (database_result != LARDON3D_PROJECT_DB_OK) {
if (database_result == LARDON3D_PROJECT_DB_CONSTRAINT) {
set_status(state, "Erreur : identité project.ini/project.db incohérente.");
set_status(state, "Error: inconsistent project.ini/project.db identity.");
} else {
set_database_status(state, database, database_error, "initialisation impossible");
}
@ -631,11 +631,11 @@ bool lardon3d_project_open(Lardon3DAppState *state, const char *directory_name)
(void)lardon3d_project_resume_recoverable_tasks(state, lardon3d_task_kind_registry_production(),
&summary);
(void)snprintf(state->status_message, sizeof(state->status_message),
"Projet ouvert — %zu tâche(s) reprise(s), %zu ignorée(s), %zu en échec%s.",
"Project opened — %zu task(s) resumed, %zu skipped, %zu failed%s.",
summary.resumed, summary.skipped, summary.failed,
summary.queue_full ? ", fenêtre de reprise saturée" : "");
summary.queue_full ? ", recovery window saturated" : "");
} else {
(void)snprintf(state->status_message, sizeof(state->status_message), "Projet ouvert : %s",
(void)snprintf(state->status_message, sizeof(state->status_message), "Project opened: %s",
state->project_name);
}
return true;
@ -647,7 +647,7 @@ void lardon3d_project_close(Lardon3DAppState *state) {
}
if (!state->project_loaded) {
set_status(state, "Aucun projet à fermer.");
set_status(state, "No project to close.");
return;
}
@ -659,7 +659,7 @@ void lardon3d_project_close(Lardon3DAppState *state) {
state->project_path[0] = '\0';
state->project_stable_id[0] = '\0';
store_recovery_summary(state, NULL);
set_status(state, "Projet fermé.");
set_status(state, "Project closed.");
}
static bool checkpoint_paths(const Lardon3DAppState *state, uint64_t task_id,

2
src/runtime_session.c
View file

@ -28,7 +28,7 @@ lardon3d_runtime_project_boundary(
if (!state->task_queue) {
(void)snprintf(state->status_message,
sizeof(state->status_message),
"Erreur : impossible de recréer la file de tâches.");
"Error: unable to recreate the task queue.");
return false;
}
return true;

68
src/tui.c
View file

@ -126,7 +126,7 @@ reload_catalog(Lardon3DAppState *state, bool announce_success)
(void)snprintf(
state->status_message,
sizeof(state->status_message),
"Erreur : impossible de construire la vue des images."
"Error: unable to build the image view."
);
lardon3d_image_view_destroy(state->image_view);
state->image_view = NULL;
@ -165,7 +165,7 @@ reload_catalog(Lardon3DAppState *state, bool announce_success)
(void)snprintf(
state->status_message,
sizeof(state->status_message),
"Catalogue rechargé : %zu image%s.",
"Catalog reloaded: %zu image%s.",
lardon3d_image_view_count(state->image_view),
lardon3d_image_view_count(state->image_view) == 1 ? "" : "s"
);
@ -212,7 +212,7 @@ reset_project_session(Lardon3DAppState *state, TuiRuntime *runtime)
if (!runtime->observer) {
(void)snprintf(state->status_message,
sizeof(state->status_message),
"Erreur : impossible de recréer l'observateur runtime.");
"Error: unable to recreate the runtime observer.");
runtime->fatal_error = true;
state->running = false;
return false;
@ -231,17 +231,17 @@ input_label(InputMode mode)
case INPUT_IMPORT_DIRECTORY:
return "Dossier source :";
case INPUT_IMAGE_FILTER:
return "Filtre :";
return "Filter:";
case INPUT_OPTICS_CREATE_BODY:
return "Body immutable: manufacturer|model|name";
case INPUT_OPTICS_CREATE_LENS:
return "Lens: interface|range|min_mm|max_mm|maker|model|name";
case INPUT_OPTICS_CREATE_CONFIGURATION:
return "Focale entière mm, ou ? pour absence explicite";
return "Integer focal length in mm, or ? for explicit absence";
case INPUT_OPTICS_INSPECT_CAPTURE:
return "Capture ID à inspecter :";
return "Capture ID to inspect:";
case INPUT_OPTICS_ASSIGN_CAPTURE:
return "Capture ID à assigner :";
return "Capture ID to assign:";
case INPUT_OPTICS_ASSIGN_GROUP:
return "Campaign Task ID:group ID :";
case INPUT_OPTICS_LOOKUP_METADATA:
@ -477,7 +477,7 @@ complete_optics_input(
if (!runtime->optics_database) {
(void)snprintf(state->status_message, sizeof(state->status_message),
"Aucun Project DB lié; aucune identité optique n'est devinée.");
"No Project DB bound; no optical identity is guessed.");
input->mode = INPUT_NONE;
return false;
}
@ -533,7 +533,7 @@ complete_optics_input(
} else {
(void)snprintf(state->status_message,
sizeof(state->status_message),
"Focale invalide: entier positif en millimètres ou ?.");
"Invalid focal length: positive integer in millimetres or ?.");
}
} else if (input->mode == INPUT_OPTICS_INSPECT_CAPTURE
|| input->mode == INPUT_OPTICS_ASSIGN_CAPTURE) {
@ -577,7 +577,7 @@ complete_optics_input(
} else {
(void)snprintf(state->status_message,
sizeof(state->status_message),
"Format métadonnées invalide: make|model|lens_make|lens_model.");
"Invalid metadata format: make|model|lens_make|lens_model.");
}
}
if (model_called) {
@ -601,7 +601,7 @@ start_import_task(
(void)snprintf(
state->status_message,
sizeof(state->status_message),
"Erreur : impossible de créer la tâche d'import."
"Error: unable to create the import task."
);
input->mode = INPUT_NONE;
return false;
@ -652,15 +652,15 @@ handle_active_input(
}
if (key == 27) {
const char *message = "Création du projet annulée.";
const char *message = "Project creation cancelled.";
if (input->mode == INPUT_PROJECT_OPEN) {
message = "Ouverture du projet annulée.";
message = "Project opening cancelled.";
} else if (input->mode == INPUT_IMPORT_DIRECTORY) {
message = "Import annulé.";
message = "Import cancelled.";
} else if (input->mode == INPUT_IMAGE_FILTER) {
message = "Filtre annulé.";
message = "Filter cancelled.";
} else if (is_optics_input(input->mode)) {
message = "Opération optique annulée.";
message = "Optics operation cancelled.";
}
input->mode = INPUT_NONE;
(void)snprintf(
@ -695,13 +695,13 @@ handle_active_input(
(void)snprintf(
state->status_message,
sizeof(state->status_message),
"Aucune image ne correspond au filtre."
"No image matches the filter."
);
} else {
(void)snprintf(
state->status_message,
sizeof(state->status_message),
"Filtre appliqué : %.230s",
"Filter applied: %.230s",
input->text
);
}
@ -742,7 +742,7 @@ handle_active_input(
(void)snprintf(
state->status_message,
sizeof(state->status_message),
"Erreur : filtre trop long."
"Error: filter is too long."
);
return true;
}
@ -750,7 +750,7 @@ handle_active_input(
(void)snprintf(
state->status_message,
sizeof(state->status_message),
"Erreur : saisie optique trop longue."
"Error: optics input is too long."
);
input->mode = INPUT_NONE;
input->text[0] = '\0';
@ -766,7 +766,7 @@ handle_active_input(
(void)snprintf(
state->status_message,
sizeof(state->status_message),
"Erreur : chemin source trop long."
"Error: source path is too long."
);
} else {
if (reset_project_session(state, runtime)
@ -810,7 +810,7 @@ handle_ssd_key(
if (!runtime->ssd_operation) {
(void)snprintf(state->status_message,
sizeof(state->status_message),
"Contrôleur SSD indisponible; état UNKNOWN, aucune action.");
"SSD controller unavailable; state UNKNOWN, no action.");
return true;
}
(void)lardon3d_tui_ssd_async_poll(
@ -818,7 +818,7 @@ handle_ssd_key(
if (runtime->ssd_operation_snapshot.running) {
(void)snprintf(state->status_message,
sizeof(state->status_message),
"Opération SSD %s déjà en cours.",
"SSD operation %s already running.",
lardon3d_tui_ssd_action_name(
runtime->ssd_operation_snapshot.action));
return true;
@ -827,7 +827,7 @@ handle_ssd_key(
|| !runtime->ssd_operation_snapshot.controller_snapshot_actionable) {
(void)snprintf(state->status_message,
sizeof(state->status_message),
"Télémétrie SSD indéterminée/invalide; contrôle désactivé.");
"SSD telemetry unknown/invalid; control disabled.");
return true;
}
Lardon3DTuiSsdAction action;
@ -836,18 +836,18 @@ handle_ssd_key(
if (!lardon3d_tui_ssd_action_for_snapshot(current, &action)) {
(void)snprintf(state->status_message,
sizeof(state->status_message),
"Aucune transition SSD sûre depuis %s.",
"No safe SSD transition from %s.",
lardon3d_ssd_state_name(current->state));
return true;
}
if (!lardon3d_tui_ssd_async_request(runtime->ssd_operation, action)) {
(void)snprintf(state->status_message,
sizeof(state->status_message),
"Impossible de lancer l'opération SSD bornée.");
"Unable to start the bounded SSD operation.");
return true;
}
(void)snprintf(state->status_message, sizeof(state->status_message),
"SSD %s lancé hors du thread ncurses.",
"SSD %s started outside the ncurses thread.",
lardon3d_tui_ssd_action_name(action));
return true;
}
@ -885,15 +885,15 @@ handle_task_key(
operation = "reprise";
result = lardon3d_task_queue_resume(state->task_queue, task_id);
} else if (key == 'c' || key == 'C') {
operation = "annulation";
operation = "cancellation";
result = lardon3d_task_queue_cancel(state->task_queue, task_id);
}
if (!operation) {
return false;
}
(void)snprintf(state->status_message, sizeof(state->status_message),
"Tâche #%llu: %s %s.", (unsigned long long)task_id,
operation, result ? "demandée" : "refusée/indisponible");
"Task #%llu: %s %s.", (unsigned long long)task_id,
operation, result ? "requested" : "rejected/unavailable");
return true;
}
@ -967,7 +967,7 @@ handle_normal_input(
(void)snprintf(
state->status_message,
sizeof(state->status_message),
"Quitter est désactivé pendant l'import."
"Quit is disabled during import."
);
} else if (key == 27) {
(void)snprintf(
@ -1129,7 +1129,7 @@ handle_normal_input(
(void)snprintf(
state->status_message,
sizeof(state->status_message),
"Aucun projet chargé."
"No project loaded."
);
return true;
}
@ -1148,7 +1148,7 @@ handle_normal_input(
(void)snprintf(
state->status_message,
sizeof(state->status_message),
"Aucun projet chargé."
"No project loaded."
);
} else {
(void)reload_catalog(state, true);
@ -1203,7 +1203,7 @@ handle_normal_input(
(void)snprintf(
state->status_message,
sizeof(state->status_message),
"Filtre effacé."
"Filter cleared."
);
}
return true;

2
tests/test_image_catalog.c
View file

@ -175,7 +175,7 @@ run_test(void)
);
CHECK(catalog);
CHECK(lardon3d_image_catalog_count(catalog) == 0);
CHECK(strcmp(error, "Aucune image importée.") == 0);
CHECK(strcmp(error, "No imported image.") == 0);
CHECK(lardon3d_image_catalog_get(catalog, 0) == NULL);
lardon3d_image_catalog_destroy(catalog);
lardon3d_image_catalog_destroy(NULL);

4
tests/test_match_result.c
View file

@ -54,7 +54,9 @@ static bool create_v9_database(const char *path) {
static const char sql[] =
"PRAGMA foreign_keys=OFF;BEGIN IMMEDIATE;"
/* This database is a true v9 fixture, not a current database whose
metadata alone was relabelled while additive v20-v23 objects survived. */
metadata alone was relabelled while additive v20-v25 objects survived. */
"DROP TABLE IF EXISTS feature_extract_batch_tasks;"
"DROP TABLE IF EXISTS raw_development_batch_tasks;"
"DROP TABLE IF EXISTS capture_calibration_selections;"
"DROP TABLE IF EXISTS optical_calibration_profiles;"
"DROP TABLE IF EXISTS capture_optical_configurations;"

10
tests/test_matcher_task.c
View file

@ -360,6 +360,16 @@ static bool downgrade_project_to_historical_v10(const char *database_path) {
}
static const char sql[] =
"PRAGMA foreign_keys=OFF;BEGIN IMMEDIATE;"
"DROP TABLE IF EXISTS feature_extract_batch_tasks;"
"DROP TABLE IF EXISTS raw_development_batch_tasks;"
"DROP TABLE IF EXISTS selected_execution_items;"
"DROP TABLE IF EXISTS selected_executions;"
"DROP TABLE IF EXISTS raw_development_tasks;"
"DROP TABLE IF EXISTS capture_source_assets;"
"DROP TABLE IF EXISTS photo_quality_triage_results;"
"DROP TABLE IF EXISTS photo_quality_triage_tasks;"
"DROP TABLE IF EXISTS acquisition_campaign_captures;"
"DROP TABLE IF EXISTS acquisition_campaign_tasks;"
"DROP TABLE IF EXISTS capture_calibration_selections;"
"DROP TABLE IF EXISTS optical_calibration_profiles;"
"DROP TABLE IF EXISTS capture_optical_configurations;"

1
tests/test_optical_profiles.c
View file

@ -1147,6 +1147,7 @@ static bool downgrade_to_v22_fixture(const char *path) {
return raw_sql(
path,
"PRAGMA foreign_keys=OFF;BEGIN IMMEDIATE;"
"DROP TABLE IF EXISTS feature_extract_batch_tasks;"
"DROP TABLE raw_development_batch_tasks;"
"DROP TABLE capture_calibration_selections;"
"DROP TABLE optical_calibration_profiles;"

2
tests/test_project.c
View file

@ -338,7 +338,7 @@ run_test(void)
CHECK(write_ini(ini_path, "Projet Cycle", "A0000000000000000000000000000000", 2));
CHECK(!lardon3d_project_open(&state, "Projet Cycle"));
CHECK(!state.project_loaded && !state.project_db);
CHECK(strstr(state.status_message, "project.ini invalide") != NULL);
CHECK(strstr(state.status_message, "invalid project.ini") != NULL);
CHECK(write_ini(ini_path, "Projet Cycle", "", 1));
CHECK(lardon3d_project_open(&state, "Projet Cycle"));
CHECK(strcmp(state.project_stable_id, stable_id) == 0);

34
tests/test_tui_layout.c
View file

@ -303,7 +303,7 @@ run_test(void)
&operation, &optics, 0, &palette,
LARDON3D_TUI_INTERACTION_IDLE, 30, 100);
CHECK(row_contains(16, 100, "Governor SSD IN_USE"));
CHECK(row_contains(16, 100, "alloc non"));
CHECK(row_contains(16, 100, "alloc no"));
CHECK(row_contains(16, 100, "leases 2"));
CHECK(row_contains(17, 100, "swap total/used"));
CHECK(resizeterm(15, 60) == OK);
@ -370,15 +370,15 @@ run_test(void)
lardon3d_layout_draw_runtime(&state, "project", "name", NULL, &runtime,
&operation, &optics, 0, &palette,
LARDON3D_TUI_INTERACTION_TEXT_INPUT, 30, 100);
CHECK(row_contains(28, 100, "Enter valider"));
CHECK(row_contains(28, 100, "ESC annuler"));
CHECK(!row_contains(28, 100, "Q quitter"));
CHECK(row_contains(28, 100, "Enter confirm"));
CHECK(row_contains(28, 100, "ESC cancel"));
CHECK(!row_contains(28, 100, "Q quit"));
CHECK(resizeterm(15, 60) == OK);
lardon3d_layout_draw_runtime(&state, "project", "name", NULL, &runtime,
&operation, &optics, 0, &palette,
LARDON3D_TUI_INTERACTION_TEXT_INPUT, 15, 60);
CHECK(row_contains(13, 60, "F10 SSD"));
CHECK(row_contains(13, 60, "Enter valider"));
CHECK(row_contains(13, 60, "Enter confirm"));
state.screen = LARDON3D_SCREEN_IMPORT;
Lardon3DImportTaskSnapshot import = {
@ -390,15 +390,15 @@ run_test(void)
lardon3d_layout_draw_runtime(&state, NULL, "", &import, &runtime,
&operation, &optics, 0, &palette,
LARDON3D_TUI_INTERACTION_IMPORT_RUNNING, 30, 100);
CHECK(row_contains(28, 100, "X annuler l'import"));
CHECK(row_contains(28, 100, "X cancel import"));
CHECK(row_contains(28, 100, "Q/ESC"));
CHECK(row_contains(9, 100, "X : annuler"));
CHECK(row_contains(9, 100, "X: cancel"));
CHECK(resizeterm(15, 60) == OK);
lardon3d_layout_draw_runtime(&state, NULL, "", &import, &runtime,
&operation, &optics, 0, &palette,
LARDON3D_TUI_INTERACTION_IMPORT_RUNNING, 15, 60);
CHECK(row_contains(13, 60, "F10 SSD"));
CHECK(row_contains(13, 60, "X annuler"));
CHECK(row_contains(13, 60, "X cancel"));
state.screen = LARDON3D_SCREEN_TASKS;
CHECK(resizeterm(30, 100) == OK);
@ -426,8 +426,8 @@ run_test(void)
lardon3d_layout_draw_runtime(&state, NULL, "", NULL, &runtime,
&operation, &optics, 0, &palette, LARDON3D_TUI_INTERACTION_IDLE,
30, 100);
CHECK(screen_contains(30, 100, "Progression scientifique"));
CHECK(!screen_contains(30, 100, "Progression runtime"));
CHECK(screen_contains(30, 100, "Scientific progress"));
CHECK(!screen_contains(30, 100, "Runtime progress"));
state.screen = LARDON3D_SCREEN_HOME;
runtime.active_task_known = true;
@ -448,7 +448,7 @@ run_test(void)
&operation, &optics, 0, &palette, LARDON3D_TUI_INTERACTION_IDLE,
30, 100);
CHECK(screen_contains(30, 100, "2.5%/s"));
CHECK(!screen_contains(30, 100, "2.5 unité/s"));
CHECK(!screen_contains(30, 100, "2.5 unit/s"));
state.screen = LARDON3D_SCREEN_OPTICS;
optics = (Lardon3DTuiOpticsSnapshot) {0};
@ -474,10 +474,10 @@ run_test(void)
lardon3d_layout_draw_runtime(&state, NULL, "", NULL, &runtime,
&operation, &optics, 0, &palette, LARDON3D_TUI_INTERACTION_IDLE,
30, 100);
CHECK(screen_contains(30, 100, "1/16 affich"));
CHECK(screen_contains(30, 100, ", suite"));
CHECK(screen_contains(30, 100, "[ premi"));
CHECK(screen_contains(30, 100, "] page suivante"));
CHECK(screen_contains(30, 100, "1/16 shown"));
CHECK(screen_contains(30, 100, ", more"));
CHECK(screen_contains(30, 100, "[ first"));
CHECK(screen_contains(30, 100, "] next page"));
/* The legacy symbol accepts only baseline-sized objects. This call also
* proves a NULL task array with a nonzero count is safely treated empty. */
@ -494,7 +494,7 @@ run_test(void)
CHECK(screen_contains(30, 100, "#55"));
lardon3d_layout_draw(&state, NULL, "", NULL, NULL, 1,
&legacy_summary, &legacy_resources, 30, 100);
CHECK(screen_contains(30, 100, "Aucune t"));
CHECK(screen_contains(30, 100, "No retained"));
CHECK(resizeterm(14, 59) == OK);
lardon3d_layout_draw_runtime(&state, NULL, "", NULL, &runtime,
@ -502,7 +502,7 @@ run_test(void)
14, 59);
char line[60] = {0};
CHECK(mvwinnstr(stdscr, 7, 0, line, 59) != ERR);
CHECK(strstr(line, "Terminal trop petit") != NULL);
CHECK(strstr(line, "Terminal too small") != NULL);
(void)endwin();
delscreen(screen);