2 files changed, 55 insertions, 21 deletions

diff --git a/addons/web/static/src/js/views/basic/basic_controller.js b/addons/web/static/src/js/views/basic/basic_controller.js
index f1e71bcfd5a..4b38ac69403 100644
--- a/addons/web/static/src/js/views/basic/basic_controller.js
+++ b/addons/web/static/src/js/views/basic/basic_controller.js
@@ -19,7 +19,8 @@ var _t = core._t;
 var BasicController = AbstractController.extend(FieldManagerMixin, {
     custom_events: _.extend({}, AbstractController.prototype.custom_events, FieldManagerMixin.custom_events, {
         reload: '_onReload',
-        sidebar_data_asked: '_onSidebarDataAsked'
+        sidebar_data_asked: '_onSidebarDataAsked',
+        translate: '_onTranslate',
     }),
     /**
      * @override
@@ -169,6 +170,8 @@ var BasicController = AbstractController.extend(FieldManagerMixin, {
      * @param {string} [recordID] - default to main recordID
      * @param {Object} [options]
      * @returns {Deferred}
+     *        Resolved with the list of field names (whose value has been modified)
+     *        Rejected if the record can't be saved
      */
     saveRecord: function (recordID, options) {
         // Some field widgets can't detect (all) their changes immediately or
@@ -367,6 +370,8 @@ var BasicController = AbstractController.extend(FieldManagerMixin, {
      *        if true, the record will only be 'locally' saved: its changes
      *        will move from the _changes key to the data key
      * @returns {Deferred}
+     *        Resolved with the list of field names (whose value has been modified)
+     *        Rejected if the record can't be saved
      */
     _saveRecord: function (recordID, options) {
         recordID = recordID || this.handle;
@@ -376,22 +381,24 @@ var BasicController = AbstractController.extend(FieldManagerMixin, {
             savePoint: false,
         });
 
-        var def = $.Deferred();
         // Check if the view is in a valid state for saving
         // Note: it is the model's job to do nothing if there is nothing to save
         if (this.canBeSaved(recordID)) {
-            def = this.model.save(recordID, { // Save then leave edit mode
+            var self = this;
+            var def = this.model.save(recordID, { // Save then leave edit mode
                 reload: options.reload,
                 savePoint: options.savePoint,
             });
-        } else {
-            def.reject(); // Cannot be saved, do nothing at all
-        }
-
-        if (options.stayInEdit) {
+            if (!options.stayInEdit) {
+                def = def.then(function (fieldNames) {
+                    return self._confirmSave(recordID).then(function () {
+                        return fieldNames;
+                    });
+                });
+            }
             return def;
         } else {
-            return def.then(this._confirmSave.bind(this, recordID));
+            return $.Deferred().reject(); // Cannot be saved
         }
     },
     /**
@@ -498,6 +505,23 @@ var BasicController = AbstractController.extend(FieldManagerMixin, {
         var sidebarEnv = this._getSidebarEnv();
         event.data.callback(sidebarEnv);
     },
+    /**
+     * open the translation view for the current field
+     *
+     * @private
+     * @param {OdooEvent} event
+     */
+    _onTranslate: function (event) {
+        var record = this.model.get(event.data.id, {raw: true});
+        this._rpc({
+            route: '/web/dataset/call_button',
+            params: {
+                model: 'ir.translation',
+                method: 'translate_fields',
+                args: [record.model, record.res_id, event.data.fieldName, record.getContext()],
+            }
+        }).then(this.do_action.bind(this));
+    },
 });
 
 return BasicController;
diff --git a/addons/web/static/src/js/views/basic/basic_model.js b/addons/web/static/src/js/views/basic/basic_model.js
index abb7242661e..ca042d63d69 100644
--- a/addons/web/static/src/js/views/basic/basic_model.js
+++ b/addons/web/static/src/js/views/basic/basic_model.js
@@ -708,6 +708,7 @@ var BasicModel = AbstractModel.extend({
      *   be 'locally' saved: its changes written in a _savePoint key that can
      *   be restored later by call discardChanges with option rollback to true
      * @returns {Deferred}
+     *   Resolved with the list of field names (whose value has been modified)
      */
     save: function (record_id, options) {
         var self = this;
@@ -723,7 +724,6 @@ var BasicModel = AbstractModel.extend({
                         rec._savePoint = _.extend({}, newValue);
                     }
                 });
-                return $.when();
             }
             var shouldReload = 'reload' in options ? options.reload : true;
             var method = self.isNew(record_id) ? 'create' : 'write';
@@ -742,10 +742,17 @@ var BasicModel = AbstractModel.extend({
                 });
             }
 
+            var def = $.Deferred();
+            var changedFields = Object.keys(changes);
+
+            if (options.savePoint) {
+                return def.resolve(changedFields);
+            }
+
             // in the case of a write, only perform the RPC if there are changes to save
-            if (method === 'create' || Object.keys(changes).length) {
+            if (method === 'create' || changedFields.length) {
                 var args = method === 'write' ? [[record.data.id], changes] : [changes];
-                return self._rpc({
+                self._rpc({
                         model: record.model,
                         method: method,
                         args: args,
@@ -759,23 +766,26 @@ var BasicModel = AbstractModel.extend({
                             record.count++;
                         }
 
-                        // Update the data directly or reload them
-                        var def;
-                        if (shouldReload) {
-                            def = self._fetchRecord(record);
-                        } else {
-                            _.extend(record.data, record._changes);
-                        }
+                        var _changes = record._changes;
 
                         // Erase changes as they have been applied
                         record._changes = {};
                         record._isDirty = false;
 
-                        return def;
+                        // Update the data directly or reload them
+                        if (shouldReload) {
+                            self._fetchRecord(record).then(function (record) {
+                                def.resolve(changedFields);
+                            });
+                        } else {
+                            _.extend(record.data, _changes);
+                            def.resolve(changedFields);
+                        }
                     });
             } else {
-                return $.when(record_id);
+                def.resolve(changedFields);
             }
+            return def;
         });
     },
     /**