In case of unparsable cookie (modified, corrupted,...), openerp would not load and crash with white screen until expiration.
With the fix goes back to login screen.
bzr revid: mat@openerp.com-20140327120826-2p6ebnojtmdl1wpm
On SearchPopupCreation, if we have initial_ids - 1st search_read() will be
missing custom context defined on the field.
1. defined view like this: <field name='my_many2one_field_id' context="{'test': 1}"/>
2. in we expand the list of available item, name_search() has 'test' in context
3. in we click on 'Search More', search_read() is missing 'test' in context
4. if we change filter add/remove item, search_read() will have 'test' in context
Step 3. is wrong, should also have 'test' in context
lp bug: https://launchpad.net/bugs/1209295 fixed
bzr revid: mat@openerp.com-20140311091522-03imwd5rj3rmwapl
- Show the fields list once we save the first one
- When delete a list, remove the selected fields
- When add a list, do not remove the selected fields
bzr revid: mat@openerp.com-20140305100843-ircqtucf1pkn3wzd
When delete a record, correctly display the number of remaining items displayed (eg: 1-79 of 99)
When no more items in a page, force switch to previous page
When no more pager, reload the content to display potential items in next page
bzr revid: mat@openerp.com-20140303164114-pzeuu9hxvq17lx02
Instead returns undefined which is handled below.
This does not solve the issue when records are not loaded properly but gives a better information on the reason.
bzr revid: mat@openerp.com-20140213085008-pnq4r0ebfl072u78
Closing previously occured on search request (so that a user wouldn't be able
to select "old" data on new search request), but ``search`` is only triggered
after the search delay. Worked when delay was 0, with it being moved to 250 a
user can get results matching the previous search instead of the current one.
Trigger a closing of the current results list on any ``input`` event, which is
when text is entered in any of the searchview's ``InputView``
bzr revid: dle@openerp.com-20140210140032-06dnlxepcc5ae21f
revert because was breaking the rendering of forms using oe_title as clearfix hack
adding clear on .oe_form_group to fix the journal form on firefox (block was unaligned, some fields out of the screen)
bzr revid: jke@openerp.com-20140203173926-ohabh1vahcwqijug
E.g. this could happen when the HistoryBack client action
was unable to restore the previous breadcrumbs item, and
used the Home action as fallback. Could be reproduce by
performing a successful import from an action without
menu and context, such as what you get after refreshing
your browser.
bzr revid: odo@openerp.com-20140107161154-430y7hlf9mvtfyfe
When dropping, would simultanously stop the edition and try a write
(so 2 writes on the same record) and generally screw up the state of
all the things, ending up with an empty row and a weird (and
incorrect) warning.
This can be fixed by preventing resequencing during the creation or
edition of a record (row) inline.
For simplicity, implemented by looking up .ui-sortable descendants —
there are no utility methods for handling that and, aside from the
class, there's no good way to know if sortability was enabled on a
list body or not (as far as I can see, jquery-ui's sortable has no API
to query that) — and using jquery-ui's sortable API for enabling and
disabling sortable on the fly.
lp bug: https://launchpad.net/bugs/1257753 fixed
bzr revid: xmo@openerp.com-20131210124755-ugr3ehf744qoh1o5
Tabbing is intercepted by keydown_TAB, which — if the current cell is
the last active field of the row — will then call _next:476. _next
then calls save_edition:300 which "takes a lock" (more precisely
serializes access to its body) and within its body checks if an
edition is active (:303) and returns immediately if not (:304).
The problem here is when a second tab event arrives during the
potentially extremely long save_edition body (since for toplevel lists
it needs to perform a complete RPC call): the overall state of the
list has not changed so the second event *also* goes into _next, then
into save_edition. There it's serialized with the ongoing call and
thus inactive until said ongoing call's termination, and reaches the
body after the current edition has been wound down. As a result, the
body of _next (:408) gets the resolution of ``$.when()``, which is
``null`` and the first condition blows up.
There are 3 possible ways to fix this:
* adding a check in keydown_TAB's handler to see whether a _next call
is ongoing. This requires adding a state flag to the object and does
not protect (or cooperate with) _next calls from outside this
specific handler, unless they are modified in turn.
* alter save_edition to *fail* in case there's no ongoing edition:
this part was originally in ensure_saved which does not care whether
a save was necessary or not and does not propagate save information,
so ``$.when()`` made sense. In save_edition, there are really 3
different outcomes: the save succeeded, the save failed (or
potentially part of save's postprocessing failed, for the current
implementation) and the save was unnecessary. But deferred only
provide 1 bit of state (success or failure), so the last state has
to be merged into either success or failure.
Both make sense, to an extent. Changing from one to the other (as
necessary here) could break existing code and have more extensive
effects than expected.
* the simplest and least far-raging change is to just alter the
save_edition().then handler to ignore cases where save_edition()
results in no saveinfo, this can be assumed to be a
bailed-out/unnecessary save call.
For simplicity, the 3rd solution was picked here although with more
extensive tests &al I'd have preferred trying out 2nd.
lp bug: https://launchpad.net/bugs/1253899 fixed
bzr revid: xmo@openerp.com-20131210093055-207fevqc1npy7fwr
IME are ways to input language which can't trivially map to a keyboard
(e.g. CJK language) with a standard-ish keyboard. For japanese IME
this is done by entering text phonetically: text is entered in romaji
and automatically converted to hiragana (or katakana) when it matches
the transcription a japanese syllable (~phoneme?) e.g. to (と). The
text is then split and reprocessed with sequences of hiragana being
converted to kanji (or not), and the possibility to pick the right
kanji when multiple kanji match e.g. for "Tokyo" toukyou -> とうきょう
-> 東京.
But to do the edition, keyboard keys are used. For the japanese IMEs
(tested on Windows, OSX and Linux) [Space] will do the initial
conversion from kana to kanji (and allow selecting an other conversion
or a different kana split) and [Return] will validate the current
conversion (removing the underline marking "unvalidated" kana or kanji
groups).
And that's where the problem hit: IME + browser combinations may or
may not suppress part of all of the event. Firefox will trigger a
keydown of the key which "starts" IME input (e.g. "t") and will
trigger a keyup for the validation key (return), except on Linux where
the initial keydown is suppressed. Inbetween these, it will fire no
keydown, keyup or keypress event but will fire input events (at least
on an input element) every time the displayed text changes.
Meanwhile webkit browsers will, for each press on the keyboard during
IME,
* trigger a keydown with the keyCode 229
* trigger a keyup event with the keycode of the key which was actually
hit
* trigger input events every time the displayed text changes
This include meta-operation uses of [Space] and [Return].
MSIE has the same behavior (including triggering the input event), but
the keydown event is augmented with ``key`` and ``char`` attributes
providing the character matching the key hit to trigger the change.
Although the triggering of the input even is useless for the purpose
of the editable list (especially here, the purpose of validating a
list row with [Return] one fact stands out: keypress is never
triggered during IME operations, hitting the [Return] key outside of
IME will trigger keydow, keypress, keyup but doing so during IME will
only trigger the first and last.
Thus by changing the binding from keyup (return) to keypress (return)
for a line validation, spurious validation during IME text entry
should be avoided. This seems to work correctly on MSIE (Windows),
Firefox (Windows, OSX, Linux), Chrome (Windows, OSX, Linux) and Safari
(OSX), after testing in IE9, IE10, Chrome 31, Firefox 25 and Safari 7,
and a quick test on a task's o2m did not reveal any regression.
note: not all differences between various browser/os combinations were
inspected in details, there may well be further differences which were
not noticed or not relevant to this precise issue.
bzr revid: xmo@openerp.com-20131206124431-q4a9l1gn9wjtmlvz
Denis Ledoux
Martin Trigaux
Mohammed Shekha
Xavier ALT
Mohammed Shekha (OpenERP)
Cecile Tonglet
jke-openerp
Xavier ALT
Olivier Dony
Xavier Morel
Michel Meyer
Christophe Simonis
niv-openerp
Anael Closson
Vidhin Mehta