diff --git a/plugins/kolab_notes/kolab_notes.php b/plugins/kolab_notes/kolab_notes.php
index 83694b9b..a0da1201 100644
--- a/plugins/kolab_notes/kolab_notes.php
+++ b/plugins/kolab_notes/kolab_notes.php
@@ -1,1182 +1,1427 @@
 <?php
 
 /**
  * Kolab notes module
  *
  * Adds simple notes management features to the web client
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
- * Copyright (C) 2014, Kolab Systems AG <contact@kolabsys.com>
+ * Copyright (C) 2014-2015, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 class kolab_notes extends rcube_plugin
 {
     public $task = '?(?!login|logout).*';
     public $allowed_prefs = array('kolab_notes_sort_col');
     public $rc;
 
     private $ui;
     private $lists;
     private $folders;
     private $cache = array();
     private $message_notes = array();
+    private $bonnie_api = false;
 
     /**
      * Required startup method of a Roundcube plugin
      */
     public function init()
     {
         $this->require_plugin('libkolab');
 
         $this->rc = rcube::get_instance();
 
         $this->register_task('notes');
 
         // load plugin configuration
         $this->load_config();
 
         // proceed initialization in startup hook
         $this->add_hook('startup', array($this, 'startup'));
     }
 
     /**
      * Startup hook
      */
     public function startup($args)
     {
         // the notes module can be enabled/disabled by the kolab_auth plugin
         if ($this->rc->config->get('kolab_notes_disabled', false) || !$this->rc->config->get('kolab_notes_enabled', true)) {
             return;
         }
 
         // load localizations
         $this->add_texts('localization/', $args['task'] == 'notes' && (!$args['action'] || $args['action'] == 'dialog-ui'));
         $this->rc->load_language($_SESSION['language'], array('notes.notes' => $this->gettext('navtitle')));  // add label for task title
 
         if ($args['task'] == 'notes') {
             $this->add_hook('storage_init', array($this, 'storage_init'));
 
             // register task actions
             $this->register_action('index', array($this, 'notes_view'));
             $this->register_action('fetch', array($this, 'notes_fetch'));
             $this->register_action('get',   array($this, 'note_record'));
             $this->register_action('action', array($this, 'note_action'));
             $this->register_action('list',  array($this, 'list_action'));
             $this->register_action('dialog-ui', array($this, 'dialog_view'));
         }
         else if ($args['task'] == 'mail') {
             $this->add_hook('storage_init', array($this, 'storage_init'));
             $this->add_hook('message_compose', array($this, 'mail_message_compose'));
 
             if (in_array($args['action'], array('show', 'preview', 'print'))) {
                 $this->add_hook('message_load', array($this, 'mail_message_load'));
                 $this->add_hook('template_object_messagebody', array($this, 'mail_messagebody_html'));
             }
 
             // add 'Append note' item to message menu
             if ($this->api->output->type == 'html' && $_REQUEST['_rel'] != 'note') {
                 $this->api->add_content(html::tag('li', null, 
                     $this->api->output->button(array(
                       'command'  => 'append-kolab-note',
                       'label'    => 'kolab_notes.appendnote',
                       'type'     => 'link',
                       'classact' => 'icon appendnote active',
                       'class'    => 'icon appendnote',
                       'innerclass' => 'icon note',
                     ))),
                     'messagemenu');
 
                 $this->api->output->add_label('kolab_notes.appendnote', 'kolab_notes.editnote', 'kolab_notes.deletenotesconfirm', 'kolab_notes.entertitle', 'save', 'delete', 'cancel', 'close');
                 $this->include_script('notes_mail.js');
             }
         }
 
         if (!$this->rc->output->ajax_call && (!$this->rc->output->env['framed'] || in_array($args['action'], array('folder-acl','dialog-ui')))) {
             $this->load_ui();
         }
 
+        // get configuration for the Bonnie API
+        if ($bonnie_config = $this->rc->config->get('kolab_bonnie_api', false)) {
+            $this->bonnie_api = new kolab_bonnie_api($bonnie_config);
+        }
+
         // notes use fully encoded identifiers
         kolab_storage::$encode_ids = true;
     }
 
     /**
      * Hook into IMAP FETCH HEADER.FIELDS command and request MESSAGE-ID
      */
     public function storage_init($p)
     {
         $p['fetch_headers'] = trim($p['fetch_headers'] . ' MESSAGE-ID');
         return $p;
     }
 
     /**
      * Load and initialize UI class
      */
     private function load_ui()
     {
         require_once($this->home . '/kolab_notes_ui.php');
         $this->ui = new kolab_notes_ui($this);
         $this->ui->init();
     }
 
     /**
      * Read available calendars for the current user and store them internally
      */
     private function _read_lists($force = false)
     {
         // already read sources
         if (isset($this->lists) && !$force)
             return $this->lists;
 
         // get all folders that have type "task"
         $folders = kolab_storage::sort_folders(kolab_storage::get_folders('note'));
         $this->lists = $this->folders = array();
 
         // find default folder
         $default_index = 0;
         foreach ($folders as $i => $folder) {
             if ($folder->default)
                 $default_index = $i;
         }
 
         // put default folder on top of the list
         if ($default_index > 0) {
             $default_folder = $folders[$default_index];
             unset($folders[$default_index]);
             array_unshift($folders, $default_folder);
         }
 
         foreach ($folders as $folder) {
             $item = $this->folder_props($folder);
             $this->lists[$item['id']] = $item;
             $this->folders[$item['id']] = $folder;
             $this->folders[$folder->name] = $folder;
         }
     }
 
     /**
      * Get a list of available folders from this source
      */
     public function get_lists(&$tree = null)
     {
         $this->_read_lists();
 
         // attempt to create a default folder for this user
         if (empty($this->lists)) {
             $folder = array('name' => 'Notes', 'type' => 'note', 'default' => true, 'subscribed' => true);
             if (kolab_storage::folder_update($folder)) {
                 $this->_read_lists(true);
             }
         }
 
         $folders = array();
         foreach ($this->lists as $id => $list) {
             if (!empty($this->folders[$id])) {
                 $folders[] = $this->folders[$id];
             }
         }
 
         // include virtual folders for a full folder tree
         if (!is_null($tree)) {
             $folders = kolab_storage::folder_hierarchy($folders, $tree);
         }
 
         $delim = $this->rc->get_storage()->get_hierarchy_delimiter();
 
         $lists = array();
         foreach ($folders as $folder) {
             $list_id = $folder->id;
             $imap_path = explode($delim, $folder->name);
 
             // find parent
             do {
               array_pop($imap_path);
               $parent_id = kolab_storage::folder_id(join($delim, $imap_path));
             }
             while (count($imap_path) > 1 && !$this->folders[$parent_id]);
 
             // restore "real" parent ID
             if ($parent_id && !$this->folders[$parent_id]) {
                 $parent_id = kolab_storage::folder_id($folder->get_parent());
             }
 
             $fullname = $folder->get_name();
             $listname = $folder->get_foldername();
 
             // special handling for virtual folders
             if ($folder instanceof kolab_storage_folder_user) {
                 $lists[$list_id] = array(
                     'id'       => $list_id,
                     'name'     => $fullname,
                     'listname' => $listname,
                     'title'    => $folder->get_title(),
                     'virtual'  => true,
                     'editable' => false,
                     'rights'   => 'l',
                     'group'    => 'other virtual',
                     'class'    => 'user',
                     'parent'   => $parent_id,
                 );
             }
             else if ($folder->virtual) {
                 $lists[$list_id] = array(
                     'id'       => $list_id,
                     'name'     => kolab_storage::object_name($fullname),
                     'listname' => $listname,
                     'virtual'  => true,
                     'editable' => false,
                     'rights'   => 'l',
                     'group'    => $folder->get_namespace(),
                     'parent'   => $parent_id,
                 );
             }
             else {
                 if (!$this->lists[$list_id]) {
                     $this->lists[$list_id] = $this->folder_props($folder);
                     $this->folders[$list_id] = $folder;
                 }
                 $this->lists[$list_id]['parent'] = $parent_id;
                 $lists[$list_id] = $this->lists[$list_id];
             }
         }
 
         return $lists;
     }
 
     /**
      * Search for shared or otherwise not listed folders the user has access
      *
      * @param string Search string
      * @param string Section/source to search
      * @return array List of notes folders
      */
     protected function search_lists($query, $source)
     {
         if (!kolab_storage::setup()) {
             return array();
         }
 
         $this->search_more_results = false;
         $this->lists = $this->folders = array();
 
         // find unsubscribed IMAP folders that have "event" type
         if ($source == 'folders') {
             foreach ((array)kolab_storage::search_folders('note', $query, array('other')) as $folder) {
                 $this->folders[$folder->id] = $folder;
                 $this->lists[$folder->id] = $this->folder_props($folder);
             }
         }
         // search other user's namespace via LDAP
         else if ($source == 'users') {
             $limit = $this->rc->config->get('autocomplete_max', 15) * 2;  // we have slightly more space, so display twice the number
             foreach (kolab_storage::search_users($query, 0, array(), $limit * 10) as $user) {
                 $folders = array();
                 // search for note folders shared by this user
                 foreach (kolab_storage::list_user_folders($user, 'note', false) as $foldername) {
                     $folders[] = new kolab_storage_folder($foldername, 'note');
                 }
 
                 if (count($folders)) {
                     $userfolder = new kolab_storage_folder_user($user['kolabtargetfolder'], '', $user);
                     $this->folders[$userfolder->id] = $userfolder;
                     $this->lists[$userfolder->id] = $this->folder_props($userfolder);
 
                     foreach ($folders as $folder) {
                         $this->folders[$folder->id] = $folder;
                         $this->lists[$folder->id] = $this->folder_props($folder);
                         $count++;
                     }
                 }
 
                 if ($count >= $limit) {
                     $this->search_more_results = true;
                     break;
                 }
             }
 
         }
 
         return $this->get_lists();
     }
 
     /**
      * Derive list properties from the given kolab_storage_folder object
      */
     protected function folder_props($folder)
     {
         if ($folder->get_namespace() == 'personal') {
             $norename = false;
             $editable = true;
             $rights = 'lrswikxtea';
             $alarms = true;
         }
         else {
             $alarms = false;
             $rights = 'lr';
             $editable = false;
             if (($myrights = $folder->get_myrights()) && !PEAR::isError($myrights)) {
                 $rights = $myrights;
                 if (strpos($rights, 't') !== false || strpos($rights, 'd') !== false)
                     $editable = strpos($rights, 'i');
             }
             $info = $folder->get_folder_info();
             $norename = $readonly || $info['norename'] || $info['protected'];
         }
 
         $list_id = $folder->id;
         return array(
             'id' => $list_id,
             'name' => $folder->get_name(),
             'listname' => $folder->get_foldername(),
             'editname' => $folder->get_foldername(),
             'editable' => $editable,
             'rights'   => $rights,
             'norename' => $norename,
             'parentfolder' => $folder->get_parent(),
             'subscribed' => (bool)$folder->is_subscribed(),
             'default'  => $folder->default,
             'group'    => $folder->default ? 'default' : $folder->get_namespace(),
             'class'    => trim($folder->get_namespace() . ($folder->default ? ' default' : '')),
         );
     }
 
     /**
      * Get the kolab_calendar instance for the given calendar ID
      *
      * @param string List identifier (encoded imap folder name)
      * @return object kolab_storage_folder Object nor null if list doesn't exist
      */
     public function get_folder($id)
     {
         // create list and folder instance if necesary
         if (!$this->lists[$id]) {
             $folder = kolab_storage::get_folder(kolab_storage::id_decode($id));
             if ($folder->type) {
                 $this->folders[$id] = $folder;
                 $this->lists[$id] = $this->folder_props($folder);
             }
         }
 
         return $this->folders[$id];
     }
 
     /*******  UI functions  ********/
 
     /**
      * Render main view of the tasklist task
      */
     public function notes_view()
     {
         $this->ui->init();
         $this->ui->init_templates();
         $this->rc->output->set_pagetitle($this->gettext('navtitle'));
         $this->rc->output->send('kolab_notes.notes');
     }
 
     /**
      * Deliver a rediced UI for inline (dialog)
      */
     public function dialog_view()
     {
         // resolve message reference
         if ($msgref = rcube_utils::get_input_value('_msg', rcube_utils::INPUT_GPC, true)) {
             $storage = $this->rc->get_storage();
             list($uid, $folder) = explode('-', $msgref, 2);
             if ($message = $storage->get_message_headers($msgref)) {
                 $this->rc->output->set_env('kolab_notes_template', array(
                     '_from_mail' => true,
                     'title' => $message->get('subject'),
                     'links' => array(kolab_storage_config::get_message_reference(
                         kolab_storage_config::get_message_uri($message, $folder),
                         'note'
                     )),
                 ));
             }
         }
 
         $this->ui->init_templates();
         $this->rc->output->send('kolab_notes.dialogview');
     }
 
     /**
      * Handler to retrieve note records for the given list and/or search query
      */
     public function notes_fetch()
     {
         $search = rcube_utils::get_input_value('_q', rcube_utils::INPUT_GPC, true);
         $list   = rcube_utils::get_input_value('_list', rcube_utils::INPUT_GPC);
 
         $data = $this->notes_data($this->list_notes($list, $search), $tags);
 
         $this->rc->output->command('plugin.data_ready', array(
                 'list'   => $list,
                 'search' => $search,
                 'data'   => $data,
                 'tags'   => array_values($tags)
         ));
     }
 
     /**
      * Convert the given note records for delivery to the client
      */
     protected function notes_data($records, &$tags)
     {
         $config = kolab_storage_config::get_instance();
         $tags   = $config->apply_tags($records);
 
         foreach ($records as $i => $rec) {
             unset($records[$i]['description']);
             $this->_client_encode($records[$i]);
         }
 
         return $records;
     }
 
     /**
      * Read note records for the given list from the storage backend
      */
     protected function list_notes($list_id, $search = null)
     {
         $results = array();
 
         // query Kolab storage
         $query = array();
 
         // full text search (only works with cache enabled)
         if (strlen($search)) {
             $words = array_filter(rcube_utils::normalize_string(mb_strtolower($search), true));
             foreach ($words as $word) {
                 if (strlen($word) > 2) {  // only words > 3 chars are stored in DB
                     $query[] = array('words', '~', $word);
                 }
             }
         }
 
         $this->_read_lists();
         if ($folder = $this->get_folder($list_id)) {
             foreach ($folder->select($query) as $record) {
                 // post-filter search results
                 if (strlen($search)) {
                     $matches = 0;
                     $contents = mb_strtolower(
                         $record['title'] .
                         ($this->is_html($record) ? strip_tags($record['description']) : $record['description'])
                     );
                     foreach ($words as $word) {
                         if (mb_strpos($contents, $word) !== false) {
                             $matches++;
                         }
                     }
 
                     // skip records not matching all search words
                     if ($matches < count($words)) {
                         continue;
                     }
                 }
                 $record['list'] = $list_id;
                 $results[] = $record;
             }
         }
 
         return $results;
     }
 
     /**
      * Handler for delivering a full note record to the client
      */
     public function note_record()
     {
         $data = $this->get_note(array(
             'uid'  => rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC),
             'list' => rcube_utils::get_input_value('_list', rcube_utils::INPUT_GPC),
         ));
 
         // encode for client use
         if (is_array($data)) {
             $this->_client_encode($data, true);
         }
 
         $this->rc->output->command('plugin.render_note', $data);
     }
 
     /**
      * Get the full note record identified by the given UID + Lolder identifier
      */
     public function get_note($note)
     {
         if (is_array($note)) {
             $uid = $note['uid'] ?: $note['id'];
             $list_id = $note['list'];
         }
         else {
             $uid = $note;
         }
 
         // deliver from in-memory cache
         $key = $list_id . ':' . $uid;
         if ($this->cache[$key]) {
             return $this->cache[$key];
         }
 
         $result = false;
 
         $this->_read_lists();
         if ($list_id) {
             if ($folder = $this->get_folder($list_id)) {
                 $result = $folder->get_object($uid);
             }
         }
         // iterate over all calendar folders and search for the event ID
         else {
             foreach ($this->folders as $list_id => $folder) {
                 if ($result = $folder->get_object($uid)) {
                     $result['list'] = $list_id;
                     break;
                 }
             }
         }
 
         if ($result) {
             // get note tags
             $result['tags'] = $this->get_tags($result['uid']);
         }
 
         return $result;
     }
 
     /**
      * Helper method to encode the given note record for use in the client
      */
     private function _client_encode(&$note, $resolve = false)
     {
         foreach ($note as $key => $prop) {
             if ($key[0] == '_' || $key == 'x-custom') {
                 unset($note[$key]);
             }
         }
 
         foreach (array('created','changed') as $key) {
             if (is_object($note[$key]) && $note[$key] instanceof DateTime) {
                 $note[$key.'_'] = $note[$key]->format('U');
                 $note[$key] = $this->rc->format_date($note[$key]);
             }
         }
 
         // clean HTML contents
         if (!empty($note['description']) && $this->is_html($note)) {
             $note['html'] = $this->_wash_html($note['description']);
         }
 
         // resolve message links
         $note['links'] = array_map(function($link) {
                 return kolab_storage_config::get_message_reference($link, 'note') ?: array('uri' => $link);
             }, $this->get_links($note['uid']));
 
         return $note;
     }
 
     /**
      * Handler for client-initiated actions on a single note record
      */
     public function note_action()
     {
         $action = rcube_utils::get_input_value('_do', rcube_utils::INPUT_POST);
         $note   = rcube_utils::get_input_value('_data', rcube_utils::INPUT_POST, true);
 
-        $success = false;
+        $success = $silent = false;
         switch ($action) {
             case 'new':
                 $temp_id = $rec['tempid'];
 
             case 'edit':
                 if ($success = $this->save_note($note)) {
                     $refresh = $this->get_note($note);
                     $refresh['tempid'] = $temp_id;
                 }
                 break;
 
             case 'move':
                 $uids = explode(',', $note['uid']);
                 foreach ($uids as $uid) {
                     $note['uid'] = $uid;
                     if (!($success = $this->move_note($note, $note['to']))) {
                         $refresh = $this->get_note($note);
                         break;
                     }
                 }
                 break;
 
             case 'delete':
                 $uids = explode(',', $note['uid']);
                 foreach ($uids as $uid) {
                     $note['uid'] = $uid;
                     if (!($success = $this->delete_note($note))) {
                         $refresh = $this->get_note($note);
                         break;
                     }
                 }
                 break;
+
+            case 'changelog':
+                $data = $this->get_changelog($note);
+                if (is_array($data) && !empty($data)) {
+                    $dtformat = $this->rc->config->get('date_format') . ' ' . $this->rc->config->get('time_format');
+                    array_walk($data, function(&$change) use ($lib, $dtformat) {
+                      if ($change['date']) {
+                          $dt = rcube_utils::anytodatetime($change['date']);
+                          if ($dt instanceof DateTime) {
+                              $change['date'] = $this->rc->format_date($dt, $dtformat);
+                          }
+                      }
+                    });
+                    $this->rc->output->command('plugin.note_render_changelog', $data);
+                }
+                else {
+                    $this->rc->output->command('plugin.note_render_changelog', false);
+                }
+                $silent = true;
+                break;
+
+            case 'diff':
+                $silent = true;
+                $data = $this->get_diff($note, $note['rev1'], $note['rev2']);
+                if (is_array($data)) {
+                    $this->rc->output->command('plugin.note_show_diff', $data);
+                }
+                else {
+                    $this->rc->output->command('display_message', $this->gettext('objectdiffnotavailable'), 'error');
+                }
+                break;
+
+            case 'show':
+                if ($rec = $this->get_revison($note, $note['rev'])) {
+                    $this->rc->output->command('plugin.note_show_revision', $this->_client_encode($rec));
+                }
+                else {
+                    $this->rc->output->command('display_message', $this->gettext('objectnotfound'), 'error');
+                }
+                $silent = true;
+                break;
+
+            case 'restore':
+                if ($this->restore_revision($note, $note['rev'])) {
+                    $refresh = $this->get_note($note);
+                    $this->rc->output->command('display_message', $this->gettext(array('name' => 'objectrestoresuccess', 'vars' => array('rev' => $note['rev']))), 'confirmation');
+                    $this->rc->output->command('plugin.close_history_dialog');
+                }
+                else {
+                    $this->rc->output->command('display_message', $this->gettext('objectrestoreerror'), 'error');
+                }
+                $silent = true;
+                break;
         }
 
         // show confirmation/error message
         if ($success) {
             $this->rc->output->show_message('successfullysaved', 'confirmation');
         }
-        else {
+        else if (!$silent) {
             $this->rc->output->show_message('errorsaving', 'error');
         }
 
         // unlock client
         $this->rc->output->command('plugin.unlock_saving');
 
         if ($refresh) {
             $this->rc->output->command('plugin.update_note', $this->_client_encode($refresh));
         }
     }
 
     /**
      * Update an note record with the given data
      *
      * @param array Hash array with note properties (id, list)
      * @return boolean True on success, False on error
      */
     private function save_note(&$note)
     {
         $this->_read_lists();
 
         $list_id = $note['list'];
         if (!$list_id || !($folder = $this->get_folder($list_id)))
             return false;
 
         // moved from another folder
         if ($note['_fromlist'] && ($fromfolder = $this->get_folder($note['_fromlist']))) {
             if (!$fromfolder->move($note['uid'], $folder->name))
                 return false;
 
             unset($note['_fromlist']);
         }
 
         // load previous version of this record to merge
         if ($note['uid']) {
             $old = $folder->get_object($note['uid']);
             if (!$old || PEAR::isError($old))
                 return false;
 
             // merge existing properties if the update isn't complete
             if (!isset($note['title']) || !isset($note['description']))
                 $note += $old;
         }
 
         // generate new note object from input
         $object = $this->_write_preprocess($note, $old);
 
         // email links and tags are handled separately
         $links = $object['links'];
         $tags  = $object['tags'];
 
         unset($object['links']);
         unset($object['tags']);
 
         $saved = $folder->save($object, 'note', $note['uid']);
 
         if (!$saved) {
             raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error saving note object to Kolab server"),
                 true, false);
             $saved = false;
         }
         else {
             // save links in configuration.relation object
             $this->save_links($object['uid'], $links);
             // save tags in configuration.relation object
             $this->save_tags($object['uid'], $tags);
 
             $note         = $object;
             $note['list'] = $list_id;
             $note['tags'] = (array) $tags;
 
             // cache this in memory for later read
             $key = $list_id . ':' . $note['uid'];
             $this->cache[$key] = $note;
         }
 
         return $saved;
     }
 
     /**
      * Move the given note to another folder
      */
     function move_note($note, $list_id)
     {
         $this->_read_lists();
 
         $tofolder   = $this->get_folder($list_id);
         $fromfolder = $this->get_folder($note['list']);
 
         if ($fromfolder && $tofolder) {
             return $fromfolder->move($note['uid'], $tofolder->name);
         }
 
         return false;
     }
 
     /**
      * Remove a single note record from the backend
      *
      * @param array   Hash array with note properties (id, list)
      * @param boolean Remove record irreversible (mark as deleted otherwise)
      * @return boolean True on success, False on error
      */
     public function delete_note($note, $force = true)
     {
         $this->_read_lists();
 
         $list_id = $note['list'];
         if (!$list_id || !($folder = $this->get_folder($list_id))) {
             return false;
         }
 
         $status = $folder->delete($note['uid'], $force);
 
         if ($status) {
             $this->save_links($note['uid'], null);
             $this->save_tags($note['uid'], null);
         }
 
         return $status;
     }
 
+    /**
+     * Provide a list of revisions for the given object
+     *
+     * @param array  $note Hash array with note properties
+     * @return array List of changes, each as a hash array
+     */
+    public function get_changelog($note)
+    {
+        if (empty($this->bonnie_api)) {
+            return false;
+        }
+
+        list($uid, $mailbox, $msguid) = $this->_resolve_note_identity($note);
+
+        $result = $uid && $mailbox ? $this->bonnie_api->changelog('note', $uid, $mailbox, $msguid) : null;
+        if (is_array($result) && $result['uid'] == $uid) {
+            return $result['changes'];
+        }
+
+        return false;
+    }
+
+    /**
+     * Return full data of a specific revision of a note record
+     *
+     * @param mixed  $note UID string or hash array with note properties
+     * @param mixed  $rev Revision number
+     *
+     * @return array Note object as hash array
+     */
+    public function get_revison($note, $rev)
+    {
+        if (empty($this->bonnie_api)) {
+            return false;
+        }
+
+        list($uid, $mailbox, $msguid) = $this->_resolve_note_identity($note);
+
+        // call Bonnie API
+        $result = $this->bonnie_api->get('note', $uid, $rev, $mailbox, $msguid);
+        if (is_array($result) && $result['uid'] == $uid && !empty($result['xml'])) {
+            $format = kolab_format::factory('note');
+            $format->load($result['xml']);
+            $rec = $format->to_array();
+
+            if ($format->is_valid()) {
+                $rec['rev'] = $result['rev'];
+                return $rec;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Get a list of property changes beteen two revisions of a note object
+     *
+     * @param array  $$note Hash array with note properties
+     * @param mixed  $rev   Revisions: "from:to"
+     *
+     * @return array List of property changes, each as a hash array
+     */
+    public function get_diff($note, $rev1, $rev2)
+    {
+        if (empty($this->bonnie_api)) {
+            return false;
+        }
+
+        list($uid, $mailbox, $msguid) = $this->_resolve_note_identity($note);
+
+        // call Bonnie API
+        $result = $this->bonnie_api->diff('note', $uid, $rev1, $rev2, $mailbox, $msguid);
+        if (is_array($result) && $result['uid'] == $uid) {
+            $result['rev1'] = $rev1;
+            $result['rev2'] = $rev2;
+
+            // convert some properties, similar to self::_client_encode()
+            $keymap = array(
+                'summary'  => 'title',
+                'lastmodified-date' => 'changed',
+            );
+
+            // map kolab object properties to keys and values the client expects
+            array_walk($result['changes'], function(&$change, $i) use ($keymap) {
+                if (array_key_exists($change['property'], $keymap)) {
+                    $change['property'] = $keymap[$change['property']];
+                }
+
+                if ($change['property'] == 'created' || $change['property'] == 'changed') {
+                    if ($old_ = rcube_utils::anytodatetime($change['old'])) {
+                        $change['old_'] = $this->rc->format_date($old_);
+                    }
+                    if ($new_ = rcube_utils::anytodatetime($change['new'])) {
+                        $change['new_'] = $this->rc->format_date($new_);
+                    }
+                }
+
+                // compute a nice diff of note contents
+                if ($change['property'] == 'description') {
+                    $change['diff_'] = libkolab::html_diff($change['old'], $change['new']);
+                    if (!empty($change['diff_'])) {
+                        unset($change['old'], $change['new']);
+                        $change['diff_'] = preg_replace(array('!^.*<body[^>]*>!Uims','!</body>.*$!Uims'), '', $change['diff_']);
+                        $change['diff_'] = preg_replace("!</(p|li|span)>\n!", '</\\1>', $change['diff_']);
+                    }
+                }
+            });
+
+            return $result;
+        }
+
+        return false;
+    }
+
+    /**
+     * Command the backend to restore a certain revision of a note.
+     * This shall replace the current object with an older version.
+     *
+     * @param array  $note Hash array with note properties (id, list)
+     * @param mixed  $rev Revision number
+     *
+     * @return boolean True on success, False on failure
+     */
+    public function restore_revision($note, $rev)
+    {
+        if (empty($this->bonnie_api)) {
+            return false;
+        }
+
+        list($uid, $mailbox, $msguid) = $this->_resolve_note_identity($note);
+
+        $folder = $this->get_folder($note['list']);
+        $success = false;
+
+        if ($folder && ($raw_msg = $this->bonnie_api->rawdata('note', $uid, $rev, $mailbox))) {
+            $imap = $this->rc->get_storage();
+
+            // insert $raw_msg as new message
+            if ($imap->save_message($folder->name, $raw_msg, null, false)) {
+                $success = true;
+
+                // delete old revision from imap and cache
+                $imap->delete_message($msguid, $folder->name);
+                $folder->cache->set($msguid, false);
+                $this->cache = array();
+            }
+        }
+
+        return $success;
+    }
+
+    /**
+     * Helper method to resolved the given note identifier into uid and mailbox
+     *
+     * @return array (uid,mailbox,msguid) tuple
+     */
+    private function _resolve_note_identity($note)
+    {
+        $mailbox = $msguid = null;
+
+        if (!is_array($note)) {
+            $note = $this->get_note($note);
+        }
+
+        if (is_array($note)) {
+            $uid = $note['uid'] ?: $note['id'];
+            $list = $note['list'];
+        }
+        else {
+            return array(null, $mailbox, $msguid);
+        }
+
+        if ($folder = $this->get_folder($list)) {
+            $mailbox = $folder->get_mailbox_id();
+
+            // get object from storage in order to get the real object uid an msguid
+            if ($rec = $folder->get_object($uid)) {
+                $msguid = $rec['_msguid'];
+                $uid = $rec['uid'];
+            }
+        }
+
+        return array($uid, $mailbox, $msguid);
+    }
+
+
     /**
      * Handler for client requests to list (aka folder) actions
      */
     public function list_action()
     {
         $action  = rcube_utils::get_input_value('_do', rcube_utils::INPUT_GPC);
         $list    = rcube_utils::get_input_value('_list', rcube_utils::INPUT_GPC, true);
         $success = $update_cmd = false;
 
         if (empty($action)) {
             $action = rcube_utils::get_input_value('action', rcube_utils::INPUT_GPC);
         }
 
         switch ($action) {
             case 'form-new':
             case 'form-edit':
                 $this->_read_lists();
                 echo $this->ui->list_editform($action, $this->lists[$list['id']], $this->folders[$list['id']]);
                 exit;
 
             case 'new':
                 $list['type'] = 'note';
                 $list['subscribed'] = true;
                 $folder = kolab_storage::folder_update($list);
 
                 if ($folder === false) {
                     $save_error = $this->gettext(kolab_storage::$last_error);
                 }
                 else {
                     $success = true;
                     $update_cmd = 'plugin.update_list';
                     $list['id'] = kolab_storage::folder_id($folder);
                     $list['_reload'] = true;
                 }
                 break;
 
             case 'edit':
                 $this->_read_lists();
                 $oldparent = $this->lists[$list['id']]['parentfolder'];
                 $newfolder = kolab_storage::folder_update($list);
 
                 if ($newfolder === false) {
                   $save_error = $this->gettext(kolab_storage::$last_error);
                 }
                 else {
                     $success = true;
                     $update_cmd = 'plugin.update_list';
                     $list['newid'] = kolab_storage::folder_id($newfolder);
                     $list['_reload'] = $list['parent'] != $oldparent;
 
                     // compose the new display name
                     $delim = $this->rc->get_storage()->get_hierarchy_delimiter();
                     $path_imap = explode($delim, $newfolder);
                     $list['name'] = kolab_storage::object_name($newfolder);
                     $list['editname'] = rcube_charset::convert(array_pop($path_imap), 'UTF7-IMAP');
                     $list['listname'] = str_repeat('&nbsp;&nbsp;&nbsp;', count($path_imap)) . '&raquo; ' . $list['editname'];
                 }
                 break;
 
             case 'delete':
                 $this->_read_lists();
                 $folder = $this->get_folder($list['id']);
                 if ($folder && kolab_storage::folder_delete($folder->name)) {
                     $success = true;
                     $update_cmd = 'plugin.destroy_list';
                 }
                 else {
                     $save_error = $this->gettext(kolab_storage::$last_error);
                 }
                 break;
 
             case 'search':
                 $this->load_ui();
                 $results = array();
                 foreach ((array)$this->search_lists(rcube_utils::get_input_value('q', rcube_utils::INPUT_GPC), rcube_utils::get_input_value('source', rcube_utils::INPUT_GPC)) as $id => $prop) {
                     $editname = $prop['editname'];
                     unset($prop['editname']);  // force full name to be displayed
 
                     // let the UI generate HTML and CSS representation for this calendar
                     $html = $this->ui->folder_list_item($id, $prop, $jsenv, true);
                     $prop += (array)$jsenv[$id];
                     $prop['editname'] = $editname;
                     $prop['html'] = $html;
 
                     $results[] = $prop;
                 }
                 // report more results available
                 if ($this->driver->search_more_results) {
                     $this->rc->output->show_message('autocompletemore', 'info');
                 }
 
                 $this->rc->output->command('multi_thread_http_response', $results, rcube_utils::get_input_value('_reqid', rcube_utils::INPUT_GPC));
                 return;
 
             case 'subscribe':
                 $success = false;
                 if ($list['id'] && ($folder = $this->get_folder($list['id']))) {
                     if (isset($list['permanent']))
                         $success |= $folder->subscribe(intval($list['permanent']));
                     if (isset($list['active']))
                         $success |= $folder->activate(intval($list['active']));
 
                     // apply to child folders, too
                     if ($list['recursive']) {
                         foreach ((array)kolab_storage::list_folders($folder->name, '*', 'node') as $subfolder) {
                             if (isset($list['permanent']))
                                 ($list['permanent'] ? kolab_storage::folder_subscribe($subfolder) : kolab_storage::folder_unsubscribe($subfolder));
                             if (isset($list['active']))
                                 ($list['active'] ? kolab_storage::folder_activate($subfolder) : kolab_storage::folder_deactivate($subfolder));
                         }
                     }
                 }
                 break;
         }
 
         $this->rc->output->command('plugin.unlock_saving');
 
         if ($success) {
             $this->rc->output->show_message('successfullysaved', 'confirmation');
 
             if ($update_cmd) {
                 $this->rc->output->command($update_cmd, $list);
             }
         }
         else {
             $error_msg = $this->gettext('errorsaving') . ($save_error ? ': ' . $save_error :'');
             $this->rc->output->show_message($error_msg, 'error');
         }
     }
 
     /**
      * Hook to add note attachments to message compose if the according parameter is present.
      * This completes the 'send note by mail' feature.
      */
     public function mail_message_compose($args)
     {
         if (!empty($args['param']['with_notes'])) {
             $uids = explode(',', $args['param']['with_notes']);
             $list = $args['param']['notes_list'];
 
             foreach ($uids as $uid) {
                 if ($note = $this->get_note(array('uid' => $uid, 'list' => $list))) {
                     $args['attachments'][] = array(
                         'name'     => abbreviate_string($note['title'], 50, ''),
                         'mimetype' => 'message/rfc822',
                         'data'     => $this->note2message($note),
                     );
 
                     if (empty($args['param']['subject'])) {
                         $args['param']['subject'] = $note['title'];
                     }
                 }
             }
 
             unset($args['param']['with_notes'], $args['param']['notes_list']);
         }
 
         return $args;
     }
 
     /**
      * Lookup backend storage and find notes associated with the given message
      */
     public function mail_message_load($p)
     {
         if (!$p['object']->headers->others['x-kolab-type']) {
             $this->message_notes = $this->get_message_notes($p['object']->headers, $p['object']->folder);
         }
     }
 
     /**
      * Handler for 'messagebody_html' hook
      */
     public function mail_messagebody_html($args)
     {
         $html = '';
         foreach ($this->message_notes as $note) {
             $html .= html::a(array(
                 'href' => $this->rc->url(array('task' => 'notes', '_list' => $note['list'], '_id' => $note['uid'])),
                 'class' => 'kolabnotesref',
                 'rel' => $note['uid'] . '@' . $note['list'],
                 'target' => '_blank',
             ), Q($note['title']));
         }
 
         // prepend note links to message body
         if ($html) {
             $this->load_ui();
             $args['content'] = html::div('kolabmessagenotes', $html) . $args['content'];
         }
 
         return $args;
     }
 
     /**
      * Determine whether the given note is HTML formatted
      */
     private function is_html($note)
     {
         // check for opening and closing <html> or <body> tags
         return (preg_match('/<(html|body)(\s+[a-z]|>)/', $note['description'], $m) && strpos($note['description'], '</'.$m[1].'>') > 0);
     }
 
     /**
      * Build an RFC 822 message from the given note
      */
     private function note2message($note)
     {
         $message = new Mail_mime("\r\n");
 
         $message->setParam('text_encoding', '8bit');
         $message->setParam('html_encoding', 'quoted-printable');
         $message->setParam('head_encoding', 'quoted-printable');
         $message->setParam('head_charset', RCUBE_CHARSET);
         $message->setParam('html_charset', RCUBE_CHARSET);
         $message->setParam('text_charset', RCUBE_CHARSET);
 
         $message->headers(array(
             'Subject' => $note['title'],
             'Date' => $note['changed']->format('r'),
         ));
 
         if ($this->is_html($note)) {
             $message->setHTMLBody($note['description']);
 
             // add a plain text version of the note content as an alternative part.
             $h2t = new rcube_html2text($note['description'], false, true, 0, RCUBE_CHARSET);
             $plain_part = rcube_mime::wordwrap($h2t->get_text(), $this->rc->config->get('line_length', 72), "\r\n", false, RCUBE_CHARSET);
             $plain_part = trim(wordwrap($plain_part, 998, "\r\n", true));
 
             // make sure all line endings are CRLF
             $plain_part = preg_replace('/\r?\n/', "\r\n", $plain_part);
 
             $message->setTXTBody($plain_part);
         }
         else {
             $message->setTXTBody($note['description']);
         }
 
         return $message->getMessage();
     }
 
     private function save_links($uid, $links)
     {
         if (empty($links)) {
             $links = array();
         }
         $config = kolab_storage_config::get_instance();
         $remove = array_diff($config->get_object_links($uid), $links);
         return $config->save_object_links($uid, $links, $remove);
     }
 
     /**
      * Find messages assigned to specified note
      */
     private function get_links($uid)
     {
         $config = kolab_storage_config::get_instance();
         return $config->get_object_links($uid);
     }
 
     /**
      * Get note tags
      */
     private function get_tags($uid)
     {
         $config = kolab_storage_config::get_instance();
         $tags   = $config->get_tags($uid);
         $tags   = array_map(function($v) { return $v['name']; }, $tags);
 
         return $tags;
     }
 
     /**
      * Find notes assigned to specified message
      */
     private function get_message_notes($message, $folder)
     {
         $config = kolab_storage_config::get_instance();
         $result = $config->get_message_relations($message, $folder, 'note');
 
         foreach ($result as $idx => $note) {
             $result[$idx]['list'] = kolab_storage::folder_id($note['_mailbox']);
         }
 
         return $result;
     }
 
     /**
      * Update note tags
      */
     private function save_tags($uid, $tags)
     {
         $config = kolab_storage_config::get_instance();
         $config->save_tags($uid, $tags);
     }
 
     /**
      * Process the given note data (submitted by the client) before saving it
      */
     private function _write_preprocess($note, $old = array())
     {
         $object = $note;
 
         // TODO: handle attachments
 
         // convert link references into simple URIs
         if (array_key_exists('links', $note)) {
             $object['links'] = array_map(function($link){ return is_array($link) ? $link['uri'] : strval($link); }, $note['links']);
         }
         else {
             $object['links'] = $old['links'];
         }
 
         // clean up HTML content
         $object['description'] = $this->_wash_html($note['description']);
         $is_html = true;
 
         // try to be smart and convert to plain-text if no real formatting is detected
         if (preg_match('!<body><(?:p|pre)>(.*)</(?:p|pre)></body>!Uims', $object['description'], $m)) {
             if (!preg_match('!<(a|b|i|strong|em|p|span|div|pre|li)(\s+[a-z]|>)!im', $m[1], $n) || !strpos($m[1], '</'.$n[1].'>')) {
                 // $converter = new rcube_html2text($m[1], false, true, 0);
                 // $object['description'] = rtrim($converter->get_text());
                 $object['description'] = html_entity_decode(preg_replace('!<br(\s+/)>!', "\n", $m[1]));
                 $is_html = false;
             }
         }
 
         // Add proper HTML header, otherwise Kontact renders it as plain text
         if ($is_html) {
             $object['description'] = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">'."\n" .
                 str_replace('<head>', '<head><meta name="qrichtext" content="1" />', $object['description']);
         }
 
         // copy meta data (starting with _) from old object
         foreach ((array)$old as $key => $val) {
             if (!isset($object[$key]) && $key[0] == '_')
                 $object[$key] = $val;
         }
 
         // make list of categories unique
         if (is_array($object['tags'])) {
             $object['tags'] = array_unique(array_filter($object['tags']));
         }
 
         unset($object['list'], $object['tempid'], $object['created'], $object['changed'], $object['created_'], $object['changed_']);
         return $object;
     }
 
     /**
      * Sanity checks/cleanups HTML content
      */
     private function _wash_html($html)
     {
         // Add header with charset spec., washtml cannot work without that
         $html = '<html><head>'
             . '<meta http-equiv="Content-Type" content="text/html; charset='.RCUBE_CHARSET.'" />'
             . '</head><body>' . $html . '</body></html>';
 
         // clean HTML with washtml by Frederic Motte
         $wash_opts = array(
             'show_washed'   => false,
             'allow_remote'  => 1,
             'charset'       => RCUBE_CHARSET,
             'html_elements' => array('html', 'head', 'meta', 'body', 'link'),
             'html_attribs'  => array('rel', 'type', 'name', 'http-equiv'),
         );
 
         // initialize HTML washer
         $washer = new rcube_washtml($wash_opts);
 
         $washer->add_callback('form', array($this, '_washtml_callback'));
         $washer->add_callback('a',    array($this, '_washtml_callback'));
 
         // Remove non-UTF8 characters
         $html = rcube_charset::clean($html);
 
         $html = $washer->wash($html);
 
         // remove unwanted comments (produced by washtml)
         $html = preg_replace('/<!--[^>]+-->/', '', $html);
 
         return $html;
     }
 
     /**
      * Callback function for washtml cleaning class
      */
     public function _washtml_callback($tagname, $attrib, $content, $washtml)
     {
         switch ($tagname) {
         case 'form':
             $out = html::div('form', $content);
             break;
 
         case 'a':
             // strip temporary link tags from plain-text markup
             $attrib = html::parse_attrib_string($attrib);
             if (!empty($attrib['class']) && strpos($attrib['class'], 'x-templink') !== false) {
                 // remove link entirely
                 if (strpos($attrib['href'], html_entity_decode($content)) !== false) {
                     $out = $content;
                     break;
                 }
                 $attrib['class'] = trim(str_replace('x-templink', '', $attrib['class']));
             }
             $out = html::a($attrib, $content);
             break;
 
         default:
             $out = '';
         }
 
         return $out;
     }
 
 }
 
diff --git a/plugins/kolab_notes/kolab_notes_ui.php b/plugins/kolab_notes/kolab_notes_ui.php
index bbb15b24..080a586c 100644
--- a/plugins/kolab_notes/kolab_notes_ui.php
+++ b/plugins/kolab_notes/kolab_notes_ui.php
@@ -1,437 +1,439 @@
 <?php
 
 class kolab_notes_ui
 {
     private $rc;
     private $plugin;
     private $ready = false;
 
     function __construct($plugin)
     {
         $this->plugin = $plugin;
         $this->rc = $plugin->rc;
     }
 
     /**
     * Calendar UI initialization and requests handlers
     */
     public function init()
     {
         if ($this->ready)  // already done
             return;
 
         // add taskbar button
         $this->plugin->add_button(array(
             'command' => 'notes',
             'class'   => 'button-notes',
             'classsel' => 'button-notes button-selected',
             'innerclass' => 'button-inner',
             'label'   => 'kolab_notes.navtitle',
         ), 'taskbar');
 
         $this->plugin->include_stylesheet($this->plugin->local_skin_path() . '/notes.css');
 
         $this->plugin->register_action('print', array($this, 'print_template'));
         $this->plugin->register_action('folder-acl', array($this, 'folder_acl'));
 
         $this->ready = true;
   }
 
     /**
     * Register handler methods for the template engine
     */
     public function init_templates()
     {
         $this->plugin->register_handler('plugin.tagslist', array($this, 'tagslist'));
         $this->plugin->register_handler('plugin.notebooks', array($this, 'folders'));
         #$this->plugin->register_handler('plugin.folders_select', array($this, 'folders_select'));
         $this->plugin->register_handler('plugin.searchform', array($this->rc->output, 'search_form'));
         $this->plugin->register_handler('plugin.listing', array($this, 'listing'));
         $this->plugin->register_handler('plugin.editform', array($this, 'editform'));
         $this->plugin->register_handler('plugin.notetitle', array($this, 'notetitle'));
         $this->plugin->register_handler('plugin.detailview', array($this, 'detailview'));
         $this->plugin->register_handler('plugin.attachments_list', array($this, 'attachments_list'));
+        $this->plugin->register_handler('plugin.object_changelog_table', array('libkolab', 'object_changelog_table'));
 
         $this->rc->output->include_script('list.js');
         $this->rc->output->include_script('treelist.js');
         $this->plugin->include_script('notes.js');
 
         jqueryui::tagedit();
 
         // include kolab folderlist widget if available
         if (in_array('libkolab', $this->plugin->api->loaded_plugins())) {
             $this->plugin->api->include_script('libkolab/js/folderlist.js');
+            $this->plugin->api->include_script('libkolab/js/audittrail.js');
         }
 
         // load config options and user prefs relevant for the UI
         $settings = array(
             'sort_col' => $this->rc->config->get('kolab_notes_sort_col', 'changed'),
             'print_template' => $this->rc->url('print'),
         );
 
         if ($list = rcube_utils::get_input_value('_list', rcube_utils::INPUT_GPC)) {
             $settings['selected_list'] = $list;
         }
         if ($uid = rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC)) {
             $settings['selected_uid'] = $uid;
         }
 
         $lang_codes = array($_SESSION['language']);
 
         if ($pos = strpos($_SESSION['language'], '_')) {
             $lang_codes[] = substr($_SESSION['language'], 0, $pos);
         }
 
         foreach ($lang_codes as $code) {
             if (file_exists(INSTALL_PATH . "program/js/tinymce/langs/$code.js")) {
                 $lang = $code;
                 break;
             }
         }
 
         if (empty($lang)) {
             $lang = 'en';
         }
 
         $settings['editor'] = array(
             'lang'       => $lang,
             'spellcheck' => intval($this->rc->config->get('enable_spellcheck')),
             'spelldict'  => intval($this->rc->config->get('spellcheck_dictionary'))
         );
 
         $this->rc->output->set_env('kolab_notes_settings', $settings);
 
-        $this->rc->output->add_label('save','cancel','delete');
+        $this->rc->output->add_label('save','cancel','delete','close');
     }
 
     public function folders($attrib)
     {
         $attrib += array('id' => 'rcmkolabnotebooks');
 
         if ($attrib['type'] == 'select') {
             $attrib['is_escaped'] = true;
             $select = new html_select($attrib);
         }
 
         $tree = $attrib['type'] != 'select' ? true : null;
         $lists = $this->plugin->get_lists($tree);
         $jsenv = array();
 
         if (is_object($tree)) {
             $html = $this->folder_tree_html($tree, $lists, $jsenv, $attrib);
         }
         else {
             $html = '';
             foreach ($lists as $prop) {
                 $id = $prop['id'];
 
                 if (!$prop['virtual']) {
                     unset($prop['user_id']);
                     $jsenv[$id] = $prop;
                 }
 
                 if ($attrib['type'] == 'select') {
                     if ($prop['editable'] || strpos($prop['rights'], 'i') !== false) {
                         $select->add($prop['name'], $prop['id']);
                     }
                 }
                 else {
                     $html .= html::tag('li', array('id' => 'rcmliknb' . rcube_utils::html_identifier($id), 'class' => $prop['group']),
                         $this->folder_list_item($id, $prop, $jsenv)
                     );
                 }
             }
         }
 
         $this->rc->output->set_env('kolab_notebooks', $jsenv);
         $this->rc->output->add_gui_object('notebooks', $attrib['id']);
 
         return $attrib['type'] == 'select' ? $select->show() : html::tag('ul', $attrib, $html, html::$common_attrib);
     }
 
     /**
      * Return html for a structured list <ul> for the folder tree
      */
     public function folder_tree_html($node, $data, &$jsenv, $attrib)
     {
         $out = '';
         foreach ($node->children as $folder) {
             $id = $folder->id;
             $prop = $data[$id];
             $is_collapsed = false; // TODO: determine this somehow?
 
             $content = $this->folder_list_item($id, $prop, $jsenv);
 
             if (!empty($folder->children)) {
                 $content .= html::tag('ul', array('style' => ($is_collapsed ? "display:none;" : null)),
                     $this->folder_tree_html($folder, $data, $jsenv, $attrib));
             }
 
             if (strlen($content)) {
                 $out .= html::tag('li', array(
                       'id' => 'rcmliknb' . rcube_utils::html_identifier($id),
                       'class' => $prop['group'] . ($prop['virtual'] ? ' virtual' : ''),
                     ),
                     $content);
             }
         }
 
         return $out;
     }
 
     /**
      * Helper method to build a tasklist item (HTML content and js data)
      */
     public function folder_list_item($id, $prop, &$jsenv, $checkbox = false)
     {
         if (!$prop['virtual']) {
             unset($prop['user_id']);
             $jsenv[$id] = $prop;
         }
 
         $classes = array('folder');
         if ($prop['virtual']) {
             $classes[] = 'virtual';
         }
         else if (!$prop['editable']) {
             $classes[] = 'readonly';
         }
         if ($prop['subscribed']) {
             $classes[] = 'subscribed';
         }
         if ($prop['class']) {
             $classes[] = $prop['class'];
         }
 
         $title = $prop['title'] ?: ($prop['name'] != $prop['listname'] || strlen($prop['name']) > 25 ?
           html_entity_decode($prop['name'], ENT_COMPAT, RCMAIL_CHARSET) : '');
 
         $label_id = 'nl:' . $id;
         $attr = $prop['virtual'] ? array('tabindex' => '0') : array('href' => $this->rc->url(array('_list' => $id)));
         return html::div(join(' ', $classes),
             html::a($attr + array('class' => 'listname', 'title' => $title, 'id' => $label_id), $prop['listname'] ?: $prop['name']) .
             ($prop['virtual'] ? '' :
                 ($checkbox ?
                     html::tag('input', array('type' => 'checkbox', 'name' => '_list[]', 'value' => $id, 'checked' => $prop['active'], 'aria-labelledby' => $label_id)) :
                     ''
                 ) .
                 html::span('handle', '') .
                 html::span('actions',
                     (!$prop['default'] ?
                         html::a(array('href' => '#', 'class' => 'remove', 'title' => $this->plugin->gettext('removelist')), ' ') :
                         ''
                     ) .
                     (isset($prop['subscribed']) ?
                         html::a(array('href' => '#', 'class' => 'subscribed', 'title' => $this->plugin->gettext('foldersubscribe'), 'role' => 'checkbox', 'aria-checked' => $prop['subscribed'] ? 'true' : 'false'), ' ') :
                         ''
                     )
                 )
             )
         );
 
         return '';
     }
 
     public function listing($attrib)
     {
         $attrib += array('id' => 'rcmkolabnoteslist');
         $this->rc->output->add_gui_object('noteslist', $attrib['id']);
         return html::tag('ul', $attrib, '', html::$common_attrib);
     }
 
     public function tagslist($attrib)
     {
         $attrib += array('id' => 'rcmkolabnotestagslist');
         $this->rc->output->add_gui_object('notestagslist', $attrib['id']);
         return html::tag('ul', $attrib, '', html::$common_attrib);
     }
 
     public function editform($attrib)
     {
         $attrib += array('action' => '#', 'id' => 'rcmkolabnoteseditform');
 
         $this->rc->output->add_gui_object('noteseditform', $attrib['id']);
         $this->rc->output->include_script('tinymce/tinymce.min.js');
 
         $textarea = new html_textarea(array('name' => 'content', 'id' => 'notecontent', 'cols' => 60, 'rows' => 20, 'tabindex' => 0));
         return html::tag('form', $attrib, $textarea->show(), array_merge(html::$common_attrib, array('action')));
     }
 
     public function detailview($attrib)
     {
         $attrib += array('id' => 'rcmkolabnotesdetailview');
         $this->rc->output->add_gui_object('notesdetailview', $attrib['id']);
         return html::div($attrib, '');
     }
 
     public function notetitle($attrib)
     {
         $attrib += array('id' => 'rcmkolabnotestitle');
         $this->rc->output->add_gui_object('noteviewtitle', $attrib['id']);
 
         $summary = new html_inputfield(array('name' => 'summary', 'class' => 'notetitle inline-edit', 'size' => 60, 'tabindex' => 0));
 
         $html = $summary->show();
         $html .= html::div(array('class' => 'tagline tagedit', 'style' => 'display:none'), '&nbsp;');
         $html .= html::div(array('class' => 'dates', 'style' => 'display:none'),
             html::label(array(), $this->plugin->gettext('created')) .
             html::span('notecreated', '') .
             html::label(array(), $this->plugin->gettext('changed')) .
             html::span('notechanged', '')
         );
 
         return html::div($attrib, $html);
     }
 
     public function attachments_list($attrib)
     {
         $attrib += array('id' => 'rcmkolabnotesattachmentslist');
         $this->rc->output->add_gui_object('notesattachmentslist', $attrib['id']);
         return html::tag('ul', $attrib, '', html::$common_attrib);
     }
 
     /**
      * Render edit for notes lists (folders)
      */
     public function list_editform($action, $list, $folder)
     {
         if (is_object($folder)) {
             $folder_name = $folder->name; // UTF7
         }
         else {
             $folder_name = '';
         }
 
         $hidden_fields[] = array('name' => 'oldname', 'value' => $folder_name);
 
         $storage = $this->rc->get_storage();
         $delim   = $storage->get_hierarchy_delimiter();
         $form   = array();
 
         if (strlen($folder_name)) {
             $options = $storage->folder_info($folder_name);
 
             $path_imap = explode($delim, $folder_name);
             array_pop($path_imap);  // pop off name part
             $path_imap = implode($path_imap, $delim);
         }
         else {
             $path_imap = '';
             $options = array();
         }
 
         // General tab
         $form['properties'] = array(
             'name' => $this->rc->gettext('properties'),
             'fields' => array(),
         );
 
         // folder name (default field)
         $input_name = new html_inputfield(array('name' => 'name', 'id' => 'noteslist-name', 'size' => 20));
         $form['properties']['fields']['name'] = array(
             'label' => $this->plugin->gettext('listname'),
             'value' => $input_name->show($list['editname'], array('disabled' => ($options['norename'] || $options['protected']))),
             'id' => 'noteslist-name',
         );
 
         // prevent user from moving folder
         if (!empty($options) && ($options['norename'] || $options['protected'])) {
             $hidden_fields[] = array('name' => 'parent', 'value' => $path_imap);
         }
         else {
             $select = kolab_storage::folder_selector('note', array('name' => 'parent', 'id' => 'parent-folder'), $folder_name);
             $form['properties']['fields']['path'] = array(
                 'label' => $this->plugin->gettext('parentfolder'),
                 'value' => $select->show(strlen($folder_name) ? $path_imap : ''),
                 'id' => 'parent-folder',
             );
         }
 
         // add folder ACL tab
         if ($action != 'form-new') {
             $form['sharing'] = array(
                 'name'    => Q($this->plugin->gettext('tabsharing')),
                 'content' => html::tag('iframe', array(
                     'src' => $this->rc->url(array('_action' => 'folder-acl', '_folder' => $folder_name, 'framed' => 1)),
                     'width' => '100%',
                     'height' => 280,
                     'border' => 0,
                     'style' => 'border:0'),
                 '')
             );
         }
 
         $form_html = '';
         if (is_array($hidden_fields)) {
             foreach ($hidden_fields as $field) {
                 $hiddenfield = new html_hiddenfield($field);
                 $form_html .= $hiddenfield->show() . "\n";
             }
         }
 
         // create form output
         foreach ($form as $tab) {
             if (is_array($tab['fields']) && empty($tab['content'])) {
                 $table = new html_table(array('cols' => 2));
                 foreach ($tab['fields'] as $col => $colprop) {
                     $label = !empty($colprop['label']) ? $colprop['label'] : $this->plugin->gettext($col);
 
                     $table->add('title', html::label($colprop['id'], Q($label)));
                     $table->add(null, $colprop['value']);
                 }
                 $content = $table->show();
             }
             else {
                 $content = $tab['content'];
             }
 
             if (!empty($content)) {
                 $form_html .= html::tag('fieldset', null, html::tag('legend', null, Q($tab['name'])) . $content) . "\n";
             }
         }
 
         return html::tag('form', array('action' => "#", 'method' => "post", 'id' => "noteslistpropform"), $form_html);
     }
 
     /**
      * Handler to render ACL form for a notes folder
      */
     public function folder_acl()
     {
         $this->plugin->require_plugin('acl');
         $this->rc->output->add_handler('folderacl', array($this, 'folder_acl_form'));
         $this->rc->output->send('kolab_notes.kolabacl');
     }
 
     /**
      * Handler for ACL form template object
      */
     public function folder_acl_form()
     {
         $folder = rcube_utils::get_input_value('_folder', rcube_utils::INPUT_GPC);
 
         if (strlen($folder)) {
             $storage = $this->rc->get_storage();
             $options = $storage->folder_info($folder);
 
             // get sharing UI from acl plugin
             $acl = $this->rc->plugins->exec_hook('folder_form',
                 array('form' => array(), 'options' => $options, 'name' => $folder));
         }
 
         return $acl['form']['sharing']['content'] ?: html::div('hint', $this->plugin->gettext('aclnorights'));
     }
 
     /**
      * Render the template for printing with placeholders
      */
     public function print_template()
     {
         header('Content-Type: text/html; charset=' . RCUBE_CHARSET);
         $this->rc->output->reset(true);
         echo $this->rc->output->parse('kolab_notes.print', false, false);
         exit;
     }
 
 }
 
diff --git a/plugins/kolab_notes/localization/en_US.inc b/plugins/kolab_notes/localization/en_US.inc
index e0ede7a9..1c1eed07 100644
--- a/plugins/kolab_notes/localization/en_US.inc
+++ b/plugins/kolab_notes/localization/en_US.inc
@@ -1,67 +1,85 @@
 <?php
 
 /**
  * Localizations for the Kolab Folders plugin
  *
  * Copyright (C) 2015, Kolab Systems AG
  *
  * For translation see https://www.transifex.com/projects/p/kolab/resource/kolab_notes/
  */
 
 $labels = array();
 $labels['navtitle'] = 'Notes';
 $labels['tags'] = 'Tags';
 $labels['lists'] = 'Notebooks';
 $labels['notes'] = 'Notes';
 $labels['create'] = 'New Note';
 $labels['createnote'] = 'Create a new note';
 $labels['send'] = 'Send';
 $labels['sendnote'] = 'Send note by email';
 $labels['newnote'] = 'New Note';
 $labels['notags'] = 'No tags';
 $labels['removetag'] = 'Remove tag';
 $labels['created'] = 'Created';
 $labels['changed'] = 'Last Modified';
 $labels['title'] = 'Title';
 $labels['now'] = 'Now';
 $labels['sortby'] = 'Sort by';
 $labels['newnotebook'] = 'Create a new notebook';
 $labels['addnotebook'] = 'Add notebook';
 $labels['editlist'] = 'Edit Notebook';
 $labels['listname'] = 'Name';
 $labels['tabsharing'] = 'Sharing';
 $labels['discard'] = 'Discard';
 $labels['abort'] = 'Abort';
 $labels['unsavedchanges'] = 'Unsaved Changes!';
 $labels['appendnote'] = 'Add a Note';
 $labels['editnote'] = 'Edit Note';
 $labels['savein'] = 'Save in';
 $labels['foldersubscribe'] = 'List permanently';
 $labels['findnotebooks'] = 'Find notebooks...';
 $labels['listsearchresults'] = 'Additional notebooks';
 $labels['nrnotebooksfound'] = '$nr notebooks found';
 $labels['nonotebooksfound'] = 'No notebooks found';
 $labels['removelist'] = 'Remove from list';
 $labels['removelink'] = 'Remove email reference';
 
 $labels['savingdata'] = 'Saving data...';
 $labels['recordnotfound'] = 'Record not found';
 $labels['norecordsfound'] = 'No notes found';
 $labels['nochanges'] = 'No changes to be saved';
 $labels['entertitle'] = 'Please enter a title for this note!';
 $labels['deletenotesconfirm'] = 'Do you really want to delete the selected notes?';
 $labels['deletenotebookconfirm'] = 'Do you really want to delete this notebook with all its notes? This action cannot be undone.';
 $labels['discardunsavedchanges'] = 'The current note has not yet been saved. Discard the changes?';
 $labels['invalidlistproperties'] = 'Invalid notebook properties! Please set a valid name.';
 $labels['entertitle'] = 'Please enter a title for this note!';
 $labels['aclnorights'] = 'You do not have administrator rights for this notebook.';
 
+// history dialog
+$labels['showhistory'] = 'Show History';
+$labels['compare'] = 'Compare';
+$labels['objectchangelog'] = 'Change History';
+$labels['objectdiff'] = 'Changes from $rev1 to $rev2';
+$labels['actionappend'] = 'Saved';
+$labels['actionmove'] = 'Moved';
+$labels['actiondelete'] = 'Deleted';
+$labels['showrevision'] = 'Show this version';
+$labels['restore'] = 'Restore this version';
+$labels['objectnotfound'] = 'Failed to load note data';
+$labels['objectchangelognotavailable'] = 'Change history is not available for this note';
+$labels['objectdiffnotavailable'] = 'No comparison possible for the selected revisions';
+$labels['revisionrestoreconfirm'] = 'Do you really want to restore revision $rev of this note? This will replace the current note with the old version.';
+$labels['objectrestoresuccess'] = 'Revision $rev successfully restored';
+$labels['objectrestoreerror'] = 'Failed to restore the old revision';
+
+// (hidden) titles and labels for accessibility annotations
 $labels['arialabelnoteslist'] = 'List of notes';
 $labels['arialabelnotesearchform'] = 'Notes search form';
 $labels['arialabelnotesquicksearchbox'] = 'Notes search input';
 $labels['arialabelnotessortmenu'] = 'Notes list sorting options';
 $labels['arialabelnotesoptionsmenu'] = 'Notebook actions menu';
 $labels['arialabelnotebookform'] = 'Notebook properties';
 $labels['arialabelmessagereferences'] = 'Linked email messages';
 $labels['arialabelfolderearchform'] = 'Notebooks search form';
 $labels['arialabelnoteform'] = 'Note edit form';
diff --git a/plugins/kolab_notes/notes.js b/plugins/kolab_notes/notes.js
index 5c8a02f4..eedd6c47 100644
--- a/plugins/kolab_notes/notes.js
+++ b/plugins/kolab_notes/notes.js
@@ -1,1527 +1,1754 @@
 /**
  * Client scripts for the Kolab Notes plugin
  *
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * @licstart  The following is the entire license notice for the
  * JavaScript code in this file.
  *
- * Copyright (C) 2014, Kolab Systems AG <contact@kolabsys.com>
+ * Copyright (C) 2014-2015, Kolab Systems AG <contact@kolabsys.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation, either version 3 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  *
  * @licend  The above is the entire license notice
  * for the JavaScript code in this file.
  */
 
 function rcube_kolab_notes_ui(settings)
 {
     /*  private vars  */
     var ui_loading = false;
     var saving_lock;
     var search_query;
     var folder_drop_target;
     var notebookslist;
     var noteslist;
     var notesdata = {};
     var tagsfilter = [];
     var tags = [];
     var search_request;
     var search_query;
     var tag_draghelper;
     var render_no_focus;
     var me = this;
 
     /*  public members  */
     this.selected_list;
     this.selected_note;
     this.notebooks = rcmail.env.kolab_notebooks || {};
 
     /**
      * initialize the notes UI
      */
     function init()
     {
         // register button commands
         rcmail.register_command('createnote', function(){
             warn_unsaved_changes(function(){ edit_note(null, 'new'); })
         }, false);
         rcmail.register_command('list-create', function(){ list_edit_dialog(null); }, true);
         rcmail.register_command('list-edit', function(){ list_edit_dialog(me.selected_list); }, false);
         rcmail.register_command('list-delete', function(){ list_delete(me.selected_list); }, false);
         rcmail.register_command('list-remove', function(){ list_remove(me.selected_list); }, false);
         rcmail.register_command('list-sort', list_set_sort, true);
         rcmail.register_command('save', save_note, true);
         rcmail.register_command('delete', delete_notes, false);
         rcmail.register_command('search', quicksearch, true);
         rcmail.register_command('reset-search', reset_search, true);
         rcmail.register_command('sendnote', send_note, false);
         rcmail.register_command('print', print_note, false);
+        rcmail.register_command('history', show_history_dialog, false);
 
         // register server callbacks
         rcmail.addEventListener('plugin.data_ready', data_ready);
         rcmail.addEventListener('plugin.render_note', render_note);
         rcmail.addEventListener('plugin.update_note', update_note);
         rcmail.addEventListener('plugin.update_list', list_update);
         rcmail.addEventListener('plugin.destroy_list', list_destroy);
         rcmail.addEventListener('plugin.unlock_saving', function(){
             if (saving_lock) {
                 rcmail.set_busy(false, null, saving_lock);
             }
             if (rcmail.gui_objects.noteseditform) {
                 rcmail.lock_form(rcmail.gui_objects.noteseditform, false);
             }
         });
 
+        rcmail.addEventListener('plugin.close_history_dialog', close_history_dialog);
+        rcmail.addEventListener('plugin.note_render_changelog', render_changelog);
+        rcmail.addEventListener('plugin.note_show_revision', render_revision);
+        rcmail.addEventListener('plugin.note_show_diff', show_diff);
+
         // initialize folder selectors
         if (settings.selected_list && !me.notebooks[settings.selected_list]) {
             settings.selected_list = null;
         }
         for (var id in me.notebooks) {
             if (me.notebooks[id].editable && !settings.selected_list) {
                 settings.selected_list = id;
             }
         }
 
         var widget_class = window.kolab_folderlist || rcube_treelist_widget;
         notebookslist = new widget_class(rcmail.gui_objects.notebooks, {
           id_prefix: 'rcmliknb',
           save_state: true,
           selectable: true,
           keyboard: false,
           searchbox: '#notebooksearch',
           search_action: 'notes/list',
           search_sources: [ 'folders', 'users' ],
           search_title: rcmail.gettext('listsearchresults','kolab_notes'),
           check_droptarget: function(node) {
               var list = me.notebooks[node.id];
               return !node.virtual && list.editable && node.id != me.selected_list;
           }
         });
         notebookslist.addEventListener('select', function(node) {
             var id = node.id;
             if (me.notebooks[id] && id != me.selected_list) {
                 warn_unsaved_changes(function(){
                     rcmail.enable_command('createnote', has_permission(me.notebooks[id], 'i'));
                     rcmail.enable_command('list-edit', has_permission(me.notebooks[id], 'a'));
                     rcmail.enable_command('list-delete', has_permission(me.notebooks[id], 'xa'));
                     rcmail.enable_command('list-remove', !me.notebooks[id].default);
                     fetch_notes(id);  // sets me.selected_list
                 },
                 function(){
                     // restore previous selection
                     notebookslist.select(me.selected_list);
                 });
             }
 
             // unfocus clicked list item
             $(notebookslist.get_item(id)).find('a.listname').first().blur();
         });
         notebookslist.addEventListener('subscribe', function(p) {
             var list;
             if ((list = me.notebooks[p.id])) {
                 list.subscribed = p.subscribed || false;
                 rcmail.http_post('list', { _do:'subscribe', _list:{ id:p.id, permanent:list.subscribed?1:0 } });
             }
         });
         notebookslist.addEventListener('remove', function(p) {
             if (me.notebooks[p.id] && !me.notebooks[p.id].default) {
                 list_remove(p.id);
             }
         });
         notebookslist.addEventListener('insert-item', function(p) {
             var list = p.data;
             if (list && list.id && !list.virtual) {
                 me.notebooks[list.id] = list;
                 if (list.subscribed)
                     rcmail.http_post('list', { _do:'subscribe', _list:{ id:p.id, permanent:1 } });
             }
         });
         notebookslist.addEventListener('click-item', function(p) {
             // avoid link execution
             return false;
         });
         notebookslist.addEventListener('search-complete', function(data) {
             if (data.length)
                 rcmail.display_message(rcmail.gettext('nrnotebooksfound','kolab_notes').replace('$nr', data.length), 'voice');
             else
                 rcmail.display_message(rcmail.gettext('nonotebooksfound','kolab_notes'), 'info');
         });
 
         $(rcmail.gui_objects.notebooks).on('click', 'div.folder > a.listname', function(e) {
             var id = String($(this).closest('li').attr('id')).replace(/^rcmliknb/, '');
             notebookslist.select(id);
             e.preventDefault();
             return false;
         });
 
         // register dbl-click handler to open list edit dialog
         $(rcmail.gui_objects.notebooks).on('dblclick', 'li:not(.virtual) a', function(e) {
             var id = String($(this).closest('li').attr('id')).replace(/^rcmliknb/, '');
             if (me.notebooks[id] && has_permission(me.notebooks[id], 'a')) {
                 list_edit_dialog(id);
             }
 
             // clear text selection (from dbl-clicking)
             var sel = window.getSelection ? window.getSelection() : document.selection;
             if (sel && sel.removeAllRanges) {
                 sel.removeAllRanges();
             }
             else if (sel && sel.empty) {
                 sel.empty();
             }
 
             e.preventDefault();
             return false;
         });
 
         // initialize notes list widget
         if (rcmail.gui_objects.noteslist) {
             noteslist = new rcube_list_widget(rcmail.gui_objects.noteslist,
                 { multiselect:true, draggable:true, keyboard:true });
             noteslist.addEventListener('select', function(list) {
                 render_no_focus = rcube_event._last_keyboard_event && $(list.list).has(rcube_event._last_keyboard_event.target);
                 var selection_changed = list.selection.length != 1 || !me.selected_note || list.selection[0] != me.selected_note.id;
                 selection_changed && warn_unsaved_changes(function(){
                     var note;
                     if (noteslist.selection.length == 1 && (note = notesdata[noteslist.selection[0]])) {
                         edit_note(note.uid, 'edit');
                     }
                     else {
                         reset_view();
                     }
                 },
                 function(){
                     // TODO: previous restore selection
                     list.select(me.selected_note.id);
                 });
 
                 rcmail.enable_command('delete', me.notebooks[me.selected_list] && has_permission(me.notebooks[me.selected_list], 'td') && list.selection.length > 0);
                 rcmail.enable_command('sendnote', list.selection.length > 0);
-                rcmail.enable_command('print', list.selection.length == 1);
+                rcmail.enable_command('print', 'history', list.selection.length == 1);
             })
             .addEventListener('dragstart', function(e) {
                 folder_drop_target = null;
                 notebookslist.drag_start();
             })
             .addEventListener('dragmove', function(e) {
                 folder_drop_target = notebookslist.intersects(rcube_event.get_mouse_pos(e), true);
             })
             .addEventListener('dragend', function(e) {
                 notebookslist.drag_end();
 
                 // move dragged notes to this folder
                 if (folder_drop_target) {
                     noteslist.draglayer.hide();
 
                     // check unsaved changes first
                     var new_folder_id = folder_drop_target;
                     warn_unsaved_changes(
                         // ok
                         function() {
                             move_notes(new_folder_id);
                             reset_view();
                             noteslist.clear_selection();
                         },
                         // nok
                         undefined,
                         // beforesave
                         function(savedata) {
                             savedata.list = new_folder_id;
 
                             // remove from list and thus avoid being moved (again)
                             var id = me.selected_note.id;
                             noteslist.remove_row(id);
                             delete notesdata[id];
                         }
                     );
                 }
                 folder_drop_target = null;
             })
             .init().focus();
         }
 
         if (settings.sort_col) {
             $('#notessortmenu a.by-' + settings.sort_col).addClass('selected');
         }
 
         // click-handler on tags list
         $(rcmail.gui_objects.notestagslist).on('click', 'li', function(e){
             var item = e.target.nodeName == 'LI' ? $(e.target) : $(e.target).closest('li'),
                 tag = item.data('value');
 
             if (!tag)
                 return false;
 
             // reset selection on regular clicks
             var index = $.inArray(tag, tagsfilter);
             var shift = e.shiftKey || e.ctrlKey || e.metaKey;
 
             if (!shift) {
                 if (tagsfilter.length > 1)
                     index = -1;
 
                 $('li', rcmail.gui_objects.notestagslist).removeClass('selected').attr('aria-checked', 'false');
                 tagsfilter = [];
             }
 
             // add tag to filter
             if (index < 0) {
                 item.addClass('selected').attr('aria-checked', 'true');
                 tagsfilter.push(tag);
             }
             else if (shift) {
                 item.removeClass('selected').attr('aria-checked', 'false');
                 var a = tagsfilter.slice(0,index);
                 tagsfilter = a.concat(tagsfilter.slice(index+1));
             }
 
             filter_notes();
 
             // clear text selection in IE after shift+click
             if (shift && document.selection)
               document.selection.empty();
 
             e.preventDefault();
             return false;
         })
         .on('keypress', 'li', function(e) {
             if (e.keyCode == 13) {
                 $(this).trigger('click', { pointerType:'keyboard' });
             }
         })
         .mousedown(function(e){
             // disable content selection with the mouse
             e.preventDefault();
             return false;
         });
 
         init_editor();
 
         if (settings.selected_list) {
             notebookslist.select(settings.selected_list)
         }
     }
     this.init = init;
 
     /**
      *
      */
     function init_dialog()
     {
         rcmail.register_command('save', save_note, true);
         rcmail.addEventListener('plugin.render_note', render_note);
         rcmail.addEventListener('plugin.update_note', function(data){
             data.id = rcmail.html_identifier_encode(data.uid);
             notesdata[data.id] = data;
             render_note(data);
         });
         rcmail.addEventListener('plugin.unlock_saving', function(){
             if (saving_lock) {
                 rcmail.set_busy(false, null, saving_lock);
             }
             if (rcmail.gui_objects.noteseditform) {
                 rcmail.lock_form(rcmail.gui_objects.noteseditform, false);
             }
         });
 
         var id;
         for (id in me.notebooks) {
             if (me.notebooks[id].editable) {
                 me.selected_list = id;
                 break;
             }
         }
 
         init_editor();
         if (settings.selected_uid) {
             me.selected_list = settings.selected_list;
             edit_note(settings.selected_uid);
         }
         else {
             setTimeout(function(){
                 me.selected_note = $.extend({
                     list: me.selected_list,
                     uid: null,
                     title: rcmail.gettext('newnote','kolab_notes'),
                     description: '',
                     tags: [],
                     created: rcmail.gettext('now', 'kolab_notes'),
                     changed: rcmail.gettext('now', 'kolab_notes')
                 }, rcmail.env.kolab_notes_template || {});
                 render_note(me.selected_note);
             }, 100);
         }
     }
     this.init_dialog = init_dialog;
 
     /**
      * initialize tinyMCE editor
      */
     function init_editor()
     {
         var editor_conf = {
             selector: '#notecontent',
             theme: 'modern',
             language: settings.editor.lang,
             content_css: rcmail.assets_path('program/js/tinymce/roundcube/content.css?v2'),
             plugins: 'autolink charmap code link paste tabfocus searchreplace table textcolor',
             toolbar: 'bold italic underline | alignleft aligncenter alignright alignjustify '
                 + '| bullist numlist outdent indent blockquote | forecolor backcolor fontselect fontsizeselect '
                 + '| link unlink table charmap | code searchreplace undo redo',
             menubar: false,
             statusbar: false,
             toolbar_items_size: 'small',
             extended_valid_elements: 'font[face|size|color|style],span[id|class|align|style]',
             relative_urls: false,
             remove_script_host: false,
             convert_urls: false,
             image_description: false,
             paste_webkit_style: "color font-size font-family",
             paste_data_images: true,
             //spellchecker_rpc_url: '../../../../../?_task=utils&_action=spell_html&_remote=1',
             //spellchecker_language: rcmail.env.spell_lang,
             accessibility_focus: false,
             tabfocus_elements: [':prev','btn-save-note'],
             setup: function(ed) {
                 // make links open on shift-click
                 ed.on('click', function(e) {
                     var link = $(e.target).closest('a');
                     if (link.length && e.shiftKey) {
                         if (!bw.mz) window.open(link.get(0).href, '_blank');
                         return false;
                     }
                 });
             }
         };
 
         // support external configuration settings e.g. from skin
         if (window.rcmail_editor_settings)
             $.extend(editor_conf, window.rcmail_editor_settings);
 
         tinyMCE.init(editor_conf);
 
         // register click handler for message links
         $(rcmail.gui_objects.notesattachmentslist).on('click', 'li a.messagelink', function(){
             rcmail.open_window(this.href);
             return false;
         });
     }
 
     /**
      * Quote HTML entities
      */
     function Q(str)
     {
         return String(str).replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
     }
 
     /**
      * Trim whitespace off the given string
      */
     function trim(str)
     {
         return String(str).replace(/\s+$/, '').replace(/^\s+/, '');
     }
 
     /**
      * Check permissions on the given list object
      */
     function has_permission(list, perm)
     {
         // multiple chars means "either of"
         if (String(perm).length > 1) {
             for (var i=0; i < perm.length; i++) {
                 if (has_permission(list, perm[i])) {
                     return true;
                 }
             }
         }
 
         if (list.rights && String(list.rights).indexOf(perm) >= 0) {
             return true;
         }
 
         return (perm == 'i' && list.editable);
     }
 
     /**
      * 
      */
     function edit_note(uid, action)
     {
         if (!uid) {
             me.selected_note = null;
             if (noteslist)
                 noteslist.clear_selection();
 
             me.selected_note = {
                 list: me.selected_list,
                 uid: null,
                 title: rcmail.gettext('newnote','kolab_notes'),
                 description: '',
                 tags: [],
                 created: rcmail.gettext('now', 'kolab_notes'),
                 changed: rcmail.gettext('now', 'kolab_notes')
             }
             render_note(me.selected_note);
             rcmail.enable_command('print', true);
         }
         else {
             ui_loading = rcmail.set_busy(true, 'loading');
             rcmail.http_request('get', { _list:me.selected_list, _id:uid }, true);
         }
     }
 
     /**
      * 
      */
     function list_edit_dialog(id)
     {
         if (!rcmail.gui_containers.notebookeditform) {
             return false;
         }
 
         // close show dialog first
         var $dialog = rcmail.gui_containers.notebookeditform;
         if ($dialog.is(':ui-dialog')) {
             $dialog.dialog('close');
         }
 
         var list = me.notebooks[id] || { name:'', editable:true };
         var form, name;
 
         $dialog.html(rcmail.get_label('loading'));
         $.ajax({
             type: 'GET',
             dataType: 'html',
             url: rcmail.url('list'),
             data: { _do: (list.id ? 'form-edit' : 'form-new'), _list: { id: list.id } },
             success: function(data) {
                 $dialog.html(data);
                 rcmail.triggerEvent('kolab_notes_editform_load', list);
 
                 // resize and reposition dialog window
                 form = $('#noteslistpropform');
                 var win = $(window), w = win.width(), h = win.height();
                 $dialog.dialog('option', { height: Math.min(h-20, form.height()+130), width: Math.min(w-20, form.width()+50) })
                     .dialog('option', 'position', ['center', 'center']);  // only works in a separate call (!?)
 
                 name = $('#noteslist-name').prop('disabled', !has_permission(list, 'a')).val(list.editname || list.name);
                 name.select();
             }
         });
 
         // dialog buttons
         var buttons = {};
         buttons[rcmail.gettext('save')] = function() {
             // form is not loaded
             if (!form || !form.length)
               return;
 
             // do some input validation
             if (!name.val() || name.val().length < 2) {
               alert(rcmail.gettext('invalidlistproperties', 'kolab_notes'));
               name.select();
               return;
             }
 
             // post data to server
             var data = form.serializeJSON();
             if (list.id)
               data.id = list.id;
 
             saving_lock = rcmail.set_busy(true, 'kolab_notes.savingdata');
             rcmail.http_post('list', { _do: (list.id ? 'edit' : 'new'), _list: data });
             $dialog.dialog('close');
         };
 
         buttons[rcmail.gettext('cancel')] = function() {
             $dialog.dialog('close');
         };
 
         // open jquery UI dialog
         $dialog.dialog({
             modal: true,
             resizable: true,
             closeOnEscape: false,
             title: rcmail.gettext((list.id ? 'editlist' : 'newnotebook'), 'kolab_notes'),
             open: function() {
                 $dialog.parent().find('.ui-dialog-buttonset .ui-button').first().addClass('mainaction');
             },
             close: function() {
                 $dialog.html('').dialog('destroy').hide();
             },
             buttons: buttons,
             minWidth: 480,
             width: 640,
         }).show();
 
     }
 
     /**
      * Callback from server after changing list properties
      */
     function list_update(prop)
     {
         if (prop._reload) {
             rcmail.redirect(rcmail.url('', { _list: (prop.newid || prop.id) }));
         }
         else if (prop.newid && prop.newid != prop.id) {
             var book = $.extend({}, me.notebooks[prop.id]);
             book.id = prop.newid;
             book.name = prop.name;
             book.listname = prop.listname;
             book.editname = prop.editname || prop.name;
 
             me.notebooks[prop.newid] = book;
             delete me.notebooks[prop.id];
 
             // update treelist item
             var li = $(notebookslist.get_item(prop.id));
             $('.listname', li).html(prop.listname);
             notebookslist.update(prop.id, { id:book.id, html:li.html() });
 
             // link all loaded note records to the new list id
             if (me.selected_list == prop.id) {
                 me.selected_list = prop.newid;
                 for (var k in notesdata) {
                     if (notesdata[k].list == prop.id) {
                         notesdata[k].list = book.id;
                     }
                 }
                 notebookslist.select(prop.newid);
             }
         }
     }
 
     /**
      * 
      */
     function list_delete(id)
     {
         var list = me.notebooks[id];
         if (list && confirm(rcmail.gettext('deletenotebookconfirm', 'kolab_notes'))) {
             saving_lock = rcmail.set_busy(true, 'kolab_notes.savingdata');
             rcmail.http_post('list', { _do: 'delete', _list: { id: list.id } });
         }
     }
 
     /**
      * 
      */
     function list_remove(id)
     {
         if (me.notebooks[id]) {
             list_destroy(me.notebooks[id]);
             rcmail.http_post('list', { _do:'subscribe', _list:{ id:id, permanent:0, recursive:1 } });
         }
     }
 
     /**
      * Callback from server on list delete command
      */
     function list_destroy(prop)
     {
         if (!me.notebooks[prop.id]) {
             return;
         }
 
         notebookslist.remove(prop.id);
         delete me.notebooks[prop.id];
 
         if (me.selected_list == prop.id) {
             for (id in me.notebooks) {
                 if (me.notebooks[id]) {
                     notebookslist.select(id);
                     break;
                 }
             }
         }
     }
 
     /**
      * Change notes list sort order
      */
     function list_set_sort(col)
     {
         if (settings.sort_col != col) {
             settings.sort_col = col;
             $('#notessortmenu a').removeClass('selected').filter('.by-' + col).addClass('selected');
             rcmail.save_pref({ name: 'kolab_notes_sort_col', value: col });
 
             // re-sort table in DOM
             $(noteslist.tbody).children().sortElements(function(la, lb){
                 var a_id = String(la.id).replace(/^rcmrow/, ''),
                     b_id = String(lb.id).replace(/^rcmrow/, ''),
                     a = notesdata[a_id],
                     b = notesdata[b_id];
 
                 if (!a || !b) {
                     return 0;
                 }
                 else if (settings.sort_col == 'title') {
                     return String(a.title).toLowerCase() > String(b.title).toLowerCase() ? 1 : -1;
                 }
                 else {
                     return b.changed_ - a.changed_;
                 }
             });
         }
     }
 
     /**
      * Execute search
      */
     function quicksearch()
     {
         var q;
         if (rcmail.gui_objects.qsearchbox && (q = rcmail.gui_objects.qsearchbox.value)) {
             var id = 'search-'+q;
 
             // ignore if query didn't change
             if (search_request == id)
                 return;
 
             warn_unsaved_changes(function(){
                 search_request = id;
                 search_query = q;
 
                 fetch_notes();
             },
             function(){
                 reset_search();
             });
         }
         else {  // empty search input equals reset
             reset_search();
         }
     }
 
     /**
      * Reset search and get back to normal listing
      */
     function reset_search()
     {
         $(rcmail.gui_objects.qsearchbox).val('');
 
         if (search_request) {
             search_request = search_query = null;
             fetch_notes();
         }
     }
 
     /**
      * 
      */
     function fetch_notes(id)
     {
         if (rcmail.busy)
             return;
 
         if (id && id != me.selected_list) {
             me.selected_list = id;
         }
 
         ui_loading = rcmail.set_busy(true, 'loading');
         rcmail.http_request('fetch', { _list:me.selected_list, _q:search_query }, true);
 
         reset_view();
         noteslist.clear(true);
         notesdata = {};
         tagsfilter = [];
         update_state();
     }
 
     function filter_notes()
     {
         // tagsfilter
         var note, tr, match;
         for (var id in noteslist.rows) {
             tr = noteslist.rows[id].obj;
             note = notesdata[id];
             match = note.tags && note.tags.length;
             for (var i=0; match && note && i < tagsfilter.length; i++) {
                 if ($.inArray(tagsfilter[i], note.tags) < 0)
                     match = false;
             }
 
             if (match || !tagsfilter.length) {
                 $(tr).show();
             }
             else {
                 $(tr).hide();
             }
 
             if (me.selected_note && me.selected_note.uid == note.uid && !match) {
                 warn_unsaved_changes(function(){
                     me.selected_note = null;
                     noteslist.clear_selection();
                 }, function(){
                     tagsfilter = [];
                     filter_notes();
                     update_tagcloud();
                 });
             }
         }
     }
 
     /**
      * 
      */
     function data_ready(data)
     {
         data.data.sort(function(a,b){
             if (settings.sort_col == 'title') {
                 return String(a.title).toLowerCase() > String(b.title).toLowerCase() ? 1 : -1;
             }
             else {
                 return b.changed_ - a.changed_;
             }
         });
 
         var i, id, rec;
         for (i=0; data.data && i < data.data.length; i++) {
             rec = data.data[i];
             rec.id = rcmail.html_identifier_encode(rec.uid);
             noteslist.insert_row({
                 id: 'rcmrow' + rec.id,
                 cols: [
                     { className:'title', innerHTML:Q(rec.title) },
                     { className:'date',  innerHTML:Q(rec.changed || '') }
                 ]
             });
 
             notesdata[rec.id] = rec;
         }
 
         render_tagslist(data.tags || [], !data.search)
         rcmail.set_busy(false, 'loading', ui_loading);
 
         // select the single result
         if (data.data.length == 1) {
             noteslist.select(data.data[0].id);
         }
         else if (settings.selected_uid) {
             noteslist.select(rcmail.html_identifier_encode(settings.selected_uid));
             delete settings.selected_uid;
         }
         else if (me.selected_note && notesdata[me.selected_note.id]) {
             noteslist.select(me.selected_note.id);
         }
         else if (!data.data.length) {
             rcmail.display_message(rcmail.gettext('norecordsfound','kolab_notes'), 'info');
         }
     }
 
     /**
      *
      */
-    function render_note(data, retry)
+    function render_note(data, container, temp, retry)
     {
         rcmail.set_busy(false, 'loading', ui_loading);
 
         if (!data) {
             rcmail.display_message(rcmail.get_label('recordnotfound', 'kolab_notes'), 'error');
             return;
         }
 
+        if (!container) {
+            container = rcmail.gui_containers['notedetailview'];
+        }
+
         var list = me.notebooks[data.list] || me.notebooks[me.selected_list] || { rights: 'lrs', editable: false };
             content = $('#notecontent').val(data.description),
             readonly = data.readonly || !(list.editable || !data.uid && has_permission(list,'i')),
-            attachmentslist = $(rcmail.gui_objects.notesattachmentslist).html('');
-        $('.notetitle', rcmail.gui_objects.noteviewtitle).val(data.title).prop('disabled', readonly).show();
-        $('.dates .notecreated', rcmail.gui_objects.noteviewtitle).html(Q(data.created || ''));
-        $('.dates .notechanged', rcmail.gui_objects.noteviewtitle).html(Q(data.changed || ''));
-        $(rcmail.gui_objects.notebooks).filter('select').val(list.id);
+            attachmentslist = gui_object('notesattachmentslist', container).html(''),
+            titlecontainer = container || rcmail.gui_objects.noteviewtitle;
+
+        $('.notetitle', titlecontainer).val(data.title).prop('disabled', readonly).show();
+        $('.dates .notecreated', titlecontainer).html(Q(data.created || ''));
+        $('.dates .notechanged', titlecontainer).html(Q(data.changed || ''));
         if (data.created || data.changed) {
-            $('.dates', rcmail.gui_objects.noteviewtitle).show();
+            $('.dates', titlecontainer).show();
         }
 
         // tag-edit line
-        var tagline = $('.tagline', rcmail.gui_objects.noteviewtitle).empty()[readonly?'addClass':'removeClass']('disabled').show();
+        var tagline = $('.tagline', titlecontainer).empty()[readonly?'addClass':'removeClass']('disabled').show();
         $.each(typeof data.tags == 'object' && data.tags.length ? data.tags : [''], function(i,val) {
             $('<input>')
                 .attr('name', 'tags[]')
                 .attr('tabindex', '0')
                 .addClass('tag')
                 .val(val)
                 .appendTo(tagline);
         });
 
         if (!data.tags || !data.tags.length) {
             $('<span>').addClass('placeholder')
               .html(rcmail.gettext('notags', 'kolab_notes'))
               .appendTo(tagline)
               .click(function(e) { $(this).parent().find('.tagedit-list').trigger('click'); });
         }
 
-        $('.tagline input.tag', rcmail.gui_objects.noteviewtitle).tagedit({
+        $('.tagline input.tag', titlecontainer).tagedit({
             animSpeed: 100,
             allowEdit: false,
             allowAdd: !readonly,
             allowDelete: !readonly,
             checkNewEntriesCaseSensitive: false,
             autocompleteOptions: { source: tags, minLength: 0, noCheck: true },
             texts: { removeLinkTitle: rcmail.gettext('removetag', 'kolab_notes') }
         });
 
         if (data.links) {
             $.each(data.links, function(i, link) {
                 var li = $('<li>').addClass('link')
                     .addClass('message eml')
                     .append($('<a>')
                         .attr('href', link.mailurl)
                         .addClass('messagelink')
                         .text(link.subject || link.uri)
                     )
                     .appendTo(attachmentslist);
 
                 if (!readonly && !data._from_mail) {
                     $('<a>')
                         .attr('href', '#delete')
                         .attr('title', rcmail.gettext('removelink', 'kolab_notes'))
                         .addClass('delete')
                         .html(rcmail.gettext('delete'))
                         .click({ uri:link.uri }, function(e) {
                             remove_link(this, e.data.uri);
                             return false;
                         })
                         .appendTo(li);
                 }
             });
         }
 
         if (!readonly) {
-            $('.tagedit-list', rcmail.gui_objects.noteviewtitle)
+            $('.tagedit-list', titlecontainer)
                 .on('click', function(){ $('.tagline .placeholder').hide(); });
         }
 
         if (!data.list)
             data.list = list.id;
 
         data.readonly = readonly;
-        me.selected_note = data;
-        me.selected_note.id = rcmail.html_identifier_encode(data.uid);
-        rcmail.enable_command('save', !readonly);
+
+        if (!temp) {
+            $(rcmail.gui_objects.notebooks).filter('select').val(list.id);
+            me.selected_note = data;
+            me.selected_note.id = rcmail.html_identifier_encode(data.uid);
+            rcmail.enable_command('save', !readonly);
+        }
 
         var html = data.html || data.description;
 
         // convert plain text to HTML and make URLs clickable
         if (html != '' && (!data.html || !html.match(/<(html|body)/))) {
             html = text2html(html);
         }
 
         var node, editor = tinyMCE.get('notecontent'), is_html = false;
         retry = retry || 0;
 
         // sometimes the editor instance is not ready yet (FF only)...
         if (!readonly && !editor && $('#notecontent').length && retry < 5) {
           // ... give it some more time
           setTimeout(function() {
-              $(rcmail.gui_objects.noteseditform).show();
-              render_note(data, retry+1);
+              gui_object('noteseditform', container).show();
+              render_note(data, container, temp, retry+1);
           }, 200);
           return;
         }
 
         if (!readonly && editor) {
-            $(rcmail.gui_objects.notesdetailview).hide();
-            $(rcmail.gui_objects.noteseditform).show();
+            gui_object('notesdetailview', container).hide();
+            gui_object('noteseditform', container).show();
             editor.setContent(html);
             node = editor.getContentAreaContainer().childNodes[0];
             if (node) node.tabIndex = content.get(0).tabIndex;
 
             if (me.selected_note.uid) {
                 if (!render_no_focus)
                     editor.getBody().focus();
             }
             else
-                $('.notetitle', rcmail.gui_objects.noteviewtitle).focus().select();
+                $('.notetitle', titlecontainer).focus().select();
 
             // read possibly re-formatted content back from editor for later comparison
             me.selected_note.description = editor.getContent({ format:'html' }).replace(/^\s*(<p><\/p>\n*)?/, '');
             is_html = true;
         }
         else {
-            $(rcmail.gui_objects.noteseditform).hide();
-            $(rcmail.gui_objects.notesdetailview).html(html).show();
+            gui_object('noteseditform', container).hide();
+            gui_object('notesdetailview', container).html(html).show();
         }
 
         render_no_focus = false;
 
         // notify subscribers
         rcmail.triggerEvent('kolab_notes_render', { data:data, readonly:readonly, html:is_html });
         if (rcmail.is_framed())
             parent.rcmail.triggerEvent('kolab_notes_render', { data:data, readonly:readonly, html:is_html });
 
         // Trigger resize (needed for proper editor resizing)
         $(window).resize();
     }
 
+    /**
+     *
+     */
+    function gui_object(name, container)
+    {
+        var elem = rcmail.gui_objects[name], selector = elem;
+        if (elem && elem.className && container) {
+            selector = '.' + String(elem.className).split(' ').join('.');
+        }
+        else if (elem && elem.id) {
+            selector = '#' + elem.id;
+        }
+
+        return $(selector, container);
+    }
+
     /**
      * Convert the given plain text to HTML contents to be displayed in editor
      */
     function text2html(str)
     {
         // simple link parser (similar to rcube_string_replacer class in PHP)
         var utf_domain = '[^?&@"\'/\\(\\)\\s\\r\\t\\n]+\\.([^\x00-\x2f\x3b-\x40\x5b-\x60\x7b-\x7f]{2,}|xn--[a-z0-9]{2,})',
             url1 = '.:;,', url2 = 'a-z0-9%=#@+?&/_~\\[\\]-',
             link_pattern = new RegExp('([hf]t+ps?://|www.)('+utf_domain+'(['+url1+']?['+url2+']+)*)?', 'ig'),
             link_replace = function(matches, p1, p2) {
                 var url = (p1 == 'www.' ? 'http://' : '') + p1 + p2;
                 return '<a href="' + url + '" class="x-templink">' + p1 + p2 + '</a>';
             };
 
         return '<pre>' + Q(str).replace(link_pattern, link_replace) + '</pre>';
     }
 
+    /**
+     *
+     */
+    function show_history_dialog()
+    {
+        var dialog, rec = me.selected_note;
+        if (!rec || !rec.uid || !window.libkolab_audittrail) {
+            return false;
+        }
+
+        // render dialog
+        $dialog = libkolab_audittrail.object_history_dialog({
+            module: 'kolab_notes',
+            container: '#notehistory',
+            title: rcmail.gettext('objectchangelog','kolab_notes') + ' - ' + rec.title,
+
+            // callback function for list actions
+            listfunc: function(action, rev) {
+                var rec = $dialog.data('rec');
+                saving_lock = rcmail.set_busy(true, 'loading', saving_lock);
+                rcmail.http_post('action', { _do: action, _data: { uid: rec.uid, list:rec.list, rev: rev } }, saving_lock);
+            },
+
+            // callback function for comparing two object revisions
+            comparefunc: function(rev1, rev2) {
+                var rec = $dialog.data('rec');
+                saving_lock = rcmail.set_busy(true, 'loading', saving_lock);
+                rcmail.http_post('action', { _do: 'diff', _data: { uid: rec.uid, list: rec.list, rev1: rev1, rev2: rev2 } }, saving_lock);
+            }
+        });
+
+        $dialog.data('rec', rec);
+
+        // fetch changelog data
+        saving_lock = rcmail.set_busy(true, 'loading', saving_lock);
+        rcmail.http_post('action', { _do: 'changelog', _data: { uid: rec.uid, list: rec.list } }, saving_lock);
+    }
+
+    /**
+     *
+     */
+    function render_changelog(data)
+    {
+        var $dialog = $('#notehistory'),
+            rec = $dialog.data('rec');
+
+        if (data === false || !data.length || !event) {
+          // display 'unavailable' message
+          $('<div class="notfound-message note-dialog-message warning">' + rcmail.gettext('objectchangelognotavailable','kolab_notes') + '</div>')
+              .insertBefore($dialog.find('.changelog-table').hide());
+          return;
+        }
+
+        data.module = 'kolab_notes';
+        libkolab_audittrail.render_changelog(data, rec, me.notebooks[rec.list]);
+
+        // set dialog size according to content
+        dialog_resize($dialog.get(0), $dialog.height(), 600);
+    }
+
+    /**
+     *
+     */
+    function render_revision(data)
+    {
+        data.readonly = true;
+
+        // clone view and render data into a dialog
+        var model = rcmail.gui_containers['notedetailview'],
+            container = model.clone();
+
+        container
+            .removeAttr('id style class role')
+            .find('.mce-container').remove();
+
+        // reset custom styles
+        container.children('div, form').removeAttr('id style');
+
+        // open jquery UI dialog
+        container.dialog({
+            modal: false,
+            resizable: true,
+            closeOnEscape: true,
+            title: data.title + ' @ ' + data.rev,
+            close: function() {
+                container.dialog('destroy').remove();
+            },
+            buttons: [
+                {
+                    text: rcmail.gettext('close'),
+                    click: function() { container.dialog('close'); },
+                    autofocus: true
+                }
+            ],
+            width: model.width(),
+            height: model.height(),
+            minWidth: 450,
+            minHeight: 400,
+        })
+        .show();
+
+        render_note(data, container, true);
+    }
+
+    /**
+     *
+     */
+    function show_diff(data)
+    {
+        var rec = me.selected_note,
+            $dialog = $('#notediff');
+
+        $dialog.find('div.form-section, h2.note-title-new').hide().data('set', false);
+
+        // always show title
+        $('.note-title', $dialog).text(rec.title).removeClass('diff-text-old').show();
+
+        // show each property change
+        $.each(data.changes, function(i, change) {
+            var prop = change.property, r2, html = false,
+                row = $('div.note-' + prop, $dialog).first();
+
+            // special case: title
+            if (prop == 'title') {
+                $('.note-title', $dialog).addClass('diff-text-old').text(change['old'] || '--');
+                $('.note-title-new', $dialog).text(change['new'] || '--').show();
+            }
+
+            // no display container for this property
+            if (!row.length) {
+                return true;
+            }
+
+            if (change.diff_) {
+                row.children('.diff-text-diff').html(change.diff_);
+                row.children('.diff-text-old, .diff-text-new').hide();
+            }
+            else {
+                if (!html) {
+                    // escape HTML characters
+                    change.old_ = Q(change.old_ || change['old'] || '--')
+                    change.new_ = Q(change.new_ || change['new'] || '--')
+                }
+                row.children('.diff-text-old').html(change.old_ || change['old'] || '--').show();
+                row.children('.diff-text-new').html(change.new_ || change['new'] || '--').show();
+            }
+
+            row.show().data('set', true);
+        });
+
+        // open jquery UI dialog
+        $dialog.dialog({
+            modal: false,
+            resizable: true,
+            closeOnEscape: true,
+            title: rcmail.gettext('objectdiff','kolab_notes').replace('$rev1', data.rev1).replace('$rev2', data.rev2) + ' - ' + rec.title,
+            open: function() {
+                $dialog.attr('aria-hidden', 'false');
+            },
+            close: function() {
+                $dialog.dialog('destroy').attr('aria-hidden', 'true').hide();
+            },
+            buttons: [
+                {
+                    text: rcmail.gettext('close'),
+                    click: function() { $dialog.dialog('close'); },
+                    autofocus: true
+                }
+            ],
+            minWidth: 400,
+            width: 480
+        }).show();
+
+        // set dialog size according to content
+        dialog_resize($dialog.get(0), $dialog.height(), rcmail.gui_containers.notedetailview.width() - 40);
+    }
+
+    // close the event history dialog
+    function close_history_dialog()
+    {
+        $('#notehistory, #notediff').each(function(i, elem) {
+        var $dialog = $(elem);
+        if ($dialog.is(':ui-dialog'))
+            $dialog.dialog('close');
+        });
+    };
+
     /**
      *
      */
     function remove_link(elem, uri)
     {
         // remove the link item matching the given uri
         me.selected_note.links = $.grep(me.selected_note.links, function(link) { return link.uri != uri; });
         me.selected_note._links_removed = true
 
         // remove UI list item
         $(elem).hide().closest('li').addClass('deleted');
     }
 
     /**
      * Open a new window to print the currently selected note
      */
     function print_note()
     {
         var printwin, data, list;
         if (me.selected_note && (printwin = rcmail.open_window(settings.print_template))) {
             list = me.notebooks[me.selected_note.list] || me.notebooks[me.selected_list] || {};
             data = get_save_data();
 
             // for read-only notes, get_save_data() won't return the content
             if (me.selected_note.readonly || !list.editable) {
                 data.description = me.selected_note.html || me.selected_note.description;
                 if (!me.selected_note.html || !data.description.match(/<(html|body)/)) {
                     data.description = text2html(data.description);
                 }
             }
 
             $(printwin).load(function(){
                 printwin.document.title = data.title;
                 $('#notetitle', printwin.document).html(Q(data.title));
                 $('#notebody',  printwin.document).html(data.description);
                 $('#notetags',  printwin.document).html('<span class="tag">' + data.tags.join('</span><span class="tag">') + '</span>');
                 $('#notecreated', printwin.document).html(Q(me.selected_note.created));
                 $('#notechanged', printwin.document).html(Q(me.selected_note.changed));
                 printwin.print();
             });
         }
     }
 
     /**
      * Redirect to message compose screen with UIDs of notes to be appended
      */
     function send_note()
     {
         var uids = [];
         for (var rec, i=0; i < noteslist.selection.length; i++) {
             if (rec = notesdata[noteslist.selection[i]]) {
                 uids.push(rec.uid);
                 // TODO: check if rec.uid == me.selected_note.uid and unsaved changes
             }
         }
 
         if (uids.length) {
             rcmail.goto_url('mail/compose', { _with_notes: uids.join(','), _notes_list: me.selected_list }, true);
         }
     }
 
     /**
      *
      */
     function render_tagslist(newtags, replace)
     {
         if (replace) {
             tags = newtags;
         }
         else {
             var append = [];
             for (var i=0; i < newtags.length; i++) {
                 if ($.inArray(newtags[i], tags) < 0)
                     append.push(newtags[i]);
             }
             if (!append.length) {
                 update_tagcloud();
                 return;  // nothing to be added
             }
             tags = tags.concat(append);
         }
 
         // sort tags first
         tags.sort(function(a,b){
             return a.toLowerCase() > b.toLowerCase() ? 1 : -1;
         })
 
         var widget = $(rcmail.gui_objects.notestagslist).html('');
 
         // append tags to tag cloud
         $.each(tags, function(i, tag){
             li = $('<li role="checkbox" aria-checked="false" tabindex="0"></li>')
                 .attr('rel', tag)
                 .data('value', tag)
                 .html(Q(tag) + '<span class="count"></span>')
                 .appendTo(widget)
                 .draggable({
                     addClasses: false,
                     revert: 'invalid',
                     revertDuration: 300,
                     helper: tag_draggable_helper,
                     start: tag_draggable_start,
                     appendTo: 'body',
                     cursor: 'pointer'
                 });
         });
 
         update_tagcloud();
     }
 
     /**
      * Display the given counts to each tag and set those inactive which don't
      * have any matching records in the current view.
      */
     function update_tagcloud(counts)
     {
         // compute counts first by iterating over all visible task items
         if (typeof counts == 'undefined') {
             counts = {};
             $.each(notesdata, function(id, rec){
                 for (var t, j=0; rec && rec.tags && j < rec.tags.length; j++) {
                     t = rec.tags[j];
                     if (typeof counts[t] == 'undefined')
                         counts[t] = 0;
                     counts[t]++;
                 }
             });
         }
 
         $(rcmail.gui_objects.notestagslist).children('li').each(function(i,li){
             var elem = $(li), tag = elem.attr('rel'),
                 count = counts[tag] || 0;
 
             elem.children('.count').html(count+'');
             if (count == 0) elem.addClass('inactive');
             else            elem.removeClass('inactive');
 
             if (tagsfilter && tagsfilter.length && $.inArray(tag, tagsfilter)) {
                 elem.addClass('selected').attr('aria-checked', 'true');
             }
             else {
                 elem.removeClass('selected').attr('aria-checked', 'false');
             }
         });
     }
 
     /**
      * Callback from server after saving a note record
      */
     function update_note(data)
     {
         data.id = rcmail.html_identifier_encode(data.uid);
 
         var row, is_new = (notesdata[data.id] == undefined && data.list == me.selected_list);
         notesdata[data.id] = data;
 
         if (is_new || me.selected_note && data.id == me.selected_note.id) {
             render_note(data);
             render_tagslist(data.tags || []);
         }
         else if (data.tags) {
             render_tagslist(data.tags);
         }
 
         // add list item on top
         if (is_new) {
             noteslist.insert_row({
                 id: 'rcmrow' + data.id,
                 cols: [
                     { className:'title', innerHTML:Q(data.title) },
                     { className:'date',  innerHTML:Q(data.changed || '') }
                 ]
             }, true);
 
             noteslist.select(data.id);
         }
         // update list item
         else if (row = noteslist.rows[data.id]) {
             $('.title', row.obj).html(Q(data.title));
             $('.date', row.obj).html(Q(data.changed || ''));
             // TODO: move to top
         }
     }
 
     /**
      * 
      */
     function reset_view()
     {
+        close_history_dialog();
         me.selected_note = null;
         $('.notetitle', rcmail.gui_objects.noteviewtitle).val('').hide();
         $('.tagline, .dates', rcmail.gui_objects.noteviewtitle).hide();
         $(rcmail.gui_objects.noteseditform).hide();
         $(rcmail.gui_objects.notesdetailview).hide();
         $(rcmail.gui_objects.notesattachmentslist).html('');
         rcmail.enable_command('save', false);
     }
 
     /**
      * Collect data from the edit form and submit it to the server
      */
     function save_note(beforesave)
     {
         if (!me.selected_note) {
             return false;
         }
 
         var savedata = get_save_data();
 
         // run savedata through the given callback function
         if (typeof beforesave == 'function') {
             beforesave(savedata);
         }
 
         // add reference to old list if changed
         if (me.selected_note.list && savedata.list != me.selected_note.list) {
             savedata._fromlist = me.selected_note.list;
         }
 
         // do some input validation
         if (savedata.title == '') {
             alert(rcmail.gettext('entertitle', 'kolab_notes'));
             $('.notetitle', rcmail.gui_objects.noteviewtitle).focus();
             return false;
         }
 
         if (check_change_state(savedata)) {
             rcmail.lock_form(rcmail.gui_objects.noteseditform, true);
             saving_lock = rcmail.set_busy(true, 'kolab_notes.savingdata');
             rcmail.http_post('action', { _data: savedata, _do: savedata.uid?'edit':'new' }, true);
         }
         else {
             rcmail.display_message(rcmail.get_label('nochanges', 'kolab_notes'), 'info');
         }
     }
 
     /**
      * Collect updated note properties from edit form for saving
      */
     function get_save_data()
     {
         var editor = tinyMCE.get('notecontent'),
             listselect = $('option:selected', rcmail.gui_objects.notebooks);
         var savedata = {
             title: trim($('.notetitle', rcmail.gui_objects.noteviewtitle).val()),
             description: editor ? editor.getContent({ format:'html' }).replace(/^\s*(<p><\/p>\n*)?/, '') : $('#notecontent').val(),
             list: listselect.length ? listselect.val() : me.selected_note.list || me.selected_list,
             uid: me.selected_note.uid,
             tags: []
         };
 
         // copy links
         if ($.isArray(me.selected_note.links)) {
             savedata.links = me.selected_note.links;
         }
 
         // collect tags
         $('.tagedit-list input[type="hidden"]', rcmail.gui_objects.noteviewtitle).each(function(i, elem){
             if (elem.value)
                 savedata.tags.push(elem.value);
         });
         // including the "pending" one in the text box
         var newtag = $('#tagedit-input').val();
         if (newtag != '') {
             savedata.tags.push(newtag);
         }
 
         return savedata;
     }
 
     /**
      * Check if the currently edited note record was changed
      */
     function check_change_state(data)
     {
         if (!me.selected_note || me.selected_note.readonly || !has_permission(me.notebooks[me.selected_note.list || me.selected_list], 'i')) {
             return false;
         }
 
         var savedata = data || get_save_data();
 
         return savedata.title != me.selected_note.title
             || savedata.description != me.selected_note.description
             || savedata.tags.join(',') != (me.selected_note.tags || []).join(',')
             || savedata.list != me.selected_note.list
             || me.selected_note._links_removed;
     }
 
     /**
      * Check for unsaved changes and warn the user
      */
     function warn_unsaved_changes(ok, nok, beforesave)
     {
         if (typeof ok != 'function')
             ok = function(){ };
         if (typeof nok != 'function')
             nok = function(){ };
 
         if (check_change_state()) {
             var dialog, buttons = [];
 
             buttons.push({
                 text: rcmail.gettext('discard', 'kolab_notes'),
                 click: function() {
                     dialog.dialog('close');
                     ok();
                 }
             });
 
             buttons.push({
                 text: rcmail.gettext('save'),
                 'class': 'mainaction',
                 click: function() {
                     save_note(beforesave);
                     dialog.dialog('close');
                     rcmail.busy = false;  // don't block next action
                     ok();
                 }
             });
 
             buttons.push({
                 text: rcmail.gettext('abort', 'kolab_notes'),
                 click: function() {
                     dialog.dialog('close');
                     nok();
                 }
             });
 
             var options = {
                 width: 460,
                 resizable: false,
                 closeOnEscape: false,
                 dialogClass: 'warning',
                 open: function(event, ui) {
                     $(this).parent().find('.ui-dialog-titlebar-close').hide();
                     setTimeout(function(){
                         dialog.parent().find('.ui-button:visible').first().focus();
                     }, 10);
                 },
                 close: function(event, ui) {
                     $(this).dialog('destroy').remove();
                 }
             };
 
             // open jquery UI dialog
             dialog = rcmail.show_popup_dialog(
                 rcmail.gettext('discardunsavedchanges', 'kolab_notes'),
                 rcmail.gettext('unsavedchanges', 'kolab_notes'),
                 buttons,
                 options
             );
 
             return false;
         }
 
         if (typeof ok == 'function') {
             ok();
         }
 
         return true;
     }
 
     /**
      *
      */
     function delete_notes()
     {
         if (!noteslist.selection.length) {
             return false;
         }
 
         if (confirm(rcmail.gettext('deletenotesconfirm','kolab_notes'))) {
             var rec, id, uids = [];
             for (var i=0; i < noteslist.selection.length; i++) {
                 id = noteslist.selection[i];
                 rec = notesdata[id];
                 if (rec) {
                     noteslist.remove_row(id);
                     uids.push(rec.uid);
                     delete notesdata[id];
                 }
             }
 
             saving_lock = rcmail.set_busy(true, 'kolab_notes.savingdata');
             rcmail.http_post('action', { _data: { uid: uids.join(','), list: me.selected_list }, _do: 'delete' }, true);
 
             reset_view();
             update_tagcloud();
             noteslist.clear_selection();
         }
     }
 
     /**
      *
      */
     function move_notes(list_id)
     {
         var rec, id, uids = [];
         for (var i=0; i < noteslist.selection.length; i++) {
             id = noteslist.selection[i];
             rec = notesdata[id];
             if (rec) {
                 noteslist.remove_row(id);
                 uids.push(rec.uid);
                 delete notesdata[id];
             }
         }
 
         if (uids.length) {
             saving_lock = rcmail.set_busy(true, 'kolab_notes.savingdata');
             rcmail.http_post('action', { _data: { uid: uids.join(','), list: me.selected_list, to: list_id }, _do: 'move' }, true);
         }
     }
 
     /**
      * update browser location to remember current view
      */
     function update_state()
     {
         var query = { _list: me.selected_list }
 
         if (settings.selected_uid) {
             query._id = settings.selected_uid;
         }
 
         if (window.history.replaceState) {
             window.history.replaceState({}, document.title, rcmail.url('', query));
         }
     }
 
 
     /*  Helper functions for drag & drop functionality of tags  */
     
     function tag_draggable_helper()
     {
         if (!tag_draghelper)
             tag_draghelper = $('<div class="tag-draghelper"></div>');
         else
             tag_draghelper.html('');
 
         $(this).clone().addClass('tag').appendTo(tag_draghelper);
         return tag_draghelper;
     }
 
     function tag_draggable_start(event, ui)
     {
         // register notes list to receive drop events
         $('li', rcmail.gui_objects.noteslist).droppable({
             hoverClass: 'droptarget',
             accept: tag_droppable_accept,
             drop: tag_draggable_dropped,
             addClasses: false
         });
 
         // allow to drop tags onto edit form title
         $(rcmail.gui_objects.noteviewtitle).droppable({
             drop: function(event, ui){
                 $('#tagedit-input').val(ui.draggable.data('value')).trigger('transformToTag');
                 $('.tagline .placeholder', rcmail.gui_objects.noteviewtitle).hide();
             },
             addClasses: false
         })
     }
 
     function tag_droppable_accept(draggable)
     {
         if (rcmail.busy)
             return false;
 
         var tag = draggable.data('value'),
             drop_id = $(this).attr('id').replace(/^rcmrow/, ''),
             drop_rec = notesdata[drop_id];
 
         // target already has this tag assigned
         if (!drop_rec || (drop_rec.tags && $.inArray(tag, drop_rec.tags) >= 0)) {
             return false;
         }
 
         return true;
     }
 
     function tag_draggable_dropped(event, ui)
     {
         var drop_id = $(this).attr('id').replace(/^rcmrow/, ''),
             tag = ui.draggable.data('value'),
             rec = notesdata[drop_id],
             savedata;
 
         if (rec && rec.id) {
             savedata = me.selected_note && rec.uid == me.selected_note.uid ? get_save_data() : $.extend({}, rec);
 
             if (savedata.id)   delete savedata.id;
             if (savedata.html) delete savedata.html;
 
             if (!savedata.tags)
                 savedata.tags = [];
             savedata.tags.push(tag);
 
             rcmail.lock_form(rcmail.gui_objects.noteseditform, true);
             saving_lock = rcmail.set_busy(true, 'kolab_notes.savingdata');
             rcmail.http_post('action', { _data: savedata, _do: 'edit' }, true);
         }
     }
 
+    // resize and reposition (center) the dialog window
+    function dialog_resize(id, height, width)
+    {
+        var win = $(window), w = win.width(), h = win.height();
+            $(id).dialog('option', { height: Math.min(h-20, height+130), width: Math.min(w-20, width+50) })
+                .dialog('option', 'position', ['center', 'center']);  // only works in a separate call (!?)
+    }
+
 }
 
 
 // extend jQuery
 // from http://james.padolsey.com/javascript/sorting-elements-with-jquery/
 jQuery.fn.sortElements = (function(){
     var sort = [].sort;
 
     return function(comparator, getSortable) {
         getSortable = getSortable || function(){ return this };
 
         var last = null;
         return sort.call(this, comparator).each(function(i){
             // at this point the array is sorted, so we can just detach each one from wherever it is, and add it after the last
             var node = $(getSortable.call(this));
             var parent = node.parent();
             if (last) last.after(node);
             else      parent.prepend(node);
             last = node;
         });
     };
 })();
 
 
 /* notes plugin UI initialization */
 var kolabnotes;
 window.rcmail && rcmail.addEventListener('init', function(evt) {
     kolabnotes = new rcube_kolab_notes_ui(rcmail.env.kolab_notes_settings);
     if (rcmail.env.action == 'dialog-ui')
         kolabnotes.init_dialog();
     else
         kolabnotes.init();
 });
 
diff --git a/plugins/kolab_notes/skins/larry/notes.css b/plugins/kolab_notes/skins/larry/notes.css
index 0c18e8ba..2c18762a 100644
--- a/plugins/kolab_notes/skins/larry/notes.css
+++ b/plugins/kolab_notes/skins/larry/notes.css
@@ -1,585 +1,684 @@
 /**
  * Kolab Notes plugin styles for skin "Larry"
  *
- * Copyright (C) 2014, Kolab Systems AG <contact@kolabsys.com>
+ * Copyright (C) 2014-2015, Kolab Systems AG <contact@kolabsys.com>
  * Screendesign by FLINT / Büro für Gestaltung, bueroflint.com
  *
  * The contents are subject to the Creative Commons Attribution-ShareAlike
  * License. It is allowed to copy, distribute, transmit and to adapt the work
  * by keeping credits to the original autors in the README file.
  * See http://creativecommons.org/licenses/by-sa/3.0/ for details.
  */
 
 
 #taskbar a.button-notes span.button-inner {
 	background-image: url('sprites.png');
 	background-position: 0 0;
 }
 
 #taskbar a.button-notes:hover span.button-inner,
 #taskbar a.button-notes.button-selected span.button-inner {
 	background-image: url('sprites.png');
 	background-position: 0 -26px;
 }
 
 .notesview div.uidialog {
 	display: none;
 }
 
 .notesview #sidebar {
 	position: absolute;
 	top: 0;
 	left: 0;
 	bottom: 0;
 	width: 240px;
 }
 
 .notesview #notestoolbar {
 	position: absolute;
 	top: -6px;
 	left: 0;
 	width: 100%;
 	height: 40px;
 	white-space: nowrap;
 }
 
 .notesview #notestoolbar a.button.createnote {
 	background-image: url('sprites.png');
 	background-position: center -54px;
 }
 
 .notesview #notestoolbar a.button.sendnote {
 	background-position: left -650px;
 }
 
 .notesview #quicksearchbar {
 	top: 2px;
 }
 
 .notesview #searchmenulink {
 	width: 15px;
 }
 
 .notesview #mainview-right {
 	position: absolute;
 	bottom: 0;
 	right: 0;
 	top: 0;
 	left: 252px;
 }
 
 .notesview #tagsbox {
 	position: absolute;
 	top: 0;
 	left: 0;
 	width: 100%;
 	height: 240px;
 }
 
 .notesview #notebooksbox {
 	position: absolute;
 	top: 252px;
 	left: 0;
 	width: 100%;
 	bottom: 0px;
 }
 
 .notesview #noteslistbox {
 	position: absolute;
 	top: 0;
 	left: 0;
 	width: 240px;
 	bottom: 0px;
 }
 
 .notesview #kolabnoteslist li {
 	border-left: 2px solid transparent;
 }
 
 .notesview #kolabnoteslist.focus li.focused {
 	border-left: 2px solid #739da8;
 }
 
 .notesview #kolabnoteslist .title {
 	display: block;
 	padding: 4px 6px;
 	overflow: hidden;
 	text-overflow: ellipsis;
 	outline: none;
 }
 
 .notesview #kolabnoteslist .date {
 	display: block;
 	padding: 0px 6px 4px 6px;
 	color: #777;
 	font-weight: normal;
 }
 
 .notesview .boxpagenav a.icon.sortoptions {
 	background: url(sprites.png) center -93px no-repeat;
 }
 
 .notesview .toolbarmenu.iconized .selected span.icon {
 	background: url(sprites.png) -4px -110px no-repeat;
 }
 
 .notesview #notedetailsbox {
 	position: absolute;
 	top: 0;
 	left: 252px;
 	right: 0;
 	bottom: 0px;
 	background-image: url(../../../../skins/larry/images/watermark.jpg);
 	background-position: center;
 	background-repeat: no-repeat;
 }
 
 .notesdialog #notedetailsbox {
 	left: 0;
 }
 
 .notesview #notedetailsbox .formbuttons {
 	position: absolute;
 	bottom: 0;
 	left: 0;
 	right: 0;
 	padding: 8px 12px;
 	background: #f9f9f9;
 }
 
-.notesview #noteform,
-.notesview #notedetails {
+.notesview #notedetailsbox .footerright {
+	float: right;
+}
+
+.notesview #notedetailsbox .formbuttons:after {
+	content: "";
+	display: inline;
+	clear: both;
+}
+
+.notesview .btn-note-history {
+	display: inline-block;
+	padding: 2px;
+	text-decoration: none;
+	visibility: hidden;
+}
+
+.notesview .btn-note-history.active {
+	visibility: visible;
+	color: #333;
+}
+
+.notesview .btn-note-history:before {
+	content: "";
+	display: inline-block;
+	position: relative;
+	top: 4px;
+	width: 16px;
+	height: 16px;
+	margin-right: 4px;
+	background: url('sprites.png') -1px -302px no-repeat;
+}
+
+.notesview .btn-note-history.active:hover {
+	text-decoration: underline;
+}
+
+.notesview .noteform,
+.notesview .notedetails {
 	display: none;
 	position: absolute;
 	top: 82px;
 	left: 0;
 	bottom: 41px;
 	width: 100%;
 }
 
-.notesview #notedetails {
+.notesview .notedetails {
 	padding: 8px;
 	-webkit-box-sizing: border-box;
 	   -moz-box-sizing: border-box;
 	    -ms-box-sizing: border-box;
 	        box-sizing: border-box;
 	border-bottom: 1px solid #dfdfdf;
 	background: #fff;
 }
 
-.notesdialog #noteform,
-.notesdialog #notedetails {
+.notesdialog .noteform,
+.notesdialog .notedetails {
 	bottom: 30px;
 }
 
-.notesview #notedetails pre {
+.notesview .notedetails pre {
 	font-family: "Lucida Grande", Verdana,  Arial, Helvetica, sans-serif;
 	font-size: 12px;
 	margin: 0;
 }
 
 .notesview #notecontent {
 	position: relative;
 	width: 100%;
 	height: 100%;
 	border: 0;
 	border-radius: 0;
 	padding: 8px 0 8px 8px;
 	resize: none;
 	font-family: "Lucida Grande", Verdana, Arial, Helvetica, sans-serif;
 	font-size: 12px;
 	outline: none;
 	-webkit-box-sizing: border-box;
 	   -moz-box-sizing: border-box;
 	    -ms-box-sizing: border-box;
 	        box-sizing: border-box;
 	-webkit-box-shadow: inset 0 0 2px 1px rgba(0,0,0, 0.2);
 	   -moz-box-shadow: inset 0 0 2px 1px rgba(0,0,0, 0.2);
 	     -o-box-shadow: inset 0 0 2px 1px rgba(0,0,0, 0.2);
 	        box-shadow: inset 0 0 2px 1px rgba(0,0,0, 0.2);
 }
 
 .notesview #notecontent:active,
 .notesview #notecontent:focus {
 	-webkit-box-shadow: inset 0 0 3px 2px rgba(71,135,177, 0.9);
 	   -moz-box-shadow: inset 0 0 3px 2px rgba(71,135,177, 0.9);
 	     -o-box-shadow: inset 0 0 3px 2px rgba(71,135,177, 0.9);
 	        box-shadow: inset 0 0 3px 2px rgba(71,135,177, 0.9);
 }
 
 .notesview .mce-panel {
 	border: 0;
 }
 
-.notesview #notedetailstitle {
+.notesview .ui-dialog-content .noteform,
+.notesview .ui-dialog-content .notedetails,
+.notesview .ui-dialog-content .notereferences {
+	position: relative;
+	width: auto;
+	height: auto;
+	top: auto;
+	bottom: auto;
+	overflow: visible;
+	border: 0;
+}
+
+.notesview .notetitle {
 	height: auto;
 	min-height: 20px;
 }
 
-.notesview #notedetailstitle .disabled .tagedit-list,
-.notesview #notedetailstitle input.inline-edit:disabled {
+.notesview .ui-dialog-content .notetitle {
+	padding: 0 0 6px 0;
+	margin-top: -6px;
+	border-bottom: 0;
+}
+
+.notesview .ui-dialog-content .tagline {
+	display: none !important;
+}
+
+.notesview .notetitle .disabled .tagedit-list,
+.notesview .notetitle input.inline-edit:disabled {
 	outline: none;
 	padding-left: 0;
 	border: 0;
 	background: rgba(255,255,255,0.01);
 	-webkit-box-shadow: none;
 	   -moz-box-shadow: none;
 	     -o-box-shadow: none;
 	        box-shadow: none;
 }
 
-.notesview #notedetailstitle input.notetitle,
-.notesview #notedetailstitle input.notetitle:focus {
+.notesview .notetitle input.notetitle,
+.notesview .notetitle input.notetitle:focus {
 	width: 100%;
 	font-size: 14px;
 	font-weight: bold;
 	color: #333;
 	-webkit-box-sizing: border-box;
 	   -moz-box-sizing: border-box;
 	    -ms-box-sizing: border-box;
 	        box-sizing: border-box;
 }
 
-.notesview #notedetailstitle .dates,
-.notesview #notedetailstitle .tagline,
+.notesview .ui-dialog-content .formbuttons,
+.notesview .ui-dialog-content .notetitle input {
+	display: none !important;
+}
+
+.notesview .notetitle .dates,
+.notesview .notetitle .tagline,
 .notesdialog .notebookselect label {
 	color: #999;
 	font-weight: normal;
 	font-size: 0.9em;
 	margin-top: 6px;
 }
 
 .notesview .notebookselect {
 	margin-top: 4px;
 }
 
-.notesview #notedetailstitle .tagline {
+.notesview .notetitle .tagline {
 	position: relative;
 	cursor: text;
 	margin: 4px 0 0 0;
 }
 
-.notesview #notedetailstitle .tagline.disabled {
+.notesview .notetitle .tagline.disabled {
 	margin-top: 0;
 }
 
-.notesview #notedetailstitle .tagline .placeholder {
+.notesview .notetitle .tagline .placeholder {
 	position: absolute;
 	top: 6px;
 	left: 6px;
 	z-index: 2;
 }
 
-.notesview #notedetailstitle .tagedit-list {
+.notesview .notetitle .tagline.disabled .placeholder {
+	left: 0;
+}
+
+.notesview .notetitle .tagedit-list {
 	position: relative;
 	z-index: 1;
 	min-height: 32px;
 /*	padding: 2px; */
 	-webkit-box-sizing: border-box;
 	   -moz-box-sizing: border-box;
 	    -ms-box-sizing: border-box;
 	        box-sizing: border-box;
 }
 
 /* Firefox 3.6 */
-_:not(), _:-moz-handler-blocked, .notesview #notedetailstitle .tagedit-list {
+_:not(), _:-moz-handler-blocked, .notesview .notetitle .tagedit-list {
 	min-height: 26px;
 }
 
-.notesview #notedetailstitle .disabled .tagedit-list {
+.notesview .notetitle .disabled .tagedit-list {
 	min-height: 26px;
 }
 
-.notesview #notedetailstitle #tagedit-input {
+.notesview .notetitle #tagedit-input {
 	background: none;
 }
 
 .notesview .tag-draghelper {
 	z-index: 1000;
 }
 
-.notesview #notedetailstitle .notecreated,
-.notesview #notedetailstitle .notechanged {
+.notesview .notetitle .notecreated,
+.notesview .notetitle .notechanged {
 	display: inline-block;
 	padding-left: 0.4em;
 	padding-right: 2em;
 	color: #777;
 }
 
-.notesview #notereferences {
+.notesview .notereferences {
 	position: absolute;
 	left: 0;
 	right: 0;
 	bottom: 41px;
 	height: 27px;
 	background: #fff;
 	padding-left: 10px;
 }
 
-.notesdialog #notereferences {
+.notesdialog .notereferences {
 	bottom: 0;
 }
 
+.notesview #notediff .note-title,
+.notesview #notediff .note-title-new {
+	margin-top: 0;
+}
+
+.notesview .note-title.diff-text-old {
+	margin-bottom: 0;
+}
+
+.notesview .diff-text-diff del,
+.notesview .diff-text-diff ins {
+	text-decoration: none;
+	color: inherit;
+}
+
+.notesview .diff-text-old,
+.notesview .diff-text-diff del {
+	background-color: #fdd;
+	text-decoration: line-through;
+}
+
+.notesview .diff-text-new,
+.notesview .diff-text-diff ins,
+.notesview .diff-text-diff .diffmod img {
+	background-color: #dfd;
+}
+
+.notesview .diff-text-diff img {
+	border: 1px solid #999;
+}
+
 .notesview #notebooksbox .scroller {
 	top: 34px;
 }
 
 .notesview #notebooks li {
 	margin: 0;
 	display: block;
 	position: relative;
 }
 
 .notesview #notebooks li > div.folder,
 .notesview #notebooksbox .searchresults li > div.folder {
 	position: relative;
 	padding: 0;
 	height: 28px;
 }
 
 .notesview #notebooks li.virtual > div.folder {
 	height: 22px;
 }
 
 .notesview #notebooks li .listname {
 	display: block;
 	cursor: default;
 	margin: 0;
 	height: 24px;
 	padding-bottom: 0;
 	padding-right: 26px;
 	color: #004458;
 	overflow: hidden;
 	text-overflow: ellipsis;
 	white-space: nowrap;
 }
 
 .notesview #notebooks li.virtual > div > .listname {
 	color: #aaa;
 	height: 18px;
 	padding-top: 3px;
 }
 
 .notesview #notebooksbox .treelist div span.actions {
 	display: inline-block;
 	position: absolute;
 	top: 2px;
 	right: 2px;
 	padding: 5px 20px 0 6px;
 	min-width: 20px;
 	height: 19px;
 	text-align: right;
 }
 
 .notesview #notebooksbox .treelist div:hover span.actions {
 	top: 1px;
 	right: 1px;
 	border: 1px solid #c6c6c6;
 	border-radius: 4px;
 	background: #f7f7f7;
 	background: -moz-linear-gradient(top, #f9f9f9 0%, #e6e6e6 100%);
 	background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#f9f9f9), color-stop(100%,#e6e6e6));
 	background: -o-linear-gradient(top, #f9f9f9 0%, #e6e6e6 100%);
 	background: -ms-linear-gradient(top, #f9f9f9 0%, #e6e6e6 100%);
 	background: linear-gradient(top, #f9f9f9 0%, #e6e6e6 100%);
 	filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#f9f9f9', endColorstr='#e6e6e6', GradientType=0);
 }
 
 .notesview #notebooksbox .treelist div a.remove,
 .notesview #notebooksbox .treelist div a.subscribed {
 	display: inline-block;
 	position: absolute;
 	top: 5px;
 	right: 4px;
 	height: 16px;
 	width: 16px;
 	padding: 0;
 	background: url(sprites.png) -100px 0 no-repeat;
 	overflow: hidden;
 	text-indent: -5000px;
 	cursor: pointer;
 }
 
 .notesview #notebooksbox .treelist div a.subscribed:focus,
 .notesview #notebooksbox .treelist div:hover a.subscribed {
 	background-position: 0 -266px;
 }
 
 .notesview #notebooksbox .treelist div.subscribed a.subscribed {
 	background-position: -16px -266px;
 }
 
 .notesview #notebooksbox .treelist div a.remove {
 	position: relative;
 	top: 0;
 	left: 0;
 	margin-right: 4px;
 }
 
 .notesview #notebooksbox .treelist div a.remove:focus,
 .notesview #notebooksbox .treelist div:hover a.remove {
 	background-position: 0 -284px;
 }
 
 .notesview #notebooksbox .treelist div a.remove:focus,
 .notesview #notebooksbox .treelist div a.subscribed:focus {
 	border-radius: 3px;
 	outline: 2px solid rgba(30,150,192, 0.5);
 }
 
 .notesview #notebooksbox .searchresults .treelist div a.remove {
 	display: none;
 }
 
 .notesview #notebooksbox .treelist input {
 	position: absolute;
 	top: 4px;
 	left: 14px;
 }
 
 .notesview #notebooks input {
 	display: none;
 }
 
 .notesview #notebooksbox .searchresults .listing li {
 	background-color: #c7e3ef;
 }
 
 .notesview #notebooksbox .searchresults a.listname {
 	padding-left: 36px;
 }
 
 .notesview #notebooks div.folder span.handle {
 	display: inline-block;
 	position: absolute;
 	top: 6px;
 	right: 26px;
 	height: 16px;
 	width: 30px;
 	padding: 0;
 	background: url('sprites.png') right -1000px no-repeat;
 }
 
 .notesview #notebooks div.readonly span.handle {
 	background-position: right -192px;
 }
 
 .notesview #notebooks div.other span.handle {
 	background-position: right -210px;
 }
 
 .notesview #notebooks div.other.readonly span.handle {
 	background-position: right -228px;
 }
 
 .notesview #notebooks div.shared span.handle {
 	background-position: right -246px;
 }
 
 .notesview #notebooks div.other .listname,
 .notesview #notebooks div.shared .listname,
 .notesview #notebooks div.readonly .listname {
 	padding-right: 46px;
 }
 
 .notesview #notebooks div.other.readonly .listname {
 	padding-right: 56px;
 }
 
 .notesview #notebooksbox .searchresults {
 	background: #b0ccd7;
 	margin-top: 8px;
 }
 
 .notesview #notebooksbox .searchresults  .boxtitle {
 	background: none;
 	padding: 2px 8px 2px 8px;
 }
 
 .notesview #notebooksbox .boxtitle a.iconbutton.search {
 	position: absolute;
 	top: 8px;
 	right: 8px;
 	width: 16px;
 	cursor: pointer;
 	background-position: -2px -317px;
 }
 
 .notesview .uidialog .tabbed {
 	margin-top: -12px;
 }
 
 .notesview .uidialog .propform fieldset.ui-tabs-panel {
 	min-height: 290px;
 }
 
 .notesview .uidialog .propform #noteslist-name {
 	width: 20em;
 }
 
 .notesdialog #notesdialogheader {
 	height: auto;
 	-webkit-box-sizing: border-box;
 	   -moz-box-sizing: border-box;
 	    -ms-box-sizing: border-box;
 	        box-sizing: border-box;
 }
 
 #kolabnotesinlinegui {
 	border: 0;
 	padding: 0;
 	-webkit-box-sizing: border-box;
 	   -moz-box-sizing: border-box;
 	    -ms-box-sizing: border-box;
 	        box-sizing: border-box;
 }
 
 .notesview .attachmentslist li.message.eml {
 	position: relative;
 	display: inline-block;
 	background-image: url(sprites.png);
 	background-position: -6px -128px;
 	margin-right: 1em;
 	padding-right: 28px;
 }
 
 .notesview .attachmentslist li.message a.messagelink {
 	padding-left: 24px;
 	padding-right: 0;
 }
 
 .notesview .attachmentslist li.message a.delete {
 	background-position: -6px -378px;
 }
 
 .notesview .attachmentslist li.deleted a.messagelink,
 .notesview .attachmentslist li.deleted a.messagelink:hover {
 	text-decoration: line-through;
 }
 
 ul.toolbarmenu li .appendnote span.icon {
 	background-image: url(sprites.png);
 	background-position: -4px -170px;
 }
 
 div.kolabmessagenotes {
 	margin: 8px 8px;
 	padding: 4px 8px;
 	border: 1px solid #dfdfdf;
 	background: #fafafa;
 	border-radius: 4px;
 }
 
 div.kolabmessagenotes a.kolabnotesref {
 	display: inline-block;
 	color: #333;
 	font-weight: bold;
 	padding: 3px 15px 2px 22px;
 	text-shadow: 0px 1px 1px #fff;
 	text-decoration: none;
 	white-space: nowrap;
 	overflow: hidden;
 	text-overflow: ellipsis;
 	max-width: 16em;
 	background: url(sprites.png) -6px -151px no-repeat;
 }
\ No newline at end of file
diff --git a/plugins/kolab_notes/skins/larry/sprites.png b/plugins/kolab_notes/skins/larry/sprites.png
index acb32d7e..1dc4e815 100644
Binary files a/plugins/kolab_notes/skins/larry/sprites.png and b/plugins/kolab_notes/skins/larry/sprites.png differ
diff --git a/plugins/kolab_notes/skins/larry/templates/notes.html b/plugins/kolab_notes/skins/larry/templates/notes.html
index 6cfcb71a..88cb4e42 100644
--- a/plugins/kolab_notes/skins/larry/templates/notes.html
+++ b/plugins/kolab_notes/skins/larry/templates/notes.html
@@ -1,200 +1,234 @@
 <roundcube:object name="doctype" value="html5" />
 <html>
 <head>
 <title><roundcube:object name="pagetitle" /></title>
 <roundcube:include file="/includes/links.html" />
 </head>
 <body class="notesview noscroll">
 
 <roundcube:include file="/includes/header.html" />
 
 <div id="mainscreen">
     <h1 class="voice"><roundcube:label name="kolab_notes.navtitle" /></h1>
 
     <div id="notestoolbar" class="toolbar" role="toolbar" aria-labelledby="aria-label-toolbar">
         <h2 id="aria-label-toolbar" class="voice"><roundcube:label name="arialabeltoolbar" /></h2>
         <roundcube:button command="createnote" type="link" class="button createnote disabled" classAct="button createnote" classSel="button createnote pressed" label="kolab_notes.create" title="kolab_notes.createnote" />
         <roundcube:button command="print" type="link" class="button print disabled" classAct="button print" classSel="button print pressed" label="print" title="print" />
         <roundcube:button command="sendnote" type="link" class="button sendnote disabled" classAct="button sendnote" classSel="button sendnote pressed" label="kolab_notes.send" title="kolab_notes.sendnote" />
         <roundcube:container name="toolbar" id="notestoolbar" />
     </div>
 
     <div id="quicksearchbar" role="search" aria-labelledby="aria-label-searchform">
         <h2 id="aria-label-searchform" class="voice"><roundcube:label name="kolab_notes.arialabelnotesearchform" /></h2>
         <label for="quicksearchbox" class="voice"><roundcube:label name="kolab_notes.arialabelnotesquicksearchbox" /></label>
         <a id="searchmenulink" class="iconbutton searchoptions" > </a>
         <roundcube:object name="plugin.searchform" id="quicksearchbox" />
         <roundcube:button command="reset-search" id="searchreset" class="iconbutton reset" title="resetsearch" content=" " />
     </div>
 
     <div id="mainscreencontent">
 
     <div id="sidebar">
         <div id="tagsbox" class="uibox listbox">
             <h2 class="boxtitle" id="aria-label-tagsbox"><roundcube:label name="kolab_notes.tags" id="taglist" /></h2>
             <div class="scroller">
                 <roundcube:object name="plugin.tagslist" id="tagslist" class="tagcloud" role="region" aria-labelledby="aria-label-tagsbox" aria-controls="kolabnoteslist" />
             </div>
         </div>
 
         <div id="notebooksbox" class="uibox listbox" role="navigation" aria-labelledby="aria-label-notebooks">
             <h2 class="boxtitle" id="aria-label-notebooks"><roundcube:label name="kolab_notes.lists" />
                 <a href="#notebooks" class="iconbutton search" title="<roundcube:label name='kolab_notes.findnotebooks' />" tabindex="0"><roundcube:label name="kolab_notes.findnotebooks" /></a>
             </h2>
             <div class="listsearchbox" style="display:none">
                 <div class="searchbox" role="search" aria-labelledby="aria-label-notebooksearchform" aria-controls="kolabnoteslist">
                     <h3 id="aria-label-notebooksearchform" class="voice"><roundcube:label name="kolab_notes.arialabelfolderearchform" /></h3>
                     <label for="notebooksearch" class="voice"><roundcube:label name="kolab_notes.searchterms" /></label>
                     <input type="text" name="q" id="notebooksearch" placeholder="<roundcube:label name='kolab_notes.findnotebooks' />" />
                     <a class="iconbutton searchicon"></a>
                     <roundcube:button command="reset-listsearch" id="notebooksearch-reset" class="iconbutton reset" title="resetsearch" label="resetsearch" />
                 </div>
             </div>
             <div class="scroller withfooter">
                 <roundcube:object name="plugin.notebooks" id="notebooks" class="listing treelist" />
             </div>
             <div class="boxfooter">
                 <roundcube:button command="list-create" type="link" title="kolab_notes.newnotebook" class="listbutton add disabled" classAct="listbutton add" innerClass="inner" label="kolab_notes.addnotebook" /><roundcube:button name="notesoptionslink" id="notesoptionsmenulink" type="link" title="kolab_notes.listactions" class="listbutton groupactions" onclick="return UI.toggle_popup('notesoptionsmenu', event)" innerClass="inner" label="kolab_notes.listactions" aria-haspopup="true" aria-expanded="false" aria-owns="notesoptionsmenu-menu" />
             </div>
         </div>
 
         <div id="notesoptionsmenu" class="popupmenu" aria-hidden="true">
             <h3 id="aria-label-optionsmenu" class="voice"><roundcube:label name="kolab_notes.arialabelnotesoptionsmenu" /></h3>
             <ul class="toolbarmenu" id="notesoptionsmenu-menu" role="menu" aria-labelledby="aria-label-optionsmenu">
                 <li role="menuitem"><roundcube:button command="list-edit" label="edit" classAct="active" /></li>
                 <li role="menuitem"><roundcube:button command="list-delete" label="delete" classAct="active" /></li>
                 <li role="menuitem"><roundcube:button command="list-remove" label="kolab_notes.removelist" classAct="active" /></li>
                 <li role="menuitem"><roundcube:button command="folders" task="settings" type="link" label="managefolders" classAct="active" /></li>
             </ul>
         </div>
     </div>
 
     <div id="mainview-right">
         <div id="noteslistbox" class="uibox listbox">
             <h3 id="aria-label-noteslist" class="boxtitle"><roundcube:label name="kolab_notes.notes" /></h3>
             <div class="scroller withfooter" aria-labelledby="aria-label-noteslist">
                 <roundcube:object name="plugin.listing" id="kolabnoteslist" class="listing" summary="kolab_notes.arialabelnoteslist" />
             </div>
             <div class="boxfooter">
                 <roundcube:button command="delete" type="link" title="delete" class="listbutton delete disabled" classAct="listbutton delete" innerClass="inner" label="delete" />
                 <roundcube:object name="plugin.recordsCountDisplay" class="countdisplay" label="fromtoshort" aria-live="polite" aria-relevant="text" />
             </div>
             <div class="boxpagenav">
                 <roundcube:button name="notessortmenulink" id="notessortmenulink" type="link" title="kolab_notes.sortby" class="icon sortoptions" onclick="return UI.toggle_popup('notessortmenu', event)" innerClass="inner" content="v" aria-haspopup="true" aria-expanded="false" aria-owns="notessortmenu-menu" />
             </div>
         </div>
 
         <div id="notedetailsbox" class="uibox contentbox" role="main" aria-labelledby="aria-label-noteform">
             <h3 id="aria-label-noteform" class="voice"><roundcube:label name="kolab_notes.arialabelnoteform" /></h3>
-            <roundcube:object name="plugin.notetitle" id="notedetailstitle" class="boxtitle" />
-            <roundcube:object name="plugin.editform" id="noteform" />
-            <roundcube:object name="plugin.detailview" id="notedetails" class="scroller" />
-            <div id="notereferences">
+            <roundcube:object name="plugin.notetitle" id="notedetailstitle" class="notetitle boxtitle" />
+            <roundcube:object name="plugin.editform" id="noteform" class="noteform" />
+            <roundcube:object name="plugin.detailview" id="notedetails" class="notedetails scroller" />
+            <div id="notereferences" class="notereferences">
                 <h3 id="aria-label-messagereferences" class="voice"><roundcube:label name="kolab_notes.arialabelmessagereferences" /></h3>
                 <roundcube:object name="plugin.attachments_list" id="attachment-list" class="attachmentslist" role="region" aria-labelledby="aria-label-messagereferences" />
             </div>
-            <div class="footerleft formbuttons">
+            <div class="formbuttons">
                 <roundcube:button command="save" type="input" class="button mainaction" label="save" id="btn-save-note" />
+                <div class="footerright">
+                <roundcube:if condition="config:kolab_bonnie_api" />
+                    <roundcube:button command="history" type="link" label="kolab_notes.showhistory" class="btn-note-history" classAct="btn-note-history active" />
+                <roundcube:endif />
+                </div>
             </div>
+            <roundcube:container name="notedetailview" id="notedetailsbox" />
         </div>
     </div>
 
     </div>
 </div>
 
+<roundcube:if condition="config:kolab_bonnie_api" />
+<div id="notehistory" class="uidialog" aria-hidden="true">
+    <roundcube:object name="plugin.object_changelog_table" class="records-table changelog-table" domain="calendar" />
+    <div class="compare-button"><input type="button" class="button" value="↳ <roundcube:label name='kolab_notes.compare' />" /></div>
+</div>
+
+<div id="notediff" class="uidialog contentbox" aria-hidden="true">
+	<h2 class="note-title">Note Title</h2>
+	<h2 class="note-title-new diff-text-new"></h2>
+
+	<div class="form-section note-tags">
+		<span class="diff-text-old"></span> &#8674;
+		<span class="diff-text-new"></span>
+	</div>
+
+	<div class="form-section note-description">
+		<div class="diff-text-diff" style="white-space:pre-wrap"></div>
+		<div class="diff-text-old"></div>
+		<div class="diff-text-new"></div>
+	</div>
+
+	<div class="form-section notereferences">
+		<div class="diff-text-old"></div>
+		<div class="diff-text-new"></div>
+	</div>
+</div>
+<roundcube:endif />
+
 <roundcube:object name="message" id="messagestack" />
 
 <div id="notessortmenu" class="popupmenu" aria-hidden="true">
     <h3 id="aria-label-sortmenu" class="voice"><roundcube:label name="kolab_notes.arialabelnotessortmenu" /></h3>
     <ul class="toolbarmenu iconized" id="notessortmenu-menu" role="menu" aria-labelledby="aria-label-sortmenu">
         <li role="menuitem"><roundcube:button command="list-sort" prop="changed" type="link" label="kolab_notes.changed" class="icon active by-changed" innerclass="icon" /></li>
         <li role="menuitem"><roundcube:button command="list-sort" prop="title" type="link" label="kolab_notes.title" class="icon active by-title" innerclass="icon" /></li>
     </ul>
 </div>
 
 <div id="notebookeditform" class="uidialog" aria-labelledby="aria-label-editform" aria-hidden="true" role="dialog">
     <h3 id="aria-label-editform" class="voice"><roundcube:label name="kolab_notes.arialabelnotebookform" /></h3>
     <roundcube:container name="notebookeditform" id="notebookeditform" />
     <roundcube:label name="loading" />
 </div>
 
 <script type="text/javascript">
 
 // UI startup
 var UI = new rcube_mail_ui();
 
 $(document).ready(function(e){
     UI.init();
 
     rcmail.addEventListener('kolab_notes_editform_load', function(e){
         UI.init_tabs($('#notebookeditform > form').addClass('propform tabbed'));
     })
 
     new rcube_splitter({ id:'notesviewsplitter', p1:'#sidebar', p2:'#mainview-right',
         orientation:'v', relative:true, start:240, min:180, size:12, render:layout_view }).init();
     new rcube_splitter({ id:'noteslistsplitter2', p1:'#noteslistbox', p2:'#notedetailsbox',
         orientation:'v', relative:true, start:242, min:180, size:12, render:layout_view }).init();
     new rcube_splitter({ id:'notesviewsplitterv', p1:'#tagsbox', p2:'#notebooksbox',
         orientation:'h', relative:true, start:242, min:120, size:12, offset:4 }).init();
 
     function layout_view()
     {
         var form = $('#noteform, #notedetails'),
             content = $('#notecontent'),
             header = $('#notedetailstitle'),
             footer = $('#notereferences'),
             w, h;
 
         if ($('#attachment-list li').length)
             footer.show();
         else
             footer.hide();
 
         form.css('top', header.outerHeight()+'px');
         form.css('bottom', ((footer.is(':visible') ? footer.outerHeight()+4 : 0) + 41) + 'px');
 
         w = form.outerWidth();
         h = form.outerHeight();
         content.width(w).height(h);
 
         $('#noteform > div.mce-tinymce').width(w);
         $('#notecontent_ifr').width(w).height(h - 4 - $('div.mce-toolbar').height());
     }
 
     $(window).resize(function(e){
         layout_view();
     });
 
     // animation to unfold list search box
     $('#notebooksbox .boxtitle a.search').click(function(e){
         var title = $('#notebooksbox .boxtitle'),
             box = $('#notebooksbox .listsearchbox'),
             dir = box.is(':visible') ? -1 : 1;
 
         box.slideToggle({
             duration: 160,
             progress: function(animation, progress) {
                 if (dir < 0) progress = 1 - progress;
                 $('#notebooksbox .scroller').css('top', (title.outerHeight() + 34 * progress) + 'px');
             },
             complete: function() {
                 box.toggleClass('expanded');
                 if (box.is(':visible')) {
                     box.find('input[type=text]').focus();
                 }
                 else {
                     $('#notebooksearch-reset').click();
                 }
                 // TODO: save state in localStorage
             }
         });
 
         return false;
     });
     
 });
 
 </script>
 
 </body>
 </html>