1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

 _load: function (dataPoint, options) {
        if (options && options.onlyGroups &&
          !(dataPoint.type === 'list' && dataPoint.groupedBy.length)) {
            return Promise.resolve(dataPoint);
        }

        if (dataPoint.type === 'record') {
            return this._fetchRecord(dataPoint, options);
        }
        if (dataPoint.type === 'list' && dataPoint.groupedBy.length) {
            return this._readGroup(dataPoint, options);
        }
        if (dataPoint.type === 'list' && !dataPoint.groupedBy.length) {
            return this._fetchUngroupedList(dataPoint, options);
        }
    },

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

_fetchRecord: function (record, options) {
        var self = this;
        options = options || {};
        var fieldNames = options.fieldNames || record.getFieldNames(options);
        fieldNames = _.uniq(fieldNames.concat(['display_name']));
        return this._rpc({
                model: record.model,
                method: 'read',
                args: [[record.res_id], fieldNames],
                context: _.extend({bin_size: true}, record.getContext()),
            })
            .then(function (result) {
                if (result.length === 0) {
                    return Promise.reject();
                }
                result = result[0];
                record.data = _.extend({}, record.data, result);
            })
            .then(function () {
                self._parseServerData(fieldNames, record, record.data);
            })
            .then(function () {
                return Promise.all([
                    self._fetchX2Manys(record, options),
                    self._fetchReferences(record, options)
                ]).then(function () {
                    return self._postprocess(record, options);
                });
            });
    },

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

_render: function () {
        var oldAllFieldWidgets = this.allFieldWidgets;
        this.allFieldWidgets = {}; // TODO maybe merging allFieldWidgets and allModifiersData into "nodesData" in some way could be great
        this.allModifiersData = [];
        var oldWidgets = this.widgets;
        this.widgets = [];
        return this._renderView().then(function () {
            _.each(oldAllFieldWidgets, function (recordWidgets) {
                _.each(recordWidgets, function (widget) {
                    widget.destroy();
                });
            });
            _.invoke(oldWidgets, 'destroy');
        });
    },

1
2
3
4
5
6

class RendererWrapper extends ComponentWrapper {
    getLocalState() { }
    setLocalState() { }
    giveFocus() { }
    resetLocalState() { } 
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

_resetState() {
    // This check is used to avoid the destruction of the dropdown.
    // The click on the header bubbles to window in order to hide
    // all the other dropdowns (in this component or other components).
    // So we need isHeaderClicked to cancel this behaviour.
    if (this.isHeaderClicked) {
        this.isHeaderClicked = false;
        return;
    }
    this.state.activeNodeHeader = {
        groupId: false,
        isXAxis: false,
        click: false
    };
}

1
2
3
4
5
6

_startRenderer: function () {
    if (this.renderer instanceof owl.Component) {
        return this.renderer.mount(this.$('.o_content')[0]);
    }
    return this.renderer.appendTo(this.$('.o_content'));
},

1
2
3
4
5

custom_events: _.extend({}, ActionMixin.custom_events, {
    navigation_move: '_onNavigationMove',
    open_record: '_onOpenRecord',
    switch_view: '_onSwitchView',
}),

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

/**
 * This is the main entry point for the controller.  Changes from the search
 * view arrive in this method, and internal changes can sometimes also call
 * this method.  It is basically the way everything notifies the controller
 * that something has changed.
 *
 * The update method is responsible for fetching necessary data, then
 * updating the renderer and wait for the rendering to complete.
 *
 * @param {Object} params will be given to the model and to the renderer
 * @param {Object} [options={}]
 * @param {boolean} [options.reload=true] if true, the model will reload data
 * @returns {Promise}
 */
async update(params, options = {}) {
    const shouldReload = 'reload' in options ? options.reload : true;
    if (shouldReload) {
        this.handle = await this.dp.add(this.model.reload(this.handle, params));
    }
    const localState = this.renderer.getLocalState();
    const state = this.model.get(this.handle, { withSampleData: true });
    const promises = [
        this._updateRendererState(state, params).then(() => {
            this.renderer.setLocalState(localState);
        }),
        this._update(this.model.get(this.handle), params)
    ];
    await this.dp.add(Promise.all(promises));
    this.updateButtons();
    this.el.classList.toggle('o_view_sample_data', this.model.isInSampleMode());
},

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

if (this.withControlPanel) {
    this._updateControlPanelProps(this.initialState);
    this._controlPanelWrapper = new ComponentWrapper(this, this.ControlPanel, this.controlPanelProps);
    this._controlPanelWrapper.env.bus.on('focus-view', this, () => this._giveFocus());
    promises.push(this._controlPanelWrapper.mount(this.el, { position: 'first-child' }));
}
if (this.withSearchPanel) {
    this._searchPanelWrapper = new ComponentWrapper(this, this.SearchPanel, this.searchPanelProps);
    const content = this.el.querySelector(':scope .o_content');
    content.classList.add('o_controller_with_searchpanel');
    promises.push(this._searchPanelWrapper.mount(content, { position: 'first-child' }));
}

1
2
3

init: function (viewInfo, params) {
    //...
}

1
2
3
4

this.rendererParams = {};
this.controllerParams = {};
this.modelParams = {};
this.loadParams = {};