[REF] mail : include real time, and replace Timeline features

This commit add instant messaging features in mail module to make it a real team collaboration tool. Lots of these new features will replace Timeleine view (which is not removed in this commit). Many files have been moved, split or created for a better structure.

- My Channels : A user can be member of channel (mail.channel). These are discussion group, but also an aggregate of notification. Setting a channel as document follower, it will receive all the message (of the chatter) in real time, as information stream.

- A new Inbox : this aims to replace the timeline view. The user will see its channels grouped by 'slot', and receive the message in real time. Jump to the form view, invite people, create private discussion group, talk directly to another employee, ... are the main features. Your message can still be starred. The 'Inbox' will only contain your needaction.

- Needaction concept : a needaction is a message calling you to do something. If you follow a document as a person, the posted message will be 'needaction' for you. It can also be a message where you are mention with a '@my_name' (this feature is not added in this commit).

- The chatter doesn't change so much. It still allow you to see the discussion about the document, to star some message, and treat your needaction.

- Chat : the only way to have a minified conversation is from the Inbox Client Action. It allow you to keep an eye on a channel when working on document.

- Compose Message : it is now common to the Inbox, and the chatter. It offers shortcode substitution, attachments management, and optional subtype.

- UI : the chat window has been clean, they have a new look now.

To do so,
- Chatter code have been completely rewrite, independently of timeline view
- Add 'bus' as mail dependency, to insure real time
- A mail.message is broadcasted on the bus channel (db, mail.channel, channel_id), and a channel header on (db, res.partner, partner_id)
- Extracting mail_thread mixin used for Chatter and ChatMailThread (Inbox client action). This uniformize the programming structure with the server side
- Clean CSS style and use LESS instead of CSS
- Define a new messafe format (message_format method in mail_message.py), compatible with fetching and broadcasting
- Apply guideline coding conventions

This commit also break the module im_livechat, since im_chat models don't exists anymore and will be fixed in the next commit.

Thanks to Thibault Delavallee (tde) for the long debates and precious advices, Richard Mathot (rim) for the support, Simon Lejeune (sle) for the client action layout, and the Usability Team (apr, lle, bst yti) for the long testing.

Conflicts:
	addons/mail/models/mail_thread.py

7 files changed, 2162 insertions, 486 deletions

diff --git a/addons/mail/static/src/js/mail.js b/addons/mail/static/src/js/mail.js
index 9dd4b2c508d..8064fca4ee1 100644
--- a/addons/mail/static/src/js/mail.js
+++ b/addons/mail/static/src/js/mail.js
@@ -1167,7 +1167,7 @@ var ComposeMessage = Attachment.extend ({
         var names_to_find = _.pluck(recipients_to_find, 'full_name');
         var recipients_to_check = _.filter(recipients, function (recipient) { return (recipient.partner_id && ! recipient.email_address); });
         var recipient_ids = _.pluck(_.filter(recipients, function (recipient) { return recipient.partner_id && recipient.email_address; }), 'partner_id');
-        
+
         var names_to_remove = [];
         var recipient_ids_to_remove = [];
 
@@ -1236,7 +1236,7 @@ var ComposeMessage = Attachment.extend ({
                 });
             });
         });
-        
+
         return check_done;
     },
 
@@ -1445,10 +1445,10 @@ var ComposeMessageTopButton = Widget.extend({
 });
 
 // Put the ComposeMessageTopButton widget in the systray menu
-SystrayMenu.Items.push(ComposeMessageTopButton);
+//SystrayMenu.Items.push(ComposeMessageTopButton);
 
 core.view_registry.add('timeline', TimelineView);
-core.form_widget_registry.add('mail_thread', TimelineRecordThread);
+//core.form_widget_registry.add('mail_thread', TimelineRecordThread);
 
 return {
     TimelineView: TimelineView,
diff --git a/addons/mail/static/src/js/mail_chat_backend.js b/addons/mail/static/src/js/mail_chat_backend.js
index cd1cc00fdf2..9353afb68ab 100644
--- a/addons/mail/static/src/js/mail_chat_backend.js
+++ b/addons/mail/static/src/js/mail_chat_backend.js
@@ -1,301 +1,1032 @@
-odoo.define('im_chat.im_chat', function (require) {
+odoo.define('mail.chat_backend', function (require) {
 "use strict";
 
-// to do: make this work in website
-
 var bus = require('bus.bus');
 var core = require('web.core');
 var data = require('web.data');
-var Model = require('web.DataModel');
-var session = require('web.session');
+var Model = require('web.Model');
+var pyeval = require('web.pyeval');
 var SystrayMenu = require('web.SystrayMenu');
+var Widget = require('web.Widget');
+var Dialog = require('web.Dialog');
+var ControlPanelMixin = require('web.ControlPanelMixin');
+var SearchView = require('web.SearchView');
+var WebClient = require('web.WebClient');
+
+var session = require('web.session');
 var utils = require('web.utils');
 var web_client = require('web.web_client');
-var Widget = require('web.Widget');
-var im_chat_common = require('im_chat.im_chat_common');
+
+var mail_utils = require('mail.utils');
+var mail_chat_common = require('mail.chat_common');
+var mail_thread = require('mail.thread');
 
 var _t = core._t;
 var QWeb = core.qweb;
-
-var USERS_LIMIT = 20;
+var internal_bus = core.bus;
 
 
-// ########## CONVERSATION extentions ###############
-
-im_chat_common.ConversationManager.include({
-    _message_receive: function(message){
+/**
+ * Widget handeling the channels, in the backend
+ *
+ * Responsible to listen the bus and apply action with the received message.  Add layer to coordinate the
+ * folded conversation and trigger event for the InstantMessagingView client action (using internal
+ * comminication bus). It is a component of the WebClient.
+ **/
+var ConversationManagerBackend = mail_chat_common.ConversationManager.extend({
+    _setup: function(init_data){
         var self = this;
-        var session_id = message.to_id[0];
-        var conv = this.sessions[message.to_id[1]];
-        if(!conv){
-            // fetch the session, and init it with the message
-            var def_session = new Model("im_chat.session").call("session_info", [], {"ids" : [session_id]}).then(function(session){
-                conv = self.session_apply(session, {'force_open': true});
-                conv.message_receive(message);
-            });
-        }else{
-            this._super(message);
+        this._super.apply(this, arguments);
+        _.each(init_data['notifications'], function(n){
+            self.on_notification(n);
+        });
+    },
+    // window title
+    window_title_change: function() {
+        this._super.apply(this, arguments);
+        var title = undefined;
+        if (this.get("waiting_messages") !== 0) {
+            title = _.str.sprintf(_t("%d Messages"), this.get("waiting_messages"));
         }
+        web_client.set_title_part("im_messages", title);
     },
-});
-
-im_chat_common.Conversation.include({
-    // user actions
-    prepare_action_menu: function(){
-        this._super();
-        this._add_action(_t('Shortcuts'), 'im_chat_option_shortcut', 'fa fa-info-circle', this.action_shorcode);
-        this._add_action(_t('Quit discussion'), 'im_chat_option_quit', 'fa fa-minus-square', this.action_quit_session);
+    // sessions and messages
+    session_apply: function(active_session, options){
+        // for chat windows
+        if(active_session.is_minimized || (!active_session.is_minimized && active_session.state === 'closed')){
+            this._super.apply(this, arguments);
+        }
+        // for client action
+        if(!active_session.is_minimized){ // if not minimized,
+            internal_bus.trigger('mail_session_receive', active_session);
+        }
     },
-    action_shorcode: function(e){
-        return web_client.action_manager.do_action({
-            type: 'ir.actions.act_window',
-            name : _t('Shortcode'),
-            res_model: 'im_chat.shortcode',
-            view_mode: 'tree,form',
-            view_type: 'tree',
-            views: [[false, 'list'], [false, 'form']],
-            target: "new",
-            limit: 80,
-            flags: {
-                action_buttons: true,
-                pager: true,
-            }
+    message_receive: function(message) {
+        var actual_channel_ids = _.map(_.keys(this.sessions), function(item){
+            return parseInt(item);
         });
+        var message_channel_ids = message.channel_ids;
+        if(_.intersection(actual_channel_ids, message_channel_ids).length){
+           this._super.apply(this, arguments);
+        }
+        // broadcast the message to the NotificationButton and the InstantMessagingView
+        internal_bus.trigger('mail_message_receive', message);
+        // increment the needaction top counter
+        if(message.needaction_partner_ids && _.contains(message.needaction_partner_ids, session.partner_id)){
+            internal_bus.trigger('mail_needaction_new', 1);
+        }
     },
-    action_quit_session: function(e){
+});
+
+
+/**
+ * Widget Minimized Conversation
+ *
+ * Add layer of WebClient integration, and user fold state handling (comminication with server)
+ **/
+mail_chat_common.Conversation.include({
+    session_fold: function(state){
         var self = this;
-        var Session = new Model("im_chat.session");
-        return Session.call("quit_user", [this.get("session").uuid]).then(function(res) {
-            if(! res){
-                self.do_warn(_t("Warning"), _t("You are only 2 identified users. Just close the conversation to leave."));
-            }
+        var args = arguments;
+        var super_call = this._super;
+        // broadcast the state changing
+        return new Model("mail.channel").call("channel_fold", [], {"uuid" : this.get("session").uuid, "state" : state}).then(function(){
+            super_call.apply(self, args);
         });
     },
-    // session
-    session_update_state: function(state){
+});
+
+/**
+ * Widget : Patch for WebClient
+ *
+ * Create the conversation manager, and attach it to the web_client.
+ **/
+WebClient.include({
+    show_application: function(){
         var self = this;
         var args = arguments;
         var super_call = this._super;
-        // broadcast the state changing
-        return new Model("im_chat.session").call("update_state", [], {"uuid" : this.get("session").uuid, "state" : state}).then(function(){
+        this.mail_conversation_manager = new ConversationManagerBackend(this);
+        this.mail_conversation_manager.start().then(function(){
             super_call.apply(self, args);
+            self.mail_conversation_manager.bus.start_polling();
         });
     },
-    // window title
-    window_title_change: function() {
-        this.super();
-        var title = undefined;
-        if (this.get("waiting_messages") !== 0) {
-            title = _.str.sprintf(_t("%d Messages"), this.get("waiting_messages"))
-        }
-        web_client.set_title_part("im_messages", title);
+});
+
+
+/**
+ * Widget Top Menu Notification Counter
+ *
+ * Counter of notification in the Systray Menu. Need to know if InstantMessagingView is displayed to
+ * increment (or not) the counter. On click, should redirect to the client action.
+ **/
+var NotificationTopButton = Widget.extend({
+    template:'mail.chat.NotificationTopButton',
+    events: {
+        "click": "on_click",
     },
-    // TODO : change this way
-    add_user: function(user){
-        return new Model("im_chat.session").call("add_user", [this.get("session").uuid , user.id]);
+    init: function(parent){
+        this._super.apply(this, arguments);
+        this.set('counter', 0);
+    },
+    willStart: function(){
+        var self = this;
+        return $.when(session.rpc('/mail/needaction'), this._super()).then(function(needaction_count){
+            self.set('counter', needaction_count);
+        });
+    },
+    start: function() {
+        var self = this;
+        this.on("change:counter", this, this.on_change_counter);
+        // events
+        internal_bus.on('mail_needaction_new', this, this.counter_increment);
+        internal_bus.on('mail_needaction_done', this, this.counter_decrement);
+        return this._super();
+    },
+    counter_increment: function(inc){
+        this.set('counter', this.get('counter')+inc);
+    },
+    counter_decrement: function(dec){
+        this.set('counter', this.get('counter')-dec);
+    },
+    on_change_counter: function() {
+        this.$('.fa-comment').html(this.get('counter') || '');
+    },
+    on_click: function(e){
+        e.preventDefault();
+        this.do_action({
+            type: 'ir.actions.client',
+            tag: 'mail.chat.instant_messaging',
+            params: {
+                'default_active_id': 'channel_inbox',
+            },
+        }, {
+            clear_breadcrumbs: true,
+        });
     },
 });
 
+SystrayMenu.Items.push(NotificationTopButton);
 
 
-// ###### BACKEND : contact panel, top menu button #########
-
-var UserWidget = Widget.extend({
-    template: "im_chat.UserWidget",
+/**
+ * Abstract Class to 'Add More/Search' Widget
+ *
+ * Inputbox using jQueryUI autocomplete to fetch selection, like a Many2One field (on form view)
+ * Used to create or pin a mail.channel or a res.partner on the InstantMessagingView
+ **/
+var AbstractAddMoreSearch = Widget.extend({
+    template: 'mail.chat.AbstractAddMoreSearch',
     events: {
-        "click": "activate_user",
+        "click .o_mail_chat_add_more_text": "on_click_text",
+        "blur .o_mail_chat_search_input": "_toggle_elements",
     },
-    init: function(parent, user) {
-        this._super(parent);
-        this.set("id", user.id);
-        this.set("name", user.name);
-        this.set("im_status", user.im_status);
-        this.set("image_url", user.image_url);
+    init: function(parent, options){
+        this._super.apply(this, arguments);
+        options = _.defaults(options || {}, {
+            'can_create': false,
+            'label': _t('+ Add More'),
+        });
+        this.limit = 10;
+        this.can_create = options.can_create;
+        this.label = options.label;
     },
-    start: function() {
-        this.$el.data("user", {id:this.get("id"), name:this.get("name")});
-        this.$el.draggable({helper: "clone"});
-        this.on("change:im_status", this, this.update_status);
-        this.update_status();
+    start: function(){
+        var self = this;
+        this.last_search_val = false;
+        this.$input = this.$('.o_mail_chat_search_input');
+        this._bind_events();
+        return this._super();
     },
-    update_status: function(){
-        this.$(".oe_im_user_online").toggle(this.get('im_status') !== 'offline');
-        var img_src = (this.get('im_status') == 'away' ? '/im_chat/static/src/img/yellow.png' : '/im_chat/static/src/img/green.png');
-        this.$(".oe_im_user_online").attr('src', img_src);
+    _bind_events: function(){
+        // autocomplete
+        var self = this;
+        this.$input.autocomplete({
+            source: function(request, response) {
+                self.last_search_val = request.term;
+                self.do_search(request.term).done(function(result){
+                    if(self.can_create){
+                        result.push({
+                            'label':  _.str.sprintf('<strong>'+_t("Create %s")+'</strong>', '<em>"'+self.last_search_val+'"</em>'),
+                            'value': '_create',
+                        });
+                    }
+                    response(result);
+                });
+            },
+            select: function(event, ui) {
+                self.on_click_item(ui.item);
+            },
+            focus: function(event, ui) {
+                event.preventDefault();
+            },
+            html: true,
+        });
+    },
+    // ui
+    _toggle_elements: function(){
+        this.$('.o_mail_chat_add_more_text').toggle();
+        this.$('.o_mail_chat_add_more_search_bar').toggle();
+        this.$input.val('');
+        this.$input.focus();
     },
-    activate_user: function() {
-        this.trigger("user_clicked", this.get("id"));
+    on_click_text: function(event){
+        event.preventDefault();
+        this._toggle_elements();
+    },
+    // to be redefined
+    do_search: function(search_val){
+        return $.when();
+    },
+    on_click_item: function(item){
+        if(item.value === '_create'){
+            if(this.last_search_val){
+                this.trigger('item_create', this.last_search_val);
+            }
+        }else{
+            this.trigger('item_clicked', item);
+        }
     },
 });
 
-var InstantMessaging = Widget.extend({
-    template: "im_chat.InstantMessaging",
-    events: {
-        "keydown .oe_im_searchbox": "input_change",
-        "keyup .oe_im_searchbox": "input_change",
-        "change .oe_im_searchbox": "input_change",
-    },
-    init: function(parent) {
-        this._super(parent);
-        this.shown = false;
-        this.set("right_offset", 0);
-        this.set("current_search", "");
-        this.users = [];
-        this.widgets = {};
-
-        // listen bus
-        this.bus = bus.bus;
-        this.bus.on("notification", this, this.on_notification);
+var PartnerAddMoreSeach = AbstractAddMoreSearch.extend({
+    /**
+     * Do the search call
+     * @override
+     */
+    do_search: function(search_val){
+        var self = this;
+        var Partner = new Model("res.partner");
+        return Partner.call('im_search', [search_val, this.limit]).then(function(result){
+            var values = [];
+            _.each(result, function(user){
+                values.push(_.extend(user, {
+                    'value': user.name,
+                    'label': user.name,
+                }));
+            });
+            return values;
+        });
     },
-    start: function() {
+});
+
+var ChannelAddMoreSearch = AbstractAddMoreSearch.extend({
+    /**
+     * Do the search call
+     * @override
+     */
+    do_search: function(search_val){
         var self = this;
-        // ui
-        this.conv_manager = new im_chat_common.ConversationManager(this);
-        this.on("change:right_offset", this.conv_manager, _.bind(function() {
-            this.conv_manager.set("right_offset", this.get("right_offset"));
-        }, this));
-        $(window).scroll(_.bind(this.position_compute, this));
-        $(window).resize(_.bind(this.position_compute, this));
-        this.$el.css("right", -this.$el.outerWidth());
-        this.position_compute();
-
-        // business
-        this.on("change:current_search", this, this.user_search);
-
-        // add a drag & drop listener
-        self.conv_manager.on("im_session_activated", self, function(conv) {
-            conv.$el.droppable({
-                drop: function(event, ui) {
-                    conv.add_user(ui.draggable.data("user"));
+        var Channel = new Model("mail.channel");
+        return Channel.call('channel_search_to_join', [search_val]).then(function(result){
+            var values = [];
+            _.each(result, function(channel){
+                values.push(_.extend(channel, {
+                    'value': channel.name,
+                    'label': channel.name,
+                }));
+            });
+            return values;
+        });
+    },
+});
+
+var PrivateGroupAddMoreSearch = AbstractAddMoreSearch.extend({
+    _bind_events: function(){
+       // don't call the super to avoid autocomplete
+       this.$input.on('keyup', this, this.on_keydown);
+    },
+    on_keydown: function(event){
+        if(event.which === $.ui.keyCode.ENTER && this.$input.val()){
+            this.trigger('item_create', this.$input.val());
+        }
+    },
+});
+
+
+/**
+ * Widget : Invite People to Channel Dialog
+ *
+ * Popup containing a 'many2many_tags' custom input to select multiple partners.
+ * Search user according to the input, and trigger event when selection is validated.
+ **/
+var PartnerInviteDialog = Dialog.extend({
+    dialog_title: _t('Invite people'),
+    template: "mail.chat.PartnerInviteDialog",
+    init: function(parent, options){
+        options = _.defaults(options || {}, {
+            buttons: [{
+                text: _t("Invite"),
+                close: true,
+                classes: "btn-primary",
+                click: _.bind(this.on_click_add, this),
+            }],
+            channel: undefined,
+        });
+        this._super.apply(this, arguments);
+        this.set("partners", []);
+        this.channel = options.channel;
+        this.PartnersModel = new Model('res.partner');
+        this.ChannelModel = new Model('mail.channel');
+        this.limit = 20;
+    },
+    start: function(){
+        var self = this;
+        this.$('.o_mail_chat_partner_invite_input').select2({
+            width: '100%',
+            allowClear: true,
+            multiple: true,
+            formatResult: function(item){
+                if(item.im_status === 'online'){
+                    return '<span class="fa fa-circle"> ' + item.text + '</span>';
                 }
+                return '<span class="fa fa-circle-o"> ' + item.text + '</span>';
+            },
+            query: function (query) {
+                self.PartnersModel.call('im_search', [query.term, self.limit]).then(function(result){
+                    var data = [];
+                    _.each(result, function(partner){
+                        partner['text'] = partner.name;
+                        data.push(partner);
+                    });
+                    query.callback({results: data});
+                });
+            }
+        });
+        return this._super.apply(this, arguments);
+    },
+    on_click_add: function(){
+        var self = this;
+        var data = this.$('.o_mail_chat_partner_invite_input').select2('data');
+        if(data.length >= 1){
+            this.ChannelModel.call('channel_invite', [], {"ids" : [this.channel.id], 'partner_ids': _.pluck(data, 'id')}).then(function(){
+                var names = _.pluck(data, 'text').join(', ');
+                self.do_notify(_t('New people'), _.str.sprintf(_t('You added <b>%s</b> to the conversation.'), names));
+                self.close();
             });
+        }else{
+            self.close();
+        }
+    },
+});
+
+/**
+ * Client Action : Instant Messaging View, inspired by Slack.com
+ *
+ * Action replacing the Inbox, and the list of group (mailing list, multiple conversation, rooms, ...)
+ * Includes real time messages (received and sent), creating group, channel, chat conversation, ...
+ **/
+var ChatMailThread = Widget.extend(mail_thread.MailThreadMixin, ControlPanelMixin, {
+    template: 'mail.chat.ChatMailThread',
+    events: {
+        // events from MailThreadMixin
+        "click .o_mail_redirect": "on_click_redirect",
+        "click .o_mail_thread_message_star": "on_message_star",
+        // events specific for ChatMailThread
+        "click .o_mail_chat_channel_item": "on_click_channel",
+        "click .o_mail_chat_partner_item": "on_click_partner",
+        "click .o_mail_chat_partner_unpin": "on_click_partner_unpin",
+        "click .o_mail_thread_message_needaction": "on_message_needaction",
+    },
+    init: function (parent, action) {
+        this._super.apply(this, arguments);
+        // attributes
+        this.action_manager = parent;
+        this.help_message = action.help || '';
+        this.context = action.context;
+        this.action = action;
+        this.loading_history = false;
+        this.chatter_needaction_auto = false;
+        this.options = this.action.params;
+        // mail thread mixin
+        mail_thread.MailThreadMixin.init.call(this);
+        // components : conversation manager and search widget (channel_type + '_search_widget')
+        this.conv_manager = web_client.mail_conversation_manager;
+        this.channel_search_widget = new ChannelAddMoreSearch(this, {'label': _t('+ Subscribe'), 'can_create': true});
+        this.group_search_widget = new PrivateGroupAddMoreSearch(this, {'label': _t('+ New private group'), 'can_create': true});
+        this.partner_search_widget = new PartnerAddMoreSeach(this);
+        // options (update the default of MailThreadMixin)
+        this.options = _.extend(this.options, {
+            'display_document_link': true,
+            'display_needaction_button': true,
+            'emoji_list': this.conv_manager.emoji_list,
         });
+        this.emoji_set_substitution(this.conv_manager.emoji_list);
+        // channel business
+        this.channels = {};
+        this.mapping = {}; // mapping partner_id/channel_id for 'direct message' channel
+        this.set('current_channel_id', false);
+        this.set('needaction_inbox_counter', 0);
+        this.search_domain = [];
+        // channel slots
+        this.set('channel_channel', []);
+        this.set('channel_direct_message', []);
+        this.set('channel_private_group', []);
+        this.set('partners', []);
+        // models
+        this.ChannelModel = new Model('mail.channel', this.context);
+        // control panel items
+        this.control_elements = {};
+    },
+    willStart: function(){
+        var self = this;
+        return session.rpc('/mail/client_action').then(function(result){
+            self.chatter_needaction_auto = result['chatter_needaction_auto'];
+            self.set('needaction_inbox_counter', result['needaction_inbox_counter']);
+            self.set('partners', result['channel_slots']['partners']);
+            self.mapping = result['channel_slots']['mapping'];
+            self._channel_slot(_.omit(result['channel_slots'], 'partners', 'mapping'));
+        });
+    },
+    start: function(){
+        var self = this;
+        this._super.apply(this, arguments);
+        mail_thread.MailThreadMixin.start.call(this);
+        // channel business events
+        this.on("change:current_channel_id", this, this.channel_change);
+        this.on("change:channel_channel", this, function(){
+            self.channel_render('channel_channel');
+        });
+        this.on("change:channel_private_group", this, function(){
+            self.channel_render('channel_private_group');
+        });
+        this.on("change:partners", this, this.partner_render);
 
-        // fetch the unread message and the recent activity (e.i. to re-init in case of refreshing page)
-        return session.rpc("/im_chat/init", {}).then(function(notifications) {
-            _.each(notifications, function(notif){
-                self.conv_manager.on_notification(notif, {'load_history': true});
+        // search widget for channel
+        this.channel_search_widget.insertAfter(this.$('.o_mail_chat_channel_slot_channel_channel'));
+        this.channel_search_widget.on('item_create', this, function(name){
+            self.channel_create(name, 'public');
+        });
+        this.channel_search_widget.on('item_clicked', this, function(item){
+            self.channel_join_and_get_info(item.id).then(function(channel){
+                self.channel_apply(channel);
+            });
+        });
+        // search widget for direct message
+        this.partner_search_widget.insertAfter(this.$('.o_mail_chat_channel_slot_partners'));
+        this.partner_search_widget.on('item_clicked', this, function(item){
+            self.channel_get([item.id]);
+            self.partner_add(item);
+        });
+        // search widget for private group
+        this.group_search_widget.insertAfter(this.$('.o_mail_chat_channel_slot_channel_private_group'));
+        this.group_search_widget.on('item_create', this, function(name){
+            self.channel_create(name, 'private');
+        });
+
+        // bind event to load history when scrolling near top
+        this.$('.o_mail_chat_messages').scroll(function() {
+            if ($(this).scrollTop() <= 50 && self.loading_history) { // at 50px of the top, load history
+                self.message_load_history().then(function(messages){
+                    if(messages.length < mail_thread.LIMIT_MESSAGE){
+                        self.loading_history = false;
+                    }
+                });
+            }
+        });
+
+        // needaction inbox counter
+        this.on('change:needaction_inbox_counter', this, this.needaction_inbox_change);
+
+        return $.when(this._super.apply(this, arguments), this.cp_render_searchview()).then(function(res){
+            // update control panel
+            self.cp_render_buttons();
+            // apply default channel
+            var channel_id = self.context.active_id || self.action.params['default_active_id'] || 'channel_inbox';
+            if(!_.isString(channel_id)){
+                if(_.contains(_.keys(self.channels), channel_id)){
+                    self.set('current_channel_id', channel_id);
+                }else{
+                    self.channel_info(channel_id).then(function(channel){
+                        self.channel_apply(channel);
+                    });
+                }
+            }else{
+                self.set('current_channel_id', channel_id);
+            }
+            // internal communication (bind here to avoid receving message from bus when client action still not totally ready)
+            internal_bus.on('mail_message_receive', self, self.message_receive);
+            internal_bus.on('mail_session_receive', self, self.channel_receive);
+            // needaction : the inbox has the same counter as the needaction top counter
+            internal_bus.on('mail_needaction_new', this, function(inc){
+                self.set('needaction_inbox_counter' , self.get('needaction_inbox_counter') + inc);
+            });
+            internal_bus.on('mail_needaction_done', this, function(dec){
+                self.set('needaction_inbox_counter' , self.get('needaction_inbox_counter') - dec);
             });
-            // start polling
-            self.bus.start_polling();
         });
     },
-    on_notification: function(notification){
-        var channel = notification[0];
-        var message = notification[1];
-        // user status notification
-        if(channel[1] === 'im_chat.presence'){
-            if(message.im_status){
-                this.user_update_status([message]);
+    // event actions
+    on_click_channel: function(event){
+        event.preventDefault();
+        var channel_id = this.$(event.currentTarget).data('channel-id');
+        this.set('current_channel_id', channel_id);
+    },
+    on_click_partner: function(event){
+        if(!this.$(event.target).hasClass('o_mail_chat_channel_unpin')){
+            event.preventDefault();
+            var partner_id = this.$(event.currentTarget).data('partner-id');
+            if(this.mapping[partner_id]){ // don't fetch if channel already in local
+                this.set('current_channel_id', this.mapping[partner_id]);
+            }else{
+                this.channel_get([partner_id]);
             }
         }
     },
-    // ui
-    position_compute: function() {
-        var top = 48;
-        this.$el.css("top", top);
-        this.$el.css("bottom", 0);
-    },
-    input_change: function() {
-        this.set("current_search", this.$(".oe_im_searchbox").val());
-    },
-    switch_display: function() {
-        this.position_compute();
-        var fct =  _.bind(function(place) {
-            this.set("right_offset", place + this.$el.outerWidth());
-            this.$(".oe_im_searchbox").focus();
-        }, this);
-        var opt = {
-            step: fct,
-        };
-        if (this.shown) {
-            this.$el.animate({
-                right: -this.$el.outerWidth(),
-            }, opt);
-        } else {
-            if (! bus.bus.activated) {
-                this.do_warn("Instant Messaging is not activated on this server. Try later.", "");
-                return;
+    on_click_partner_unpin: function(event){
+        event.preventDefault();
+        var self = this;
+        var $source = this.$(event.currentTarget);
+        var partner_id = $source.data('partner-id');
+        var channel_id = this.mapping[partner_id];
+        var channel = this.channels[channel_id];
+        this.channel_pin(channel.uuid, false).then(function(){
+            self.set('partners', _.filter(self.get('partners'), function(p){ return p.id !== partner_id; }));
+            self.channel_remove(channel_id);
+            delete self.mapping[partner_id];
+            // if unpin current channel, switch to inbox
+            if(self.get('current_channel_id') === channel_id){
+                self.set('current_channel_id', 'channel_inbox');
             }
-            // update the list of user status when show the IM
-            this.user_search();
-            this.$el.animate({
-                right: 0,
-            }, opt);
+        });
+    },
+    on_click_button_minimize: function(event){
+        event.preventDefault();
+        var current_channel = this.channels[this.get('current_channel_id')];
+        if(current_channel){
+            var channel_uuid = current_channel.uuid;
+            return this.ChannelModel.call("channel_minimize", [channel_uuid, true]);
         }
-        this.shown = ! this.shown;
+        return $.Deferred.reject();
     },
-    // user methods
-    user_search: function(e) {
+    on_click_button_invite: function(event){
+        var dialog = new PartnerInviteDialog(this, {
+            title: _.str.sprintf(_t('Invite people to %s.'), this.get_current_channel_name()),
+            channel: this.channels[this.get('current_channel_id')],
+        }).open();
+    },
+    on_click_button_unsubscribe: function(event){
         var self = this;
-        var user_model = new Model("res.users");
-        return user_model.call('im_search', [this.get("current_search"), USERS_LIMIT]).then(function(result){
-            self.$(".oe_im_input").val("");
-            var old_widgets = self.widgets;
-            self.widgets = {};
-            self.users = [];
-            _.each(result, function(user) {
-                user.image_url = session.url('/web/image', {model:'res.users', field: 'image_small', id: user.id});
-                var widget = new UserWidget(self, user);
-                widget.appendTo(self.$(".oe_im_users"));
-                widget.on("user_clicked", self, self.user_clicked);
-                self.widgets[user.id] = widget;
-                self.users.push(user);
-            });
-            _.each(old_widgets, function(w) {
-                w.destroy();
-            });
+        this.ChannelModel.call('action_unfollow', [[this.get('current_channel_id')]]).then(function(){
+            var channel = self.channels[self.get('current_channel_id')]
+            var slot = self.get_channel_slot(channel);
+            self.set(slot, _.filter(self.get(slot), function(c){ return c.id !== channel.id; }));
+            self.do_notify(_t('Unsubscribe'), _.str.sprintf(_t('You unsubscribe from <b>%s</b>.'), self.get_current_channel_name()));
+            self.set('current_channel_id', 'channel_inbox'); // jump to inbox
         });
     },
-    user_clicked: function(user_id) {
+    on_click_button_settings: function(event){
+        this.do_action({
+            type: 'ir.actions.act_window',
+            res_model: "mail.channel",
+            res_id: this.get('current_channel_id'),
+            views: [[false, 'form']],
+            target: 'current'
+        }, {
+            clear_breadcrumbs: true
+        });
+    },
+    on_message_needaction: function(event){
         var self = this;
-        var sessions = new Model("im_chat.session");
-        return sessions.call("session_get", [user_id]).then(function(session) {
-            self.conv_manager.session_apply(session, {'focus': true, 'force_open': true});
+        mail_thread.MailThreadMixin.on_message_needaction.call(this, event).then(function(message_id){
+            // decrement the needaction top counter
+            internal_bus.trigger('mail_needaction_done', 1);
+            // decrement the channel labels
+            var treated_messages = _.filter(self.get('messages'), function(m){ return m.id == message_id; });
+            if(treated_messages.length){
+                self.needaction_decrement(treated_messages[0].channel_ids || []);
+            }
         });
     },
-    user_update_status: function(users_list){
+    // control panel
+    cp_update: function(){
         var self = this;
-        _.each(users_list, function(el) {
-            if (self.widgets[el.id]) {
-                self.widgets[el.id].set("im_status", el.im_status);
+        var current_channel_id = this.get('current_channel_id');
+        var current_channel_name = this.get_current_channel_name();
+        // toggle cp buttons
+        if(_.isString(current_channel_id)){
+            self.control_elements.$buttons.find('button').hide();
+        }else{
+            self.control_elements.$buttons.find('button').show();
+            var current_channel = this.channels[current_channel_id];
+            if(current_channel.channel_type == 'chat'){
+                self.control_elements.$buttons.find('.o_mail_chat_button_invite, .o_mail_chat_button_more').hide();
             }
+        }
+        // update control panel
+        var status = {
+            breadcrumbs: this.action_manager.get_breadcrumbs().concat([{'title': current_channel_name, 'action': _.clone(this)}]),
+            cp_content: {
+                $buttons: self.control_elements.$buttons,
+                $searchview: self.control_elements.$searchview,
+                $searchview_buttons: self.control_elements.$searchview_buttons,
+                $switch_buttons: false,
+                $pager: false,
+            },
+            searchview: self.searchview,
+        };
+        this.update_control_panel(status, {clear: false});
+    },
+    cp_render_buttons: function() {
+        var self = this;
+        this.control_elements.$buttons = $(QWeb.render("mail.chat.ControlButtons", {}));
+        this.control_elements.$buttons.on('click', '.o_mail_chat_button_minimize', _.bind(this.on_click_button_minimize, this));
+        this.control_elements.$buttons.on('click', '.o_mail_chat_button_invite', _.bind(this.on_click_button_invite, this));
+        this.control_elements.$buttons.on('click', '.o_mail_chat_button_unsubscribe', _.bind(this.on_click_button_unsubscribe, this));
+        this.control_elements.$buttons.on('click', '.o_mail_chat_button_settings', _.bind(this.on_click_button_settings, this));
+    },
+    cp_render_searchview: function(){
+        var self = this;
+        var options = {
+            $buttons: $("<div>"),
+            action: this.action,
+        };
+        var view_id = (this.action && this.action.search_view_id && this.action.search_view_id[0]) || false;
+        this.searchview = new SearchView(this, this.MessageDatasetSearch, view_id, {}, options);
+
+        this.searchview.on('search_data', this, this.on_search);
+        return $.when(this.searchview.appendTo($("<div>"))).done(function() {
+            self.control_elements.$searchview = self.searchview.$el;
+            self.control_elements.$searchview_buttons = self.searchview.$buttons.contents();
+            // hack to hide 'group by' button, since it is not relevant
+            self.searchview.$buttons.find('.oe-groupby-menu').hide();
+        });
+    },
+    /**
+     * Method call when action if done after redirecting (using 'on_click_redirect')
+     * @override
+     */
+    on_reverse_breadcrumb: function(){
+        var current_channel_id = this.get('current_channel_id');
+        this.cp_update(); // do not reload the client action, just display it, but a refresh of the control panel is needed.
+        // push state
+        this.action_manager.do_push_state({
+            action: this.action.id,
+            active_id: current_channel_id,
+        });
+    },
+    // messages search methods
+    on_search: function(domains, contexts, groupbys){
+        var self = this;
+        return pyeval.eval_domains_and_contexts({
+            domains: [[]].concat(domains || []),
+            contexts: [this.context].concat(contexts || []),
+            group_by_seq: groupbys || []
+        }).done(function(results){
+            if (results.error) {
+                throw new Error(_.str.sprintf(_t("Failed to evaluate search criterions")+": \n%s", JSON.stringify(results.error)));
+            }
+            // modify the search domain and do search
+            self.search_domain = results.domain;
+            return self.message_load_new();
+        });
+    },
+    // channels
+    /**
+     * Set the channel slot
+     * @param {Object[]} fetch_result : should contains only the slot name (as key) and the list of channel header as value.
+     */
+    _channel_slot: function(fetch_result){
+        var self = this;
+        var channel_slots = _.keys(fetch_result);
+        _.each(channel_slots, function(slot){
+            // update the channel slot
+            self.set(slot, fetch_result[slot]);
+            // flatten the result : update the complete channel list
+            _.each(fetch_result[slot], function(channel){
+                self.channels[channel.id] = channel;
+            });
+        });
+    },
+    /**
+     * Apply a channel means adding it, and swith to it
+     * @param {Object} channel : channel header
+     */
+    channel_apply: function(channel){
+        this.channel_add(channel);
+        this.set('current_channel_id', channel.id);
+    },
+    /**
+     * Add the given channel, or update it if already exists and loaded
+     * @param {Object} channel : channel header to add
+     */
+    channel_add: function(channel){
+        var channel_slot = this.get_channel_slot(channel);
+        var existing = this.get(channel_slot);
+        if(_.contains(_.pluck(existing, 'id'), channel.id)){
+            // update the old channel
+            var filtered_channels = _.filter(existing, function(item){ return item.id != channel.id; });
+            this.set(channel_slot, filtered_channels.concat([channel]));
+        }else{
+            // simply add the reveiced channel
+            this.set(channel_slot, existing.concat([channel]));
+        }
+        // also update the flatten list
+        this.channels[channel.id] = channel;
+
+        // update the mapping for 'direct message' channel, and the partner list
+        if(channel_slot === 'channel_direct_message'){
+            var partner = channel.direct_partner[0];
+            this.mapping[partner.id] = channel.id;
+            this.partner_add(partner);
+        }
+    },
+    channel_remove: function(channel_id){
+        var channel = this.channels[channel_id];
+        var slot = this.get_channel_slot(channel);
+        this.set(slot, _.filter(this.get(slot), function(c){ return c.id !== channel_id; }));
+        delete this.channels[channel_id];
+    },
+    /**
+     * Get the channel the current user has with the given partner, and get the channel header
+     * @param {Number[]} partner_ids : list of res.partner identifier
+     */
+    channel_get: function(partner_ids){
+        var self = this;
+        return this.ChannelModel.call('channel_get', [partner_ids]).then(function(channel){
+            self.channel_apply(channel);
+        });
+    },
+    /**
+     * Create a channel with the given name and type, and apply it
+     * @param {String} channel_name : the name of the channel
+     * @param {String} privacy : the privacy of the channel (groups, public, ...)
+     */
+    channel_create: function(channel_name, privacy){
+        var self = this;
+        return this.ChannelModel.call('channel_create', [channel_name, privacy]).then(function(channel){
+            self.channel_apply(channel);
+        });
+    },
+    channel_info: function(channel_id){
+        var self = this;
+        return this.ChannelModel.call('channel_info', [[channel_id]]).then(function(channels){
+            return channels[0];
+        });
+    },
+    channel_pin: function(uuid, pinned){
+        return this.ChannelModel.call('channel_pin', [uuid, pinned]);
+    },
+    channel_join_and_get_info: function(channel_id){
+        return this.ChannelModel.call('channel_join_and_get_info', [[channel_id]]);
+    },
+    channel_change: function(){
+        var self = this;
+        var current_channel_id = this.get('current_channel_id');
+        var current_channel = this.channels[current_channel_id];
+        // mail chat compose message (destroy and replace it)
+        this.mail_chat_compose_message && this.mail_chat_compose_message.destroy();
+        this.mail_chat_compose_message = new mail_thread.MailComposeMessage(this, new data.DataSetSearch(this, 'mail.channel', this.context), {
+            'emoji_list': this.options.emoji_list,
+            'context': _.extend(this.context, {
+                'default_res_id': current_channel_id,
+            }),
+            'display_mode': 'chat',
+        });
+        if(_.isString(current_channel_id)){
+            this.$('.o_mail_chat_composer_wrapper').hide();
+        }else{
+            this.$('.o_mail_chat_composer_wrapper').show();
+        }
+        this.mail_chat_compose_message.appendTo(this.$('.o_mail_chat_composer_wrapper'));
+        this.mail_chat_compose_message.focus();
+
+        // push state (the action is referred by action_manager, and no reloaded when jumping
+        // channel, so update context is requried)
+        this.action.context['active_id'] = current_channel_id;
+        this.action.context['active_ids'] = [current_channel_id];
+        web_client.action_manager.do_push_state({
+            action: this.action.id,
+            active_id: current_channel_id,
         });
-    }
-});
 
+        // update control panel
+        this.cp_update();
 
-var ImTopButton = Widget.extend({
-    template:'im_chat.ImTopButton',
-    events: {
-        "click": "clicked",
+        // fetch the messages
+        return this.message_load_new().then(function(raw_messages){
+            // allow loading history
+            self.loading_history = true;
+            // if normal channel, update last message id, and unbold
+            var def = $.Deferred().resolve();
+            if(_.isNumber(current_channel_id)){
+                def = self.ChannelModel.call('channel_seen', [[current_channel_id]]);
+            }else{
+                // auto treat needaction from inbox
+                if(current_channel_id === 'channel_inbox' && self.chatter_needaction_auto){
+                    def = self.MessageDatasetSearch._model.query(['id', 'channel_ids']).filter([['needaction', '=', true]]).all().then(function(messages){
+                        // get needaction message ids
+                        var message_ids = _.pluck(messages, 'id');
+                        if(message_ids){
+                            // call to unlink
+                            self.MessageDatasetSearch._model.call('set_message_done',[message_ids]).then(function(){
+                                // decrement channel items in batch
+                                var flatten_channel_ids = _.flatten(_.pluck(messages, 'channel_ids'));
+                                var channel_count = _.countBy(flatten_channel_ids, function(cid) {
+                                  return cid;
+                                });
+                                _.each(_.keys(channel_count), function(cid){
+                                    self.needaction_decrement([cid], channel_count[cid]);
+                                });
+                                // decrement the needaction top counter
+                                internal_bus.trigger('mail_needaction_done', message_ids.length);
+                            });
+                        }
+                    });
+                }
+            }
+            def.then(function(){
+                self._toggle_unread_message(current_channel_id, false, true);
+                self._scroll();
+            });
+        });
     },
-    start: function() {
-        // Create the InstantMessaging widget and put it in the DOM
-        var im = new InstantMessaging(this);
-        web_client.im_messaging = im;
-        im.appendTo(web_client.$el);
-        // Bind the click action to the ImTopButton
-        this.on("clicked", im, im.switch_display);
-        return this._super();
+    channel_render: function(channel_slot){
+        this.$('.o_mail_chat_channel_slot_' + channel_slot).replaceWith(QWeb.render("mail.chat.ChatMailThread.channels", {'widget': this, 'channel_slot': channel_slot}));
+    },
+    // partners
+    partner_add: function(partner){
+        var partners = _.filter(this.get('partners'), function(p){ return p.id != partner.id; });
+        this.set('partners', partners.concat([partner]));
+    },
+    partner_render: function(){
+        this.$('.o_mail_chat_channel_slot_partners').replaceWith(QWeb.render("mail.chat.ChatMailThread.partners", {'widget': this}));
+    },
+    // needaction
+    needaction_increment: function(channel_ids, inc){
+        var self = this;
+        _.each(channel_ids, function(channel_id){
+            if(self.channels[channel_id]){
+                var count = (self.channels[channel_id].message_needaction_counter || 0) + (inc || 1);
+                self.channels[channel_id].message_needaction_counter = count;
+                self.$('.o_mail_chat_needaction[data-channel-id='+channel_id+']').html(count);
+                self.$('.o_mail_chat_needaction[data-channel-id='+channel_id+']').show();
+            }
+        });
     },
-    clicked: function(ev) {
-        ev.preventDefault();
-        this.trigger("clicked");
+    needaction_decrement: function(channel_ids, dec){
+        var self = this;
+        _.each(channel_ids, function(channel_id){
+            if(self.channels[channel_id]){
+                var count = (self.channels[channel_id].message_needaction_counter || 0) - (dec || 1);
+                self.channels[channel_id].message_needaction_counter = count;
+                self.$('.o_mail_chat_needaction[data-channel-id='+channel_id+']').html(count);
+                if(count <= 0){
+                    self.$('.o_mail_chat_needaction[data-channel-id='+channel_id+']').show();
+                }
+            }
+        });
+    },
+    needaction_inbox_change: function(inc){
+        var count = this.get('needaction_inbox_counter');
+        var $elem = this.$('.o_mail_chat_needaction[data-channel-id="channel_inbox"]');
+        $elem.html(count);
+        if(count > 0){
+            $elem.show();
+        }else{
+            $elem.hide();
+        }
+    },
+    // from bus
+    channel_receive: function(channel){
+        this.channel_add(channel);
+    },
+    message_receive: function(message){
+        var self = this;
+        // if current channel should reveice message, give it to it
+        if(_.contains(message['channel_ids'], this.get('current_channel_id'))){
+            this.message_insert([message]);
+        }
+        // for other message channel, get the channel if not loaded yet, and bolded them
+        var other_message_channel_ids = _.without(message['channel_ids'], this.get('current_channel_id'));
+        var active_channel_ids = _.map(_.keys(this.channels), function(cid){
+            return parseInt(cid);
+        }); // integer as key of a dict is cast as string in javascript
+        var channel_to_fetch = _.difference(other_message_channel_ids, active_channel_ids);
+        // fetch unloaded channels and add it
+        var def = $.Deferred();
+        if(channel_to_fetch.length >= 1){
+            def = this.ChannelModel.call("channel_info", [], {"ids" : channel_to_fetch}).then(function(channels){
+                _.each(channels, function(channel){
+                    self.channel_add(channel);
+                });
+            });
+        }else{
+            def.resolve([]);
+        }
+        // bold the channel to indicate unread messages
+        def.then(function(){
+            // bold channel having unread messages
+            _.each(other_message_channel_ids, function(channel_id){
+                self._toggle_unread_message(channel_id, true);
+            });
+            // auto scroll to bottom
+            self._scroll();
+        });
+        // if needaction, then increment the label
+        if(message.needaction_partner_ids && _.contains(message.needaction_partner_ids, session.partner_id)){
+            this.needaction_increment(message.channel_ids || []);
+        }
+    },
+    // utils function
+    get_channel_slot: function(channel){
+        if(channel.channel_type === 'channel'){
+            if(channel.public === 'private'){
+                return 'channel_private_group';
+            }
+            return 'channel_channel';
+        }
+        if(channel.channel_type === 'chat'){
+            return 'channel_direct_message';
+        }
+    },
+    get_current_channel_name: function(){
+        var current_channel_id = this.get('current_channel_id');
+        var current_channel = this.channels[current_channel_id];
+        var current_channel_name = current_channel && current_channel.name || _t('Unknown');
+        // virtual channel id (for inbox, or starred channel)
+        if(_.isString(current_channel_id)){
+            if(current_channel_id == 'channel_inbox'){
+                current_channel_name = _t('Inbox');
+            }
+            if(current_channel_id == 'channel_starred'){
+                current_channel_name = _t('Starred');
+            }
+        }
+        return current_channel_name;
+    },
+    _toggle_unread_message: function(channel_id, add_or_remove, set_as_active){
+        var partner_id = false;
+        var inverse_mapping = _.invert(this.mapping);
+        // toggle bold channel/partner item
+        this.$('.o_mail_chat_sidebar .o_mail_chat_channel_item[data-channel-id="'+channel_id+'"]').toggleClass('o_mail_chat_channel_unread', add_or_remove);
+        if(_.contains(_.keys(inverse_mapping), channel_id.toString())){
+            partner_id = parseInt(inverse_mapping[channel_id]);
+            this.$('.o_mail_chat_sidebar .o_mail_chat_partner_item[data-partner-id="'+partner_id+'"]').toggleClass('o_mail_chat_channel_unread', add_or_remove);
+        }
+        // set the channel/partner item as the active one
+        if(set_as_active){
+            this.$('.o_mail_chat_sidebar .o_mail_chat_channel_item, .o_mail_chat_sidebar .o_mail_chat_partner_item').find('a').removeClass('active');
+            this.$('.o_mail_chat_sidebar .o_mail_chat_channel_item[data-channel-id="'+channel_id+'"]').find('a').addClass('active');
+            if(partner_id){
+                this.$('.o_mail_chat_sidebar .o_mail_chat_partner_item[data-partner-id="'+partner_id+'"]').find('a').addClass('active');
+            }
+        }
+    },
+    _scroll: function(){
+        var current_channel_id = this.get('current_channel_id');
+        var current_channel = this.channels[current_channel_id];
+        if(_.isNumber(current_channel_id)){
+            if(current_channel.seen_message_id){
+                if(this.$(".o_mail_thread_message[data-message-id="+current_channel.seen_message_id+"]")){
+                    this.$('.o_mail_chat_messages').scrollTop(this.$(".o_mail_thread_message[data-message-id="+current_channel.seen_message_id+"]").offset().top);
+                }else{
+                    this.$('.o_mail_chat_messages').scrollTop(0);
+                }
+            }else{
+                this.$('.o_mail_chat_messages').scrollTop(this.$('.o_mail_chat_messages')[0].scrollHeight);
+            }
+            current_channel.seen_message_id = false;
+        }else{
+            this.$('.o_mail_chat_messages').scrollTop(this.$('.o_mail_chat_messages')[0].scrollHeight);
+        }
+    },
+    /**
+     * Render the messages
+     * @override
+     */
+    message_render: function(){
+        this.$('.o_mail_chat_messages_content').html(QWeb.render('mail.chat.ChatMailThread.content', {'widget': this}));
+    },
+    /**
+     * Return the message domain for the current channel
+     * @override
+     */
+    get_message_domain: function(){
+        // default channel domain
+        var current_channel_id = this.get('current_channel_id');
+        var domain = [['channel_ids', 'in', current_channel_id]];
+        // virtual channel id (for inbox, or starred channel)
+        if(_.isString(current_channel_id)){
+            if(current_channel_id == 'channel_inbox'){
+                domain = [['needaction', '=', true]];
+            }
+            if(current_channel_id == 'channel_starred'){
+                domain = [['starred', '=', true]];
+            }
+        }
+        // add search domain
+        domain = domain.concat(this.search_domain);
+        return domain;
     },
 });
 
-// Put the ImTopButton widget in the systray menu if the user is an employee
-var Users = new Model('res.users');
-Users.call('has_group', ['base.group_user']).done(function(is_employee) {
-    if (is_employee) {
-        SystrayMenu.Items.push(ImTopButton);
-    }
-});
+core.action_registry.add('mail.chat.instant_messaging', ChatMailThread);
+
 
 return {
-    InstantMessaging: InstantMessaging,
-    UserWidget: UserWidget,
+    ChatMailThread: ChatMailThread,
 };
 
 });
diff --git a/addons/mail/static/src/js/mail_chat_common.js b/addons/mail/static/src/js/mail_chat_common.js
index 0aaa0e68d16..a5f52ddf4b1 100644
--- a/addons/mail/static/src/js/mail_chat_common.js
+++ b/addons/mail/static/src/js/mail_chat_common.js
@@ -1,13 +1,12 @@
-odoo.define('im_chat.im_chat_common', function (require) {
+odoo.define('mail.chat_common', function (require) {
 "use strict";
 
-// to do: make this work in website
-
 var bus = require('bus.bus');
 var core = require('web.core');
 var session = require('web.session');
 var time = require('web.time');
 var Widget = require('web.Widget');
+var mail_utils = require('mail.utils');
 
 var _t = core._t;
 var QWeb = core.qweb;
@@ -15,140 +14,130 @@ var QWeb = core.qweb;
 var NBR_LIMIT_HISTORY = 20;
 
 
+/**
+ * Widget handeling the sessions/conversations
+ *
+ * Responsible to listen the bus and do the correct action according to the received notifications (fetch
+ * conversation, add message, ...)
+ **/
 var ConversationManager = Widget.extend({
     init: function(parent, options) {
         var self = this;
         this._super(parent);
         this.options = _.clone(options) || {};
         _.defaults(this.options, {
-            inputPlaceholder: _t("Say something..."),
-            defaultMessage: null,
-            defaultUsername: _t("Visitor"),
-            force_open: false,
+            placeholder: _t("Say something..."),
+            default_username: _t("Visitor"),
             load_history: true,
             focus: false,
         });
+        this.emoji_list = [];
         // business
         this.sessions = {};
         this.bus = bus.bus;
         this.bus.on("notification", this, this.on_notification);
-        this.bus.options.im_presence = true;
-
         // ui
         this.set("right_offset", 0);
         this.set("bottom_offset", 0);
         this.on("change:right_offset", this, this.calc_positions);
         this.on("change:bottom_offset", this, this.calc_positions);
 
-        this.set("window_focus", true);
-        this.on("change:window_focus", self, function(e) {
-            self.bus.options.im_presence = self.get("window_focus");
-        });
         this.set("waiting_messages", 0);
         this.on("change:waiting_messages", this, this.window_title_change);
         $(window).on("focus", _.bind(this.window_focus, this));
-        $(window).on("blur", _.bind(this.window_blur, this));
         this.window_title_change();
+        // session widgets deferred (for their creation)
+        this._session_defs = {};
+    },
+    start: function(){
+        var self = this;
+        return $.when(session.rpc("/mail/chat_init"), this._super.apply(this, arguments)).then(function(result){
+            self._setup(result);
+        });
+    },
+    _setup: function(init_data){
+        this.emoji_list = init_data['emoji'];
+        this.options['emoji'] = mail_utils.shortcode_substitution(init_data['emoji']);
     },
     on_notification: function(notification, options) {
         var self = this;
         var channel = notification[0];
         var message = notification[1];
         var regex_uuid = new RegExp(/(\w{8}(-\w{4}){3}-\w{12}?)/g);
+        var is_channel_uuid = regex_uuid.test(channel);
 
-        // Concern im_chat : if the channel is the im_chat.session or im_chat.status, or a 'private' channel (aka the UUID of a session)
-        if((Array.isArray(channel) && (channel[1] === 'im_chat.session')) || (regex_uuid.test(channel))){
-            // message to display in the chatview
-            if (message.type === "message" || message.type === "meta") {
-                self.message_receive(message);
-            }
+        // (dbname, 'res.partner', partner_id) receive only the new mail.channel header
+        if((Array.isArray(channel) && (channel[1] === 'res.partner')) || is_channel_uuid){
             // activate the received session
             if(message.uuid){
-                 this.session_apply(message, options);
+                this.session_apply(message, options);
+            }
+        }
+        // (dbname, 'mail.channel', channel_id) receive only the mail.message of the channel
+        if((Array.isArray(channel) && (channel[1] === 'mail.channel')) || is_channel_uuid){
+            // message to display in the chatview
+            if (message.message_type) {
+                self.message_receive(message);
             }
         }
     },
-
     // window focus unfocus beep and title
     window_focus: function() {
-        this.set("window_focus", true);
         this.set("waiting_messages", 0);
     },
-    window_blur: function() {
-        this.set("window_focus", false);
-    },
     window_beep: function() {
-        if (typeof(Audio) === "undefined") {
-            return;
-        }
-        var audio = new Audio();
-        var ext = audio.canPlayType("audio/ogg; codecs=vorbis") ? ".ogg" : ".mp3";
-        audio.src = session.url("/im_chat/static/src/audio/ting") + ext;
-        audio.play();
+        mail_utils.beep(session);
     },
     window_title_change: function() {
         var title = undefined;
         if (this.get("waiting_messages") !== 0) {
-            title = _.str.sprintf(_t("%d Messages"), this.get("waiting_messages"));
             this.window_beep();
         }
     },
-    // sessions and messages
-    session_apply: function(active_session, options){
-        // options used by this function : force_open and focus (load_history can be usefull)
+    // sessions methods
+    session_apply: function(session, options){
+        // options used by this function : focus (load_history can be usefull)
         var self = this;
-        options = _.extend(_.clone(this.options), options || {});
-        // force open
-        var session = _.clone(active_session);
-        if(options['force_open']){
-            session.state = 'open';
-        }
+        options = _.defaults(options || {}, {
+            'focus': true,
+        }, this.options);
         // create/get the conversation widget
-        var conv = this.sessions[session.uuid];
+        var conv = this.sessions[session.id];
         if (! conv) {
             if(session.state !== 'closed'){
-                conv = new Conversation(this, this, session, options);
-                conv.appendTo($("body"));
+                conv = new Conversation(this, session, options);
+                // store this deferred to apply next action (notifications) when it is resolved.
+                this._session_defs[session.id] = conv.appendTo($("body"));
+                this._session_defs[session.id].then(function() {
+                    self.calc_positions();
+                });
                 conv.on("destroyed", this, _.bind(this.session_delete, this));
-                this.sessions[session.uuid] = conv;
-                this.calc_positions();
+                this.sessions[session.id] = conv;
             }
         }else{
-            conv.set("session", session);
-        }
-        // if force open, broadcast it
-        if(options['force_open'] && active_session.state !== 'open'){
-            conv.session_update_state('open');
-        }
-        // apply the focus
-        if (options['focus']){
-            conv.focus();
+            // update the state only when the 'contruction' deferred is resolved.
+            this._session_defs[session.id].then(function(){
+                conv.set('session', session);
+            });
         }
         return conv;
     },
-    session_delete: function(uuid){
-        delete this.sessions[uuid];
+    session_delete: function(channel_id){
+        delete this.sessions[channel_id];
         this.calc_positions();
     },
-    message_receive: function(message) {
+    /**
+     * Adding a message in all its channels
+     * /!\ Suppose the channel are already loaded in the ConversationManager /!\
+     * @param {Object} message : the received message (formatted server side)
+     */
+    message_receive: function(message){
         var self = this;
-        var session_id = message.to_id[0];
-        var uuid = message.to_id[1];
-        var from_id = message['from_id'] ? message['from_id'][0] : false;
-        if (! this.get("window_focus") && from_id != this.get_current_uid()) {
-            this.set("waiting_messages", this.get("waiting_messages") + 1);
-        }
-        this._message_receive(message);
-    },
-    _message_receive: function(message){
-        var uuid = message.to_id[1];
-        var conv = this.sessions[uuid];
-        conv.message_receive(message);
+        _.each(message.channel_ids, function(channel_id){
+            self.sessions[channel_id].message_receive(message);
+        });
     },
     // others
-    get_current_uid: function(){
-        return session && !_.isUndefined(session.uid) ? session.uid : false;
-    },
     calc_positions: function() {
         var self = this;
         var current = this.get("right_offset");
@@ -159,84 +148,72 @@ var ConversationManager = Widget.extend({
         });
     },
     destroy: function() {
-        $(window).off("unload", this.unload);
         $(window).off("focus", this.window_focus);
         $(window).off("blur", this.window_blur);
         return this._super();
     }
 });
 
-
+/**
+ * Widget Conversation
+ *
+ * Display the conversation in a 'portable' window, manage sending and receiving message,
+ * and the fold state of the conversation.
+ **/
 var Conversation = Widget.extend({
-    className: "openerp_style oe_im_chatview",
+    template: "mail.chat.im.Conversation",
     events: {
         "keydown input": "keydown",
-        "click .oe_im_chatview_close": "click_close",
-        "click .oe_im_chatview_header": "click_header"
+        "click .o_mail_chat_im_window_close": "on_click_close",
+        "click .o_mail_chat_im_window_header": "on_click_header"
     },
-    init: function(parent, c_manager, session, options) {
+    init: function(parent, session, options) {
         this._super(parent);
-        this.c_manager = c_manager;
-        this.options = options || {};
-        this.loading_history = true;
+        this.options = _.defaults(options || {}, {
+            'emoji': {},
+            'placeholder': _t('Write something ...'),
+            'loading_history': true,
+            'focus': true,
+        });
         this.set("messages", []);
         this.set("session", session);
+        this.set("pending", 0);
         this.set("right_position", 0);
         this.set("bottom_position", 0);
-        this.set("pending", 0);
-        this.inputPlaceholder = this.options.defaultInputPlaceholder;
+    },
+    willStart: function(){
+        if(this.options.loading_history){
+            return $.when(this.message_history(), this._super.apply(this, arguments));
+        }
+        return this._super.apply(this, arguments);
     },
     start: function() {
         var self = this;
-        self._super.apply(this, arguments);
-        self.prepare_action_menu();
         // ui
-        self.$().append(QWeb.render("im_chat.Conversation", {widget: self}));
         self.on("change:right_position", self, self.calc_pos);
         self.on("change:bottom_position", self, self.calc_pos);
-        self.on("change:pending", self, _.bind(function() {
-            if (self.get("pending") === 0) {
-                self.$(".nbr_messages").text("");
-            } else {
-                self.$(".nbr_messages").text("(" + self.get("pending") + ")");
-            }
-        }, self));
+        self.on("change:pending", self, self.message_pending_change);
+
         self.full_height = self.$().height();
-        self.calc_pos();
-        // business
-        self.bind_action_menu();
-        self.on("change:session", self, self.session_update);
-        self.on("change:messages", self, self.render_messages);
-        self.$('.oe_im_chatview_content').on('scroll',function(){
+        self.$('.o_mail_chat_im_window_content').on('scroll',function(){
             if($(this).scrollTop() === 0){
                 self.message_history();
             }
         });
-        if(self.options['load_history']){ // load history if asked
-            self.message_history();
-        }
-        // prepare the header and the correct state
-        self.session_update();
-    },
-    // action menu
-    _add_action: function(label, style_class, icon_fa_class, callback){
-        this.actions.push({
-            'label': label,
-            'class': style_class,
-            'icon_class': icon_fa_class,
-            'callback': callback,
-        });
-    },
-    prepare_action_menu: function(){
-        // override this method to add action with _add_action()
-        this.actions = [];
-    },
-    bind_action_menu: function(){
-        var self = this;
-        _.each(this.actions, function(action){
-            if(action.callback){
-                self.$('.button_option_group .' + action.class).on('click', _.bind(action.callback, self));
+        // business
+        self.on("change:session", self, self.session_change);
+        self.on("change:messages", self, self.message_render);
+
+        return self._super.apply(this, arguments).then(function(){
+            // place the conversation window correctly on the screen
+            self.calc_pos();
+            // focus if needed
+            if(self.options.focus){
+                self.focus();
             }
+            // re-apply the session to display the correct state
+            self.set('session', _.clone(self.get('session')));
+            self._go_bottom();
         });
     },
     // ui
@@ -248,7 +225,7 @@ var Conversation = Widget.extend({
     },
     hide: function(){
         this.$().animate({
-            height: this.$(".oe_im_chatview_header").outerHeight()
+            height: this.$(".o_mail_chat_im_window_header").outerHeight()
         });
     },
     calc_pos: function() {
@@ -256,21 +233,25 @@ var Conversation = Widget.extend({
         this.$().css("bottom", this.get("bottom_position"));
     },
     // session
-    session_update_state: function(state){
+    /**
+     * Set the fold state LOCALLY for the session. This will
+     * trigger a ui update
+     * @param {string} state : the fold state ('fold', 'closed' or 'open')
+     */
+    session_fold: function(state){
         var session = this.get('session');
         session.state = state;
         this.set('session', session);
     },
-    session_update: function(){
-        // built the name
-        var names = [];
-        _.each(this.get("session").users, function(user){
-            if( (session.uid !== user.id) && !(_.isUndefined(session.uid) && !user.id) ){
-                names.push(user.name);
-            }
-        });
-        this.$(".header_name").text(names.join(", "));
-        this.$(".header_name").attr('title', names.join(", "));
+    /**
+     * Triggered when the session has changed : it update the header name
+     * and fold the window (ui) according to its state.
+     */
+    session_change: function(){
+        // update conversation name in header
+        var name = this.get("session").name || _t('Unknown Channel');
+        this.$(".o_mail_chat_im_window_header_name").text(name);
+        this.$(".o_mail_chat_im_window_header_name").attr('title', name);
         // update the fold state
         if(this.get("session").state){
             if(this.get("session").state === 'closed'){
@@ -285,39 +266,53 @@ var Conversation = Widget.extend({
         }
     },
     // messages
+    /**
+     * Load the history of the current session, and insert it into already loaded messages
+     * @returns {Deferred} resolved with the new loaded messages (Object[])
+     */
     message_history: function(){
         var self = this;
-        if(this.loading_history){
-            var data = {uuid: self.get("session").uuid, limit: NBR_LIMIT_HISTORY};
-            var lastid = _.first(this.get("messages")) ? _.first(this.get("messages")).id : false;
-            if(lastid){
-                data.last_id = lastid;
-            }
-            session.rpc("/im_chat/history", data).then(function(messages){
+        if(this.options.loading_history){
+            var data = {
+                uuid: self.get("session").uuid,
+                limit: NBR_LIMIT_HISTORY,
+                last_id: _.first(this.get("messages")) ? _.first(this.get("messages")).id : false,
+            };
+            return session.rpc("/mail/chat_history", data).then(function(messages){
                 if(messages){
-                    self.insert_messages(messages);
+                    self.message_insert(messages);
                     if(messages.length != NBR_LIMIT_HISTORY){
-                        self.loading_history = false;
+                        self.options.loading_history = false;
                     }
                 }else{
-                    self.loading_history = false;
+                    self.options.loading_history = false;
                 }
+                return messages;
             });
         }
+        return $.Deferred().resolve([]);
     },
     message_receive: function(message) {
-        if (this.get('session').state === 'open') {
-            this.set("pending", 0);
-        } else {
-            this.set("pending", this.get("pending") + 1);
+        // don't add duplicated message (this can happen when refreshing and receiving already recieved
+        // message that are still in the bus queue/buffer).
+        if(!_.contains(_.pluck(this.get('messages'), 'id'), message.id)){
+            // is pending message ?
+            if (this.get('session').state === 'open') {
+                this.set("pending", 0);
+            } else {
+                if(!this.message_am_i_author(message)){
+                    this.set("pending", this.get("pending") + 1);
+                }
+            }
+            // insert it
+            this.message_insert([message]);
+            this._go_bottom();
         }
-        this.insert_messages([message]);
-        this._go_bottom();
     },
-    message_send: function(message, type) {
+    message_send: function(message) {
         var self = this;
         var send_it = function() {
-            return session.rpc("/im_chat/post", {uuid: self.get("session").uuid, message_type: type, message_content: message});
+            return session.rpc("/mail/chat_post", {uuid: self.get("session").uuid, message_content: message});
         };
         var tries = 0;
         send_it().fail(function(error, e) {
@@ -327,71 +322,65 @@ var Conversation = Widget.extend({
                 return send_it();
         });
     },
-    insert_messages: function(messages){
+    /**
+     * Preporcess the message (add informations in the Object, ...)
+     * @param {Object[]} messages : server side formatted message (from message_format method)
+     */
+    _message_preprocess: function(raw_messages){
         var self = this;
-        // avoid duplicated messages
-        messages = _.filter(messages, function(m){ return !_.contains(_.pluck(self.get("messages"), 'id'), m.id) ; });
-        // escape the message content and set the timezone
-        _.map(messages, function(m){
-            if(!m.from_id){
-                m.from_id = [false,self. get_anonymous_name()];
+        _.each(raw_messages, function(m){
+            m.date = moment(time.str_to_datetime(m.date)).format('YYYY-MM-DD HH:mm:ss'); // set the date in the correct browser user timezone
+            if(m.body){
+                m.body = mail_utils.shortcode_apply(m.body, self.options.emoji);
             }
-            m.create_date = moment(time.str_to_datetime(m.create_date)).format('YYYY-MM-DD HH:mm:ss');
-            return m;
+            _.each(m.attachment_ids, function(a){
+                a.url = mail_utils.get_attachment_url(session, m.id, a.id);
+                a.fa_class = mail_utils.attachment_filetype_to_fa_class(a.file_type_icon);
+            });
         });
+        return raw_messages;
+    },
+    /**
+     * Insert new raw message into the current ones
+     * @param {Object[]} messages : server side formatted message (from message_format method)
+     */
+    message_insert: function(raw_messages){
+        var messages = this._message_preprocess(raw_messages);
         this.set("messages", _.sortBy(this.get("messages").concat(messages), function(m){ return m.id; }));
     },
-    render_messages: function(){
+    message_render: function(){
         var self = this;
-        var res = {};
-        var last_date_day, last_user_id = -1;
-        _.each(this.get("messages"), function(current){
-            // add the url of the avatar for all users in the conversation
-            current.from_id[2] = session.url(_.str.sprintf("/im_chat/image/%s/%s", self.get('session').uuid, current.from_id[0]));
-            var date_day = current.create_date.split(" ")[0];
-            if(date_day !== last_date_day){
-                res[date_day] = [];
-                last_user_id = -1;
-            }
-            last_date_day = date_day;
-            if(current.type == "message"){ // traditionnal message
-                if(last_user_id === current.from_id[0]){
-                    _.last(res[date_day]).push(current);
-                }else{
-                    res[date_day].push([current]);
-                }
-                last_user_id = current.from_id[0];
-            }else{ // meta message
-                res[date_day].push([current]);
-                last_user_id = -1;
-            }
-        });
-        // render and set the content of the chatview
-        // TODO jem : when refactoring this, don't forget to pre-process date in this function before render quweb template
-        // since, moment will not be define in qweb on the website pages, because the helper (see csn) is in core.js and cannot be
-        // imported in the frontend.
-        this.$('.oe_im_chatview_content_bubbles').html($(QWeb.render("im_chat.Conversation_content", {"list": res})));
-        this._go_bottom();
+        var message_html = $(QWeb.render("mail.chat.im.Conversation.messages", {"widget": this}));
+        this.$('.o_mail_chat_im_window_content').html(message_html);
+    },
+    message_am_i_author: function(message){
+        return message.author_id && message.author_id[0] === session.partner_id;
+    },
+    message_pending_change: function(event){
+        if (this.get("pending") === 0) {
+            this.$(".o_mail_chat_im_window_header_counter").text("");
+        } else {
+            this.$(".o_mail_chat_im_window_header_counter").text("(" + this.get("pending") + ")");
+        }
     },
     // utils and event
-    get_anonymous_name: function(){
-        var name = this.options["defaultUsername"];
-        _.each(this.get('session').users, function(u){
-            if(!u.id){
-                name = u.name;
-            }
-        });
-        return name;
+    _go_bottom: function() {
+        if(this.$(".o_mail_chat_im_window_content").length){
+            this.$(".o_mail_chat_im_window_content").scrollTop(this.$(".o_mail_chat_im_window_content").get(0).scrollHeight);
+        }
+    },
+    focus: function() {
+        this.$(".o_mail_chat_im_window_input").focus();
     },
     keydown: function(e) {
         if(e && e.which == 27) {
-            if(this.$el.prev().find('.oe_im_chatview_input').length > 0){
-                this.$el.prev().find('.oe_im_chatview_input').focus();
+            if(this.$el.prev().find('.o_mail_chat_im_window_input').length > 0){
+                this.$el.prev().find('.o_mail_chat_im_window_input').focus();
             }else{
-                this.$el.next().find('.oe_im_chatview_input').focus();
+                this.$el.next().find('.o_mail_chat_im_window_input').focus();
             }
             e.stopPropagation();
-            this.session_update_state('closed');
+            this.session_fold('closed');
         }
         if(e && e.which !== 13) {
             return;
@@ -401,25 +390,17 @@ var Conversation = Widget.extend({
             return;
         }
         this.$("input").val("");
-        this.message_send(mes, "message");
+        this.message_send(mes);
     },
-    _go_bottom: function() {
-        this.$(".oe_im_chatview_content").scrollTop(this.$(".oe_im_chatview_content").get(0).scrollHeight);
+    on_click_header: function(event){
+        this.session_fold();
     },
-    focus: function() {
-        this.$(".oe_im_chatview_input").focus();
-    },
-    click_header: function(event){
-        var classes = event.target.className.split(' ');
-        if(_.contains(classes, 'header_name') || _.contains(classes, 'oe_im_chatview_header')){
-            this.session_update_state();
-        }
-    },
-    click_close: function(event) {
-        this.session_update_state('closed');
+    on_click_close: function(event) {
+        event.stopPropagation(); // avoid triggering event for 'on_click_header'
+        this.session_fold('closed');
     },
     destroy: function() {
-        this.trigger("destroyed", this.get('session').uuid);
+        this.trigger("destroyed", this.get('session').id);
         return this._super();
     }
 });
@@ -430,4 +411,4 @@ return {
     ConversationManager: ConversationManager,
 };
 
-});
\ No newline at end of file
+});
diff --git a/addons/mail/static/src/js/mail_chatter.js b/addons/mail/static/src/js/mail_chatter.js
new file mode 100644
index 00000000000..7032f864eb4
--- /dev/null
+++ b/addons/mail/static/src/js/mail_chatter.js
@@ -0,0 +1,471 @@
+odoo.define('mail.chatter', function (require) {
+"use strict";
+
+var core = require('web.core');
+var data = require('web.data');
+var session = require('web.session');
+var web_client = require('web.web_client');
+var Model = require('web.Model');
+var Widget = require('web.Widget');
+var form_common = require('web.form_common');
+var SystrayMenu = require('web.SystrayMenu');
+var mail_utils = require('mail.utils');
+var mail_thread = require('mail.thread');
+
+var QWeb = core.qweb;
+var _t = core._t;
+var internal_bus = core.bus;
+
+
+/**
+ * Mail Compose Message for Chatter
+ *
+ * Extends the basic MailComposeMessage Widget to add 'suggested partner' layer (open popup
+ * when suggested partner is selected without email, or other informations), and the button
+ * to open the 'mail.compose.message' wizard.
+ **/
+var ChatterMailComposeMessage = mail_thread.MailComposeMessage.extend({
+    template: 'mail.chatter.ComposeMessage',
+    init: function(parent, dataset, options){
+        this._super.apply(this, arguments);
+        this.suggested_partners = [];
+        this.context = options.context || {};
+        // options
+        this.options = _.defaults(options, {
+            'record_name': false,
+            'is_log': false,
+            'internal_subtypes': [],
+        });
+    },
+    willStart: function(){
+        if(this.options.is_log){
+            return this._super.apply(this, arguments);
+        }
+        return $.when(this._super.apply(this, arguments), this.message_get_suggested_recipients());
+    },
+    start: function(){
+        this.$input = this.$('.o_mail_compose_message_input');
+        this.$input.focus();
+        // add mail compose message full button
+        this.$('.o_mail_compose_message_button_group').append('<button class="btn btn-default o_mail_compose_message_button_full_message" type="button" data-toggle="popover"><i class="fa fa-pencil-square-o"/></button>')
+        this.$('.o_mail_compose_message_button_full_message').on('click', this, this.on_compose_message);
+        return this._super.apply(this, arguments);
+    },
+    message_get_suggested_recipients: function(){
+        var self = this;
+        var email_addresses = _.pluck(this.suggested_partners, 'email_address');
+        return this.thread_dataset.call('message_get_suggested_recipients', [[this.context.default_res_id], this.context]).done(function (suggested_recipients) {
+            var thread_recipients = suggested_recipients[self.context.default_res_id];
+            _.each(thread_recipients, function (recipient) {
+                var parsed_email = mail_utils.parse_email(recipient[1]);
+                if (_.indexOf(email_addresses, parsed_email[1]) == -1) {
+                    self.suggested_partners.push({
+                        'checked': true,
+                        'partner_id': recipient[0],
+                        'full_name': recipient[1],
+                        'name': parsed_email[0],
+                        'email_address': parsed_email[1],
+                        'reason': recipient[2],
+                    });
+                }
+            });
+        });
+    },
+    /**
+     * Get the list of selected suggested partner
+     * @returns Array() : list of 'recipient' selected partner (may not be created in db)
+     **/
+    get_checked_suggested_partners: function(){
+        var self = this;
+        var checked_partners = [];
+        this.$('.o_mail_chatter_compose_message_suggested_partners input:checked').each(function(index){
+            var $input = $(this);
+            var full_name = $input.data('fullname');
+            checked_partners = checked_partners.concat(_.filter(self.suggested_partners, function(item){
+                return full_name === item.full_name;
+            }));
+        });
+        return checked_partners;
+    },
+    /**
+     * Check the additionnal partners (not necessary registered partners), and open a popup form view
+     * for the ones who informations is missing.
+     * @param Array : list of 'recipient' partners to complete informations or validate
+     * @returns Deferred resolved with the list of checked suggested partners (real partner)
+     **/
+    check_suggested_partners: function (checked_suggested_partners) {
+        var self = this;
+        var check_done = $.Deferred();
+
+        var recipients = _.filter(checked_suggested_partners, function (recipient) { return recipient.checked; });
+        var recipients_to_find = _.filter(recipients, function (recipient) { return (! recipient.partner_id); });
+        var names_to_find = _.pluck(recipients_to_find, 'full_name');
+        var recipients_to_check = _.filter(recipients, function (recipient) { return (recipient.partner_id && ! recipient.email_address); });
+        var recipient_ids = _.pluck(_.filter(recipients, function (recipient) { return recipient.partner_id && recipient.email_address; }), 'partner_id');
+
+        var names_to_remove = [];
+        var recipient_ids_to_remove = [];
+
+        // have unknown names -> call message_get_partner_info_from_emails to try to find partner_id
+        var find_done = $.Deferred();
+        if (names_to_find.length > 0) {
+            find_done = self.thread_dataset.call('message_partner_info_from_emails', [[this.context.default_res_id], names_to_find]);
+        } else {
+            find_done.resolve([]);
+        }
+
+        // for unknown names + incomplete partners -> open popup - cancel = remove from recipients
+        $.when(find_done).pipe(function (result) {
+            var emails_deferred = [];
+            var recipient_popups = result.concat(recipients_to_check);
+
+            _.each(recipient_popups, function (partner_info) {
+                var deferred = $.Deferred();
+                emails_deferred.push(deferred);
+
+                var partner_name = partner_info.full_name;
+                var partner_id = partner_info.partner_id;
+                var parsed_email = mail_utils.parse_email(partner_name);
+
+                var pop = new form_common.FormViewDialog(this, {
+                    res_model: 'res.partner',
+                    res_id: partner_id,
+                    context: {
+                        'force_email': true,
+                        'ref': "compound_context",
+                        'default_name': parsed_email[0],
+                        'default_email': parsed_email[1],
+                    },
+                    title: _t("Please complete partner's informations"),
+                }).open();
+                pop.on('closed', self, function () {
+                    deferred.resolve();
+                });
+                pop.view_form.on('on_button_cancel', self, function () {
+                    names_to_remove.push(partner_name);
+                    if (partner_id) {
+                        recipient_ids_to_remove.push(partner_id);
+                    }
+                });
+            });
+            $.when.apply($, emails_deferred).then(function () {
+                var new_names_to_find = _.difference(names_to_find, names_to_remove);
+                find_done = $.Deferred();
+                if (new_names_to_find.length > 0) {
+                    find_done = self.thread_dataset.call('message_partner_info_from_emails', [[self.context.default_res_id], new_names_to_find, true]);
+                } else {
+                    find_done.resolve([]);
+                }
+                $.when(find_done).pipe(function (result) {
+                    var recipient_popups = result.concat(recipients_to_check);
+                    _.each(recipient_popups, function (partner_info) {
+                        if (partner_info.partner_id && _.indexOf(partner_info.partner_id, recipient_ids_to_remove) == -1) {
+                            recipient_ids.push(partner_info.partner_id);
+                        }
+                    });
+                }).pipe(function () {
+                    check_done.resolve(recipient_ids);
+                });
+            });
+        });
+        return check_done;
+    },
+    message_post: function(body, attachment_ids, values){
+        var self = this;
+        var _super = self._super;
+        // default values
+        values = _.defaults(values || {}, {
+            'message_type': 'comment',
+            'content_subtype': 'html',
+            'partner_ids': [],
+            'subtype_id': false,
+            'subtype': false,
+        });
+        // update subtype
+        if(this.options.is_log) {
+            var subtype_id = parseInt(this.$('.o_mail_chatter_compose_message_subtype_select').val());
+            if(_.indexOf(_.pluck(this.internal_subtypes, 'id'), subtype_id) == -1) {
+                values['subtype'] = 'mail.mt_note'
+            }else{
+                values['subtype_id'] = subtype_id;
+            }
+        }else{
+            values['subtype'] = 'mail.mt_comment';
+        }
+        // update partner_ids
+        var def = $.when();
+        if(this.options.is_log){
+            // directly call the super()
+            def = _.bind(_super, self)(body, attachment_ids, values);
+        }else{
+            // call the super() when all partner popup are treated
+            var checked_suggested_partners = this.get_checked_suggested_partners();
+            this.check_suggested_partners(checked_suggested_partners).done(function(partner_ids){
+                // update context
+                values['partner_ids'] = partner_ids;
+                values['context'] = _.defaults(self.context, {
+                    'mail_post_autofollow': true,
+                    'mail_post_autofollow_partner_ids': partner_ids,
+                });
+                def = _.bind(_super, self)(body, attachment_ids, values);
+            });
+        }
+        return def
+    },
+    is_empty: function(){
+        return this.$input.val() === '';
+    },
+    on_compose_message: function(event){
+        var self = this;
+        if (!this.do_check_attachment_upload()){
+            return false;
+        }
+
+        var recipient_done = $.Deferred();
+        if (this.options.is_log){
+            recipient_done.resolve([]);
+        }else{
+            var checked_suggested_partners = this.get_checked_suggested_partners();
+            recipient_done = this.check_suggested_partners(checked_suggested_partners);
+        }
+        recipient_done.then(function(partner_ids){
+            var context = {
+                'default_parent_id': self.id,
+                'default_body': mail_utils.get_text2html(self.$('.o_mail_compose_message_input').val()),
+                'default_attachment_ids': _.pluck(self.get('attachment_ids'), 'id'),
+                'default_partner_ids': partner_ids,
+                'default_is_log': self.options.is_log,
+                'mail_post_autofollow': true,
+                'mail_post_autofollow_partner_ids': partner_ids,
+            };
+
+            if (self.context.default_model && self.context.default_res_id) {
+                context.default_model = self.context.default_model;
+                context.default_res_id = self.context.default_res_id;
+            }
+
+            self.do_action({
+                type: 'ir.actions.act_window',
+                res_model: 'mail.compose.message',
+                view_mode: 'form',
+                view_type: 'form',
+                views: [[false, 'form']],
+                target: 'new',
+                context: context,
+            }, {
+                on_close: function() {
+                    self.trigger('need_refresh');
+                },
+            });
+        });
+    }
+});
+
+
+/**
+ * Document Chatter ('mail_thread' widget)
+ *
+ * Displayed on every document. Since it is displayed on a form view, it extends 'AbstractField' widget, and
+ * required the behaviour of 'MailThreadMixin' to manage mail.message (using common methods).
+ * This widget is responsible of the toggle the message composer and the custom message rendering.
+ **/
+var ChatterMailThread = form_common.AbstractField.extend(mail_thread.MailThreadMixin, {
+    template: 'mail.chatter.ChatterMailThread',
+    events: {
+        "click .o_mail_redirect": "on_click_redirect",
+        "click .o_mail_thread_message_star": "on_message_star",
+        "click .o_mail_thread_message_needaction": "on_message_needaction",
+        "click .o_mail_chatter_show_more_message": "on_message_show_more",
+        // toggle message composer (!! declaration order is important !!)
+        "click .o_mail_chatter_button_new_message": "on_open_composer",
+        "click .o_mail_chatter_button_log_note": "on_open_composer",
+        "blur .o_mail_compose_message_input": "on_close_composer",
+        "mousedown .o_mail_chatter_compose_message": function(event) {
+            this.stay_open = true;
+        },
+        "focus .o_mail_compose_message_input": function(event) {
+            this.stay_open = false;
+        },
+        "keydown .o_mail_compose_message_input": function(event) {
+            this.stay_open = false;
+        },
+    },
+    init: function (parent, node){
+        this._super.apply(this, arguments);
+        mail_thread.MailThreadMixin.init.call(this);
+        this.message_composer = undefined;
+        this.record_name = '';
+        this.context = this.options.context || {};
+        // options from 'message_ids' node in field_view_get
+        this.options = _.defaults(this.options, {
+            'display_log_button': true,
+            'display_document_link': false,
+            'internal_subtypes': [],
+            'emoji_list': [],
+        });
+        this.emoji_set_substitution(this.options.emoji_list);
+    },
+    start: function(){
+        mail_thread.MailThreadMixin.start.call(this);
+        return this._super.apply(this, arguments);
+    },
+    on_message_show_more: function(event){
+        var self = this;
+        this.message_load_history().then(function(messages){
+            if(messages.length < mail_thread.LIMIT_MESSAGE){
+                self.$('.o_mail_chatter_show_more_message').hide();
+            }
+        });
+    },
+    /**
+     * When a message is correctly posted, fetch its data to render it
+     * @param {Number} message_id : the identifier of the new posted message
+     * @returns {Deferred}
+     */
+    on_message_post: function(message_id){
+        var self = this;
+        return this.message_format([message_id]).then(function(messages){
+            self.stay_open = false;
+            self.message_insert(messages);
+            self.on_close_composer();
+        });
+    },
+    /**
+     * The value of the field has change (modification or switch to next document). Form view is
+     * not re-rendered, simply updated. A re-fetch is needed.
+     * @override
+     */
+    render_value: function(){
+        var self = this;
+        // re-rendering for mail composer message
+        this.options.display_show_more_message = this.get_value().length > mail_thread.LIMIT_MESSAGE;
+        this.renderElement();
+        // reset dataset
+        this.ThreadDataset = this.view.dataset;
+        // update context (require for mail.compose.message wizard)
+        this.context = _.extend({
+            'mail_read_set_read': true,  // set messages as read in Chatter TODO JEM : not used anymore
+            'default_res_id': this.view.datarecord.id || false,
+            'default_model': this.view.model || false,
+        }, this.options.context || {});
+        // fetch messages of current document
+        this.message_format(this.get_value().slice(0, mail_thread.LIMIT_MESSAGE)).then(function(raw_messages){
+            self._message_replace(self._message_preprocess(raw_messages));
+            self.record_name = _.last(raw_messages) ? _.last(raw_messages).record_name : '';
+            // set the thread as read
+            self.ThreadDataset.call('message_set_read', [[self.view.datarecord.id]]).then(function(message_ids){
+                // decrement the needaction top counter
+                internal_bus.trigger('mail_needaction_done', message_ids.length);
+            });
+        });
+    },
+    // composer toggle
+    on_open_composer: function(event){
+        var self = this;
+        this.$('.o_mail_chatter_compose_buttons').hide();
+        this.$('.o_mail_chatter_compose_message_wrap').show();
+        // destroy existing composer
+        if(this.message_composer){
+            this.message_composer.destroy();
+        }
+        // create the new composer
+        this.message_composer = new ChatterMailComposeMessage(this, this.ThreadDataset, {
+            'internal_subtypes': this.options.internal_subtypes,
+            'is_log': this.$(event.currentTarget).hasClass('o_mail_chatter_button_log_note'),
+            'emoji_list': this.options.emoji_list,
+            'context': this.context,
+            'record_name': this.record_name,
+        });
+        this.message_composer.appendTo(this.$('.o_mail_chatter_compose_message_wrap'));
+        this.message_composer.on('message_sent', this, this.on_message_post);
+        this.message_composer.on('need_refresh', this, function(e){
+            self.message_refresh();
+            self.on_close_composer();
+        });
+    },
+    on_close_composer: function(event){
+        if(this.message_composer && this.message_composer.is_empty() && !this.stay_open){
+            this.$('.o_mail_chatter_compose_buttons').show();
+            this.$('.o_mail_chatter_compose_message_wrap').hide();
+        }
+    },
+    /**
+     * Refresh the current message, and set them as current message. Use 'message_fetch', since its
+     * domain don't use 'ids', so if there is new messages, they'll be fetched.
+     * @returns {Deferred}
+     */
+    message_refresh: function(){
+        return this.message_load_new();
+    },
+    /**
+     * Render the messages
+     * @override
+     */
+    message_render: function(){
+        this.$('.o_mail_chatter_messages').html(QWeb.render('mail.chatter.ChatterMailThread.messages', {'widget': this}));
+    },
+    /**
+     * Order the messages
+     * @param {Object[]} messages : messages to order
+     * @override
+     */
+    _message_order: function(messages){
+        var messages = mail_thread.MailThreadMixin._message_order.call(this, messages);
+        return messages.reverse();
+    },
+    /**
+     * Return the message domain for the current document mail thread
+     * @override
+     */
+    get_message_domain: function(){
+        var res_id = this.ThreadDataset.ids[this.ThreadDataset.index];
+        return [['model', '=', this.ThreadDataset.model], ['res_id', '=', res_id]];
+    }
+});
+
+core.form_widget_registry.add('mail_thread', ChatterMailThread);
+
+
+
+/**
+ * Global ComposeMessage Top Button
+ *
+ * Add a link on the top user bar to write a full mail. It opens the form view
+ * of the mail.compose.message (in a modal).
+ */
+var ComposeMessageTopButton = Widget.extend({
+    template:'mail.ComposeMessageTopButton',
+    events: {
+        "click": "on_compose_message",
+    },
+    on_compose_message: function (ev) {
+        ev.preventDefault();
+        var ctx = {};
+        if ($('button.o_timeline_compose_post') && $('button.o_timeline_compose_post').is(":visible") == true &&
+             (this.getParent()).getParent().action_manager.inner_widget.active_view.type == 'form'){
+            ctx = {
+                'default_res_id': (this.getParent()).getParent().action_manager.inner_widget.active_view.controller.datarecord.id,
+                'default_model': (this.getParent()).getParent().action_manager.inner_widget.active_view.controller.model,
+            };
+        }
+        web_client.action_manager.do_action({
+            type: 'ir.actions.act_window',
+            res_model: 'mail.compose.message',
+            view_mode: 'form',
+            view_type: 'form',
+            views: [[false, 'form']],
+            target: 'new',
+            context: ctx,
+        });
+    },
+});
+
+// Put the ComposeMessageTopButton widget in the systray menu
+SystrayMenu.Items.push(ComposeMessageTopButton);
+
+
+return {
+    ChatterMailThread: ChatterMailThread,
+};
+
+});
diff --git a/addons/mail/static/src/js/mail_followers.js b/addons/mail/static/src/js/mail_followers.js
index 0f2353c729e..124ed218a7e 100644
--- a/addons/mail/static/src/js/mail_followers.js
+++ b/addons/mail/static/src/js/mail_followers.js
@@ -13,9 +13,9 @@ var web_client = require('web.web_client');
 var _t = core._t;
 var qweb = core.qweb;
 
-/** 
+/**
  * ------------------------------------------------------------
- * timeline_followers Widget
+ * Mail Followers Widget
  * ------------------------------------------------------------
  *
  * This widget handles the display of a list of records as a vertical
@@ -27,7 +27,7 @@ var qweb = core.qweb;
 
 
 var Followers = form_common.AbstractField.extend({
-    template: 'mail_followers',
+    template: 'mail.Followers',
 
     init: function() {
         this._super.apply(this, arguments);
@@ -40,7 +40,7 @@ var Followers = form_common.AbstractField.extend({
         this.value = [];
         this.followers = [];
         this.data_subtype = {};
-        
+
         this.view_is_editable = this.__parentedParent.is_action_enabled('edit');
     },
 
@@ -112,7 +112,7 @@ var Followers = form_common.AbstractField.extend({
                         size: 'small',
                         title: _t('Edit Subscription of ') + $currentTarget.siblings('a').text(),
                         buttons: [
-                                { text: _t("Apply"), click: function() { 
+                                { text: _t("Apply"), click: function() {
                                     self.do_update_subscription(event, user_pid);
                                     this.parents('.modal').modal('hide');
                                 }},
@@ -236,11 +236,11 @@ var Followers = form_common.AbstractField.extend({
         var user_follower = _.filter(this.followers, function (rec) { return rec['is_uid'];});
         this.message_is_follower = user_follower.length >= 1;
         this.follower_id = this.message_is_follower ? user_follower[0]['id'] : undefined;
-        $(qweb.render('mail_followers_add_more', {'widget': self})).appendTo(node_user_list);
+        $(qweb.render('mail.Followers.add_more', {'widget': self})).appendTo(node_user_list);
 
         // truncate number of displayed followers
         _(this.followers).each(function (record) {
-            $(qweb.render('mail_followers_partner', {
+            $(qweb.render('mail.Followers.partner', {
                 'record': _.extend(record, {'avatar_url': '/web/image/' + record['res_model'] + '/' + record['res_id'] + '/image_small'}),
                 'widget': self})
             ).appendTo(node_user_list);
@@ -279,7 +279,7 @@ var Followers = form_common.AbstractField.extend({
 
         if (user_pid) {
             dialog = true;
-        } 
+        }
         else {
             var subtype_list_ul = this.$('.o_timeline_subtype_list ul').empty();
             if (! this.message_is_follower) {
@@ -302,7 +302,7 @@ var Followers = form_common.AbstractField.extend({
     display_subtypes:function (data, dialog) {
         var self = this;
         var $list = this.$('.o_timeline_subtype_list ul');
-    
+
         if (_.isEmpty(this.data_subtype)) {
             this.data_subtype = data;
 
@@ -326,7 +326,7 @@ var Followers = form_common.AbstractField.extend({
                 }
                 old_parent_model = record.parent_model;
                 record.followed = record.followed || undefined;
-                $(qweb.render('mail_followers_subtype', {'record': record, 
+                $(qweb.render('mail.Followers.subtype', {'record': record,
                                                          'dialog': dialog}))
                 .appendTo($list);
             });
@@ -336,9 +336,9 @@ var Followers = form_common.AbstractField.extend({
     do_follow: function () {
         var context = new data.CompoundContext(this.build_context(), {});
         this.$('.o_timeline_subtype_list > .dropdown-toggle').attr('disabled', false);
-        this.ds_model.call('message_subscribe_users', [[this.view.datarecord.id], 
-                                                       [session.uid], 
-                                                       undefined, 
+        this.ds_model.call('message_subscribe_users', [[this.view.datarecord.id],
+                                                       [session.uid],
+                                                       undefined,
                                                        context])
             .then(this.proxy('read_value'));
 
@@ -403,9 +403,9 @@ var Followers = form_common.AbstractField.extend({
                 $(event.target).attr("checked", "checked");
             }
             else {
-                  self.$('.o_timeline_subtype_list ul').empty(); 
+                  self.$('.o_timeline_subtype_list ul').empty();
             }
-        } 
+        }
         else {
             var context = new data.CompoundContext(this.build_context(), {});
             return this.ds_model.call(action_subscribe, [[this.view.datarecord.id], follower_ids, undefined, checklist, context])
diff --git a/addons/mail/static/src/js/mail_thread.js b/addons/mail/static/src/js/mail_thread.js
new file mode 100644
index 00000000000..b40e1df5ced
--- /dev/null
+++ b/addons/mail/static/src/js/mail_thread.js
@@ -0,0 +1,430 @@
+odoo.define('mail.thread', function (require) {
+"use strict";
+
+var core = require('web.core');
+var data = require('web.data');
+var time = require('web.time');
+var Widget = require('web.Widget');
+var session = require('web.session');
+var web_client = require('web.web_client');
+var mail_utils = require('mail.utils');
+
+var _t = core._t;
+var QWeb = core.qweb;
+
+
+var LIMIT_MESSAGE = 20;
+
+/**
+ * Widget : Input textbox to post messages
+ *
+ * Input with 2 buttons to manage attachment and emoji
+ *      - Attachment : upload selected attachment (one at a time) and display them below the textbox. Prevent
+          posting message while uploading
+ *      - Emoji : popover exposing emoji list, and append emoji shortcode to the textbox when click on emoji image
+ * It triggers 'message_sent' event with the posted message, when it is sent to the server.
+ */
+var MailComposeMessage = Widget.extend({
+    template: 'mail.ComposeMessage',
+    events: {
+        "keydown .o_mail_compose_message_input": "on_keydown",
+        "change input.oe_form_binary_file": "on_attachment_change",
+        "click .o_mail_compose_message_attachment_list .o_mail_attachment_delete": "on_attachment_delete",
+        "click .o_mail_compose_message_button_attachment": 'on_click_attachment',
+        "click .o_mail_compose_message_button_send": 'message_send',
+    },
+    /**
+     * Contructor
+     * @param {Object} options : the options of the MailComposeMessage
+     * @param {Object[]} [options.emoji_list] : the list of emoji
+     * @param {Object} options.context : the context. It should contains the default_res_id' (id of the current document).
+     * @param {chat|mail} options.display_mode : the 'chat' mode will display an input, when the 'mail' mode will display a texarea.
+     */
+    init: function(parent, dataset, options){
+        this._super.apply(this, arguments);
+        this.thread_dataset = dataset;
+        this.options = _.defaults(options || {}, {
+            'emoji_list': {},
+            'context': {},
+            'display_mode': 'mail',
+        });
+        this.emoji_list = this.options.emoji_list;
+        this.context = this.options.context;
+        // attachment handeling
+        this.AttachmentDataSet = new data.DataSetSearch(this, 'ir.attachment', this.context);
+        this.fileupload_id = _.uniqueId('o_mail_chat_fileupload');
+        this.set('attachment_ids', []);
+    },
+    start: function(){
+        var self = this;
+        this.$input = this.$('.o_mail_compose_message_input');
+        this.$input.focus();
+        this.$attachment_button = this.$(".o_mail_compose_message_button_attachment");
+        // attachments
+        $(window).on(this.fileupload_id, this.on_attachment_loaded);
+        this.on("change:attachment_ids", this, this.attachment_render);
+        // emoji
+        self.$('.o_mail_compose_message_button_emoji').popover({
+            placement: 'top',
+            content: function(){
+                if(!self.$emoji){ // lazy rendering
+                    self.$emoji = $(QWeb.render('mail.ComposeMessage.emoji', {'widget': self}));
+                    self.$emoji.find('.o_mail_compose_message_emoji_img').on('click', self, self.on_click_emoji_img);
+                }
+                return self.$emoji;
+            },
+            html: true,
+            container: '.o_mail_compose_message_emoji',
+            trigger: 'focus',
+        });
+        return this._super();
+    },
+    // events
+    on_click_attachment: function(event){
+        event.preventDefault();
+        this.$('input.oe_form_binary_file').click();
+    },
+    on_click_emoji_img: function(event){
+        this.$input.val(this.$input.val() + " " + $(event.currentTarget).data('emoji')+ " ");
+        this.$input.focus();
+    },
+    on_keydown: function(event){
+        if(event.which === 13 && this.options.display_mode === 'chat') {
+            this.message_send();
+        }
+    },
+    message_send: function(){
+        var $input = this.$('.o_mail_compose_message_input');
+        var mes = mail_utils.get_text2html($input.val());
+        if (! mes.trim() && this.do_check_attachment_upload()) {
+            return;
+        }
+        $input.val("");
+        this.message_post(mes, _.pluck(this.get('attachment_ids'), 'id'));
+    },
+    /**
+     * Sent the message to the server to create a mail.message, using 'message_post' method
+     * @param {String} body : the core of the message (html, or plaintext)
+     * @param {Number[]} attachment_ids : attachment_ids linked to the message
+     * @param {Object} kwargs : other parameters (in a dictionnary)
+     * @returns {Deferred} resolved when the message is posted, and returning the new message id
+     */
+    message_post: function(body, attachment_ids, kwargs){
+        var self = this;
+        var values = _.defaults(kwargs || {}, {
+            'body': body,
+            'attachment_ids': attachment_ids || [],
+            'message_type': 'comment',
+            'content_subtype': 'html',
+            'partner_ids': [],
+            'subtype': 'mail.mt_comment',
+        });
+        return this.thread_dataset._model.call('message_post', [this.context.default_res_id], values).then(function(message_id){
+            self.clean_attachments(); // empty attachment list
+            self.trigger('message_sent', message_id);
+            return message_id;
+        });
+    },
+    // attachment business
+    on_attachment_change: function(event){
+        var $target = $(event.target);
+        if ($target.val() !== '') {
+            var filename = $target.val().replace(/.*[\\\/]/,'');
+            // if the files exits for this answer, delete the file before upload
+            var attachments = [];
+            for (var i in this.get('attachment_ids')) {
+                if ((this.get('attachment_ids')[i].filename || this.get('attachment_ids')[i].name) == filename) {
+                    if (this.get('attachment_ids')[i].upload) {
+                        return false;
+                    }
+                    this.AttachmentDataSet.unlink([this.get('attachment_ids')[i].id]);
+                } else {
+                    attachments.push(this.get('attachment_ids')[i]);
+                }
+            }
+            // submit filename
+            this.$('form.oe_form_binary_form').submit();
+            this.$attachment_button.prop('disabled', true);
+
+            attachments.push({
+                'id': 0,
+                'name': filename,
+                'filename': filename,
+                'url': '',
+                'upload': true
+            });
+            this.set('attachment_ids', attachments);
+        }
+    },
+    on_attachment_loaded: function(event, result){
+        var attachment_ids = [];
+        if (result.error || !result.id ) {
+            this.do_warn(result.error);
+            attachment_ids = _.filter(this.get('attachment_ids'), function (val) { return !val.upload; });
+        }else{
+            _.each(this.get('attachment_ids'), function(a){
+                if (a.filename == result.filename && a.upload) {
+                    attachment_ids.push({
+                        'id': result.id,
+                        'name': result.name || result.filename,
+                        'filename': result.filename,
+                        'url': session.url('/web/binary/saveas', {model: 'ir.attachment', field: 'datas', filename_field: 'name', 'id': result.id}),
+                    });
+                }else{
+                    attachment_ids.push(a);
+                }
+            });
+        }
+        this.set('attachment_ids', attachment_ids);
+
+        // TODO JEM : understand the 2 lines below ....
+        var $input = this.$('input.oe_form_binary_file');
+        $input.after($input.clone(true)).remove();
+
+        this.$attachment_button.prop('disabled', false);
+    },
+    on_attachment_delete: function(event){
+        event.stopPropagation();
+        var self = this;
+        var attachment_id = $(event.target).data("id");
+        if (attachment_id) {
+            var attachments = [];
+            _.each(this.get('attachment_ids'), function(attachment){
+                if (attachment_id != attachment.id) {
+                    attachments.push(attachment);
+                } else {
+                    self.AttachmentDataSet.unlink([attachment_id]);
+                }
+            });
+            this.set('attachment_ids', attachments);
+        }
+    },
+    do_check_attachment_upload: function () {
+        if (_.find(this.get('attachment_ids'), function (file) {return file.upload;})) {
+            this.do_warn(_t("Uploading error"), _t("Please, wait while the file is uploading."));
+            return false;
+        }
+        return true;
+    },
+    clean_attachments: function(){
+        this.set('attachment_ids', []);
+    },
+    // ui
+    attachment_render: function(){
+        this.$('.o_mail_compose_message_attachment_list').html(QWeb.render('mail.ComposeMessage.attachments', {'widget': this}));
+    },
+    focus: function(){
+        this.$input.focus();
+    }
+});
+
+
+/**
+ * Mail Thread Mixin : Messages Managment
+ *
+ * Load, Fetch, Display mail.message
+ * This is a mixin since it will be inherit by a form_common.AbstractField and a Wigdet (Client Action)
+ *
+ * @mixin
+ **/
+var MailThreadMixin = {
+    /**
+     * Constructor of the 'mail_thread' mixin
+     * @param {Boolean} [options.display_log_button] : display of the 'log a note' button
+     * @param {Boolean} [options.display_document_link] : display document link on message
+     * @param {Boolean} [options.display_needaction_button] : display the needaction 'check' button on messages
+     * @param {Object[]} [options.internal_subtypes]: list of internal subtype (for employee only)
+     * @param {Object[]} [options.emoji_list] : list of emoji
+     */
+    init: function(){
+        this.MessageDatasetSearch = new data.DataSetSearch(this, 'mail.message');
+        this.set('messages', []);
+        this.emoji_substitution = {};
+        // options
+        this.options = _.defaults(this.options || {}, {
+            'display_log_button': false,
+            'display_document_link': false,
+            'display_needaction_button': false,
+            'internal_subtypes': [],
+            'emoji_list': [],
+        });
+    },
+    start: function(){
+        this.on("change:messages", this, this.message_render);
+    },
+    // Common Actions (They should be bind on the implementing widget, the 'events' dict)
+    /**
+     * Generic redirect action : redirect to the form view if the
+     * click node contains 'data-oe-model' and 'data-oe-id'.
+     */
+    on_click_redirect: function(event){
+        event.preventDefault();
+        var res_id = $(event.target).data('oe-id');
+        var res_model = $(event.target).data('oe-model');
+        web_client.action_manager.do_push_state({
+            'model': res_model,
+            'id': res_id,
+            'title': this.record_name,
+        });
+        this.do_action({
+            type:'ir.actions.act_window',
+            view_type: 'form',
+            view_mode: 'form',
+            res_model: res_model,
+            views: [[false, 'form']],
+            res_id: res_id,
+        }, {
+            'on_reverse_breadcrumb': this.on_reverse_breadcrumb,
+        });
+    },
+    /**
+     * Will be called when clicking on the Breadcrumb (mainly of client action)
+     * Need to be override
+     */
+    on_reverse_breadcrumb: function(){
+
+    },
+    /**
+     * Toggle a message as 'starred' (or not), by toggling the 'o_mail_message_starred' css class.
+     * Trigger when clicking on selector '.o_mail_thread_message_star'.
+     */
+    on_message_star: function(event){
+        var $source = this.$(event.currentTarget);
+        var mid = $source.data('message-id');
+        var is_starred = !$source.hasClass('o_mail_message_starred');
+        return this.MessageDatasetSearch.call('set_message_starred', [[mid], is_starred]).then(function(res){
+            $source.toggleClass('o_mail_message_starred');
+            return mid;
+        });
+    },
+    on_message_needaction: function(event){
+        var $source = this.$(event.currentTarget);
+        var mid = $source.data('message-id');
+        return this.MessageDatasetSearch.call('set_message_done', [[mid]]).then(function(res){
+            $source.remove();
+            return mid;
+        });
+    },
+    // Message functions
+    /**
+     * Fetch given message
+     * @param  {Number[]} message_ids : list of mail.message identifiers to fetch
+     * @returns {Deferred} resolved when the messages are loaded
+     */
+    message_format: function(message_ids){
+        return this.MessageDatasetSearch._model.call('message_format', [message_ids]);
+    },
+    /**
+     * Fetch mail.message in the format defined server side
+     * @param {Array} domain : Odoo Domain of the message to fetch
+     * @param {Number} limit : the limit of messages to fetch
+     * @returns {Deferred} resolved when the messages are loaded
+     */
+    message_fetch: function(domain, limit){
+        domain = domain || this.get_message_domain();
+        limit = limit || LIMIT_MESSAGE;
+        return this.MessageDatasetSearch._model.call('message_fetch', [domain], {limit: limit});
+    },
+    _message_replace: function(messages){
+        this.set('messages', this._message_order(messages));
+    },
+    /**
+     * Order the message in a particular order, to be defined by implementation
+     * @param {Object[]} messages : messages to order
+     */
+    _message_order: function(messages){
+        return _.sortBy(messages, 'date');
+    },
+    /**
+     * Insert messages in the current list
+     * @param {Object[]} messages : list of mail.message (formatted server side)
+     */
+    message_insert: function(raw_messages){
+        var current_messages = this.get('messages');
+        current_messages = current_messages.concat(this._message_preprocess(raw_messages));
+        this._message_replace(current_messages);
+    },
+    /**
+     * Load history of message, with the 'history' domain, and insert them in the current list
+     * @returns {Deferred} resolved when the messages are fetched and returning the raw
+     *                     messages (formatted server side)
+     */
+    message_load_history: function(){
+        var self = this;
+        return this.message_fetch(this.get_message_domain_history()).then(function(raw_messages){
+            self.message_insert(raw_messages);
+            return raw_messages
+        });
+    },
+    /**
+     * Load messages according to the current domain, and set that new list as current messages,
+     * erasing the old ones.
+     * @returns {Deferred} resolved when the messages are fetched and returning the raw
+     *                     messages (formatted server side)
+     */
+    message_load_new: function(){
+        var self = this;
+        return this.message_fetch(this.get_message_domain()).then(function(raw_messages){
+            self._message_replace(self._message_preprocess(raw_messages));
+            return raw_messages
+        });
+    },
+    /**
+     * Preprocess the list of messages before rendering, add 'computed' field (is_needaction,
+     * is_starred, ...), and apply image shortcode to the message body.
+     * @param {Object[]} messages : list of raw mail.message (formatted server side)
+     * @returns list of messages. It can be sorted, grouped, ...
+     */
+    _message_preprocess: function(messages){
+        var self = this;
+        _.each(messages, function(m){
+            m.is_needaction = _.contains(m.needaction_partner_ids, session.partner_id);
+            m.is_starred = _.contains(m.starred_partner_ids, session.partner_id);
+            m.date = moment(time.str_to_datetime(m.date)).format('YYYY-MM-DD HH:mm:ss'); // set the date in the correct browser user timezone
+            if(m.body){
+                m.body = mail_utils.shortcode_apply(m.body, self.emoji_substitution);
+            }
+            _.each(m.attachment_ids, function(a){
+                a.url = mail_utils.get_attachment_url(session, m.id, a.id);
+            });
+        });
+        return _.sortBy(messages, 'date');
+    },
+    /**
+     * Take the current messages, render them, and insert the rendering in the DOM.
+     * This is triggered when the mesasge list change.
+     * Must be redefined, since it depends on the complete DOM widget
+     */
+    message_render: function(){
+
+    },
+    // Message Domains
+    /**
+     * Return the current domain to fetch the message of the thread. this should
+     * be redifined by the thread implementation.
+     */
+    get_message_domain: function(){
+        return [];
+    },
+    get_message_domain_history: function(){
+        return this.get_message_domain().concat([['id', '<', _.min(_.pluck(this.get('messages'), 'id'))]]);
+    },
+    // Others
+    /**
+     * Set the list of emoji to be substituted in message body
+     * @param {Object[]} emoji_list : list of emoji Object
+     */
+    emoji_set_substitution: function(emoji_list){
+        this.emoji_substitution = mail_utils.shortcode_substitution(emoji_list);
+    },
+};
+
+
+return {
+    MailComposeMessage: MailComposeMessage,
+    MailThreadMixin: MailThreadMixin,
+    LIMIT_MESSAGE: LIMIT_MESSAGE,
+}
+
+
+});
diff --git a/addons/mail/static/src/js/mail_utils.js b/addons/mail/static/src/js/mail_utils.js
index 656dc941a75..a18dc449d6b 100644
--- a/addons/mail/static/src/js/mail_utils.js
+++ b/addons/mail/static/src/js/mail_utils.js
@@ -5,7 +5,7 @@ odoo.define('mail.utils', function () {
  * ------------------------------------------------------------
  * ChatterUtils
  * ------------------------------------------------------------
- * 
+ *
  * This class holds a few tools method for Chatter.
  * Some regular expressions not used anymore, kept because I want to
  * - (^|\s)@((\w|@|\.)*): @login@log.log
@@ -28,24 +28,6 @@ function parse_email(text) {
 }
 
 /**
- * Replaces some expressions
- * - :name - shortcut to an image
- */
-function do_replace_expressions(string) {
-    var icon_list = ['al', 'pinky'];
-    /* special shortcut: :name, try to find an icon if in list */
-    var regex_login = new RegExp(/(^|\s):((\w)*)/g);
-    var regex_res = regex_login.exec(string);
-    while (regex_res !== null) {
-        var icon_name = regex_res[2];
-        if (_.include(icon_list, icon_name))
-            string = string.replace(regex_res[0], regex_res[1] + '<img src="/mail/static/src/img/_' + icon_name + '.png" width="22px" height="22px" alt="' + icon_name + '"/>');
-        regex_res = regex_login.exec(string);
-    }
-    return string;
-}
-
-/**
  * Replaces textarea text into html text (add <p>, <a>)
  * TDE note : should be done server-side, in Python -> use mail.compose.message ?
  */
@@ -55,7 +37,7 @@ function get_text2html(text) {
         .replace(/[\n\r]/g,'<br/>');
 }
 
-/* Returns the complete domain with "&" 
+/* Returns the complete domain with "&"
  * TDE note: please add some comments to explain how/why
  */
 function expand_domain(domain) {
@@ -90,6 +72,8 @@ function breakword(str){
     return out;
 }
 
+
+// TODO JEM : remove me in master
 function bindTooltipTo($el, value, position) {
     $el.tooltip({
         'title': value,
@@ -106,13 +90,92 @@ function bindTooltipTo($el, value, position) {
     });
 }
 
+
+/**
+ * ------------------------------------------------------------
+ * MailChat Utils
+ * ------------------------------------------------------------
+ */
+
+ /**
+  * Apply the given shortcode to the 'str' message.
+  * @param str : the text to substitute (html).
+  * @param shortcodes : dict where key is the shortcode, and the value is the substitution
+  */
+function shortcode_apply(str, shortcodes){
+    var re_escape = function(str){
+        return String(str).replace(/([.*+?=^!:${}()|[\]\/\\])/g, '\\$1');
+    };
+    _.each(_.keys(shortcodes), function(key){
+        str = str.replace( new RegExp("(?:^|\\s|<[a-z]*>)(" + re_escape(key) + ")(?:\\s|$|</[a-z]*>)"), ' <span class="o_mail_emoji">'+shortcodes[key]+'</span> ');
+    });
+    return str;
+}
+
+/**
+ * Transform the list of emoji (shortcode Object) into a key-array representing
+ * the substitution to apply
+ * @param {Ojbect[]} emoji_list : list of emoji object
+ * @returns {Object} mapping between the code (as key) and the substitution (as value)
+ */
+function shortcode_substitution(emoji_list){
+    var emoji_substitution = {};
+    _.each(emoji_list, function(emoji){
+        emoji_substitution[emoji.source] = emoji.substitution;
+    });
+    return emoji_substitution;
+}
+
+/**
+ * Associate a font awesome class to a attachment file type
+ * @param {string} file_type : file type to analyse
+ * @returns {string} the fa class associated
+ */
+function attachment_filetype_to_fa_class(file_type){
+    var mapping = {
+        'text': 'fa fa-file-text-o',
+        'document': 'fa fa-file-word-o',
+        'audio': 'fa fa-file-audio-o',
+        'archive': 'fa fa-file-archive-o',
+        'disk': 'fa fa-file-archive-o',
+        'image': 'fa fa-file-photo-o',
+        'webimage': 'fa fa-file-photo-o',
+        'script': 'fa fa-file-code-o',
+        'html': 'fa fa-file-code-o',
+        'video': 'fa fa-file-movie-o',
+        'spreadsheet': 'fa fa-file-excel-o',
+        'print': 'fa fa-file-pdf-o',
+        'presentation': 'fa fa-file-powerpoint-o',
+    }
+    if(_.contains(_.keys(mapping), file_type)){
+        return mapping[file_type];
+    }
+    return 'fa fa-file-o';
+}
+
+/**
+ * Play the noise 'ting' to notify user
+ */
+function beep(session){
+    if (typeof(Audio) === "undefined") {
+        return;
+    }
+    var audio = new Audio();
+    var ext = audio.canPlayType("audio/ogg; codecs=vorbis") ? ".ogg" : ".mp3";
+    audio.src = session.url("/mail/static/src/audio/ting") + ext;
+    audio.play();
+}
+
 return {
     parse_email: parse_email,
-    do_replace_expressions: do_replace_expressions,
     get_text2html: get_text2html,
     expand_domain: expand_domain,
     breakword: breakword,
     bindTooltipTo: bindTooltipTo,
+    shortcode_apply: shortcode_apply,
+    shortcode_substitution: shortcode_substitution,
+    attachment_filetype_to_fa_class: attachment_filetype_to_fa_class,
+    beep: beep,
 };
 
 });