| Age | Commit message (Collapse) | Author |
|---|
|
This commit introduce a full redesign of all JS views. We started
basically from scratch. The goal was to unify all the various views
under a common framework, to make them testable, to make then usable in
different conditions (in studio, or in the frontend), and to make our
lives easier.
Some important points are:
- we introduced new coding guidelines (camelCase, 80 chars width, ...)
- we have a brand new testing framework (still QUnit based)
- kanban view moved to the web addon
- calendar view (formerly web_calender) moved to web as well
- the tree view was removed
- all new code should be documented
We hope that this code is the start of a new era for the Odoo web
client, we want to have a high quality codebase, well documented, well
tested, well designed.
Work done by the framework team: mostly aab, ged, chm, dmo, qsm
|
|
Purpose:
========
When user opens a wizard , the cursor should be placed in the first field which saves a click for the user.
Right now , in odoo the cursor is not coming in the first field by default.
|
|
Instantiate the Dialog with the optional dialog_size specified in
the action's context.
|
|
|
|
This comportement was added in the DebugManager to trigger an event.
As this event could be useful in other situations (e.g. studio), we trigger
the event directly in the ActionManager. By default, the WebClient does not
use this event but an handler is added to be overwritten.
This handler is overwritten in some widgets (DebugManager, Studio, etc.) that
requires the Systray items instances so we add them in ´widgets´ in the Systray Menu.
As the module dashboard uses multiple ActionManager, the event bubbling should be
avoided in this case.
|
|
|
|
|
|
Now that the debug URL parameter can be equal to "assets", the session
debug variable has to be updated to not only be true or false. Now, its
value is false if the debug parameter is not specified in the url and
a the URL parameter string value otherwise (or 1 if the value is an
empty string).
Also modify all redirection which kept the debug mode to also keep
=assets. Use the $.param.querystring function.
|
|
|
|
New value for the selection field 'target' of ir_actions_act_window which
forces the breadcrumbs to be cleared before executing the action.
|
|
Before this commit, the action manager could in some case have a
reference of a modal dialog, even after it has been destroyed (for
example, when the "X" button has been clicked to close a modal).
Unfortunately, it has some unexpected consequences, for example, the
do_push_state method check the existence of self.dialog to update the
url.
|
|
With this commit, actions can have a type=fullscreen. This means that
the navbar will be hidden, for the action and for all subsequent actions
open in the breadcrumb
There is no real security behind this, this is just a feature for
convenience, so users can bookmark an url an open some action in a way
that they are not distracted by anything. In short, this is some kind of
light 'kiosk' mode.
|
|
Avoid duplicating web addon in enterprise by extracting a common basis.
Enterprise features stay in enterprise, but use that common basis.
Mainly:
- JS refactoring and linting
- Conversion of .sass into .less split into multiple files
- Templates cleaning and DOM simplification
- Re-generation of web.pot, and update of .po files
|
|
Introduction of 'data_manager' service which handles meta-data related to
actions and views (fields_views, fields and filters). Ideally, all RPCs to
get that kind of information should go through data_manager, as it holds an
internal cache.
|
|
|
|
After a refresh or when opening odoo in a new tab, if view_type="form" is
specified in the url, RPCs to load the default multi-record view will be
performed if/when the user clicks on the breadcrumbs.
Moreover, the view manager is directly initialized with the res_id to load
after a refresh on a form view, to prevent the form view to fetch the defaults
values, to render in 'create' more, and then load the requested record and
switch back to 'view' mode.
Some code refactoring as well:
- don't propagate state to the view_manager, but directly the view_type and
res_id
- remove unused argument no_store from switch_mode()
- view_registry.get(): remove unused second argument
- no need to switch_mode in do_load_state() as the correct mode is now loaded
directly, even if it is a mono-record view
Also adapt code in dashboard.js according to changes in view_manager.
|
|
Always initialize a view_manager with its dataset and views, but without the
action (at least explicitely, as the action might still be given within the
options).
This is a backport of changes in enterprise to keep the view_manager's API
similar in both repository, which is required the large refactoring that will
arrive.
|
|
We fixed it for the graph view in 6bdf72bac5f6e8 but this
needs to be fixed for every views.
|
|
The problem occured when the user quickly clicked several times on the view
switcher or the breadcrumbs. The function switch_mode() of the view manager
was called once per click. This function's role is to prepare the requested
view, and once it is ready, to remove the former one from the DOM and insert
the new one instead. It is thus asynchronous as it waits for the
fields_view_get and search_read RPCs' response.
Unfortunately, when those calls to switch_mode() overlapped, the former view
reference was lost and it was thus never removed, producing a weird situation
where two views were displayed one above the other. This may happen when a
view takes a while to load, or simply when the user double-clicks on the
breadcrumbs or view switcher.
This rev. makes sure that calls to switch_mode() can never overlap by refusing
any other call when there is still one processing.
We also added a protection against breadcrumbs and view switcher double-clicks.
opw 658924
|
|
Keep debug mode status when going on another location url (backend,
frontend, pos, ...).
|
|
Opening a view (kanban or list) in a dialog thanks to a target=new
action did not work anymore (only in community).
The cause was the 'search_view' action flag which was set to false
in case of a popup (preventing the view to search the records and so
to display them). This commit sets this flag to true if the popup
has to display a list/kanban view.
Backport of aab enterprise work.
|
|
|
|
when there is a view_id parameter in the url, the web client should
honor that request, instead of using default view
|
|
The options dictionnary given when performing a do_action is now transmitted
to the client action initialization.
This was required for the mail client action, to correctly redirect to a given
channel.
|
|
When an error occured while executing an action (e.g. access rights), the
action manager's state was inconsistent as inner_action, inner_widget and
action_stack were all updated before trying to execute the action. Then, if the
user tried to open another action, the screen was split into two because the
reference of the previous action was lost, and thus it couldn't be detached.
We now restore inner_action, inner_widget and action_stack to their previous
state in the case of a rejected deferred.
A better fix would be to update all three variables once the deferred is
resolved, but it would require a refactoring of the way the action manager
and the view manager communicate to perform the do_push_state and to compute
the breadcrumbs. Indeed, those operations directly rely on the internal state
of the action manager, and they are performed before the callbacks in
push_state are called. Such a refactoring should probably not be done in
stable.
Partly fixes #8886.
|
|
when the widget's title changes, as it is displayed in the breadcrumbs
|
|
Client actions are wrapped into a container since rev. 4e24b816. However,
when opening a new action from a client action (i.e. when stacking over a
client action), the client action should be detached together with its
container. It wasn't the case as only the action was detached.
|
|
for widgets that don't use it, instead of hidding it directly. Doing so, the
control panel is hidden simultaneously with the old view, and there is no more
flickering.
|
|
When clicking on the breadcrumb to come back to a previously loaded action, the
restore() function is called. With this rev, this old action is shown only once
the Deferred returned by the optional on_reverse_breadcrumb callback is
resolved, i.e. when the action is ready, as it should be.
|
|
this way we can style the div and use the trick to have the child of a
flex-item filling 100% of its parent (flex item in relative position and
flex child in an absolute position). It is needed to have a consistent
look betwenn Odoo enterprise and Odoo community.
|
|
The problem of $el.show()/hide() is that calling show() on a jQuery element on which
there is no display rule in the stylesheet automatically sets 'display: block'.
However, when a jQuery element is not yet in the DOM, the rules defined on it are not yet
applied, meaning that calling show() will set its display to block (in inline style),
even if there is different a css rule (e.g. 'dislay: flex'). As the inline style takes the
priority over the stylesheet, the correct display won't be applied, even when the widget
will be appended in the DOM, resulting in a possibly broken layout.
|
|
The main purpose of this commit is to be consistent with the enterprise edition,
in which the event 'DOM_updated' is triggered when new content is inserted in
the DOM. This way, addons that need to know when a view has been attached in the DOM
(e.g. web_tip) can listen to this event and will work fine with both editions
of the web addon.
With the actual structure of the webclient (action_manager, view_manager),
there is no easy way to decide whether or not a view is attached in the DOM,
because every rendering is performed in a detached element. For instance,
when a view_manager instantiates a new view, it appends it in its $el once
the view is ready, but it can't know if its $el is attached in the DOM (it is
only the case if the view_manager is the current action of the action manager).
This rev. introduces utility functions to centralize the appending/prepending of
content, so that an event can be triggered (at a unique place) when the content
is really in the DOM. These functions are used by the the action_manager and the
view_manager.
Another change is that the action_manager keeps the view_manager informed when
they are attached in/detached from the DOM, through the variable is_in_DOM.
|
|
instead of the browser confirm dialogs, for the sake of uniformity.
|
|
|
|
|
|
|
|
if the inner widget doesn't use it.
|
|
|
|
Creation of the ControlPanelMixin that should be used by widgets
needing a ControlPanel. It facilitates the way those widgets communicate
with the ControlPanel to update it according to their status.
From now on, client action widgets can easily use the main ControlPanel.
|
|
When a new state is rendered, it is now first appended to a
documentFragment, and then appended to the DOM when ready. Doing so,
there is no more a intermediate step where two widgets are in the DOM,
the new one being appended below.
This required a web_calendar fix:
Not exactly fixed per-se, apparently when fullcalendar is rendered
hidden/out of document it doesn't generate correct range dates, and
calls the events callback with invalid dates. The code would blindly
take those invalid date, get bits out of them (NaN), generate a
timestamp full of NaNs and blindly search() the table with that.
Just skip the events callback entirely if the start or end date of the
current period is invalid (~isNaN(date.valueOf())).
|
|
Creation of the One2ManyControlPanel template. The One2ManyControlPanel
can only contain action_buttons and a pager. Typically, in One2Many
Kanban, buttons are displayed (in edit mode) and in One2Many Lists,
the pager is displayed.
Improvement of all Views.buttons templates so that if there is no
button to render, it does not render an empty div. This was necessary
for Kanban buttons to prevent padding when there is no button
displayed. Changes in the other views were motivated by uniformity
concerns. This prevents to add empty div in the DOM as well.
Exception for FormView where the outer div is required for the option
footer_to_buttons to work.
This fixes a bug as the pager is now available in One2Many Lists, which
was not the case before, even if there were more than 80 items in the
list, i.e. some items were unreachable.
cp_bus argument in ViewManager init() is now required. If there is no
ControlPanel to communicate with, a dummy Bus should be given ot the
ViewManager.
|
|
Big refactoring of Action, WidgetAction and ViewManagerAction to clean
their API. Mainly, renamming from State to Action and removal of unused
functions (or functions that are only used by the DebugManager, for
which we tolerate introspection).
Some logic has also been moved from the ActionManager to the Actions
themselves. The specific behavior of each type of Action is now handled
in the implementation of those Actions.
In ActionManager, this.states is renammed to this.action_stack to be
consistent with view_stack in ViewManager.
The setup_search_view() and render_switch_buttons() functions have been
moved from ControlPanel to ViewManager as it was before, since actual
design allows it and it makes more sense.
The ControlPanel API has also been simplified as some functions were not
used anymore. The ControlPanel is now updated directly by the widgets
using it, bypassing the ActionManager. The control panel elements are
stored by the widgets themselves to allow restoring them later.
|
|
Change the logic of rendering and displaying/hidding the control
elements (buttons, sidebar and pager) of all views. The views do no
more render automatically their elements as this is rather done
through the render_[element] function called by the ViewManager.
This function only appends the element to the $node given as argument.
If no argument is given, then it may appends it to the DOM directly,
within the adequate div of its template.
This allows the ViewManager to attach/detach all elements of the
ControlPanel in an atomic may, to prevent the ControlPanel from
flickering.
Also detach the contents of the ControlPanel in headless mode. Headless
means that the ControlPanel exists, but is hidden. Detaching its
contents permits to have a cleaner DOM.
Also remove the oe_form_dirty class on the buttons in the FormView, as
this class is only used on the view itself.
Side changes:
* base_import: import.js:
Extend render_buttons function to be compliant with the new buttons
rendering logic
* board: dashboard.js:
Set flag search_view to True as the searchview is needed for the
Views displayed in the Dashboard to retrieve the records to display.
Necessary since we do no more construct the searchview when this
is set to false
* google_drive: drive.js,
share: share.js:
Module extending the Sidebar widget often add their own buttons
by extending the start(), which is called each time the Widget
is appended to the DOM. With our new design, this could be done
in start() anymore as it should be done only one. It is now done
in init() instead.
|
|
Creation of a widget for the DebugManager and move it from the ControlPanel
to the Systray.
Refactoring of the widget to improve/facilitate the way of adding
options in the DebugManager as the view_editor does.
Add a do_action() function in the WebClient that forwards the action to
the main ActionManager so that widget that are not in the scope of the
ActionManager (e.g. Menu) can performed actions as well.
Note: The DebugManager is currently in the Systray but it will finally be
moved to a dedicated spot above the ControlPanel.
|
|
A unique main ControlPanel is instantiated by the ActionManager and it
is updated each time the state changes (i.e. when an action is performed
on the ActionManager or when switch_mode() is called on the ViewManager).
Introduction of State classes to facilitate the way of restoring
previously rendered states in ControlPanel. The notion of widgets
previously used in the ActionManager is now encapsulated in the notion
of states.
The search() function has been moved from ControlPanel to ViewManager as
it makes more sense like this.
The ViewManager doesn't have the reference to the ControlPanel but
rather communicate with it through a dedicated bus.
Some refactoring has been done on the ControlPanel as well so that it
doesn't need to know the ActionManager and the current Action anymore
(it communicates with the AM with events, and it updates itself using
information passed in arguments).
Improves the way the ViewManager requests the ControlPanel to
instantiate a SearchView, and how it waits for this SearchView to be
corretly loaded.
Move back the views logic to the ViewManager which directly asks
the ControlPanel to render the buttons and switch-buttons areas with
the views passed in arguments.
Removes option replace_breadcrumb in push_state() of ActionManager as it
is not used.
Side changes:
* Account: account_widget.js:
Adapt code to retrieve the current state of the ActionManager.
Required due to the introduction of State classes that encapsulate
the notions of widgets and inner_widget in the ActionManager.
* Board: dashboard.js:
Some refactoring to adapt the code according to the new Widgets
structure. Several dependencies (e.g. searchview, action) were
unnecessary. Do not append the "add to dashboard" option to the
Favorite menu if there is no ViewManager available (e.g. in
Messaging) instead of hidding it with a CSS rule, as a ViewManager
required to retrieve the active_view.
* Google_spreadsheet: search.js:
Change the way to retrieve the list_view_id s.t. it does not rely on
parent of the SearchView anymore.
* Web: search.js:
Change the way to retrieve the title in search.js for Favorites s.t.
it does not rely on the parent of the SearchView anymore. Doing so,
the ControlPanel does not need the title attribute anymore.
|
|
The ControlPanel is still instantiated by the ViewManager.
Changes details:
* web: views.js:
Code related to views header is extracted from the ViewManager
to a new Widget named ControlPanel.
Also uses the headless flag to tell the inner view not to put
its buttons (use case: kanban) or pager (use case: list) in the
header as it is hidden.
* web: view_form.js, base.xml:
Uses the headless flag at initialization of the One2ManyViewManager
widget instead of extending the ViewManager template (which doesn't
handle the header anymore).
* web: view_list.js:
Test on this.options.$pager instead of this.options.$buttons
when dealing with pager.
Note: the behavior for list view is unchanged and has a bug.
If there are more then 80 records to display, only the 80th
first are display, and as there is no pager, there is no way
to see the remaining ones. A fix for this would be to use a
light ControlPanel in One2Many views as well. With this,
there won't be duplicated .oe-'view'-buttons/sidebar/pager
anymore.
* web: view_graph.js, view_pivot.js:
Only render buttons in non-headless mode
* web_dashboard: dashboard.js:
Fix some references that were broken with ControlPanel extraction
* web_view_editor: web_view_editor.js:
Extend ControlPanel instead of ViewManager
* Changes in selector of ControlPanel elements in several addons:
* base_import
* mail
* web
|
|
The module system needs to know the dependencies of a given module
before executing the function. This is why the dependencies were
defined once in an array, and then were described one more times in the
call to require.
But a trick can simplify this: the boot function can parse the string
representation of the module and extract the calls to require from it.
It is more work for the processor, but it leads to simpler module
definitions.
|
|
This commit introduces a new module system for the javascript code.
Instead of using global (namespaced) variables everywhere (like
openerp.web.whatever, ...), each file declare one (or more) module
with its dependencies. Each module will be loaded after its
dependencies, and will be given a reference to the return values.
This change is a massive departure from the way the client worked
previously. It will sadly break some/most history, but I am sure that
the future git ecosystem will allow you to easily browse the history
past this revision (one can dream).
This commit feature:
* main namespace is now odoo instead of openerp
* a way to define modules and dependencies (inspired by requirejs)
* many files have been splitted in simpler subfiles
* basic support for debugging in odoo.__DEBUG__
* no global variable (i.e. nothing in window.openerp)
* many bug fixes, many new bugs
Future vision: this modularization should simplify future code
development, simplify debugging and will allow a serious testing effort
|
