return this.do_action(action_client, options);
} else if (_.isNumber(action) || _.isString(action)) {
var self = this;
- return self.rpc("/web/action/load", { action_id: action }).then(function(result) {
+ var additional_context = {
+ active_id : options.additional_context.active_id,
+ active_ids : options.additional_context.active_ids,
+ active_model : options.additional_context.active_model
+ };
+ return self.rpc("/web/action/load", { action_id: action, additional_context : additional_context }).then(function(result) {
return self.do_action(result, options);
});
}
+ instance.web.bus.trigger('action', action);
+
// Ensure context & domain are evaluated and can be manipulated/used
var ncontext = new instance.web.CompoundContext(options.additional_context, action.context || {});
action.context = instance.web.pyeval.eval('context', ncontext);
}
var widget = executor.widget();
if (executor.action.target === 'new') {
+ var pre_dialog = (this.dialog && !this.dialog.isDestroyed()) ? this.dialog : null;
+ if (pre_dialog){
+ // prevent previous dialog to consider itself closed,
+ // right now, as we're opening a new one (prevents
+ // reload of original form view)
+ pre_dialog.off('closing', null, pre_dialog.on_close);
+ }
if (this.dialog_widget && !this.dialog_widget.isDestroyed()) {
this.dialog_widget.destroy();
}
+ // explicitly passing a closing action to dialog_stop() prevents
+ // it from reloading the original form view
this.dialog_stop(executor.action);
this.dialog = new instance.web.Dialog(this, {
title: executor.action.name,
dialogClass: executor.klass,
});
- this.dialog.on("closing", null, options.on_close);
+
+ // chain on_close triggers with previous dialog, if any
+ this.dialog.on_close = function(){
+ options.on_close.apply(null, arguments);
+ if (pre_dialog && pre_dialog.on_close){
+ // no parameter passed to on_close as this will
+ // only be called when the last dialog is truly
+ // closing, and *should* trigger a reload of the
+ // underlying form view (see comments above)
+ pre_dialog.on_close();
+ }
+ };
+ this.dialog.on("closing", null, this.dialog.on_close);
if (widget instanceof instance.web.ViewManager) {
_.extend(widget.flags, {
$buttons: this.dialog.$buttons,
this.dialog.open();
return initialized;
} else {
+ // explicitly passing a closing action to dialog_stop() prevents
+ // it from reloading the original form view - we're opening a
+ // completely new action anyway
this.dialog_stop(executor.action);
this.inner_action = executor.action;
this.inner_widget = widget;
action_views_ids : views_ids
}, self.flags, self.flags[view.view_type] || {}, view.options || {})
});
-
+
views_ids[view.view_type] = view.view_id;
});
if (this.flags.views_switcher === false) {
}
// If no default view defined, switch to the first one in sequence
var default_view = this.flags.default_view || this.views_src[0].view_type;
-
+
return this.switch_mode(default_view, null, this.flags[default_view] && this.flags[default_view].options);
-
-
+
+
},
switch_mode: function(view_type, no_store, view_options) {
var self = this;
}
controller.on('switch_mode', self, this.switch_mode);
controller.on('previous_view', self, this.prev_view);
-
+
var container = this.$el.find("> div > div > .oe_view_manager_body > .oe_view_manager_view_" + view_type);
var view_promise = controller.appendTo(container);
this.views[view_type].controller = controller;
- this.views[view_type].deferred.resolve(view_type);
return $.when(view_promise).done(function() {
+ self.views[view_type].deferred.resolve(view_type);
if (self.searchview
&& self.flags.auto_search
&& view.controller.searchable !== false) {
}
views.push(mode);
}
+ instance.web.bus.trigger('view_switch_mode', self, mode);
});
var item = _.extend({
widget: this,
url: '/web/tests?mod=*'
});
break;
- case 'perm_read':
+ case 'get_metadata':
var ids = current_view.get_selected_ids();
if (ids.length === 1) {
- this.dataset.call('perm_read', [ids]).done(function(result) {
+ this.dataset.call('get_metadata', [ids]).done(function(result) {
var dialog = new instance.web.Dialog(this, {
- title: _.str.sprintf(_t("View Log (%s)"), self.dataset.model),
+ title: _.str.sprintf(_t("Metadata (%s)"), self.dataset.model),
size: 'medium',
}, QWeb.render('ViewManagerDebugViewLog', {
perm : result[0],
return self.switch_mode(state.view_type, true);
})
);
- }
+ }
- $.when(defs).done(function() {
+ $.when(this.views[this.active_view] ? this.views[this.active_view].deferred : $.when(), defs).done(function() {
self.views[self.active_view].controller.do_load_state(state, warm);
});
},
add_items: function(section_code, items) {
var self = this;
if (items) {
- this.items[section_code].push.apply(this.items[section_code],items);
+ this.items[section_code].unshift.apply(this.items[section_code],items);
this.redraw();
}
},
if (action_data.special === 'cancel') {
return handler({"type":"ir.actions.act_window_close"});
} else if (action_data.type=="object") {
- var args = [[record_id]], additional_args = [];
+ var args = [[record_id]];
if (action_data.args) {
try {
// Warning: quotes and double quotes problem due to json and xml clash
// Maybe we should force escaping in xml or do a better parse of the args array
- additional_args = JSON.parse(action_data.args.replace(/'/g, '"'));
+ var additional_args = JSON.parse(action_data.args.replace(/'/g, '"'));
args = args.concat(additional_args);
} catch(e) {
console.error("Could not JSON.parse arguments", action_data.args);
},
do_show: function () {
this.$el.show();
+ instance.web.bus.trigger('view_shown', this);
},
do_hide: function () {
this.$el.hide();
/**
* Switches to a specific view type
*/
- do_switch_view: function() {
+ do_switch_view: function() {
this.trigger.apply(this, ['switch_mode'].concat(_.toArray(arguments)));
},
- /**
- * Cancels the switch to the current view, switches to the previous one
- *
- * @param {Object} [options]
- * @param {Boolean} [options.created=false] resource was created
- * @param {String} [options.default=null] view to switch to if no previous view
- */
-
- do_search: function(view) {
+ do_search: function(domain, context, group_by) {
},
on_sidebar_export: function() {
new instance.web.DataExport(this, this.dataset).open();
if (typeof model === 'string') {
model = new instance.web.Model(args.model, args.context);
}
- return args.model.call('fields_view_get', [args.view_id, args.view_type, args.context, args.toolbar]).then(function(fvg) {
+ return args.model.call('fields_view_get', {
+ view_id: args.view_id,
+ view_type: args.view_type,
+ context: args.context,
+ toolbar: args.toolbar
+ }).then(function(fvg) {
return postprocess(fvg);
});
};