@yuneta/gobj-ui 7.25.15 → 7.25.17

package/src/c_g6_nodes_tree.js

@@ -493,6 +493,7 @@ let PRIVATE_DATA = {
     __graphs__:         [],         // Rows of __graphs__
     _graph_properties:  {},         // topic_name → {nodes: {node_id: {x,y,size,...}}}
     _saved_graph_properties: {},    // the same, as the BACKEND has it: what a Save compares against
+    _graphs_writes_owed: {},        // topic_name → true: a __graphs__ write the host said did not land
     yet_showed:         false,
     edit_mode:          false,
     operation_mode:     null,
@@ -3283,6 +3284,9 @@ function save_topic_graph_properties(gobj, topic_name)
      *  The host says when one does NOT land (EV_GRAPHS_WRITE_REFUSED),
      *  and the next Save writes the topic again.  */
     priv._saved_graph_properties[topic_name] = json_deep_copy(properties);
+    /*  Paid: this is the write that was owed, if one was. Refused
+     *  again, EV_GRAPHS_WRITE_REFUSED owes it again.  */
+    delete priv._graphs_writes_owed[topic_name];
 
     let kw_update = {
         treedb_name: priv.treedb_name,
@@ -3388,9 +3392,16 @@ function update_history_buttons(gobj)
                 disableElements($container, ".EV_HISTORY_UNDO");
                 set_active_state($container, ".EV_HISTORY_UNDO", false);
 
-                // No more undos: graph is back to original state, disable save
-                disableElements($container, ".EV_SAVE_GRAPH");
-                set_submit_state($container, ".EV_SAVE_GRAPH", false);
+                /*  No more undos: the graph is back to what was loaded
+                 *  or saved -- unless a write of it did not land. That
+                 *  one is still owed, and only a Save pays it.  */
+                if(graphs_write_is_owed(gobj)) {
+                    enableElements($container, ".EV_SAVE_GRAPH");
+                    set_submit_state($container, ".EV_SAVE_GRAPH", true);
+                } else {
+                    disableElements($container, ".EV_SAVE_GRAPH");
+                    set_submit_state($container, ".EV_SAVE_GRAPH", false);
+                }
             }
         } else {
             disableElements($container, ".EV_HISTORY_REDO");
@@ -4763,6 +4774,17 @@ function run_preview_undo(gobj, key)
     }
 }
 
+/************************************************************
+ *  Is a `__graphs__` write owed? The host said one did not land
+ *  (EV_GRAPHS_WRITE_REFUSED), and no Save has written that topic
+ *  since. The Save button stays lit while it is: the history
+ *  knows nothing of it, so `canUndo()` alone would put it out.
+ ************************************************************/
+function graphs_write_is_owed(gobj)
+{
+    return Object.keys(gobj.priv._graphs_writes_owed).length > 0;
+}
+
 function mark_graph_dirty(gobj)
 {
     let $container = gobj_read_attr(gobj, "$container");
@@ -10346,6 +10368,11 @@ function ac_clear_data(gobj, event, kw, src)
 
     gobj_write_attr(gobj, "records", {});
 
+    /*  A write owed is owed on the arrangement being thrown away: the
+     *  reload brings what the backend holds, and that is what the view
+     *  will hold.  */
+    priv._graphs_writes_owed = {};
+
     /*  The node counters belong to the data that is going away: a refresh
      *  that kept them would decide the layout on the previous treedb. */
     priv._nodes_total = 0;
@@ -10495,10 +10522,13 @@ function ac_save_graph(gobj, event, kw, src)
         let history = graph_get_plugin(gobj, "history");
         if(history) {
             history.clear();
-            update_history_buttons(gobj);
         }
 
         save_geometry(gobj); // Publish an EV_UPDATE_NODE of each node
+
+        /*  After the writes: they pay a write owed, and the buttons
+         *  are repainted from what is still owed.  */
+        update_history_buttons(gobj);
     }
 
     return 0;
@@ -10526,6 +10556,9 @@ function ac_graphs_write_refused(gobj, event, kw, src)
     log_warning(`${gobj_short_name(gobj)}: the arrangement of '${topic_name}' ` +
         `was not saved: the next Save writes it again`);
     forget_refused_graphs_write(priv._saved_graph_properties, topic_name);
+    /*  Owed until a Save writes it: update_history_buttons() keeps
+     *  the Save lit while it is, in edition and on entering it.  */
+    priv._graphs_writes_owed[topic_name] = true;
     if(priv.edit_mode) {
         mark_graph_dirty(gobj);
     }

package/src/c_yui_schema_editor.js

@@ -117,6 +117,7 @@ import {
     kw_get_int,
     kw_get_dict,
     is_object,
+    json_deep_copy,
     is_array,
     empty_string,
 } from "@yuneta/gobj-js";
@@ -246,6 +247,8 @@ let PRIVATE_DATA = {
     dropped_round:  0,      /*  the load a drop ended: its failures are the drop, said once  */
     dropped_write:  0,      /*  the same for the write a drop ended  */
     reload_after_write: false,  /*  a write given up turned out DONE while another was in flight  */
+    refresh_after_write: false, /*  EV_REFRESH heard while writes were in flight: run at their end  */
+    reopen_form:    null,   /*  the form whose Save ran the owed reload: opened again once it lands  */
 
     /*  A position that arrived while a load or a write was in flight  */
     pending_seg:    null,
@@ -400,7 +403,11 @@ function el_attrs(attrs)
 }
 
 /***************************************************************
- *  The body stops answering while a write is in flight.
+ *  The body stops answering while a write is in flight. For the
+ *  keyboard too: `pointer-events` stops the mouse alone, and the
+ *  shell's focus trap puts the focus back on the row control that
+ *  had it, where Enter or Delete sent an action ST_SAVING does
+ *  not declare. `inert` takes the whole body out of reach.
  ***************************************************************/
 function set_busy(gobj, busy)
 {
@@ -408,6 +415,7 @@ function set_busy(gobj, busy)
 
     if($body) {
         $body.classList.toggle("SCHEMA_BUSY", !!busy);
+        $body.toggleAttribute("inert", !!busy);
     }
 }
 
@@ -522,12 +530,37 @@ function owes_reload(gobj)
         state !== "ST_LOADING" && state !== "ST_SAVING";
 }
 
-function reload_first(gobj, event)
+function reload_first(gobj, event, reopen)
 {
+    let priv = gobj.priv;
+
     if(!owes_reload(gobj)) {
         return false;
     }
-    gobj.priv.reload_on_open = false;
+    priv.reload_on_open = false;
+
+    /*  The Save of a FORM: what the operator typed is not thrown away
+     *  with the model it was typed on. The load that lands closes the
+     *  form (end_load()) and opens it again on the schemas it read,
+     *  with the fields the operator CHANGED put back on top -- only
+     *  those: a field left as it was shows what the store holds now,
+     *  so the next Save does not write the old value over a newer
+     *  one. Closed alone, the form took what was typed with it.  */
+    if(reopen && priv.dialog) {
+        priv.reopen_form = Object.assign(json_deep_copy(reopen), {
+            dialog:    priv.dialog,
+            treedb_id: priv.treedb_id
+        });
+        log_warning(`${gobj_short_name(gobj)}: ${event} refused, the schemas shown ` +
+            `may be out of date: they are read again first, and the form opens again ` +
+            `on them with its changes`);
+        yui_shell_show_error(yui_shell_of(gobj),
+            "the schemas shown may be out of date: they are read again, and the form opens again on them with your changes",
+            {t: t});
+        request_model(gobj, true);
+        return true;
+    }
+
     log_warning(`${gobj_short_name(gobj)}: ${event} refused, the schemas shown ` +
         `may be out of date: they are read again first`);
     yui_shell_show_error(yui_shell_of(gobj),
@@ -537,6 +570,53 @@ function reload_first(gobj, event)
     return true;
 }
 
+/***************************************************************
+ *  The form reload_first() took down, opened again on the model
+ *  the load just made, with the operator's changes on top.
+ *
+ *  Only where it can mean the same thing: on the treedb it was
+ *  opened on, on the screen whose Save it has, and on a record
+ *  that is still there. Otherwise it is not opened, and that is
+ *  said -- a form opened on another treedb, or on nothing, would
+ *  save somewhere the operator never meant.
+ ***************************************************************/
+function reopen_form(gobj, r)
+{
+    let priv = gobj.priv;
+    let state = gobj_current_state(gobj);
+    let treedb = current_treedb(gobj);
+    let topic = null;
+    let col = null;
+    let fits = false;
+
+    if(treedb && r.treedb_id === priv.treedb_id) {
+        if(r.form === "column" && state === "ST_COLUMNS") {
+            topic = find_topic(priv.model, priv.treedb_id, r.topic);
+            col = (topic && !r.creating) ?
+                find_col(priv.model, priv.treedb_id, r.topic, r.col) : null;
+            fits = !!topic && (r.creating || !!col);
+        } else if(r.form === "topic" && state === "ST_TOPICS") {
+            topic = r.creating ? null : find_topic(priv.model, priv.treedb_id, r.topic);
+            fits = r.creating || !!topic;
+        }
+    }
+    if(!fits) {
+        log_warning(`${gobj_short_name(gobj)}: the ${r.form} form was not opened again: ` +
+            `what it edited is not on the schemas the reload read ` +
+            `(${r.treedb_id} ${r.topic}${r.col ? "." + r.col : ""}, now ${state})`);
+        yui_shell_show_error(yui_shell_of(gobj),
+            "the schemas were read again and what the form was editing is not there any more",
+            {t: t});
+        return -1;
+    }
+    if(r.form === "column") {
+        open_column_form(gobj, topic, col, null, r.changed);
+    } else {
+        open_topic_form(gobj, treedb, topic, r.changed);
+    }
+    return 0;
+}
+
 function reload_after_move(gobj)
 {
     if(!owes_reload(gobj)) {
@@ -632,7 +712,7 @@ function request_model(gobj, keep_written)
         priv.records_before = null;
         priv.load_round++;
         priv.reload_on_open = true;
-        priv.load_error = t("cannot reach the treedb");
+        priv.load_error = "cannot reach the treedb";   /*  a key: the notice translates it  */
         if(priv.model) {
             yui_shell_show_error(yui_shell_of(gobj), "cannot reach the treedb", {t: t});
         }
@@ -725,7 +805,7 @@ function build_model(gobj)
  *  measurement of "changed since" can be measured against.
  *
  *  `written` is forgotten only by an EV_REFRESH (the view's own
- *  Refresh button, or a host that sends one). Since M36 a write moves no
+ *  Refresh button, or a host that sends one). Since 7.23.196 a write moves no
  *  version, so `written` is the draft chip of what this session
  *  wrote and no longer half of a version measurement: a reload of
  *  the reconnect, or of a write that turned out done, forgot the
@@ -918,9 +998,14 @@ function show_notice(gobj, key, detail)
     $notice.appendChild(createElement2(
         ["span", {class: "SCHEMA_NOTICE_TEXT", i18n: key}, t(key)]
     ));
-    if(detail) {
+    /*  The detail is a KEY too (ours, or the backend's words, which
+     *  translate to themselves when no locale has them), so a change
+     *  of language changes it with the rest. One that repeats the
+     *  title says nothing.  */
+    if(detail && detail !== key) {
         $notice.appendChild(createElement2(
-            ["span", {class: "SCHEMA_NOTICE_DETAIL yui-text-quiet ml-2"}, `${detail}`]
+            ["span", {class: "SCHEMA_NOTICE_DETAIL yui-text-quiet ml-2", i18n: `${detail}`},
+                t(`${detail}`)]
         ));
     }
 }
@@ -1915,6 +2000,75 @@ function read_form($root)
     return out;
 }
 
+/***************************************************************
+ *  A column form as its Save sends it: the fields and the flags.
+ ***************************************************************/
+function column_form_state($form)
+{
+    let values = read_form($form);
+    values.flag = read_flags($form);
+    return values;
+}
+
+/***************************************************************
+ *  The fields the operator CHANGED: those whose value is not the
+ *  one the form was opened with.
+ ***************************************************************/
+function form_changes(initial, values)
+{
+    let changed = {};
+
+    for(let name of Object.keys(values)) {
+        if(JSON.stringify(values[name]) !== JSON.stringify(initial[name])) {
+            changed[name] = values[name];
+        }
+    }
+    return changed;
+}
+
+/***************************************************************
+ *  Put changes back into a form just built (reopen_form()). The
+ *  flags are drawn again for the type the changes leave, holding
+ *  the flags they name, so none of them is hidden by the type.
+ ***************************************************************/
+function apply_form_changes(gobj, $form, changes)
+{
+    for(let name of Object.keys(changes)) {
+        if(name === "flag") {
+            continue;
+        }
+        let $control = $form.querySelector(`[data-name="${name}"]`);
+        if(!$control) {
+            log_warning(`${gobj_short_name(gobj)}: a change of '${name}' has no field ` +
+                `in the form opened again: not put back`);
+            continue;
+        }
+        if($control.type === "checkbox") {
+            $control.checked = !!changes[name];
+        } else {
+            $control.value = changes[name];
+        }
+    }
+
+    let $type = $form.querySelector('[data-name="type"]');
+    if($type && $form.querySelector(".SCHEMA_FLAGS")) {
+        let flags = Array.isArray(changes.flag) ? changes.flag : read_flags($form);
+        redraw_flags(gobj, $form, $type.value, flags);
+    }
+}
+
+/***************************************************************
+ *  Draw the flags of a column form again, for `type`, with
+ *  `current` checked.
+ ***************************************************************/
+function redraw_flags(gobj, $form, type, current)
+{
+    let $holder = $form.querySelector(".SCHEMA_FLAGS");
+    let $new = createElement2(flags_field(gobj, type, current));
+    $holder.parentNode.replaceChild($new, $holder);
+    refresh_language($new, t);
+}
+
 /***************************************************************
  *  The flags of a column, as checkboxes that say what they do.
  *
@@ -1977,7 +2131,7 @@ function read_flags($root)
  *  Offering a field that silently does something else is worse
  *  than not offering it.
  ***************************************************************/
-function open_column_form(gobj, topic, col, prefill)
+function open_column_form(gobj, topic, col, prefill, changes)
 {
     let priv = gobj.priv;
     /*  A DUPLICATE is a creation whose fields start filled: the name must
@@ -2051,11 +2205,7 @@ function open_column_form(gobj, topic, col, prefill)
      *  new type does not use.  */
     let $type = $form.querySelector('[data-name="type"]');
     $type.addEventListener("change", () => {
-        let $holder = $form.querySelector(".SCHEMA_FLAGS");
-        let current = read_flags($form);
-        let $new = createElement2(flags_field(gobj, $type.value, current));
-        $holder.parentNode.replaceChild($new, $holder);
-        refresh_language($new, t);
+        redraw_flags(gobj, $form, $type.value, read_flags($form));
     });
 
     /*  A flag that excludes another is answered here and not on save,
@@ -2075,15 +2225,22 @@ function open_column_form(gobj, topic, col, prefill)
         evt.stopPropagation();
         close_dialog(gobj);
     });
+    /*  What the form showed before the operator touched it: what
+     *  was CHANGED is measured against it (form_changes()).  */
+    let initial = column_form_state($form);
+    if(changes) {
+        apply_form_changes(gobj, $form, changes);
+    }
+
     $form.querySelector(".SCHEMA_COL_FORM_SAVE").addEventListener("click", (evt) => {
         evt.stopPropagation();
-        let values = read_form($form);
-        values.flag = read_flags($form);
+        let values = column_form_state($form);
         gobj_send_event(gobj, "EV_SAVE_COLUMN", {
             topic:     topic.name,
             col:       creating ? "" : col.name,
             creating:  creating,
             values:    values,
+            changed:   creating ? values : form_changes(initial, values),
             model_gen: model_gen
         }, gobj);
     });
@@ -2112,7 +2269,7 @@ function stringify_field(value)
  *  actually has: a pkey naming no column is a topic that does
  *  not open, and it is the first thing the validator looks for.
  ***************************************************************/
-function open_topic_form(gobj, treedb, topic)
+function open_topic_form(gobj, treedb, topic, changes)
 {
     let record = (topic && topic.record) || {};
     let creating = !topic;
@@ -2171,12 +2328,19 @@ function open_topic_form(gobj, treedb, topic)
         evt.stopPropagation();
         close_dialog(gobj);
     });
+    let initial = read_form($form);
+    if(changes) {
+        apply_form_changes(gobj, $form, changes);
+    }
+
     $form.querySelector(".SCHEMA_TOPIC_FORM_SAVE").addEventListener("click", (evt) => {
         evt.stopPropagation();
+        let values = read_form($form);
         gobj_send_event(gobj, "EV_SAVE_TOPIC", {
             topic:     creating ? "" : topic.name,
             creating:  creating,
-            values:    read_form($form),
+            values:    values,
+            changed:   creating ? values : form_changes(initial, values),
             model_gen: model_gen
         }, gobj);
     });
@@ -2756,27 +2920,46 @@ function end_load(gobj)
 {
     let priv = gobj.priv;
     let seg = priv.pending_seg;
+    let reopen = priv.reopen_form;
 
     priv.pending_seg = null;
+    priv.reopen_form = null;
     if(priv.dialog && priv.dialog_gen !== priv.model_gen) {
-        log_warning(`${gobj_short_name(gobj)}: a dialog was open on the schemas ` +
-            `the load replaced: closed`);
+        /*  The form whose Save asked for this load is opened again,
+         *  below, once the screen is there (reload_first()). Any other
+         *  dialog is closed, and that is said.  */
+        if(!reopen || reopen.dialog !== priv.dialog) {
+            reopen = null;
+            log_warning(`${gobj_short_name(gobj)}: a dialog was open on the schemas ` +
+                `the load replaced: closed`);
+            yui_shell_show_error(yui_shell_of(gobj),
+                "the schemas were read again: open the dialog again", {t: t});
+        }
         close_dialog(gobj);
-        yui_shell_show_error(yui_shell_of(gobj),
-            "the schemas were read again: open the dialog again", {t: t});
+    } else {
+        /*  Closed meanwhile by the operator, or a load that replaced
+         *  nothing: the form is where it was, or where it was left.  */
+        reopen = null;
     }
+
+    let ret = 0;
     if(priv.model) {
         if(seg !== null) {
-            return apply_seg(gobj, seg);
+            ret = apply_seg(gobj, seg);
+        } else {
+            ret = go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
         }
-        return go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
+    } else {
+        if(seg !== null) {
+            adopt_seg(gobj, seg);
+        }
+        gobj_change_state(gobj, "ST_IDLE");
+        render(gobj);
     }
-    if(seg !== null) {
-        adopt_seg(gobj, seg);
+    if(reopen) {
+        reopen_form(gobj, reopen);
     }
-    gobj_change_state(gobj, "ST_IDLE");
-    render(gobj);
-    return 0;
+    return ret;
 }
 
 /***************************************************************
@@ -2819,7 +3002,17 @@ function end_writes(gobj, error)
         render(gobj);
         publish_check(gobj);
     }
-    reload_if_owed(gobj);
+    if(priv.refresh_after_write) {
+        /*  The EV_REFRESH heard while the writes were in flight
+         *  (ac_refresh_after_the_writes()), run now that none is. It
+         *  reads the store whole, so it also pays a reload a late
+         *  write owed.  */
+        priv.refresh_after_write = false;
+        priv.reload_after_write = false;
+        request_model(gobj, false);
+    } else {
+        reload_if_owed(gobj);
+    }
     return error ? -1 : 0;
 }
 
@@ -3167,7 +3360,7 @@ function ac_mt_command_answer(gobj, event, kw, src)
         }
         priv.pending--;
         if(result < 0) {
-            priv.load_error = comment || t("cannot load the schemas");
+            priv.load_error = comment || "cannot load the schemas";   /*  a key  */
         } else if(priv.records && Array.isArray(priv.records[topic_name])) {
             priv.records[topic_name] = Array.isArray(data) ? data : [];
         }
@@ -3244,10 +3437,11 @@ function ac_mt_command_answer(gobj, event, kw, src)
             return end_writes(gobj, comment || t("the treedb refused the write"));
         }
         priv.save_wrote = true;
+        let record = null;
         if(command === "delete-node") {
             forget_record(gobj, topic_name, kw_get_str(gobj, md, "record_id", "", 0));
         } else {
-            let record = is_object(data) ? data
+            record = is_object(data) ? data
                 : (Array.isArray(data) && is_object(data[0]) ? data[0] : null);
             if(record) {
                 patch_record(gobj, topic_name, record);
@@ -3270,7 +3464,7 @@ function ac_mt_command_answer(gobj, event, kw, src)
                 }
                 if(topic_name === T_TOPICS || topic_name === T_COLS) {
                     let write = priv.save_queue[0];
-                    mark_written(gobj, topic_name, write ? write.record : null);
+                    mark_written(gobj, topic_name, null, write ? write.record : null);
                 }
                 priv.reload_after_write = false;
                 priv.save_queue = [];
@@ -3279,16 +3473,21 @@ function ac_mt_command_answer(gobj, event, kw, src)
                 gobj_publish_event(gobj, "EV_RECORD_WRITTEN", {
                     treedb_name: gobj_read_str_attr(gobj, "treedb_name")
                 });
-                request_model(gobj, true);
+                /*  An EV_REFRESH heard during the writes is paid by this
+                 *  load: it forgets the drafts, as the refresh would.  */
+                let refresh = priv.refresh_after_write;
+                priv.refresh_after_write = false;
+                request_model(gobj, !refresh);
                 return 0;
             }
         }
         if(topic_name === T_TOPICS || topic_name === T_COLS) {
-            /*  Which record it was is in the QUEUE, not in the answer: an
-             *  adapter echoes only what it was asked to echo, and the
-             *  record is not small enough to be worth echoing.  */
+            /*  Which record it was: the one the store answered, else the
+             *  one in the QUEUE -- an adapter echoes only what it was
+             *  asked to echo, and the record is not small enough to be
+             *  worth echoing.  */
             let write = priv.save_queue[0];
-            mark_written(gobj, topic_name, write ? write.record : null);
+            mark_written(gobj, topic_name, record, write ? write.record : null);
         }
         priv.save_queue.shift();
         return run_next_write(gobj);
@@ -3357,35 +3556,46 @@ function late_write_done(gobj, command, topic_name, data)
 function mark_written_record(gobj, topic_name, record)
 {
     let priv = gobj.priv;
+    let marked = 0;
 
     if(!record) {
-        return;
+        return 0;
     }
     if(topic_name === T_TOPICS && typeof record.id === "string" && record.id) {
         priv.written[record.id] = true;
-        return;
+        return 1;
     }
     if(topic_name !== T_COLS) {
-        return;
+        return 0;
     }
     for(let ref of parse_fkey_ref(record.topics)) {
         priv.written[ref.id] = true;
+        marked++;
     }
+    return marked;
 }
 
 /***************************************************************
  *  Remember which topic this write belongs to, which is what
  *  "its version still has to move" is asked about.
+ *
+ *  Asked of the RECORD first: the one the store answered (a new
+ *  topic has its id only there), then the one queued (a column
+ *  names its topic in its fkey). The screen is the last resort,
+ *  and a poor one: an import writes topics the operator is not
+ *  on, and from the topics screen there is no topic on it at all.
  ***************************************************************/
-function mark_written(gobj, topic_name, record)
+function mark_written(gobj, topic_name, answered, queued)
 {
     let priv = gobj.priv;
-    let topic = current_topic(gobj);
 
-    if(topic_name === T_TOPICS && record && record.id) {
-        priv.written[record.id] = true;
+    if(mark_written_record(gobj, topic_name, answered) > 0) {
+        return;
+    }
+    if(mark_written_record(gobj, topic_name, queued) > 0) {
         return;
     }
+    let topic = current_topic(gobj);
     if(topic) {
         priv.written[topic.id] = true;
     }
@@ -3475,6 +3685,25 @@ function ac_refresh(gobj, event, kw, src)
     return request_model(gobj, false);
 }
 
+/***************************************************************
+ *  EV_REFRESH while writes are in flight: the view's own Refresh
+ *  is busy then, so it is a host's (after a Save, say).
+ *
+ *  Run when the writes END (end_writes()), not now. Run now, the
+ *  load replaced ST_SAVING and what was still queued was never
+ *  sent, with no word: nothing but the end of what is in flight
+ *  moves this view out of ST_LOADING or ST_SAVING.
+ ***************************************************************/
+function ac_refresh_after_the_writes(gobj, event, kw, src)
+{
+    let priv = gobj.priv;
+
+    log_warning(`${gobj_short_name(gobj)}: ${event} while writes are in flight: ` +
+        `the schemas are read again when the writes end`);
+    priv.refresh_after_write = true;
+    return 0;
+}
+
 /***************************************************************
  *  What a DIALOG sends while the model is being read again: the
  *  Save of a form left open when the reload started, a
@@ -3717,7 +3946,8 @@ function ac_save_column(gobj, event, kw, src)
     if(refuse_if_readonly(gobj, event)) {
         return -1;
     }
-    if(reload_first(gobj, event)) {
+    if(reload_first(gobj, event, {form: "column", topic: kw.topic, col: kw.col,
+                                  creating: !!kw.creating, changed: kw.changed || {}})) {
         return -1;
     }
     if(built_on_a_replaced_model(gobj, event, kw)) {
@@ -3892,7 +4122,8 @@ function ac_save_topic(gobj, event, kw, src)
     if(refuse_if_readonly(gobj, event)) {
         return -1;
     }
-    if(reload_first(gobj, event)) {
+    if(reload_first(gobj, event, {form: "topic", topic: kw.topic, col: "",
+                                  creating: !!kw.creating, changed: kw.changed || {}})) {
         return -1;
     }
     if(built_on_a_replaced_model(gobj, event, kw)) {
@@ -4306,7 +4537,9 @@ function create_gclass(gclass_name)
          *  the host are heard: every other action would be computed
          *  against a model the answer still in the air is about to
          *  change.  */
-        ["ST_SAVING", COMMON.slice()]
+        ["ST_SAVING", COMMON.filter((a) => a[0] !== "EV_REFRESH").concat([
+            ["EV_REFRESH",          ac_refresh_after_the_writes, null]
+        ])]
     ];
 
     /*---------------------------------------------*