From fca5a4be4a52a57b15d81c32ec87f622e8bd663f Mon Sep 17 00:00:00 2001 From: Matthew Ball <13823657+matthewrball@users.noreply.github.com> Date: Wed, 11 Nov 2026 02:20:35 -0800 Subject: [PATCH] Agent: give the Quit prompt the Editorial redesign --- apps/maple-agent/app/locales/de/app.ftl | 44 ++- apps/maple-agent/app/locales/en/app.ftl | 44 ++- apps/maple-agent/app/locales/es/app.ftl | 44 ++- apps/maple-agent/app/src/desktop.rs | 280 ++++++++++++++---- .../app/translation-revisions/de.txt | 12 +- .../app/translation-revisions/es.txt | 12 +- 6 files changed, 365 insertions(+), 71 deletions(-) diff --git a/apps/maple-agent/app/locales/de/app.ftl b/apps/maple-agent/app/locales/de/app.ftl index c92284593..967e6a6bf 100644 --- a/apps/maple-agent/app/locales/de/app.ftl +++ b/apps/maple-agent/app/locales/de/app.ftl @@ -1336,8 +1336,8 @@ native-installed = Update installiert native-restart = Maple neu starten native-keep-open = Geöffnet lassen native-retry-quit = Beenden erneut versuchen -native-stop-title = Maple-Host dieses Computers stoppen? -native-still-open = Maple ist noch geöffnet +native-stop-title = Läuft noch… +native-still-open = Noch geöffnet. native-unknown-activity = Der Host konnte seine Aktivität nicht melden. Beim Beenden wird versucht, verbundene Editoren, Aufgaben und Fernverbindungen zu stoppen und darauf zu warten, dass der Host die lokalen Daten freigibt. native-keep-open-title = Maple geöffnet lassen? native-no-tray = Dieser Desktop hat keinen verfügbaren Infobereich, um Maple erneut zu öffnen. Lass dieses Fenster geöffnet, solange Maple lokale Daten entsperrt hält, oder beende Maple, um seinen Host zu stoppen. @@ -1366,8 +1366,44 @@ native-stop-unavailable = Maple kann das Stoppen seines Hosts nicht erneut versu native-stop-failed = Maple konnte seinen Host nicht vollständig stoppen: { $error }. Lass dieses Fenster geöffnet und versuche erneut, den Host zu stoppen, bevor du Maple neu startest. # $error is an external diagnostic, preserved verbatim. native-restart-failed = Maple konnte nicht neu gestartet werden: { $error } -# Counts of $tasks running tasks, $editors attached editors, $controllers remote controllers, $jobs background jobs and $requests API requests. -native-quit-activity = Beim Beenden werden laufende Aufgaben ({ $tasks }), verbundene Editoren ({ $editors }), Fernsteuerungen ({ $controllers }) und Hintergrundaufträge ({ $jobs }) gestoppt. Auch die lokale API dieses Computers und ihre aktiven Anfragen ({ $requests }) werden gestoppt. Maple wartet auf deren Abschluss, bevor es sich schließt. +# $count running tasks for the Quit prompt. +native-quit-item-tasks = { $count } laufende { $count -> + [one] Aufgabe + *[other] Aufgaben +} +# $count attached editors for the Quit prompt. +native-quit-item-editors = { $count -> + [one] { $count } verbundener Editor + *[other] { $count } verbundene Editoren +} +# $count remote controllers for the Quit prompt. +native-quit-item-controllers = { $count } { $count -> + [one] Fernsteuerung + *[other] Fernsteuerungen +} +# $count background jobs for the Quit prompt. +native-quit-item-jobs = { $count } { $count -> + [one] Hintergrundauftrag + *[other] Hintergrundaufträge +} +# $count API requests for the Quit prompt. +native-quit-item-requests = { $count } { $count -> + [one] API-Anfrage + *[other] API-Anfragen +} +# The Quit prompt's body: $count is how many kinds of work are live (at most +# five), $a, $b, $c, $d and $e are those items, and $api is +# ", including the local API," or empty when the local API is not running. +native-quit-activity = { $count -> + [1] { $a }. Beim Beenden wird der Host{ $api } gestoppt; Maple wartet, bis alles abgeschlossen ist. + [2] { $a } und { $b }. Beim Beenden wird der Host{ $api } gestoppt; Maple wartet, bis alles abgeschlossen ist. + [3] { $a }, { $b } und { $c }. Beim Beenden wird der Host{ $api } gestoppt; Maple wartet, bis alles abgeschlossen ist. + [4] { $a }, { $b }, { $c } und { $d }. Beim Beenden wird der Host{ $api } gestoppt; Maple wartet, bis alles abgeschlossen ist. + [5] { $a }, { $b }, { $c }, { $d } und { $e }. Beim Beenden wird der Host{ $api } gestoppt; Maple wartet, bis alles abgeschlossen ist. + *[0] Beim Beenden wird der Host{ $api } gestoppt; Maple wartet, bis alles abgeschlossen ist. +} +# The $api clause of native-quit-activity. +native-quit-api-clause = , einschließlich der lokalen API, # $version is the app version; $status is the localized updater status. native-about-details = Version { $version } { $status } diff --git a/apps/maple-agent/app/locales/en/app.ftl b/apps/maple-agent/app/locales/en/app.ftl index 580c55706..9cb633ab4 100644 --- a/apps/maple-agent/app/locales/en/app.ftl +++ b/apps/maple-agent/app/locales/en/app.ftl @@ -1336,8 +1336,8 @@ native-installed = Update installed native-restart = Restart Maple native-keep-open = Keep open native-retry-quit = Retry Quit -native-stop-title = Stop this computer's Maple host? -native-still-open = Maple is still open +native-stop-title = Still working... +native-still-open = Still open. native-unknown-activity = The host could not report its activity. Quitting will attempt to stop any attached editors, tasks and remote connections, and wait for the host to release local data. native-keep-open-title = Keep Maple open? native-no-tray = This desktop has no available tray to reopen Maple. Keep this window open while Maple holds local data unlocked, or Quit Maple to stop its host. @@ -1366,8 +1366,44 @@ native-stop-unavailable = Maple cannot retry stopping its host. Keep this proces native-stop-failed = Maple could not finish stopping its host: { $error }. Keep this window open and retry stopping the host before relaunching Maple. # $error is an external diagnostic, preserved verbatim. native-restart-failed = Could not restart Maple: { $error } -# Counts of $tasks running tasks, $editors attached editors, $controllers remote controllers, $jobs background jobs and $requests API requests. -native-quit-activity = Quitting stops running tasks ({ $tasks }), attached editors ({ $editors }), remote controllers ({ $controllers }) and background jobs ({ $jobs }). It also stops this computer's local API and its active requests ({ $requests }). Maple waits for them to drain before closing. +# $count running tasks for the Quit prompt. +native-quit-item-tasks = { $count } running { $count -> + [one] task + *[other] tasks +} +# $count attached editors for the Quit prompt. +native-quit-item-editors = { $count } attached { $count -> + [one] editor + *[other] editors +} +# $count remote controllers for the Quit prompt. +native-quit-item-controllers = { $count } remote { $count -> + [one] controller + *[other] controllers +} +# $count background jobs for the Quit prompt. +native-quit-item-jobs = { $count } background { $count -> + [one] job + *[other] jobs +} +# $count API requests for the Quit prompt. +native-quit-item-requests = { $count } API { $count -> + [one] request + *[other] requests +} +# The Quit prompt's body: $count is how many kinds of work are live (at most +# five), $a, $b, $c, $d and $e are those items, and $api is +# ", including the local API," or empty when the local API is not running. +native-quit-activity = { $count -> + [1] { $a }. Quitting stops the host{ $api } and waits for it to drain. + [2] { $a } and { $b }. Quitting stops the host{ $api } and waits for them to drain. + [3] { $a }, { $b }, and { $c }. Quitting stops the host{ $api } and waits for them to drain. + [4] { $a }, { $b }, { $c }, and { $d }. Quitting stops the host{ $api } and waits for them to drain. + [5] { $a }, { $b }, { $c }, { $d }, and { $e }. Quitting stops the host{ $api } and waits for them to drain. + *[0] Quitting stops the host{ $api } and waits for it to drain. +} +# The $api clause of native-quit-activity. +native-quit-api-clause = , including the local API, # $version is the app version; $status is the localized updater status. native-about-details = Version { $version } { $status } diff --git a/apps/maple-agent/app/locales/es/app.ftl b/apps/maple-agent/app/locales/es/app.ftl index 982976bdf..f49984363 100644 --- a/apps/maple-agent/app/locales/es/app.ftl +++ b/apps/maple-agent/app/locales/es/app.ftl @@ -1236,8 +1236,8 @@ native-installed = Actualización instalada native-restart = Reiniciar Maple native-keep-open = Mantener abierto native-retry-quit = Reintentar salir -native-stop-title = ¿Detener el host de Maple de esta computadora? -native-still-open = Maple sigue abierto +native-stop-title = Aún trabajando… +native-still-open = Sigue abierto. native-unknown-activity = El host no pudo informar su actividad. Al salir, Maple intentará detener los editores conectados, las tareas y las conexiones remotas, y esperará a que el host libere los datos locales. native-keep-open-title = ¿Mantener Maple abierto? native-no-tray = Este escritorio no tiene una bandeja disponible para volver a abrir Maple. Mantén esta ventana abierta mientras Maple tenga los datos locales desbloqueados, o sal de Maple para detener su host. @@ -1266,8 +1266,44 @@ native-stop-unavailable = Maple no puede volver a intentar detener su host. Mant native-stop-failed = Maple no pudo terminar de detener su host: { $error }. Mantén esta ventana abierta e intenta detener el host de nuevo antes de volver a iniciar Maple. # $error is an external diagnostic, preserved verbatim. native-restart-failed = No se pudo reiniciar Maple: { $error } -# Counts of tasks, attached editors, remote controllers, background jobs, and API requests. -native-quit-activity = Al salir, Maple detiene las tareas en ejecución ({ $tasks }), los editores conectados ({ $editors }), los controladores remotos ({ $controllers }) y los trabajos en segundo plano ({ $jobs }). También detiene la API local de esta computadora y sus solicitudes activas ({ $requests }). Maple espera a que terminen antes de cerrar. +# $count running tasks for the Quit prompt. +native-quit-item-tasks = { $count } { $count -> + [one] tarea en ejecución + *[other] tareas en ejecución +} +# $count attached editors for the Quit prompt. +native-quit-item-editors = { $count } { $count -> + [one] editor conectado + *[other] editores conectados +} +# $count remote controllers for the Quit prompt. +native-quit-item-controllers = { $count } { $count -> + [one] controlador remoto + *[other] controladores remotos +} +# $count background jobs for the Quit prompt. +native-quit-item-jobs = { $count } { $count -> + [one] trabajo en segundo plano + *[other] trabajos en segundo plano +} +# $count API requests for the Quit prompt. +native-quit-item-requests = { $count } { $count -> + [one] solicitud de API + *[other] solicitudes de API +} +# The Quit prompt's body: $count is how many kinds of work are live (at most +# five), $a, $b, $c, $d and $e are those items, and $api is +# ", including the local API," or empty when the local API is not running. +native-quit-activity = { $count -> + [1] { $a }. Al salir, se detiene el host{ $api } y Maple espera a que todo termine. + [2] { $a } y { $b }. Al salir, se detiene el host{ $api } y Maple espera a que todo termine. + [3] { $a }, { $b } y { $c }. Al salir, se detiene el host{ $api } y Maple espera a que todo termine. + [4] { $a }, { $b }, { $c } y { $d }. Al salir, se detiene el host{ $api } y Maple espera a que todo termine. + [5] { $a }, { $b }, { $c }, { $d } y { $e }. Al salir, se detiene el host{ $api } y Maple espera a que todo termine. + *[0] Al salir, se detiene el host{ $api } y Maple espera a que todo termine. +} +# The $api clause of native-quit-activity. +native-quit-api-clause = , incluida la API local, # $version is the app version; $status is the localized updater status. native-about-details = Versión { $version } { $status } diff --git a/apps/maple-agent/app/src/desktop.rs b/apps/maple-agent/app/src/desktop.rs index c97b9ec1f..40460b4a7 100644 --- a/apps/maple-agent/app/src/desktop.rs +++ b/apps/maple-agent/app/src/desktop.rs @@ -2746,7 +2746,7 @@ fn quit_app(cx: &mut App) { .map_err(|_| "The host did not answer its activity check".to_string())? }); cx.spawn(async move |cx| match activity.await { - Ok(Ok(activity)) if activity.needs_confirmation() => { + Ok(Ok(activity)) if activity.needs_confirmation() || DEBUG_QUIT_PROMPT_LOOP => { cx.update(|cx| show_quit_prompt(QuitPromptKind::Confirm(activity), cx)); } Ok(Ok(_)) => cx.update(|cx| drain_and_quit(state, cx)), @@ -2928,10 +2928,19 @@ fn main_window_failure(error: &impl std::fmt::Display) -> String { /// A separate window also works when Quit comes from a tray with no open window. fn show_quit_prompt(kind: QuitPromptKind, cx: &mut App) { - let bounds = Bounds::centered(None, size(px(560.), px(270.)), cx); + let height = match &kind { + QuitPromptKind::Failed(_) => 340., + _ => 300., + }; + let bounds = Bounds::centered(None, size(px(520.), px(height)), cx); + let reopen_kind = kind.clone(); if let Err(error) = cx.open_window( WindowOptions { window_bounds: Some(WindowBounds::Windowed(bounds)), + titlebar: Some(gpui::TitlebarOptions { + title: Some(crate::profile::DISPLAY_NAME.into()), + ..Default::default() + }), ..Default::default() }, |window, cx| { @@ -2943,7 +2952,14 @@ fn show_quit_prompt(kind: QuitPromptKind, cx: &mut App) { let closing = prompt.downgrade(); window.on_window_should_close(cx, move |_, cx| { cancel_quit(cx); - closing.update(cx, |prompt, cx| prompt.close(cx)).is_err() + closing + .update(cx, |prompt, cx| { + if !prompt.closing { + prompt.close(cx); + reopen_quit_prompt_after_close(reopen_kind.clone(), cx); + } + }) + .is_err() }); prompt }, @@ -2958,6 +2974,64 @@ fn show_quit_warning(message: UiText, cx: &mut App) { show_quit_prompt(QuitPromptKind::Failed(message), cx); } +/// Debug builds (never tests, never release) confirm every Quit and bring the +/// prompt back after it is dismissed, so the dialog can be exercised without +/// live host activity. Release and test binaries keep today's behavior. +const DEBUG_QUIT_PROMPT_LOOP: bool = cfg!(debug_assertions) && !cfg!(test); + +/// The [`DEBUG_QUIT_PROMPT_LOOP`] test loop: re-open the Quit prompt shortly +/// after it is dismissed. A no-op in release builds and tests. +fn reopen_quit_prompt_after_close(kind: QuitPromptKind, cx: &mut App) { + if !DEBUG_QUIT_PROMPT_LOOP { + return; + } + cx.spawn(async move |cx| { + cx.background_executor() + .timer(std::time::Duration::from_millis(400)) + .await; + cx.update(|cx| show_quit_prompt(kind, cx)); + }) + .detach(); +} + +/// The Editorial prompt's body: the host's live work as one sentence, then +/// what quitting does with it. Zero counts are omitted; the local API joins +/// the second sentence when its listener is running. +fn quit_activity_body( + activity: &HostActivity, + messages: &ui::i18n::MessageCache, +) -> gpui::SharedString { + let mut items: Vec = Vec::new(); + for (count, key) in [ + (activity.running_tasks, "native-quit-item-tasks"), + (activity.acp_clients, "native-quit-item-editors"), + (activity.remote_controllers, "native-quit-item-controllers"), + (activity.background_tasks, "native-quit-item-jobs"), + (activity.local_api_requests, "native-quit-item-requests"), + ] { + if count > 0 { + items.push(messages.get(key, [("count", count.into())]).to_string()); + } + } + let api = if activity.local_api_running { + tr("native-quit-api-clause").to_string() + } else { + String::new() + }; + let count = items.len(); + let item_args = ["a", "b", "c", "d", "e"] + .into_iter() + .zip(items) + .map(|(name, item)| (name, item.into())); + messages.get( + "native-quit-activity", + [("count", count.into()), ("api", api.into())] + .into_iter() + .chain(item_args), + ) +} + +#[derive(Clone)] enum QuitPromptKind { Confirm(HostActivity), UnknownActivity, @@ -2985,16 +3059,7 @@ impl QuitPrompt { match &self.kind { QuitPromptKind::Confirm(activity) => ( tr("native-stop-title"), - self.messages.get( - "native-quit-activity", - [ - ("tasks", activity.running_tasks.into()), - ("editors", activity.acp_clients.into()), - ("controllers", activity.remote_controllers.into()), - ("jobs", activity.background_tasks.into()), - ("requests", activity.local_api_requests.into()), - ], - ), + quit_activity_body(activity, &self.messages), false, ), QuitPromptKind::Failed(message) => (tr("native-still-open"), message.resolve(), true), @@ -3012,38 +3077,61 @@ impl Render for QuitPrompt { window.on_next_frame(|window, _| window.remove_window()); return div() .size_full() - .bg(gpui::rgb(ui::theme::bg_app())) + .bg(gpui::rgb(ui::theme::bg_elevated())) .into_any_element(); } - let (title, message, retry) = self.presentation(); + // The Editorial prompt: an Array headline, one calm sentence about the + // live work, and a quiet Keep open beside the single accent Quit pill. + let (headline, body, retry) = self.presentation(); + let kind = self.kind.clone(); div() .id("quit-prompt") .role(gpui::Role::Dialog) - .aria_label(title.clone()) + .aria_label(headline.clone()) .size_full() .flex() .flex_col() - .gap_4() - .p_6() - .bg(gpui::rgb(ui::theme::bg_app())) + .px(px(36.)) + .pt(px(20.)) + .pb(px(28.)) + .bg(gpui::rgb(ui::theme::bg_elevated())) .text_color(gpui::rgb(ui::theme::text_primary())) - .child(div().text_lg().child(gpui::text!(title))) - .child(gpui::text!(message)) + .child( + div() + .font_family(crate::assets::FONT_DISPLAY) + .text_size(px(40.)) + .line_height(px(42.)) + .text_color(gpui::rgb(ui::theme::text_heading())) + .child(gpui::text!(headline)), + ) + .child( + div() + .mt_4() + .max_w(px(360.)) + .text_size(px(15.)) + .line_height(px(24.)) + .text_color(gpui::rgb(ui::theme::text_secondary())) + .child(gpui::text!(body)), + ) + .child(div().flex_1()) .child( div() .flex() - .gap_4() + .items_center() + .justify_end() + .gap_2() .child( - ui::widgets::secondary_button("keep-maple-open") + ui::widgets::ghost_button("keep-maple-open") .debug_selector(|| "keep-maple-open".to_string()) .child(gpui::text!(tr("native-keep-open"))) - .on_click(cx.listener(|prompt, _, _, cx| { + .on_click(cx.listener(move |prompt, _, _, cx| { cancel_quit(cx); prompt.close(cx); + reopen_quit_prompt_after_close(kind.clone(), cx); })), ) .child( - ui::widgets::secondary_button("retry-maple-quit") + ui::widgets::primary_button("retry-maple-quit") .debug_selector(|| "retry-maple-quit".to_string()) .child(gpui::text!(tr(if retry { "native-retry-quit" @@ -4270,6 +4358,19 @@ mod tests { #[test] fn quit_warning_preserves_all_counts_when_switching_locale() { let _locale = ui::i18n::TestLocalizationGuard::enable(); + // The Editorial body omits zero counts, so an idle host with only the + // API listener reads as the host draining alone. + let items = |count: usize, singular: [&str; 5], plural: [&str; 5]| { + if count == 0 { + Vec::new() + } else { + let labels = if count == 1 { singular } else { plural }; + labels + .iter() + .map(|label| format!("{count} {label}")) + .collect::>() + } + }; for count in [0, 1, 2] { let prompt = QuitPrompt { closing: false, @@ -4283,48 +4384,76 @@ mod tests { }), messages: Default::default(), }; - for (locale, labels, drain) in [ + let english = items( + count, + [ + "running task", + "attached editor", + "remote controller", + "background job", + "API request", + ], + [ + "running tasks", + "attached editors", + "remote controllers", + "background jobs", + "API requests", + ], + ); + let spanish = items( + count, + [ + "tarea en ejecución", + "editor conectado", + "controlador remoto", + "trabajo en segundo plano", + "solicitud de API", + ], + [ + "tareas en ejecución", + "editores conectados", + "controladores remotos", + "trabajos en segundo plano", + "solicitudes de API", + ], + ); + for (locale, labels, api_clause, drain) in [ ( "en", - [ - "running tasks", - "attached editors", - "remote controllers", - "background jobs", - "active requests", - ], - "waits for them to drain", + english.clone(), + ", including the local API,", + if count == 0 { + "waits for it to drain" + } else { + "waits for them to drain" + }, ), ( "es", - [ - "tareas en ejecución", - "editores conectados", - "controladores remotos", - "trabajos en segundo plano", - "solicitudes activas", - ], - "espera a que terminen", + spanish, + ", incluida la API local,", + "espera a que todo termine", ), ( "en", - [ - "running tasks", - "attached editors", - "remote controllers", - "background jobs", - "active requests", - ], - "waits for them to drain", + english, + ", including the local API,", + if count == 0 { + "waits for it to drain" + } else { + "waits for them to drain" + }, ), ] { ui::i18n::apply_preference(Some(locale)); let (_, detail, retry) = prompt.presentation(); assert!(!retry); - for label in labels { - assert!(detail.contains(&format!("{label} ({count})")), "{detail}"); + for label in &labels { + assert!(detail.contains(label.as_str()), "{detail}"); } - assert!(detail.contains(drain)); + assert!(detail.contains(api_clause), "{detail}"); + assert!(detail.contains(drain), "{detail}"); assert!( matches!(&prompt.kind, QuitPromptKind::Confirm(activity) if activity.needs_confirmation()) ); @@ -5945,6 +6074,51 @@ mod tests { ); } + #[test] + fn quit_prompt_body_lists_live_work_in_one_sentence() { + let _localization = ui::i18n::TestLocalizationGuard::enable(); + let messages = ui::i18n::MessageCache::default(); + let activity = HostActivity { + running_tasks: 2, + acp_clients: 1, + remote_controllers: 1, + background_tasks: 1, + local_api_running: true, + local_api_requests: 3, + }; + assert_eq!( + quit_activity_body(&activity, &messages).as_ref(), + "2 running tasks, 1 attached editor, 1 remote controller, 1 background job, and 3 API \ + requests. Quitting stops the host, including the local API, and waits for them to \ + drain." + ); + // Only the API listener is live: no list, and the host drains alone. + let activity = HostActivity { + local_api_running: true, + ..Default::default() + }; + assert_eq!( + quit_activity_body(&activity, &messages).as_ref(), + "Quitting stops the host, including the local API, and waits for it to drain." + ); + // An idle host, as the debug loop shows, has nothing to list. + assert_eq!( + quit_activity_body(&HostActivity::default(), &messages).as_ref(), + "Quitting stops the host and waits for it to drain." + ); + // Two items join without the serial comma. + let activity = HostActivity { + running_tasks: 1, + acp_clients: 2, + ..Default::default() + }; + assert_eq!( + quit_activity_body(&activity, &messages).as_ref(), + "1 running task and 2 attached editors. Quitting stops the host and waits for them to \ + drain." + ); + } + #[test] fn fullscreen_does_not_replace_the_windowed_state() { let windowed = window_state_for(WindowBounds::Windowed(bounds(1280., 860.))).unwrap(); diff --git a/apps/maple-agent/app/translation-revisions/de.txt b/apps/maple-agent/app/translation-revisions/de.txt index bc1ae8d7d..b79538925 100644 --- a/apps/maple-agent/app/translation-revisions/de.txt +++ b/apps/maple-agent/app/translation-revisions/de.txt @@ -626,7 +626,13 @@ native-previous-task 734676d4a618631b native-project-connection-changed 1b6aa285fa0e484e native-project-unavailable b302ac1288025f11 native-quit 7153470fd130ba03 -native-quit-activity 5ec266eef24b9fdf +native-quit-activity 6e2248d91a1ef9f5 +native-quit-api-clause 0b3722ee5ba8756d +native-quit-item-controllers dafe4ccec668c1f1 +native-quit-item-editors 5a64767ba5081296 +native-quit-item-jobs b37d3346b54e45ec +native-quit-item-requests a27a7dc70af431c4 +native-quit-item-tasks 5dec32f3a63bbdcb native-quit-maple b5ff0e18ac2bde8d native-quit-not-stopped 5e850a01db579ca3 native-redo fde55386dab4c9e4 @@ -653,14 +659,14 @@ native-startup-details-copied a4c8b9ab0e005829 native-startup-log-file d3733b03f65070bf native-startup-show-log 8c3bdc092aea302b native-startup-title 83dcbcacdd2edc3b -native-still-open 6db9b5a5d75a0866 +native-still-open fab8033155d9dbc7 native-stop-complete a91d816053f90684 native-stop-existing 5c990c13126b4733 native-stop-existing-detail b63229cd0a3373bd native-stop-existing-title 5fc7288609db090f native-stop-failed 12de981c7243b1a9 native-stop-reopen f6ed898c8037af8e -native-stop-title 07d28d61cb6f68e8 +native-stop-title 88f19e307a6524a8 native-stop-unavailable 3085e8336f4c25db native-stopping 2be82390308fdac4 native-stopping-host dccf37ec7252d5cd diff --git a/apps/maple-agent/app/translation-revisions/es.txt b/apps/maple-agent/app/translation-revisions/es.txt index bc1ae8d7d..b79538925 100644 --- a/apps/maple-agent/app/translation-revisions/es.txt +++ b/apps/maple-agent/app/translation-revisions/es.txt @@ -626,7 +626,13 @@ native-previous-task 734676d4a618631b native-project-connection-changed 1b6aa285fa0e484e native-project-unavailable b302ac1288025f11 native-quit 7153470fd130ba03 -native-quit-activity 5ec266eef24b9fdf +native-quit-activity 6e2248d91a1ef9f5 +native-quit-api-clause 0b3722ee5ba8756d +native-quit-item-controllers dafe4ccec668c1f1 +native-quit-item-editors 5a64767ba5081296 +native-quit-item-jobs b37d3346b54e45ec +native-quit-item-requests a27a7dc70af431c4 +native-quit-item-tasks 5dec32f3a63bbdcb native-quit-maple b5ff0e18ac2bde8d native-quit-not-stopped 5e850a01db579ca3 native-redo fde55386dab4c9e4 @@ -653,14 +659,14 @@ native-startup-details-copied a4c8b9ab0e005829 native-startup-log-file d3733b03f65070bf native-startup-show-log 8c3bdc092aea302b native-startup-title 83dcbcacdd2edc3b -native-still-open 6db9b5a5d75a0866 +native-still-open fab8033155d9dbc7 native-stop-complete a91d816053f90684 native-stop-existing 5c990c13126b4733 native-stop-existing-detail b63229cd0a3373bd native-stop-existing-title 5fc7288609db090f native-stop-failed 12de981c7243b1a9 native-stop-reopen f6ed898c8037af8e -native-stop-title 07d28d61cb6f68e8 +native-stop-title 88f19e307a6524a8 native-stop-unavailable 3085e8336f4c25db native-stopping 2be82390308fdac4 native-stopping-host dccf37ec7252d5cd