diff --git a/plugins/calendar/calendar.php b/plugins/calendar/calendar.php
index 3e0c0adf..e416ea7d 100644
--- a/plugins/calendar/calendar.php
+++ b/plugins/calendar/calendar.php
@@ -1,3316 +1,3316 @@
 <?php
 
 /**
  * Calendar plugin for Roundcube webmail
  *
  * @author Lazlo Westerhof <hello@lazlo.me>
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2010, Lazlo Westerhof <hello@lazlo.me>
  * 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 calendar extends rcube_plugin
 {
   const FREEBUSY_UNKNOWN = 0;
   const FREEBUSY_FREE = 1;
   const FREEBUSY_BUSY = 2;
   const FREEBUSY_TENTATIVE = 3;
   const FREEBUSY_OOF = 4;
 
   const SESSION_KEY = 'calendar_temp';
 
   public $task = '?(?!logout).*';
   public $rc;
   public $lib;
   public $resources_dir;
   public $home;  // declare public to be used in other classes
   public $urlbase;
   public $timezone;
   public $timezone_offset;
   public $gmt_offset;
   public $ui;
 
   public $defaults = array(
     'calendar_default_view' => "agendaWeek",
     'calendar_timeslots'    => 2,
     'calendar_work_start'   => 6,
     'calendar_work_end'     => 18,
     'calendar_agenda_range' => 60,
     'calendar_agenda_sections' => 'smart',
     'calendar_event_coloring'  => 0,
     'calendar_time_indicator'  => true,
     'calendar_allow_invite_shared' => false,
     'calendar_itip_send_option'    => 3,
     'calendar_itip_after_action'   => 0,
   );
 
   private $ical;
   private $itip;
   private $driver;
 
 
   /**
    * Plugin initialization.
    */
   function init()
   {
     $this->require_plugin('libcalendaring');
 
     $this->rc = rcube::get_instance();
     $this->lib = libcalendaring::get_instance();
 
     $this->register_task('calendar', 'calendar');
 
     // load calendar configuration
     $this->load_config();
 
     // load localizations
     $this->add_texts('localization/', $this->rc->task == 'calendar' && (!$this->rc->action || $this->rc->action == 'print'));
 
     $this->timezone = $this->lib->timezone;
     $this->gmt_offset = $this->lib->gmt_offset;
     $this->dst_active = $this->lib->dst_active;
     $this->timezone_offset = $this->gmt_offset / 3600 - $this->dst_active;
 
     require($this->home . '/lib/calendar_ui.php');
     $this->ui = new calendar_ui($this);
 
     // catch iTIP confirmation requests that don're require a valid session
     if ($this->rc->action == 'attend' && !empty($_REQUEST['_t'])) {
       $this->add_hook('startup', array($this, 'itip_attend_response'));
     }
     else if ($this->rc->action == 'feed' && !empty($_REQUEST['_cal'])) {
       $this->add_hook('startup', array($this, 'ical_feed_export'));
     }
     else {
       // default startup routine
       $this->add_hook('startup', array($this, 'startup'));
     }
 
     $this->add_hook('user_delete', array($this, 'user_delete'));
   }
 
   /**
    * Startup hook
    */
   public function startup($args)
   {
     // the calendar module can be enabled/disabled by the kolab_auth plugin
     if ($this->rc->config->get('calendar_disabled', false) || !$this->rc->config->get('calendar_enabled', true))
         return;
 
     // load Calendar user interface
     if (!$this->rc->output->ajax_call && (!$this->rc->output->env['framed'] || $args['action'] == 'preview')) {
       $this->ui->init();
 
       // settings are required in (almost) every GUI step
       if ($args['action'] != 'attend')
         $this->rc->output->set_env('calendar_settings', $this->load_settings());
     }
 
     if ($args['task'] == 'calendar' && $args['action'] != 'save-pref') {
       if ($args['action'] != 'upload') {
         $this->load_driver();
       }
 
       // register calendar actions
       $this->register_action('index', array($this, 'calendar_view'));
       $this->register_action('event', array($this, 'event_action'));
       $this->register_action('calendar', array($this, 'calendar_action'));
       $this->register_action('count', array($this, 'count_events'));
       $this->register_action('load_events', array($this, 'load_events'));
       $this->register_action('export_events', array($this, 'export_events'));
       $this->register_action('import_events', array($this, 'import_events'));
       $this->register_action('upload', array($this, 'attachment_upload'));
       $this->register_action('get-attachment', array($this, 'attachment_get'));
       $this->register_action('freebusy-status', array($this, 'freebusy_status'));
       $this->register_action('freebusy-times', array($this, 'freebusy_times'));
       $this->register_action('randomdata', array($this, 'generate_randomdata'));
       $this->register_action('print', array($this,'print_view'));
       $this->register_action('mailimportitip', array($this, 'mail_import_itip'));
       $this->register_action('mailimportattach', array($this, 'mail_import_attachment'));
       $this->register_action('mailtoevent', array($this, 'mail_message2event'));
       $this->register_action('inlineui', array($this, 'get_inline_ui'));
       $this->register_action('check-recent', array($this, 'check_recent'));
       $this->register_action('itip-status', array($this, 'event_itip_status'));
       $this->register_action('itip-remove', array($this, 'event_itip_remove'));
       $this->register_action('itip-decline-reply', array($this, 'mail_itip_decline_reply'));
       $this->register_action('itip-delegate', array($this, 'mail_itip_delegate'));
       $this->register_action('resources-list', array($this, 'resources_list'));
       $this->register_action('resources-owner', array($this, 'resources_owner'));
       $this->register_action('resources-calendar', array($this, 'resources_calendar'));
       $this->register_action('resources-autocomplete', array($this, 'resources_autocomplete'));
       $this->add_hook('refresh', array($this, 'refresh'));
 
       // remove undo information...
       if ($undo = $_SESSION['calendar_event_undo']) {
         // ...after timeout
         $undo_time = $this->rc->config->get('undo_timeout', 0);
         if ($undo['ts'] < time() - $undo_time) {
           $this->rc->session->remove('calendar_event_undo');
           // @TODO: do EXPUNGE on kolab objects?
         }
       }
     }
     else if ($args['task'] == 'settings') {
       // add hooks for Calendar settings
       $this->add_hook('preferences_sections_list', array($this, 'preferences_sections_list'));
       $this->add_hook('preferences_list', array($this, 'preferences_list'));
       $this->add_hook('preferences_save', array($this, 'preferences_save')); 
     }
     else if ($args['task'] == 'mail') {
       // hooks to catch event invitations on incoming mails
       if ($args['action'] == 'show' || $args['action'] == 'preview') {
         $this->add_hook('template_object_messagebody', array($this, 'mail_messagebody_html'));
       }
 
       // add 'Create event' item to message menu
       if ($this->api->output->type == 'html') {
         $this->api->add_content(html::tag('li', null, 
           $this->api->output->button(array(
             'command'  => 'calendar-create-from-mail',
             'label'    => 'calendar.createfrommail',
             'type'     => 'link',
             'classact' => 'icon calendarlink active',
             'class'    => 'icon calendarlink',
             'innerclass' => 'icon calendar',
           ))),
           'messagemenu');
 
         $this->api->output->add_label('calendar.createfrommail');
       }
 
       $this->add_hook('messages_list', array($this, 'mail_messages_list'));
       $this->add_hook('message_compose', array($this, 'mail_message_compose'));
     }
     else if ($args['task'] == 'addressbook') {
       if ($this->rc->config->get('calendar_contact_birthdays')) {
         $this->add_hook('contact_update', array($this, 'contact_update'));
         $this->add_hook('contact_create', array($this, 'contact_update'));
       }
     }
 
     // add hooks to display alarms
     $this->add_hook('pending_alarms', array($this, 'pending_alarms'));
     $this->add_hook('dismiss_alarms', array($this, 'dismiss_alarms'));
   }
 
   /**
    * Helper method to load the backend driver according to local config
    */
   private function load_driver()
   {
     if (is_object($this->driver))
       return;
 
     $driver_name = $this->rc->config->get('calendar_driver', 'database');
     $driver_class = $driver_name . '_driver';
 
     require_once($this->home . '/drivers/calendar_driver.php');
     require_once($this->home . '/drivers/' . $driver_name . '/' . $driver_class . '.php');
 
     $this->driver = new $driver_class($this);
 
     if ($this->driver->undelete)
       $this->driver->undelete = $this->rc->config->get('undo_timeout', 0) > 0;
   }
 
   /**
    * Load iTIP functions
    */
   private function load_itip()
   {
     if (!$this->itip) {
       require_once($this->home . '/lib/calendar_itip.php');
       $this->itip = new calendar_itip($this);
       
       if ($this->rc->config->get('kolab_invitation_calendars'))
         $this->itip->set_rsvp_actions(array('accepted','tentative','declined','delegated','needs-action'));
     }
 
     return $this->itip;
   }
 
   /**
    * Load iCalendar functions
    */
   public function get_ical()
   {
     if (!$this->ical) {
       $this->ical = libcalendaring::get_ical();
     }
     
     return $this->ical;
   }
 
   /**
    * Get properties of the calendar this user has specified as default
    */
   public function get_default_calendar($sensitivity = null)
   {
     $default_id = $this->rc->config->get('calendar_default_calendar');
     $calendars = $this->driver->list_calendars(calendar_driver::FILTER_PERSONAL | calendar_driver::FILTER_WRITEABLE);
     $calendar = $calendars[$default_id] ?: null;
     if (!$calendar || $sensitivity) {
       foreach ($calendars as $cal) {
         if ($sensitivity && $cal['subtype'] == $sensitivity) {
           $calendar = $cal;
           break;
         }
         if ($cal['default'] && $cal['editable']) {
           $calendar = $cal;
         }
         if ($cal['editable']) {
           $first = $cal;
         }
       }
     }
 
     return $calendar ?: $first;
   }
 
 
   /**
    * Render the main calendar view from skin template
    */
   function calendar_view()
   {
     $this->rc->output->set_pagetitle($this->gettext('calendar'));
 
     // Add CSS stylesheets to the page header
     $this->ui->addCSS();
 
     // Add JS files to the page header
     $this->ui->addJS();
 
     $this->ui->init_templates();
     $this->rc->output->add_label('lowest','low','normal','high','highest','delete','cancel','uploading','noemailwarning','close');
     $this->rc->output->add_label('libcalendaring.itipaccepted','libcalendaring.itiptentative','libcalendaring.itipdeclined','libcalendaring.itipdelegated','libcalendaring.expandattendeegroup','libcalendaring.expandattendeegroupnodata');
 
     // initialize attendees autocompletion
     $this->rc->autocomplete_init();
 
     $this->rc->output->set_env('timezone', $this->timezone->getName());
     $this->rc->output->set_env('calendar_driver', $this->rc->config->get('calendar_driver'), false);
     $this->rc->output->set_env('calendar_resources', (bool)$this->rc->config->get('calendar_resources_driver'));
     $this->rc->output->set_env('mscolors', jqueryui::get_color_values());
     $this->rc->output->set_env('identities-selector', $this->ui->identity_select(array('id' => 'edit-identities-list', 'aria-label' => $this->gettext('roleorganizer'))));
 
     $view = rcube_utils::get_input_value('view', rcube_utils::INPUT_GPC);
     if (in_array($view, array('agendaWeek', 'agendaDay', 'month', 'table')))
       $this->rc->output->set_env('view', $view);
 
     if ($date = rcube_utils::get_input_value('date', rcube_utils::INPUT_GPC))
       $this->rc->output->set_env('date', $date);
 
     if ($msgref = rcube_utils::get_input_value('itip', rcube_utils::INPUT_GPC))
       $this->rc->output->set_env('itip_events', $this->itip_events($msgref));
 
     $this->rc->output->send("calendar.calendar");
   }
 
   /**
    * Handler for preferences_sections_list hook.
    * Adds Calendar settings sections into preferences sections list.
    *
    * @param array Original parameters
    * @return array Modified parameters
    */
   function preferences_sections_list($p)
   {
     $p['list']['calendar'] = array(
       'id' => 'calendar', 'section' => $this->gettext('calendar'),
     );
 
     return $p;
   }
 
   /**
    * Handler for preferences_list hook.
    * Adds options blocks into Calendar settings sections in Preferences.
    *
    * @param array Original parameters
    * @return array Modified parameters
    */
   function preferences_list($p)
   {
     if ($p['section'] != 'calendar') {
       return $p;
     }
 
     $no_override = array_flip((array)$this->rc->config->get('dont_override'));
 
     $p['blocks']['view']['name'] = $this->gettext('mainoptions');
 
     if (!isset($no_override['calendar_default_view'])) {
       if (!$p['current']) {
         $p['blocks']['view']['content'] = true;
         return $p;
       }
 
       $field_id = 'rcmfd_default_view';
       $select = new html_select(array('name' => '_default_view', 'id' => $field_id));
       $select->add($this->gettext('day'), "agendaDay");
       $select->add($this->gettext('week'), "agendaWeek");
       $select->add($this->gettext('month'), "month");
       $select->add($this->gettext('agenda'), "table");
       $p['blocks']['view']['options']['default_view'] = array(
         'title' => html::label($field_id, rcube::Q($this->gettext('default_view'))),
         'content' => $select->show($this->rc->config->get('calendar_default_view', $this->defaults['calendar_default_view'])),
       );
     }
 
     if (!isset($no_override['calendar_timeslots'])) {
       if (!$p['current']) {
         $p['blocks']['view']['content'] = true;
         return $p;
       }
 
       $field_id = 'rcmfd_timeslot';
       $choices = array('1', '2', '3', '4', '6');
       $select = new html_select(array('name' => '_timeslots', 'id' => $field_id));
       $select->add($choices);
       $p['blocks']['view']['options']['timeslots'] = array(
         'title' => html::label($field_id, rcube::Q($this->gettext('timeslots'))),
         'content' => $select->show(strval($this->rc->config->get('calendar_timeslots', $this->defaults['calendar_timeslots']))),
       );
     }
 
     if (!isset($no_override['calendar_first_day'])) {
       if (!$p['current']) {
         $p['blocks']['view']['content'] = true;
         return $p;
       }
 
       $field_id = 'rcmfd_firstday';
       $select = new html_select(array('name' => '_first_day', 'id' => $field_id));
       $select->add($this->gettext('sunday'), '0');
       $select->add($this->gettext('monday'), '1');
       $select->add($this->gettext('tuesday'), '2');
       $select->add($this->gettext('wednesday'), '3');
       $select->add($this->gettext('thursday'), '4');
       $select->add($this->gettext('friday'), '5');
       $select->add($this->gettext('saturday'), '6');
       $p['blocks']['view']['options']['first_day'] = array(
         'title' => html::label($field_id, rcube::Q($this->gettext('first_day'))),
         'content' => $select->show(strval($this->rc->config->get('calendar_first_day', $this->defaults['calendar_first_day']))),
       );
     }
 
     if (!isset($no_override['calendar_first_hour'])) {
       if (!$p['current']) {
         $p['blocks']['view']['content'] = true;
         return $p;
       }
 
       $time_format = $this->rc->config->get('time_format', libcalendaring::to_php_date_format($this->rc->config->get('calendar_time_format', $this->defaults['calendar_time_format'])));
       $select_hours = new html_select();
       for ($h = 0; $h < 24; $h++)
         $select_hours->add(date($time_format, mktime($h, 0, 0)), $h);
 
       $field_id = 'rcmfd_firsthour';
       $p['blocks']['view']['options']['first_hour'] = array(
         'title' => html::label($field_id, rcube::Q($this->gettext('first_hour'))),
         'content' => $select_hours->show($this->rc->config->get('calendar_first_hour', $this->defaults['calendar_first_hour']), array('name' => '_first_hour', 'id' => $field_id)),
       );
     }
 
     if (!isset($no_override['calendar_work_start'])) {
       if (!$p['current']) {
         $p['blocks']['view']['content'] = true;
         return $p;
       }
 
       $field_id = 'rcmfd_workstart';
       $p['blocks']['view']['options']['workinghours'] = array(
         'title' => html::label($field_id, rcube::Q($this->gettext('workinghours'))),
         'content' => $select_hours->show($this->rc->config->get('calendar_work_start', $this->defaults['calendar_work_start']), array('name' => '_work_start', 'id' => $field_id)) .
         ' &mdash; ' . $select_hours->show($this->rc->config->get('calendar_work_end', $this->defaults['calendar_work_end']), array('name' => '_work_end', 'id' => $field_id)),
       );
     }
 
     if (!isset($no_override['calendar_event_coloring'])) {
       if (!$p['current']) {
         $p['blocks']['view']['content'] = true;
         return $p;
       }
 
       $field_id = 'rcmfd_coloring';
       $select_colors = new html_select(array('name' => '_event_coloring', 'id' => $field_id));
       $select_colors->add($this->gettext('coloringmode0'), 0);
       $select_colors->add($this->gettext('coloringmode1'), 1);
       $select_colors->add($this->gettext('coloringmode2'), 2);
       $select_colors->add($this->gettext('coloringmode3'), 3);
 
       $p['blocks']['view']['options']['eventcolors'] = array(
         'title' => html::label($field_id . 'value', rcube::Q($this->gettext('eventcoloring'))),
         'content' => $select_colors->show($this->rc->config->get('calendar_event_coloring', $this->defaults['calendar_event_coloring'])),
       );
     }
 
     // loading driver is expensive, don't do it if not needed
     $this->load_driver();
 
     if (!isset($no_override['calendar_default_alarm_type']) || !isset($no_override['calendar_default_alarm_offset'])) {
       if (!$p['current']) {
         $p['blocks']['view']['content'] = true;
         return $p;
       }
 
       $alarm_type = $alarm_offset = '';
 
       if (!isset($no_override['calendar_default_alarm_type'])) {
         $field_id    = 'rcmfd_alarm';
         $select_type = new html_select(array('name' => '_alarm_type', 'id' => $field_id));
         $select_type->add($this->gettext('none'), '');
 
         foreach ($this->driver->alarm_types as $type) {
           $select_type->add($this->rc->gettext(strtolower("alarm{$type}option"), 'libcalendaring'), $type);
         }
 
         $alarm_type = $select_type->show($this->rc->config->get('calendar_default_alarm_type', ''));
       }
 
       if (!isset($no_override['calendar_default_alarm_offset'])) {
         $field_id      = 'rcmfd_alarm';
         $input_value   = new html_inputfield(array('name' => '_alarm_value', 'id' => $field_id . 'value', 'size' => 3));
         $select_offset = new html_select(array('name' => '_alarm_offset', 'id' => $field_id . 'offset'));
 
         foreach (array('-M','-H','-D','+M','+H','+D') as $trigger) {
           $select_offset->add($this->rc->gettext('trigger' . $trigger, 'libcalendaring'), $trigger);
         }
 
         $preset = libcalendaring::parse_alarm_value($this->rc->config->get('calendar_default_alarm_offset', '-15M'));
         $alarm_offset = $input_value->show($preset[0]) . ' ' . $select_offset->show($preset[1]);
       }
 
       $p['blocks']['view']['options']['alarmtype'] = array(
         'title' => html::label($field_id, rcube::Q($this->gettext('defaultalarmtype'))),
         'content' => $alarm_type . ' ' . $alarm_offset,
       );
     }
 
     if (!isset($no_override['calendar_default_calendar'])) {
       if (!$p['current']) {
         $p['blocks']['view']['content'] = true;
         return $p;
       }
       // default calendar selection
       $field_id = 'rcmfd_default_calendar';
       $select_cal = new html_select(array('name' => '_default_calendar', 'id' => $field_id, 'is_escaped' => true));
       foreach ((array)$this->driver->list_calendars(calendar_driver::FILTER_PERSONAL) as $id => $prop) {
         $select_cal->add($prop['name'], strval($id));
         if ($prop['default'])
           $default_calendar = $id;
       }
       $p['blocks']['view']['options']['defaultcalendar'] = array(
         'title' => html::label($field_id . 'value', rcube::Q($this->gettext('defaultcalendar'))),
         'content' => $select_cal->show($this->rc->config->get('calendar_default_calendar', $default_calendar)),
       );
     }
 
     $p['blocks']['itip']['name'] = $this->gettext('itipoptions');
 
     // Invitations handling
     if (!isset($no_override['calendar_itip_after_action'])) {
       if (!$p['current']) {
         $p['blocks']['itip']['content'] = true;
         return $p;
       }
 
       $field_id = 'rcmfd_after_action';
       $select   = new html_select(array('name' => '_after_action', 'id' => $field_id,
         'onchange' => "\$('#{$field_id}_select')[this.value == 4 ? 'show' : 'hide']()"));
 
       $select->add($this->gettext('afternothing'), '');
       $select->add($this->gettext('aftertrash'), 1);
       $select->add($this->gettext('afterdelete'), 2);
       $select->add($this->gettext('afterflagdeleted'), 3);
       $select->add($this->gettext('aftermoveto'), 4);
 
       $val = $this->rc->config->get('calendar_itip_after_action', $this->defaults['calendar_itip_after_action']);
       if ($val !== null && $val !== '' && !is_int($val)) {
         $folder = $val;
         $val    = 4;
       }
 
       $folders = $this->rc->folder_selector(array(
           'id'            => $field_id . '_select',
           'name'          => '_after_action_folder',
           'maxlength'     => 30,
           'folder_filter' => 'mail',
           'folder_rights' => 'w',
           'style'         => $val !== 4 ? 'display:none' : '',
       ));
 
       $p['blocks']['itip']['options']['after_action'] = array(
         'title'   => html::label($field_id, rcube::Q($this->gettext('afteraction'))),
         'content' => $select->show($val) . $folders->show($folder),
       );
     }
 
     // category definitions
     if (!$this->driver->nocategories && !isset($no_override['calendar_categories'])) {
         $p['blocks']['categories']['name'] = $this->gettext('categories');
 
         if (!$p['current']) {
           $p['blocks']['categories']['content'] = true;
           return $p;
         }
 
         $categories = (array) $this->driver->list_categories();
         $categories_list = '';
         foreach ($categories as $name => $color) {
           $key = md5($name);
           $field_class = 'rcmfd_category_' . str_replace(' ', '_', $name);
           $category_remove = new html_inputfield(array('type' => 'button', 'value' => 'X', 'class' => 'button', 'onclick' => '$(this).parent().remove()', 'title' => $this->gettext('remove_category')));
           $category_name  = new html_inputfield(array('name' => "_categories[$key]", 'class' => $field_class, 'size' => 30, 'disabled' => $this->driver->categoriesimmutable));
           $category_color = new html_inputfield(array('name' => "_colors[$key]", 'class' => "$field_class colors", 'size' => 6));
           $hidden = $this->driver->categoriesimmutable ? html::tag('input', array('type' => 'hidden', 'name' => "_categories[$key]", 'value' => $name)) : '';
           $categories_list .= html::div(null, $hidden . $category_name->show($name) . '&nbsp;' . $category_color->show($color) . '&nbsp;' . $category_remove->show());
         }
 
         $p['blocks']['categories']['options']['category_' . $name] = array(
           'content' => html::div(array('id' => 'calendarcategories'), $categories_list),
         );
 
         $field_id = 'rcmfd_new_category';
         $new_category = new html_inputfield(array('name' => '_new_category', 'id' => $field_id, 'size' => 30));
         $add_category = new html_inputfield(array('type' => 'button', 'class' => 'button', 'value' => $this->gettext('add_category'),  'onclick' => "rcube_calendar_add_category()"));
         $p['blocks']['categories']['options']['categories'] = array(
           'content' => $new_category->show('') . '&nbsp;' . $add_category->show(),
         );
 
         $this->rc->output->add_script('function rcube_calendar_add_category(){
           var name = $("#rcmfd_new_category").val();
           if (name.length) {
             var input = $("<input>").attr("type", "text").attr("name", "_categories[]").attr("size", 30).val(name);
             var color = $("<input>").attr("type", "text").attr("name", "_colors[]").attr("size", 6).addClass("colors").val("000000");
             var button = $("<input>").attr("type", "button").attr("value", "X").addClass("button").click(function(){ $(this).parent().remove() });
             $("<div>").append(input).append("&nbsp;").append(color).append("&nbsp;").append(button).appendTo("#calendarcategories");
             color.miniColors({ colorValues:(rcmail.env.mscolors || []) });
             $("#rcmfd_new_category").val("");
           }
         }');
 
         $this->rc->output->add_script('$("#rcmfd_new_category").keypress(function(event){
           if (event.which == 13) {
             rcube_calendar_add_category();
             event.preventDefault();
           }
         });
         ', 'docready');
 
         // load miniColors js/css files
         jqueryui::miniColors();
     }
 
     // virtual birthdays calendar
     if (!isset($no_override['calendar_contact_birthdays'])) {
       $p['blocks']['birthdays']['name'] = $this->gettext('birthdayscalendar');
 
       if (!$p['current']) {
         $p['blocks']['birthdays']['content'] = true;
         return $p;
       }
 
       $field_id = 'rcmfd_contact_birthdays';
       $input    = new html_checkbox(array('name' => '_contact_birthdays', 'id' => $field_id, 'value' => 1, 'onclick' => '$(".calendar_birthday_props").prop("disabled",!this.checked)'));
 
       $p['blocks']['birthdays']['options']['contact_birthdays'] = array(
         'title'   => html::label($field_id, $this->gettext('displaybirthdayscalendar')),
         'content' => $input->show($this->rc->config->get('calendar_contact_birthdays')?1:0),
       );
 
       $input_attrib = array(
         'class' => 'calendar_birthday_props',
         'disabled' => !$this->rc->config->get('calendar_contact_birthdays'),
       );
 
       $sources = array();
       $checkbox = new html_checkbox(array('name' => '_birthday_adressbooks[]') + $input_attrib);
       foreach ($this->rc->get_address_sources(false, true) as $source) {
         $active = in_array($source['id'], (array)$this->rc->config->get('calendar_birthday_adressbooks', array())) ? $source['id'] : '';
         $sources[] = html::label(null, $checkbox->show($active, array('value' => $source['id'])) . '&nbsp;' . rcube::Q($source['realname'] ?: $source['name']));
       }
 
       $p['blocks']['birthdays']['options']['birthday_adressbooks'] = array(
         'title'   => rcube::Q($this->gettext('birthdayscalendarsources')),
         'content' => join(html::br(), $sources),
       );
 
       $field_id = 'rcmfd_birthdays_alarm';
       $select_type = new html_select(array('name' => '_birthdays_alarm_type', 'id' => $field_id) + $input_attrib);
       $select_type->add($this->gettext('none'), '');
       foreach ($this->driver->alarm_types as $type) {
         $select_type->add($this->rc->gettext(strtolower("alarm{$type}option"), 'libcalendaring'), $type);
       }
 
       $input_value = new html_inputfield(array('name' => '_birthdays_alarm_value', 'id' => $field_id . 'value', 'size' => 3) + $input_attrib);
       $select_offset = new html_select(array('name' => '_birthdays_alarm_offset', 'id' => $field_id . 'offset') + $input_attrib);
       foreach (array('-M','-H','-D') as $trigger)
         $select_offset->add($this->rc->gettext('trigger' . $trigger, 'libcalendaring'), $trigger);
 
       $preset = libcalendaring::parse_alarm_value($this->rc->config->get('calendar_birthdays_alarm_offset', '-1D'));
       $p['blocks']['birthdays']['options']['birthdays_alarmoffset'] = array(
         'title' => html::label($field_id . 'value', rcube::Q($this->gettext('showalarms'))),
         'content' => $select_type->show($this->rc->config->get('calendar_birthdays_alarm_type', '')) . ' ' . $input_value->show($preset[0]) . '&nbsp;' . $select_offset->show($preset[1]),
       );
     }
 
     return $p;
   }
 
   /**
    * Handler for preferences_save hook.
    * Executed on Calendar settings form submit.
    *
    * @param array Original parameters
    * @return array Modified parameters
    */
   function preferences_save($p)
   {
     if ($p['section'] == 'calendar') {
       $this->load_driver();
 
       // compose default alarm preset value
       $alarm_offset  = rcube_utils::get_input_value('_alarm_offset', rcube_utils::INPUT_POST);
       $alarm_value   = rcube_utils::get_input_value('_alarm_value', rcube_utils::INPUT_POST);
       $default_alarm = $alarm_offset[0] . intval($alarm_value) . $alarm_offset[1];
 
       $birthdays_alarm_offset = rcube_utils::get_input_value('_birthdays_alarm_offset', rcube_utils::INPUT_POST);
       $birthdays_alarm_value  = rcube_utils::get_input_value('_birthdays_alarm_value', rcube_utils::INPUT_POST);
       $birthdays_alarm_value  = $birthdays_alarm_offset[0] . intval($birthdays_alarm_value) . $birthdays_alarm_offset[1];
 
       $p['prefs'] = array(
         'calendar_default_view' => rcube_utils::get_input_value('_default_view', rcube_utils::INPUT_POST),
         'calendar_timeslots'    => intval(rcube_utils::get_input_value('_timeslots', rcube_utils::INPUT_POST)),
         'calendar_first_day'    => intval(rcube_utils::get_input_value('_first_day', rcube_utils::INPUT_POST)),
         'calendar_first_hour'   => intval(rcube_utils::get_input_value('_first_hour', rcube_utils::INPUT_POST)),
         'calendar_work_start'   => intval(rcube_utils::get_input_value('_work_start', rcube_utils::INPUT_POST)),
         'calendar_work_end'     => intval(rcube_utils::get_input_value('_work_end', rcube_utils::INPUT_POST)),
         'calendar_event_coloring'       => intval(rcube_utils::get_input_value('_event_coloring', rcube_utils::INPUT_POST)),
         'calendar_default_alarm_type'   => rcube_utils::get_input_value('_alarm_type', rcube_utils::INPUT_POST),
         'calendar_default_alarm_offset' => $default_alarm,
         'calendar_default_calendar'     => rcube_utils::get_input_value('_default_calendar', rcube_utils::INPUT_POST),
         'calendar_date_format' => null,  // clear previously saved values
         'calendar_time_format' => null,
         'calendar_contact_birthdays'    => rcube_utils::get_input_value('_contact_birthdays', rcube_utils::INPUT_POST) ? true : false,
         'calendar_birthday_adressbooks' => (array) rcube_utils::get_input_value('_birthday_adressbooks', rcube_utils::INPUT_POST),
         'calendar_birthdays_alarm_type'   => rcube_utils::get_input_value('_birthdays_alarm_type', rcube_utils::INPUT_POST),
         'calendar_birthdays_alarm_offset' => $birthdays_alarm_value ?: null,
         'calendar_itip_after_action'      => intval(rcube_utils::get_input_value('_after_action', rcube_utils::INPUT_POST)),
       );
 
       if ($p['prefs']['calendar_itip_after_action'] == 4) {
         $p['prefs']['calendar_itip_after_action'] = rcube_utils::get_input_value('_after_action_folder', rcube_utils::INPUT_POST, true);
       }
 
       // categories
       if (!$this->driver->nocategories) {
         $old_categories = $new_categories = array();
         foreach ($this->driver->list_categories() as $name => $color) {
           $old_categories[md5($name)] = $name;
         }
 
         $categories = (array) rcube_utils::get_input_value('_categories', rcube_utils::INPUT_POST);
         $colors     = (array) rcube_utils::get_input_value('_colors', rcube_utils::INPUT_POST);
 
         foreach ($categories as $key => $name) {
           $color = preg_replace('/^#/', '', strval($colors[$key]));
 
           // rename categories in existing events -> driver's job
           if ($oldname = $old_categories[$key]) {
             $this->driver->replace_category($oldname, $name, $color);
             unset($old_categories[$key]);
           }
           else
             $this->driver->add_category($name, $color);
 
           $new_categories[$name] = $color;
         }
 
         // these old categories have been removed, alter events accordingly -> driver's job
         foreach ((array)$old_categories[$key] as $key => $name) {
           $this->driver->remove_category($name);
         }
 
         $p['prefs']['calendar_categories'] = $new_categories;
       }
     }
 
     return $p;
   }
 
   /**
    * Dispatcher for calendar actions initiated by the client
    */
   function calendar_action()
   {
     $action = rcube_utils::get_input_value('action', rcube_utils::INPUT_GPC);
     $cal    = rcube_utils::get_input_value('c', rcube_utils::INPUT_GPC);
     $success = $reload = false;
 
     if (isset($cal['showalarms']))
       $cal['showalarms'] = intval($cal['showalarms']);
 
     switch ($action) {
       case "form-new":
       case "form-edit":
         echo $this->ui->calendar_editform($action, $cal);
         exit;
       case "new":
         $success = $this->driver->create_calendar($cal);
         $reload = true;
         break;
       case "edit":
         $success = $this->driver->edit_calendar($cal);
         $reload = true;
         break;
       case "delete":
         if ($success = $this->driver->delete_calendar($cal))
           $this->rc->output->command('plugin.destroy_source', array('id' => $cal['id']));
         break;
       case "subscribe":
         if (!$this->driver->subscribe_calendar($cal))
           $this->rc->output->show_message($this->gettext('errorsaving'), 'error');
         return;
       case "search":
         $results    = array();
         $color_mode = $this->rc->config->get('calendar_event_coloring', $this->defaults['calendar_event_coloring']);
         $query      = rcube_utils::get_input_value('q', rcube_utils::INPUT_GPC);
         $source     = rcube_utils::get_input_value('source', rcube_utils::INPUT_GPC);
 
         foreach ((array) $this->driver->search_calendars($query, $source) as $id => $prop) {
           $editname = $prop['editname'];
           unset($prop['editname']);  // force full name to be displayed
           $prop['active'] = false;
 
           // let the UI generate HTML and CSS representation for this calendar
           $html = $this->ui->calendar_list_item($id, $prop, $jsenv);
           $cal = $jsenv[$id];
           $cal['editname'] = $editname;
           $cal['html'] = $html;
           if (!empty($prop['color']))
             $cal['css'] = $this->ui->calendar_css_classes($id, $prop, $color_mode);
 
           $results[] = $cal;
         }
         // 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;
     }
     
     if ($success)
       $this->rc->output->show_message('successfullysaved', 'confirmation');
     else {
       $error_msg = $this->gettext('errorsaving') . ($this->driver->last_error ? ': ' . $this->driver->last_error :'');
       $this->rc->output->show_message($error_msg, 'error');
     }
 
     $this->rc->output->command('plugin.unlock_saving');
 
     if ($success && $reload)
       $this->rc->output->command('plugin.reload_view');
   }
   
   
   /**
    * Dispatcher for event actions initiated by the client
    */
   function event_action()
   {
     $action = rcube_utils::get_input_value('action', rcube_utils::INPUT_GPC);
     $event  = rcube_utils::get_input_value('e', rcube_utils::INPUT_POST, true);
     $success = $reload = $got_msg = false;
     
     // force notify if hidden + active
     if ((int)$this->rc->config->get('calendar_itip_send_option', $this->defaults['calendar_itip_send_option']) === 1)
       $event['_notify'] = 1;
 
     // read old event data in order to find changes
     if (($event['_notify'] || $event['_decline']) && $action != 'new') {
       $old = $this->driver->get_event($event);
 
       // load main event if savemode is 'all' or if deleting 'future' events
       if (($event['_savemode'] == 'all' || ($event['_savemode'] == 'future' && $action == 'remove' && !$event['_decline'])) && $old['recurrence_id']) {
         $old['id'] = $old['recurrence_id'];
         $old = $this->driver->get_event($old);
       }
     }
 
     switch ($action) {
       case "new":
         // create UID for new event
         $event['uid'] = $this->generate_uid();
         $this->write_preprocess($event, $action);
         if ($success = $this->driver->new_event($event)) {
           $event['id'] = $event['uid'];
           $event['_savemode'] = 'all';
           $this->cleanup_event($event);
           $this->event_save_success($event, null, $action, true);
         }
         $reload = $success && $event['recurrence'] ? 2 : 1;
         break;
         
       case "edit":
         $this->write_preprocess($event, $action);
         if ($success = $this->driver->edit_event($event)) {
           $this->cleanup_event($event);
           $this->event_save_success($event, $old, $action, $success);
         }
         $reload = $success && ($event['recurrence'] || $event['_savemode'] || $event['_fromcalendar']) ? 2 : 1;
         break;
       
       case "resize":
         $this->write_preprocess($event, $action);
         if ($success = $this->driver->resize_event($event)) {
           $this->event_save_success($event, $old, $action, $success);
         }
         $reload = $event['_savemode'] ? 2 : 1;
         break;
       
       case "move":
         $this->write_preprocess($event, $action);
         if ($success = $this->driver->move_event($event)) {
           $this->event_save_success($event, $old, $action, $success);
         }
         $reload  = $success && $event['_savemode'] ? 2 : 1;
         break;
       
       case "remove":
         // remove previous deletes
         $undo_time = $this->driver->undelete ? $this->rc->config->get('undo_timeout', 0) : 0;
         $this->rc->session->remove('calendar_event_undo');
         
         // search for event if only UID is given
         if (!isset($event['calendar']) && $event['uid']) {
           if (!($event = $this->driver->get_event($event, calendar_driver::FILTER_WRITEABLE))) {
             break;
           }
           $undo_time = 0;
         }
 
         $success = $this->driver->remove_event($event, $undo_time < 1);
         $reload = (!$success || $event['_savemode']) ? 2 : 1;
 
         if ($undo_time > 0 && $success) {
           $_SESSION['calendar_event_undo'] = array('ts' => time(), 'data' => $event);
           // display message with Undo link.
           $msg = html::span(null, $this->gettext('successremoval'))
             . ' ' . html::a(array('onclick' => sprintf("%s.http_request('event', 'action=undo', %s.display_message('', 'loading'))",
               rcmail_output::JS_OBJECT_NAME, rcmail_output::JS_OBJECT_NAME)), $this->gettext('undo'));
           $this->rc->output->show_message($msg, 'confirmation', null, true, $undo_time);
           $got_msg = true;
         }
         else if ($success) {
           $this->rc->output->show_message('calendar.successremoval', 'confirmation');
           $got_msg = true;
         }
 
         // send cancellation for the main event
         if ($event['_savemode'] == 'all') {
           unset($old['_instance'], $old['recurrence_date'], $old['recurrence_id']);
         }
         // send an update for the main event's recurrence rule instead of a cancellation message
         else if ($event['_savemode'] == 'future' && $success !== false && $success !== true) {
           $event['_savemode'] = 'all';  // force event_save_success() to load master event
           $action = 'edit';
           $success = true;
         }
 
         // send iTIP reply that participant has declined the event
         if ($success && $event['_decline']) {
           $emails = $this->get_user_emails();
           foreach ($old['attendees'] as $i => $attendee) {
             if ($attendee['role'] == 'ORGANIZER')
               $organizer = $attendee;
             else if ($attendee['email'] && in_array(strtolower($attendee['email']), $emails)) {
               $old['attendees'][$i]['status'] = 'DECLINED';
               $reply_sender = $attendee['email'];
             }
           }
 
           if ($event['_savemode'] == 'future' && $event['id'] != $old['id']) {
             $old['thisandfuture'] = true;
           }
 
           $itip = $this->load_itip();
           $itip->set_sender_email($reply_sender);
           if ($organizer && $itip->send_itip_message($old, 'REPLY', $organizer, 'itipsubjectdeclined', 'itipmailbodydeclined'))
             $this->rc->output->command('display_message', $this->gettext(array('name' => 'sentresponseto', 'vars' => array('mailto' => $organizer['name'] ? $organizer['name'] : $organizer['email']))), 'confirmation');
           else
             $this->rc->output->command('display_message', $this->gettext('itipresponseerror'), 'error');
         }
         else if ($success) {
           $this->event_save_success($event, $old, $action, $success);
         }
         break;
 
       case "undo":
         // Restore deleted event
         $event  = $_SESSION['calendar_event_undo']['data'];
 
         if ($event)
           $success = $this->driver->restore_event($event);
 
         if ($success) {
           $this->rc->session->remove('calendar_event_undo');
           $this->rc->output->show_message('calendar.successrestore', 'confirmation');
           $got_msg = true;
           $reload = 2;
         }
 
         break;
 
       case "rsvp":
         $itip_sending  = $this->rc->config->get('calendar_itip_send_option', $this->defaults['calendar_itip_send_option']);
         $status        = rcube_utils::get_input_value('status', rcube_utils::INPUT_POST);
         $attendees     = rcube_utils::get_input_value('attendees', rcube_utils::INPUT_POST);
         $reply_comment = $event['comment'];
 
         $this->write_preprocess($event, 'edit');
         $ev = $this->driver->get_event($event);
         $ev['attendees'] = $event['attendees'];
         $ev['free_busy'] = $event['free_busy'];
         $ev['_savemode'] = $event['_savemode'];
 
         // send invitation to delegatee + add it as attendee
         if ($status == 'delegated' && $event['to']) {
           $itip = $this->load_itip();
           if ($itip->delegate_to($ev, $event['to'], (bool)$event['rsvp'], $attendees)) {
             $this->rc->output->show_message('calendar.itipsendsuccess', 'confirmation');
             $noreply = false;
           }
         }
 
         $event = $ev;
 
         // compose a list of attendees affected by this change
         $updated_attendees = array_filter(array_map(function($j) use ($event) {
           return $event['attendees'][$j];
         }, $attendees));
 
         if ($success = $this->driver->edit_rsvp($event, $status, $updated_attendees)) {
           $noreply = rcube_utils::get_input_value('noreply', rcube_utils::INPUT_GPC);
           $noreply = intval($noreply) || $status == 'needs-action' || $itip_sending === 0;
           $reload  = $event['calendar'] != $ev['calendar'] || $event['recurrence'] ? 2 : 1;
           $organizer = null;
           $emails = $this->get_user_emails();
 
           foreach ($event['attendees'] as $i => $attendee) {
             if ($attendee['role'] == 'ORGANIZER') {
               $organizer = $attendee;
             }
             else if ($attendee['email'] && in_array(strtolower($attendee['email']), $emails)) {
               $reply_sender = $attendee['email'];
             }
           }
 
           if (!$noreply) {
             $itip = $this->load_itip();
             $itip->set_sender_email($reply_sender);
             $event['comment'] = $reply_comment;
             $event['thisandfuture'] = $event['_savemode'] == 'future';
             if ($organizer && $itip->send_itip_message($event, 'REPLY', $organizer, 'itipsubject' . $status, 'itipmailbody' . $status))
               $this->rc->output->command('display_message', $this->gettext(array('name' => 'sentresponseto', 'vars' => array('mailto' => $organizer['name'] ? $organizer['name'] : $organizer['email']))), 'confirmation');
             else
               $this->rc->output->command('display_message', $this->gettext('itipresponseerror'), 'error');
           }
 
           // refresh all calendars
           if ($event['calendar'] != $ev['calendar']) {
             $this->rc->output->command('plugin.refresh_calendar', array('source' => null, 'refetch' => true));
             $reload = 0;
           }
         }
         break;
 
       case "dismiss":
         $event['ids'] = explode(',', $event['id']);
         $plugin = $this->rc->plugins->exec_hook('dismiss_alarms', $event);
         $success = $plugin['success'];
         foreach ($event['ids'] as $id) {
             if (strpos($id, 'cal:') === 0)
                 $success |= $this->driver->dismiss_alarm(substr($id, 4), $event['snooze']);
         }
         break;
 
       case "changelog":
         $data = $this->driver->get_event_changelog($event);
         if (is_array($data) && !empty($data)) {
           $lib = $this->lib;
           $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 = $lib->adjust_timezone($change['date']);
               if ($dt instanceof DateTime)
                 $change['date'] = $this->rc->format_date($dt, $dtformat, false);
             }
           });
           $this->rc->output->command('plugin.render_event_changelog', $data);
         }
         else {
           $this->rc->output->command('plugin.render_event_changelog', false);
         }
         $got_msg = true;
         $reload = false;
         break;
 
       case "diff":
         $data = $this->driver->get_event_diff($event, $event['rev1'], $event['rev2']);
         if (is_array($data)) {
           // convert some properties, similar to self::_client_event()
           $lib = $this->lib;
           array_walk($data['changes'], function(&$change, $i) use ($event, $lib) {
             // convert date cols
             foreach (array('start','end','created','changed') as $col) {
               if ($change['property'] == $col) {
                 $change['old'] = $lib->adjust_timezone($change['old'], strlen($change['old']) == 10)->format('c');
                 $change['new'] = $lib->adjust_timezone($change['new'], strlen($change['new']) == 10)->format('c');
               }
             }
             // create textual representation for alarms and recurrence
             if ($change['property'] == 'alarms') {
               if (is_array($change['old']))
                 $change['old_'] = libcalendaring::alarm_text($change['old']);
               if (is_array($change['new']))
                 $change['new_'] = libcalendaring::alarm_text(array_merge((array)$change['old'], $change['new']));
             }
             if ($change['property'] == 'recurrence') {
               if (is_array($change['old']))
                 $change['old_'] = $lib->recurrence_text($change['old']);
               if (is_array($change['new']))
                 $change['new_'] = $lib->recurrence_text(array_merge((array)$change['old'], $change['new']));
             }
             if ($change['property'] == 'attachments') {
               if (is_array($change['old']))
                 $change['old']['classname'] = rcube_utils::file2class($change['old']['mimetype'], $change['old']['name']);
               if (is_array($change['new']))
                 $change['new']['classname'] = rcube_utils::file2class($change['new']['mimetype'], $change['new']['name']);
             }
             // compute a nice diff of description texts
             if ($change['property'] == 'description') {
               $change['diff_'] = libkolab::html_diff($change['old'], $change['new']);
             }
           });
           $this->rc->output->command('plugin.event_show_diff', $data);
         }
         else {
           $this->rc->output->command('display_message', $this->gettext('objectdiffnotavailable'), 'error');
         }
         $got_msg = true;
         $reload = false;
         break;
 
       case "show":
         if ($event = $this->driver->get_event_revison($event, $event['rev'])) {
           $this->rc->output->command('plugin.event_show_revision', $this->_client_event($event));
         }
         else {
           $this->rc->output->command('display_message', $this->gettext('objectnotfound'), 'error');
         }
         $got_msg = true;
         $reload = false;
         break;
 
       case "restore":
         if ($success = $this->driver->restore_event_revision($event, $event['rev'])) {
           $_event = $this->driver->get_event($event);
           $reload = $_event['recurrence'] ? 2 : 1;
           $this->rc->output->command('display_message', $this->gettext(array('name' => 'objectrestoresuccess', 'vars' => array('rev' => $event['rev']))), 'confirmation');
           $this->rc->output->command('plugin.close_history_dialog');
         }
         else {
           $this->rc->output->command('display_message', $this->gettext('objectrestoreerror'), 'error');
           $reload = 0;
         }
         $got_msg = true;
         break;
     }
 
     // show confirmation/error message
     if (!$got_msg) {
       if ($success)
         $this->rc->output->show_message('successfullysaved', 'confirmation');
       else
         $this->rc->output->show_message('calendar.errorsaving', 'error');
     }
 
     // unlock client
     $this->rc->output->command('plugin.unlock_saving');
 
     // update event object on the client or trigger a complete refretch if too complicated
     if ($reload) {
       $args = array('source' => $event['calendar']);
       if ($reload > 1)
         $args['refetch'] = true;
       else if ($success && $action != 'remove')
         $args['update'] = $this->_client_event($this->driver->get_event($event), true);
       $this->rc->output->command('plugin.refresh_calendar', $args);
     }
   }
 
   /**
    * Helper method sending iTip notifications after successful event updates
    */
   private function event_save_success(&$event, $old, $action, $success)
   {
     // $success is a new event ID
     if ($success !== true) {
       // send update notification on the main event
       if ($event['_savemode'] == 'future' && $event['_notify'] && $old['attendees'] && $old['recurrence_id']) {
         $master = $this->driver->get_event(array('id' => $old['recurrence_id'], 'calendar' => $old['calendar']), 0, true);
         unset($master['_instance'], $master['recurrence_date']);
 
         $sent = $this->notify_attendees($master, null, $action, $event['_comment'], false);
         if ($sent < 0)
           $this->rc->output->show_message('calendar.errornotifying', 'error');
 
         $event['attendees'] = $master['attendees'];  // this tricks us into the next if clause
       }
 
       // delete old reference if saved as new
       if ($event['_savemode'] == 'future' || $event['_savemode'] == 'new') {
         $old = null;
       }
 
       $event['id'] = $success;
       $event['_savemode'] = 'all';
     }
 
     // send out notifications
     if ($event['_notify'] && ($event['attendees'] || $old['attendees'])) {
       $_savemode = $event['_savemode'];
 
       // send notification for the main event when savemode is 'all'
       if ($action != 'remove' && $_savemode == 'all' && ($event['recurrence_id'] || $old['recurrence_id'] || ($old && $old['id'] != $event['id']))) {
         $event['id'] = $event['recurrence_id'] ?: ($old['recurrence_id'] ?: $old['id']);
         $event = $this->driver->get_event($event, 0, true);
         unset($event['_instance'], $event['recurrence_date']);
       }
       else {
         // make sure we have the complete record
         $event = $action == 'remove' ? $old : $this->driver->get_event($event, 0, true);
       }
 
       $event['_savemode'] = $_savemode;
 
       if ($old) {
         $old['thisandfuture'] = $_savemode == 'future';
       }
 
       // only notify if data really changed (TODO: do diff check on client already)
       if (!$old || $action == 'remove' || self::event_diff($event, $old)) {
         $sent = $this->notify_attendees($event, $old, $action, $event['_comment']);
         if ($sent > 0)
           $this->rc->output->show_message('calendar.itipsendsuccess', 'confirmation');
         else if ($sent < 0)
           $this->rc->output->show_message('calendar.errornotifying', 'error');
       }
     }
   }
 
   /**
    * Handler for load-requests from fullcalendar
    * This will return pure JSON formatted output
    */
   function load_events()
   {
     $events = $this->driver->load_events(
       rcube_utils::get_input_value('start', rcube_utils::INPUT_GET),
       rcube_utils::get_input_value('end', rcube_utils::INPUT_GET),
       ($query = rcube_utils::get_input_value('q', rcube_utils::INPUT_GET)),
       rcube_utils::get_input_value('source', rcube_utils::INPUT_GET)
     );
     echo $this->encode($events, !empty($query));
     exit;
   }
 
   /**
    * Handler for requests fetching event counts for calendars
    */
   public function count_events()
   {
     // don't update session on these requests (avoiding race conditions)
     $this->rc->session->nowrite = true;
 
     $start = rcube_utils::get_input_value('start', rcube_utils::INPUT_GET);
     if (!$start) {
       $start = new DateTime('today 00:00:00', $this->timezone);
       $start = $start->format('U');
     }
 
     $counts = $this->driver->count_events(
       rcube_utils::get_input_value('source', rcube_utils::INPUT_GET),
       $start,
       rcube_utils::get_input_value('end', rcube_utils::INPUT_GET)
     );
 
     $this->rc->output->command('plugin.update_counts', array('counts' => $counts));
   }
 
   /**
    * Load event data from an iTip message attachment
    */
   public function itip_events($msgref)
   {
     $path = explode('/', $msgref);
     $msg = array_pop($path);
     $mbox = join('/', $path);
     list($uid, $mime_id) = explode('#', $msg);
     $events = array();
 
     if ($event = $this->lib->mail_get_itip_object($mbox, $uid, $mime_id, 'event')) {
       $partstat = 'NEEDS-ACTION';
 /*
       $user_emails = $this->lib->get_user_emails();
       foreach ($event['attendees'] as $attendee) {
         if (in_array($attendee['email'], $user_emails)) {
           $partstat = $attendee['status'];
           break;
         }
       }
 */
       $event['id'] = $event['uid'];
       $event['temporary'] = true;
       $event['readonly'] = true;
       $event['calendar'] = '--invitation--itip';
       $event['className'] = 'fc-invitation-' . strtolower($partstat);
       $event['_mbox'] = $mbox;
       $event['_uid']  = $uid;
       $event['_part'] = $mime_id;
 
       $events[] = $this->_client_event($event, true);
 
       // add recurring instances
       if (!empty($event['recurrence'])) {
         foreach ($this->driver->get_recurring_events($event, $event['start']) as $recurring) {
           $recurring['temporary'] = true;
           $recurring['readonly'] = true;
           $recurring['calendar'] = '--invitation--itip';
           $events[] = $this->_client_event($recurring, true);
         }
       }
     }
 
     return $events;
   }
 
   /**
    * Handler for keep-alive requests
    * This will check for updated data in active calendars and sync them to the client
    */
   public function refresh($attr)
   {
      // refresh the entire calendar every 10th time to also sync deleted events
     if (rand(0,10) == 10) {
         $this->rc->output->command('plugin.refresh_calendar', array('refetch' => true));
         return;
     }
 
     $counts = array();
 
     foreach ($this->driver->list_calendars(calendar_driver::FILTER_ACTIVE) as $cal) {
       $events = $this->driver->load_events(
         rcube_utils::get_input_value('start', rcube_utils::INPUT_GPC),
         rcube_utils::get_input_value('end', rcube_utils::INPUT_GPC),
         rcube_utils::get_input_value('q', rcube_utils::INPUT_GPC),
         $cal['id'],
         1,
         $attr['last']
       );
 
       foreach ($events as $event) {
         $this->rc->output->command('plugin.refresh_calendar',
           array('source' => $cal['id'], 'update' => $this->_client_event($event)));
       }
 
       // refresh count for this calendar
       if ($cal['counts']) {
         $today = new DateTime('today 00:00:00', $this->timezone);
         $counts += $this->driver->count_events($cal['id'], $today->format('U'));
       }
     }
 
     if (!empty($counts)) {
       $this->rc->output->command('plugin.update_counts', array('counts' => $counts));
     }
   }
 
   /**
    * Handler for pending_alarms plugin hook triggered by the calendar module on keep-alive requests.
    * This will check for pending notifications and pass them to the client
    */
   public function pending_alarms($p)
   {
     $this->load_driver();
     $time = $p['time'] ?: time();
     if ($alarms = $this->driver->pending_alarms($time)) {
       foreach ($alarms as $alarm) {
         $alarm['id'] = 'cal:' . $alarm['id'];  // prefix ID with cal:
         $p['alarms'][] = $alarm;
       }
     }
 
     // get alarms for birthdays calendar
     if ($this->rc->config->get('calendar_contact_birthdays') && $this->rc->config->get('calendar_birthdays_alarm_type') == 'DISPLAY') {
       $cache = $this->rc->get_cache('calendar.birthdayalarms', 'db');
 
       foreach ($this->driver->load_birthday_events($time, $time + 86400 * 60) as $e) {
         $alarm = libcalendaring::get_next_alarm($e);
 
         // overwrite alarm time with snooze value (or null if dismissed)
         if ($dismissed = $cache->get($e['id']))
           $alarm['time'] = $dismissed['notifyat'];
 
         // add to list if alarm is set
         if ($alarm && $alarm['time'] && $alarm['time'] <= $time) {
           $e['id'] = 'cal:bday:' . $e['id'];
           $e['notifyat'] = $alarm['time'];
           $p['alarms'][] = $e;
         }
       }
     }
 
     return $p;
   }
 
   /**
    * Handler for alarm dismiss hook triggered by libcalendaring
    */
   public function dismiss_alarms($p)
   {
       $this->load_driver();
       foreach ((array)$p['ids'] as $id) {
           if (strpos($id, 'cal:bday:') === 0) {
               $p['success'] |= $this->driver->dismiss_birthday_alarm(substr($id, 9), $p['snooze']);
           }
           else if (strpos($id, 'cal:') === 0) {
               $p['success'] |= $this->driver->dismiss_alarm(substr($id, 4), $p['snooze']);
           }
       }
 
       return $p;
   }
 
   /**
    * Handler for check-recent requests which are accidentally sent to calendar
    */
   function check_recent()
   {
     // NOP
     $this->rc->output->send();
   }
 
   /**
    * Hook triggered when a contact is saved
    */
   function contact_update($p)
   {
     // clear birthdays calendar cache
     if (!empty($p['record']['birthday'])) {
       $cache = $this->rc->get_cache('calendar.birthdays', 'db');
       $cache->remove();
     }
   }
 
   /**
    *
    */
   function import_events()
   {
     // Upload progress update
     if (!empty($_GET['_progress'])) {
       $this->rc->upload_progress();
     }
 
     @set_time_limit(0);
 
     // process uploaded file if there is no error
     $err = $_FILES['_data']['error'];
 
     if (!$err && $_FILES['_data']['tmp_name']) {
       $calendar   = rcube_utils::get_input_value('calendar', rcube_utils::INPUT_GPC);
       $rangestart = $_REQUEST['_range'] ? date_create("now -" . intval($_REQUEST['_range']) . " months") : 0;
 
       // extract zip file
       if ($_FILES['_data']['type'] == 'application/zip') {
         $count = 0;
         if (class_exists('ZipArchive', false)) {
           $zip = new ZipArchive();
           if ($zip->open($_FILES['_data']['tmp_name'])) {
             $randname = uniqid('zip-' . session_id(), true);
             $tmpdir = slashify($this->rc->config->get('temp_dir', sys_get_temp_dir())) . $randname;
             mkdir($tmpdir, 0700);
 
             // extract each ical file from the archive and import it
             for ($i = 0; $i < $zip->numFiles; $i++) { 
               $filename = $zip->getNameIndex($i);
               if (preg_match('/\.ics$/i', $filename)) {
                 $tmpfile = $tmpdir . '/' . basename($filename);
                 if (copy('zip://' . $_FILES['_data']['tmp_name'] . '#'.$filename, $tmpfile)) {
                   $count += $this->import_from_file($tmpfile, $calendar, $rangestart, $errors);
                   unlink($tmpfile);
                 }
               }
             }
 
             rmdir($tmpdir);
             $zip->close();
           }
           else {
             $errors = 1;
             $msg = 'Failed to open zip file.';
           }
         }
         else {
           $errors = 1;
           $msg = 'Zip files are not supported for import.';
         }
       }
       else {
         // attempt to import teh uploaded file directly
         $count = $this->import_from_file($_FILES['_data']['tmp_name'], $calendar, $rangestart, $errors);
       }
 
       if ($count) {
         $this->rc->output->command('display_message', $this->gettext(array('name' => 'importsuccess', 'vars' => array('nr' => $count))), 'confirmation');
         $this->rc->output->command('plugin.import_success', array('source' => $calendar, 'refetch' => true));
       }
       else if (!$errors) {
         $this->rc->output->command('display_message', $this->gettext('importnone'), 'notice');
         $this->rc->output->command('plugin.import_success', array('source' => $calendar));
       }
       else {
         $this->rc->output->command('plugin.import_error', array('message' => $this->gettext('importerror') . ($msg ? ': ' . $msg : '')));
       }
     }
     else {
       if ($err == UPLOAD_ERR_INI_SIZE || $err == UPLOAD_ERR_FORM_SIZE) {
         $msg = $this->gettext(array('name' => 'filesizeerror', 'vars' => array(
             'size' => $this->rc->show_bytes(parse_bytes(ini_get('upload_max_filesize'))))));
       }
       else {
         $msg = $this->gettext('fileuploaderror');
       }
 
       $this->rc->output->command('plugin.import_error', array('message' => $msg));
     }
 
     $this->rc->output->send('iframe');
   }
 
   /**
    * Helper function to parse and import a single .ics file
    */
   private function import_from_file($filepath, $calendar, $rangestart, &$errors)
   {
     $user_email = $this->rc->user->get_username();
 
     $ical = $this->get_ical();
     $errors = !$ical->fopen($filepath);
     $count = $i = 0;
     foreach ($ical as $event) {
       // keep the browser connection alive on long import jobs
       if (++$i > 100 && $i % 100 == 0) {
           echo "<!-- -->";
           ob_flush();
       }
 
       // TODO: correctly handle recurring events which start before $rangestart
       if ($event['end'] < $rangestart && (!$event['recurrence'] || ($event['recurrence']['until'] && $event['recurrence']['until'] < $rangestart)))
         continue;
 
       $event['_owner'] = $user_email;
       $event['calendar'] = $calendar;
       if ($this->driver->new_event($event)) {
         $count++;
       }
       else {
         $errors++;
       }
     }
 
     return $count;
   }
 
 
   /**
    * Construct the ics file for exporting events to iCalendar format;
    */
   function export_events($terminate = true)
   {
     $start = rcube_utils::get_input_value('start', rcube_utils::INPUT_GET);
     $end   = rcube_utils::get_input_value('end', rcube_utils::INPUT_GET);
 
     if (!isset($start))
       $start = 'today -1 year';
     if (!is_numeric($start))
       $start = strtotime($start . ' 00:00:00');
     if (!$end)
       $end = 'today +10 years';
     if (!is_numeric($end))
       $end = strtotime($end . ' 23:59:59');
 
     $event_id    = rcube_utils::get_input_value('id', rcube_utils::INPUT_GET);
     $attachments = rcube_utils::get_input_value('attachments', rcube_utils::INPUT_GET);
     $calid = $filename = rcube_utils::get_input_value('source', rcube_utils::INPUT_GET);
 
     $calendars = $this->driver->list_calendars();
     $events = array();
 
     if ($calendars[$calid]) {
       $filename = $calendars[$calid]['name'] ? $calendars[$calid]['name'] : $calid;
       $filename = asciiwords(html_entity_decode($filename));  // to 7bit ascii
       if (!empty($event_id)) {
         if ($event = $this->driver->get_event(array('calendar' => $calid, 'id' => $event_id), 0, true)) {
           if ($event['recurrence_id']) {
             $event = $this->driver->get_event(array('calendar' => $calid, 'id' => $event['recurrence_id']), 0, true);
           }
           $events = array($event);
           $filename = asciiwords($event['title']);
           if (empty($filename))
             $filename = 'event';
         }
       }
       else {
          $events = $this->driver->load_events($start, $end, null, $calid, 0);
          if (empty($filename))
            $filename = $calid;
       }
     }
 
     header("Content-Type: text/calendar");
     header("Content-Disposition: inline; filename=".$filename.'.ics');
 
     $this->get_ical()->export($events, '', true, $attachments ? array($this->driver, 'get_attachment_body') : null);
 
     if ($terminate)
       exit;
   }
 
 
   /**
    * Handler for iCal feed requests
    */
   function ical_feed_export()
   {
     $session_exists = !empty($_SESSION['user_id']);
 
     // process HTTP auth info
     if (!empty($_SERVER['PHP_AUTH_USER']) && isset($_SERVER['PHP_AUTH_PW'])) {
       $_POST['_user'] = $_SERVER['PHP_AUTH_USER']; // used for rcmail::autoselect_host()
       $auth = $this->rc->plugins->exec_hook('authenticate', array(
         'host' => $this->rc->autoselect_host(),
         'user' => trim($_SERVER['PHP_AUTH_USER']),
         'pass' => $_SERVER['PHP_AUTH_PW'],
         'cookiecheck' => true,
         'valid' => true,
       ));
       if ($auth['valid'] && !$auth['abort'])
         $this->rc->login($auth['user'], $auth['pass'], $auth['host']);
     }
 
     // require HTTP auth
     if (empty($_SESSION['user_id'])) {
       header('WWW-Authenticate: Basic realm="Roundcube Calendar"');
       header('HTTP/1.0 401 Unauthorized');
       exit;
     }
 
     // decode calendar feed hash
     $format = 'ics';
     $calhash = rcube_utils::get_input_value('_cal', rcube_utils::INPUT_GET);
     if (preg_match(($suff_regex = '/\.([a-z0-9]{3,5})$/i'), $calhash, $m)) {
       $format = strtolower($m[1]);
       $calhash = preg_replace($suff_regex, '', $calhash);
     }
 
     if (!strpos($calhash, ':'))
       $calhash = base64_decode($calhash);
 
     list($user, $_GET['source']) = explode(':', $calhash, 2);
 
     // sanity check user
     if ($this->rc->user->get_username() == $user) {
       $this->load_driver();
       $this->export_events(false);
     }
     else {
       header('HTTP/1.0 404 Not Found');
     }
 
     // don't save session data
     if (!$session_exists)
       session_destroy();
     exit;
   }
 
 
   /**
    *
    */
   function load_settings()
   {
     $this->lib->load_settings();
     $this->defaults += $this->lib->defaults;
 
     $settings = array();
 
     // configuration
     $settings['default_calendar'] = $this->rc->config->get('calendar_default_calendar');
     $settings['default_view'] = (string)$this->rc->config->get('calendar_default_view', $this->defaults['calendar_default_view']);
     $settings['date_agenda'] = (string)$this->rc->config->get('calendar_date_agenda', $this->defaults['calendar_date_agenda']);
 
     $settings['timeslots'] = (int)$this->rc->config->get('calendar_timeslots', $this->defaults['calendar_timeslots']);
     $settings['first_day'] = (int)$this->rc->config->get('calendar_first_day', $this->defaults['calendar_first_day']);
     $settings['first_hour'] = (int)$this->rc->config->get('calendar_first_hour', $this->defaults['calendar_first_hour']);
     $settings['work_start'] = (int)$this->rc->config->get('calendar_work_start', $this->defaults['calendar_work_start']);
     $settings['work_end'] = (int)$this->rc->config->get('calendar_work_end', $this->defaults['calendar_work_end']);
     $settings['agenda_range'] = (int)$this->rc->config->get('calendar_agenda_range', $this->defaults['calendar_agenda_range']);
     $settings['agenda_sections'] = $this->rc->config->get('calendar_agenda_sections', $this->defaults['calendar_agenda_sections']);
     $settings['event_coloring'] = (int)$this->rc->config->get('calendar_event_coloring', $this->defaults['calendar_event_coloring']);
     $settings['time_indicator'] = (int)$this->rc->config->get('calendar_time_indicator', $this->defaults['calendar_time_indicator']);
     $settings['invite_shared'] = (int)$this->rc->config->get('calendar_allow_invite_shared', $this->defaults['calendar_allow_invite_shared']);
     $settings['invitation_calendars'] = (bool)$this->rc->config->get('kolab_invitation_calendars', false);
     $settings['itip_notify'] = (int)$this->rc->config->get('calendar_itip_send_option', $this->defaults['calendar_itip_send_option']);
 
     // get user identity to create default attendee
     if ($this->ui->screen == 'calendar') {
       foreach ($this->rc->user->list_emails() as $rec) {
         if (!$identity)
           $identity = $rec;
         $identity['emails'][] = $rec['email'];
         $settings['identities'][$rec['identity_id']] = $rec['email'];
       }
       $identity['emails'][] = $this->rc->user->get_username();
       $settings['identity'] = array('name' => $identity['name'], 'email' => strtolower($identity['email']), 'emails' => ';' . strtolower(join(';', $identity['emails'])));
     }
 
     return $settings;
   }
 
   /**
    * Encode events as JSON
    *
    * @param  array  Events as array
    * @param  boolean Add CSS class names according to calendar and categories
    * @return string JSON encoded events
    */
   function encode($events, $addcss = false)
   {
     $json = array();
     foreach ($events as $event) {
       $json[] = $this->_client_event($event, $addcss);
     }
     return json_encode($json);
   }
 
   /**
    * Convert an event object to be used on the client
    */
   private function _client_event($event, $addcss = false)
   {
     // compose a human readable strings for alarms_text and recurrence_text
     if ($event['valarms']) {
       $event['alarms_text'] = libcalendaring::alarms_text($event['valarms']);
       $event['valarms'] = libcalendaring::to_client_alarms($event['valarms']);
     }
     if ($event['recurrence']) {
       $event['recurrence_text'] = $this->lib->recurrence_text($event['recurrence']);
       $event['recurrence'] = $this->lib->to_client_recurrence($event['recurrence'], $event['allday']);
       unset($event['recurrence_date']);
     }
 
     foreach ((array)$event['attachments'] as $k => $attachment) {
       $event['attachments'][$k]['classname'] = rcube_utils::file2class($attachment['mimetype'], $attachment['name']);
     }
 
     // convert link URIs references into structs
     if (array_key_exists('links', $event)) {
-      foreach ((array)$event['links'] as $i => $link) {
-        if (strpos($link, 'imap://') === 0 && ($msgref = $this->driver->get_message_reference($link))) {
-          $event['links'][$i] = $msgref;
+        foreach ((array) $event['links'] as $i => $link) {
+            if (strpos($link, 'imap://') === 0 && ($msgref = $this->driver->get_message_reference($link))) {
+                $event['links'][$i] = $msgref;
+            }
         }
-      }
     }
 
     // check for organizer in attendees list
     $organizer = null;
     foreach ((array)$event['attendees'] as $i => $attendee) {
       if ($attendee['role'] == 'ORGANIZER') {
         $organizer = $attendee;
       }
       if ($attendee['status'] == 'DELEGATED' && $attendee['rsvp'] == false) {
         $event['attendees'][$i]['noreply'] = true;
       }
       else {
         unset($event['attendees'][$i]['noreply']);
       }
     }
 
     if ($organizer === null && !empty($event['organizer'])) {
       $organizer = $event['organizer'];
       $organizer['role'] = 'ORGANIZER';
       if (!is_array($event['attendees']))
         $event['attendees'] = array();
       array_unshift($event['attendees'], $organizer);
     }
 
     // Convert HTML description into plain text
     if ($this->is_html($event)) {
       $h2t = new rcube_html2text($event['description'], false, true, 0);
       $event['description'] = trim($h2t->get_text());
     }
 
     // mapping url => vurl because of the fullcalendar client script
     $event['vurl'] = $event['url'];
     unset($event['url']);
 
     return array(
       '_id'   => $event['calendar'] . ':' . $event['id'],  // unique identifier for fullcalendar
       'start' => $this->lib->adjust_timezone($event['start'], $event['allday'])->format('c'),
       'end'   => $this->lib->adjust_timezone($event['end'], $event['allday'])->format('c'),
       // 'changed' might be empty for event recurrences (Bug #2185)
       'changed' => $event['changed'] ? $this->lib->adjust_timezone($event['changed'])->format('c') : null,
       'created' => $event['created'] ? $this->lib->adjust_timezone($event['created'])->format('c') : null,
       'title'       => strval($event['title']),
       'description' => strval($event['description']),
       'location'    => strval($event['location']),
       'className'   => ($addcss ? 'fc-event-cal-'.asciiwords($event['calendar'], true).' ' : '') .
           'fc-event-cat-' . asciiwords(strtolower(join('-', (array)$event['categories'])), true) .
           rtrim(' ' . $event['className']),
       'allDay'      => ($event['allday'] == 1),
     ) + $event;
   }
 
 
   /**
    * Generate a unique identifier for an event
    */
   public function generate_uid()
   {
     return strtoupper(md5(time() . uniqid(rand())) . '-' . substr(md5($this->rc->user->get_username()), 0, 16));
   }
 
 
   /**
    * TEMPORARY: generate random event data for testing
    * Create events by opening http://<roundcubeurl>/?_task=calendar&_action=randomdata&_num=500&_date=2014-08-01&_dev=120
    */
   public function generate_randomdata()
   {
     @set_time_limit(0);
 
     $num   = $_REQUEST['_num'] ? intval($_REQUEST['_num']) : 100;
     $date  = $_REQUEST['_date'] ?: 'now';
     $dev   = $_REQUEST['_dev'] ?: 30;
     $cats  = array_keys($this->driver->list_categories());
     $cals  = $this->driver->list_calendars(calendar_driver::FILTER_ACTIVE);
     $count = 0;
 
     while ($count++ < $num) {
       $spread = intval($dev) * 86400; // days
       $refdate = strtotime($date);
       $start = round(($refdate + rand(-$spread, $spread)) / 600) * 600;
       $duration = round(rand(30, 360) / 30) * 30 * 60;
       $allday = rand(0,20) > 18;
       $alarm = rand(-30,12) * 5;
       $fb = rand(0,2);
       
       if (date('G', $start) > 23)
         $start -= 3600;
       
       if ($allday) {
         $start = strtotime(date('Y-m-d 00:00:00', $start));
         $duration = 86399;
       }
       
       $title = '';
       $len = rand(2, 12);
       $words = explode(" ", "The Hough transform is named after Paul Hough who patented the method in 1962. It is a technique which can be used to isolate features of a particular shape within an image. Because it requires that the desired features be specified in some parametric form, the classical Hough transform is most commonly used for the de- tection of regular curves such as lines, circles, ellipses, etc. A generalized Hough transform can be employed in applications where a simple analytic description of a feature(s) is not possible. Due to the computational complexity of the generalized Hough algorithm, we restrict the main focus of this discussion to the classical Hough transform. Despite its domain restrictions, the classical Hough transform (hereafter referred to without the classical prefix ) retains many applications, as most manufac- tured parts (and many anatomical parts investigated in medical imagery) contain feature boundaries which can be described by regular curves. The main advantage of the Hough transform technique is that it is tolerant of gaps in feature boundary descriptions and is relatively unaffected by image noise.");
 //      $chars = "!# abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890";
       for ($i = 0; $i < $len; $i++)
         $title .= $words[rand(0,count($words)-1)] . " ";
       
       $this->driver->new_event(array(
         'uid' => $this->generate_uid(),
         'start' => new DateTime('@'.$start),
         'end' => new DateTime('@'.($start + $duration)),
         'allday' => $allday,
         'title' => rtrim($title),
         'free_busy' => $fb == 2 ? 'outofoffice' : ($fb ? 'busy' : 'free'),
         'categories' => $cats[array_rand($cats)],
         'calendar' => array_rand($cals),
         'alarms' => $alarm > 0 ? "-{$alarm}M:DISPLAY" : '',
         'priority' => rand(0,9),
       ));
     }
     
     $this->rc->output->redirect('');
   }
 
   /**
    * Handler for attachments upload
    */
   public function attachment_upload()
   {
     $this->lib->attachment_upload(self::SESSION_KEY, 'cal-');
   }
 
   /**
    * Handler for attachments download/displaying
    */
   public function attachment_get()
   {
     // show loading page
     if (!empty($_GET['_preload'])) {
         return $this->lib->attachment_loading_page();
     }
 
     $event_id = rcube_utils::get_input_value('_event', rcube_utils::INPUT_GPC);
     $calendar = rcube_utils::get_input_value('_cal', rcube_utils::INPUT_GPC);
     $id       = rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC);
     $rev      = rcube_utils::get_input_value('_rev', rcube_utils::INPUT_GPC);
 
     $event = array('id' => $event_id, 'calendar' => $calendar, 'rev' => $rev);
     $attachment = $this->driver->get_attachment($id, $event);
 
     // show part page
     if (!empty($_GET['_frame'])) {
         $this->lib->attachment = $attachment;
         $this->register_handler('plugin.attachmentframe', array($this->lib, 'attachment_frame'));
         $this->register_handler('plugin.attachmentcontrols', array($this->lib, 'attachment_header'));
         $this->rc->output->send('calendar.attachment');
     }
     // deliver attachment content
     else if ($attachment) {
         $attachment['body'] = $this->driver->get_attachment_body($id, $event);
         $this->lib->attachment_get($attachment);
     }
 
     // if we arrive here, the requested part was not found
     header('HTTP/1.1 404 Not Found');
     exit;
   }
 
   /**
    * Determine whether the given event description is HTML formatted
    */
   private function is_html($event)
   {
       // check for opening and closing <html> or <body> tags
       return (preg_match('/<(html|body)(\s+[a-z]|>)/', $event['description'], $m) && strpos($event['description'], '</'.$m[1].'>') > 0);
   }
 
   /**
    * Prepares new/edited event properties before save
    */
   private function write_preprocess(&$event, $action)
   {
     // convert dates into DateTime objects in user's current timezone
     $event['start'] = new DateTime($event['start'], $this->timezone);
     $event['end'] = new DateTime($event['end'], $this->timezone);
     $event['allday'] = (bool)$event['allday'];
 
     // start/end is all we need for 'move' action (#1480)
     if ($action == 'move') {
       return;
     }
 
     // convert the submitted recurrence settings
     if (is_array($event['recurrence'])) {
       $event['recurrence'] = $this->lib->from_client_recurrence($event['recurrence'], $event['start']);
     }
 
     // convert the submitted alarm values
     if ($event['valarms']) {
       $event['valarms'] = libcalendaring::from_client_alarms($event['valarms']);
     }
 
     $attachments = array();
     $eventid     = 'cal-'.$event['id'];
 
     if (is_array($_SESSION[self::SESSION_KEY]) && $_SESSION[self::SESSION_KEY]['id'] == $eventid) {
       if (!empty($_SESSION[self::SESSION_KEY]['attachments'])) {
         foreach ($_SESSION[self::SESSION_KEY]['attachments'] as $id => $attachment) {
           if (is_array($event['attachments']) && in_array($id, $event['attachments'])) {
             $attachments[$id] = $this->rc->plugins->exec_hook('attachment_get', $attachment);
           }
         }
       }
     }
 
     $event['attachments'] = $attachments;
 
     // convert link references into simple URIs
     if (array_key_exists('links', $event)) {
       $event['links'] = array_map(function($link) {
           return is_array($link) ? $link['uri'] : strval($link);
         }, (array)$event['links']);
     }
 
     // check for organizer in attendees
     if ($action == 'new' || $action == 'edit') {
       if (!$event['attendees'])
         $event['attendees'] = array();
 
       $emails = $this->get_user_emails();
       $organizer = $owner = false;
       foreach ((array)$event['attendees'] as $i => $attendee) {
         if ($attendee['role'] == 'ORGANIZER')
           $organizer = $i;
         if ($attendee['email'] == in_array(strtolower($attendee['email']), $emails))
           $owner = $i;
         if (!isset($attendee['rsvp']))
           $event['attendees'][$i]['rsvp'] = true;
         else if (is_string($attendee['rsvp']))
           $event['attendees'][$i]['rsvp'] = $attendee['rsvp'] == 'true' || $attendee['rsvp'] == '1';
       }
 
       // set new organizer identity
       if ($organizer !== false && !empty($event['_identity']) && ($identity = $this->rc->user->get_identity($event['_identity']))) {
         $event['attendees'][$organizer]['name'] = $identity['name'];
         $event['attendees'][$organizer]['email'] = $identity['email'];
       }
 
       // set owner as organizer if yet missing
       if ($organizer === false && $owner !== false) {
         $event['attendees'][$owner]['role'] = 'ORGANIZER';
         unset($event['attendees'][$owner]['rsvp']);
       }
     }
 
     // mapping url => vurl because of the fullcalendar client script
     if (array_key_exists('vurl', $event)) {
       $event['url'] = $event['vurl'];
       unset($event['vurl']);
     }
   }
 
   /**
    * Releases some resources after successful event save
    */
   private function cleanup_event(&$event)
   {
     // remove temp. attachment files
     if (!empty($_SESSION[self::SESSION_KEY]) && ($eventid = $_SESSION[self::SESSION_KEY]['id'])) {
       $this->rc->plugins->exec_hook('attachments_cleanup', array('group' => $eventid));
       $this->rc->session->remove(self::SESSION_KEY);
     }
   }
 
   /**
    * Send out an invitation/notification to all event attendees
    */
   private function notify_attendees($event, $old, $action = 'edit', $comment = null, $rsvp = null)
   {
     if ($action == 'remove' || ($event['status'] == 'CANCELLED' && $old['status'] != $event['status'])) {
       $event['cancelled'] = true;
       $is_cancelled = true;
     }
 
     if ($rsvp === null)
       $rsvp = !$old || $event['sequence'] > $old['sequence'];
 
     $itip = $this->load_itip();
     $emails = $this->get_user_emails();
     $itip_notify = (int)$this->rc->config->get('calendar_itip_send_option', $this->defaults['calendar_itip_send_option']);
 
     // add comment to the iTip attachment
     $event['comment'] = $comment;
 
     // set a valid recurrence-id if this is a recurrence instance
     libcalendaring::identify_recurrence_instance($event);
 
     // compose multipart message using PEAR:Mail_Mime
     $method = $action == 'remove' ? 'CANCEL' : 'REQUEST';
     $message = $itip->compose_itip_message($event, $method, $rsvp);
 
     // list existing attendees from $old event
     $old_attendees = array();
     foreach ((array)$old['attendees'] as $attendee) {
       $old_attendees[] = $attendee['email'];
     }
 
     // send to every attendee
     $sent = 0; $current = array();
     foreach ((array)$event['attendees'] as $attendee) {
       $current[] = strtolower($attendee['email']);
       
       // skip myself for obvious reasons
       if (!$attendee['email'] || in_array(strtolower($attendee['email']), $emails))
         continue;
 
       // skip if notification is disabled for this attendee
       if ($attendee['noreply'] && $itip_notify & 2)
         continue;
 
       // skip if this attendee has delegated and set RSVP=FALSE
       if ($attendee['status'] == 'DELEGATED' && $attendee['rsvp'] === false)
         continue;
 
       // which template to use for mail text
       $is_new = !in_array($attendee['email'], $old_attendees);
       $is_rsvp = $is_new || $event['sequence'] > $old['sequence'];
       $bodytext = $is_cancelled ? 'eventcancelmailbody' : ($is_new ? 'invitationmailbody' : 'eventupdatemailbody');
       $subject  = $is_cancelled ? 'eventcancelsubject'  : ($is_new ? 'invitationsubject' : ($event['title'] ? 'eventupdatesubject':'eventupdatesubjectempty'));
 
       $event['comment'] = $comment;
 
       // finally send the message
       if ($itip->send_itip_message($event, $method, $attendee, $subject, $bodytext, $message, $is_rsvp))
         $sent++;
       else
         $sent = -100;
     }
 
     // TODO: on change of a recurring (main) event, also send updates to differing attendess of recurrence exceptions
 
     // send CANCEL message to removed attendees
     foreach ((array)$old['attendees'] as $attendee) {
       if ($attendee['role'] == 'ORGANIZER' || !$attendee['email'] || in_array(strtolower($attendee['email']), $current))
         continue;
 
       $vevent = $old;
       $vevent['cancelled'] = $is_cancelled;
       $vevent['attendees'] = array($attendee);
       $vevent['comment']   = $comment;
       if ($itip->send_itip_message($vevent, 'CANCEL', $attendee, 'eventcancelsubject', 'eventcancelmailbody'))
         $sent++;
       else
         $sent = -100;
     }
 
     return $sent;
   }
 
   /**
    * Echo simple free/busy status text for the given user and time range
    */
   public function freebusy_status()
   {
     $email = rcube_utils::get_input_value('email', rcube_utils::INPUT_GPC);
     $start = rcube_utils::get_input_value('start', rcube_utils::INPUT_GPC);
     $end   = rcube_utils::get_input_value('end', rcube_utils::INPUT_GPC);
 
     // convert dates into unix timestamps
     if (!empty($start) && !is_numeric($start)) {
       $dts = new DateTime($start, $this->timezone);
       $start = $dts->format('U');
     }
     if (!empty($end) && !is_numeric($end)) {
       $dte = new DateTime($end, $this->timezone);
       $end = $dte->format('U');
     }
     
     if (!$start) $start = time();
     if (!$end) $end = $start + 3600;
     
     $fbtypemap = array(calendar::FREEBUSY_UNKNOWN => 'UNKNOWN', calendar::FREEBUSY_FREE => 'FREE', calendar::FREEBUSY_BUSY => 'BUSY', calendar::FREEBUSY_TENTATIVE => 'TENTATIVE', calendar::FREEBUSY_OOF => 'OUT-OF-OFFICE');
     $status = 'UNKNOWN';
     
     // if the backend has free-busy information
     $fblist = $this->driver->get_freebusy_list($email, $start, $end);
     if (is_array($fblist)) {
       $status = 'FREE';
       
       foreach ($fblist as $slot) {
         list($from, $to, $type) = $slot;
         if ($from < $end && $to > $start) {
           $status = isset($type) && $fbtypemap[$type] ? $fbtypemap[$type] : 'BUSY';
           break;
         }
       }
     }
     
     // let this information be cached for 5min
     $this->rc->output->future_expire_header(300);
     
     echo $status;
     exit;
   }
   
   /**
    * Return a list of free/busy time slots within the given period
    * Echo data in JSON encoding
    */
   public function freebusy_times()
   {
     $email = rcube_utils::get_input_value('email', rcube_utils::INPUT_GPC);
     $start = rcube_utils::get_input_value('start', rcube_utils::INPUT_GPC);
     $end   = rcube_utils::get_input_value('end', rcube_utils::INPUT_GPC);
     $interval  = intval(rcube_utils::get_input_value('interval', rcube_utils::INPUT_GPC));
     $strformat = $interval > 60 ? 'Ymd' : 'YmdHis';
 
     // convert dates into unix timestamps
     if (!empty($start) && !is_numeric($start)) {
       $dts = rcube_utils::anytodatetime($start, $this->timezone);
       $start = $dts ? $dts->format('U') : null;
     }
     if (!empty($end) && !is_numeric($end)) {
       $dte = rcube_utils::anytodatetime($end, $this->timezone);
       $end = $dte ? $dte->format('U') : null;
     }
 
     if (!$start) $start = time();
     if (!$end)   $end = $start + 86400 * 30;
     if (!$interval) $interval = 60;  // 1 hour
     
     if (!$dte) {
       $dts = new DateTime('@'.$start);
       $dts->setTimezone($this->timezone);
     }
     
     $fblist = $this->driver->get_freebusy_list($email, $start, $end);
     $slots = array();
     
     // build a list from $start till $end with blocks representing the fb-status
     for ($s = 0, $t = $start; $t <= $end; $s++) {
       $status = self::FREEBUSY_UNKNOWN;
       $t_end = $t + $interval * 60;
       $dt = new DateTime('@'.$t);
       $dt->setTimezone($this->timezone);
 
       // determine attendee's status
       if (is_array($fblist)) {
         $status = self::FREEBUSY_FREE;
         foreach ($fblist as $slot) {
           list($from, $to, $type) = $slot;
 
           // check for possible all-day times
           if (gmdate('His', $from) == '000000' && gmdate('His', $to) == '235959') {
               // shift into the user's timezone for sane matching
               $from -= $this->gmt_offset;
               $to   -= $this->gmt_offset;
           }
 
           if ($from < $t_end && $to > $t) {
             $status = isset($type) ? $type : self::FREEBUSY_BUSY;
             if ($status == self::FREEBUSY_BUSY)  // can't get any worse :-)
               break;
           }
         }
       }
       
       $slots[$s] = $status;
       $times[$s] = intval($dt->format($strformat));
       $t = $t_end;
     }
     
     $dte = new DateTime('@'.$t_end);
     $dte->setTimezone($this->timezone);
     
     // let this information be cached for 5min
     $this->rc->output->future_expire_header(300);
     
     echo json_encode(array(
       'email' => $email,
       'start' => $dts->format('c'),
       'end'   => $dte->format('c'),
       'interval' => $interval,
       'slots' => $slots,
       'times' => $times,
     ));
     exit;
   }
 
   /**
    * Handler for printing calendars
    */
   public function print_view()
   {
     $title = $this->gettext('print');
 
     $view = rcube_utils::get_input_value('view', rcube_utils::INPUT_GPC);
     if (!in_array($view, array('agendaWeek', 'agendaDay', 'month', 'table')))
       $view = 'agendaDay';
 
     $this->rc->output->set_env('view',$view);
 
     if ($date = rcube_utils::get_input_value('date', rcube_utils::INPUT_GPC))
       $this->rc->output->set_env('date', $date);
 
     if ($range = rcube_utils::get_input_value('range', rcube_utils::INPUT_GPC))
       $this->rc->output->set_env('listRange', intval($range));
 
     if (isset($_REQUEST['sections']))
       $this->rc->output->set_env('listSections', rcube_utils::get_input_value('sections', rcube_utils::INPUT_GPC));
 
     if ($search = rcube_utils::get_input_value('search', rcube_utils::INPUT_GPC)) {
       $this->rc->output->set_env('search', $search);
       $title .= ' "' . $search . '"';
     }
 
     // Add CSS stylesheets to the page header
     $skin_path = $this->local_skin_path();
     $this->include_stylesheet($skin_path . '/fullcalendar.css');
     $this->include_stylesheet($skin_path . '/print.css');
     
     // Add JS files to the page header
     $this->include_script('print.js');
     $this->include_script('lib/js/fullcalendar.js');
     
     $this->register_handler('plugin.calendar_css', array($this->ui, 'calendar_css'));
     $this->register_handler('plugin.calendar_list', array($this->ui, 'calendar_list'));
     
     $this->rc->output->set_pagetitle($title);
     $this->rc->output->send("calendar.print");
   }
 
   /**
    *
    */
   public function get_inline_ui()
   {
     foreach (array('save','cancel','savingdata') as $label)
       $texts['calendar.'.$label] = $this->gettext($label);
     
     $texts['calendar.new_event'] = $this->gettext('createfrommail');
     
     $this->ui->init_templates();
     $this->ui->calendar_list();  # set env['calendars']
     echo $this->api->output->parse('calendar.eventedit', false, false);
     echo html::tag('script', array('type' => 'text/javascript'),
       "rcmail.set_env('calendars', " . json_encode($this->api->output->env['calendars']) . ");\n".
       "rcmail.set_env('deleteicon', '" . $this->api->output->env['deleteicon'] . "');\n".
       "rcmail.set_env('cancelicon', '" . $this->api->output->env['cancelicon'] . "');\n".
       "rcmail.set_env('loadingicon', '" . $this->api->output->env['loadingicon'] . "');\n".
       "rcmail.gui_object('attachmentlist', '"  . $this->ui->attachmentlist_id . "');\n".
       "rcmail.add_label(" . json_encode($texts) . ");\n"
     );
     exit;
   }
 
   /**
    * Compare two event objects and return differing properties
    *
    * @param array Event A
    * @param array Event B
    * @return array List of differing event properties
    */
   public static function event_diff($a, $b)
   {
     $diff = array();
     $ignore = array('changed' => 1, 'attachments' => 1);
     foreach (array_unique(array_merge(array_keys($a), array_keys($b))) as $key) {
       if (!$ignore[$key] && $key[0] != '_' && $a[$key] != $b[$key])
         $diff[] = $key;
     }
     
     // only compare number of attachments
     if (count($a['attachments']) != count($b['attachments']))
       $diff[] = 'attachments';
     
     return $diff;
   }
 
   /**
    * Update attendee properties on the given event object
    *
    * @param array The event object to be altered
    * @param array List of hash arrays each represeting an updated/added attendee
    */
   public static function merge_attendee_data(&$event, $attendees, $removed = null)
   {
     if (!empty($attendees) && !is_array($attendees[0])) {
       $attendees = array($attendees);
     }
 
     foreach ($attendees as $attendee) {
       $found = false;
 
       foreach ($event['attendees'] as $i => $candidate) {
         if ($candidate['email'] == $attendee['email']) {
           $event['attendees'][$i] = $attendee;
           $found = true;
           break;
         }
       }
 
       if (!$found) {
         $event['attendees'][] = $attendee;
       }
     }
 
     // filter out removed attendees
     if (!empty($removed)) {
       $event['attendees'] = array_filter($event['attendees'], function($attendee) use ($removed) {
         return !in_array($attendee['email'], $removed);
       });
     }
   }
 
 
   /****  Resource management functions  ****/
 
   /**
    * Getter for the configured implementation of the resource directory interface
    */
   private function resources_directory()
   {
     if (is_object($this->resources_dir)) {
       return $this->resources_dir;
     }
 
     if ($driver_name = $this->rc->config->get('calendar_resources_driver')) {
       $driver_class = 'resources_driver_' . $driver_name;
 
       require_once($this->home . '/drivers/resources_driver.php');
       require_once($this->home . '/drivers/' . $driver_name . '/' . $driver_class . '.php');
 
       $this->resources_dir = new $driver_class($this);
     }
 
     return $this->resources_dir;
   }
 
   /**
    * Handler for resoruce autocompletion requests
    */
   public function resources_autocomplete()
   {
     $search = rcube_utils::get_input_value('_search', rcube_utils::INPUT_GPC, true);
     $sid    = rcube_utils::get_input_value('_reqid', rcube_utils::INPUT_GPC);
     $maxnum = (int)$this->rc->config->get('autocomplete_max', 15);
     $results = array();
 
     if ($directory = $this->resources_directory()) {
       foreach ($directory->load_resources($search, $maxnum) as $rec) {
         $results[]  = array(
             'name'  => $rec['name'],
             'email' => $rec['email'],
             'type'  => $rec['_type'],
         );
       }
     }
 
     $this->rc->output->command('ksearch_query_results', $results, $search, $sid);
     $this->rc->output->send();
   }
 
   /**
    * Handler for load-requests for resource data
    */
   function resources_list()
   {
     $data = array();
 
     if ($directory = $this->resources_directory()) {
       foreach ($directory->load_resources() as $rec) {
         $data[] = $rec;
       }
     }
 
     $this->rc->output->command('plugin.resource_data', $data);
     $this->rc->output->send();
   }
 
   /**
    * Handler for requests loading resource owner information
    */
   function resources_owner()
   {
     if ($directory = $this->resources_directory()) {
       $id = rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC);
       $data = $directory->get_resource_owner($id);
     }
 
     $this->rc->output->command('plugin.resource_owner', $data);
     $this->rc->output->send();
   }
 
   /**
    * Deliver event data for a resource's calendar
    */
   function resources_calendar()
   {
     $events = array();
 
     if ($directory = $this->resources_directory()) {
       $events = $directory->get_resource_calendar(
         rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC),
         rcube_utils::get_input_value('start', rcube_utils::INPUT_GET),
         rcube_utils::get_input_value('end', rcube_utils::INPUT_GET));
     }
 
     echo $this->encode($events);
     exit;
   }
 
 
   /****  Event invitation plugin hooks ****/
 
   /**
    * Handler for calendar/itip-status requests
    */
   function event_itip_status()
   {
     $data = rcube_utils::get_input_value('data', rcube_utils::INPUT_POST, true);
 
     // find local copy of the referenced event
     $this->load_driver();
     $existing = $this->driver->get_event($data, calendar_driver::FILTER_WRITEABLE | calendar_driver::FILTER_PERSONAL);
 
     $itip = $this->load_itip();
     $response = $itip->get_itip_status($data, $existing);
 
     // get a list of writeable calendars to save new events to
     if (!$existing && !$data['nosave'] && $response['action'] == 'rsvp' || $response['action'] == 'import') {
       $calendars = $this->driver->list_calendars(calendar_driver::FILTER_PERSONAL);
       $calendar_select = new html_select(array('name' => 'calendar', 'id' => 'itip-saveto', 'is_escaped' => true));
       $calendar_select->add('--', '');
       $numcals = 0;
       foreach ($calendars as $calendar) {
         if ($calendar['editable']) {
           $calendar_select->add($calendar['name'], $calendar['id']);
           $numcals++;
         }
       }
       if ($numcals <= 1)
         $calendar_select = null;
     }
 
     if ($calendar_select) {
       $default_calendar = $this->get_default_calendar($data['sensitivity']);
       $response['select'] = html::span('folder-select', $this->gettext('saveincalendar') . '&nbsp;' .
         $calendar_select->show($default_calendar['id']));
     }
     else if ($data['nosave']) {
       $response['select'] = html::tag('input', array('type' => 'hidden', 'name' => 'calendar', 'id' => 'itip-saveto', 'value' => ''));
     }
 
     // render small agenda view for the respective day
     if ($data['method'] == 'REQUEST' && !empty($data['date']) && $response['action'] == 'rsvp') {
       $event_start = rcube_utils::anytodatetime($data['date']);
       $day_start = new Datetime(gmdate('Y-m-d 00:00', $data['date']), $this->lib->timezone);
       $day_end = new Datetime(gmdate('Y-m-d 23:59', $data['date']), $this->lib->timezone);
 
       // get events on that day from the user's personal calendars
       $calendars = $this->driver->list_calendars(calendar_driver::FILTER_PERSONAL);
       $events = $this->driver->load_events($day_start->format('U'), $day_end->format('U'), null, array_keys($calendars));
       usort($events, function($a, $b) { return $a['start'] > $b['start'] ? 1 : -1; });
 
       $before = $after = array();
       foreach ($events as $event) {
         // TODO: skip events with free_busy == 'free' ?
         if ($event['uid'] == $data['uid'] || $event['end'] < $day_start || $event['start'] > $day_end)
           continue;
         else if ($event['start'] < $event_start)
           $before[] = $this->mail_agenda_event_row($event);
         else
           $after[] = $this->mail_agenda_event_row($event);
       }
 
       $response['append'] = array(
         'selector' => '.calendar-agenda-preview',
         'replacements' => array(
           '%before%' => !empty($before) ? join("\n", array_slice($before,  -3)) : html::div('event-row no-event', $this->gettext('noearlierevents')),
           '%after%'  => !empty($after)  ? join("\n", array_slice($after, 0, 3)) : html::div('event-row no-event', $this->gettext('nolaterevents')),
         ),
       );
     }
 
     $this->rc->output->command('plugin.update_itip_object_status', $response);
   }
 
   /**
    * Handler for calendar/itip-remove requests
    */
   function event_itip_remove()
   {
     $success  = false;
     $uid      = rcube_utils::get_input_value('uid', rcube_utils::INPUT_POST);
     $instance = rcube_utils::get_input_value('_instance', rcube_utils::INPUT_POST);
     $savemode = rcube_utils::get_input_value('_savemode', rcube_utils::INPUT_POST);
 
     // search for event if only UID is given
     if ($event = $this->driver->get_event(array('uid' => $uid, '_instance' => $instance), calendar_driver::FILTER_WRITEABLE)) {
       $event['_savemode'] = $savemode;
       $success = $this->driver->remove_event($event, true);
     }
 
     if ($success) {
       $this->rc->output->show_message('calendar.successremoval', 'confirmation');
     }
     else {
       $this->rc->output->show_message('calendar.errorsaving', 'error');
     }
   }
 
   /**
    * Handler for URLs that allow an invitee to respond on his invitation mail
    */
   public function itip_attend_response($p)
   {
     if ($p['action'] == 'attend') {
       $this->ui->init();
 
       $this->rc->output->set_env('task', 'calendar');  // override some env vars
       $this->rc->output->set_env('refresh_interval', 0);
       $this->rc->output->set_pagetitle($this->gettext('calendar'));
 
       $itip  = $this->load_itip();
       $token = rcube_utils::get_input_value('_t', rcube_utils::INPUT_GPC);
 
       // read event info stored under the given token
       if ($invitation = $itip->get_invitation($token)) {
         $this->token = $token;
         $this->event = $invitation['event'];
 
         // show message about cancellation
         if ($invitation['cancelled']) {
           $this->invitestatus = html::div('rsvp-status declined', $itip->gettext('eventcancelled'));
         }
         // save submitted RSVP status
         else if (!empty($_POST['rsvp'])) {
           $status = null;
           foreach (array('accepted','tentative','declined') as $method) {
             if ($_POST['rsvp'] == $itip->gettext('itip' . $method)) {
               $status = $method;
               break;
             }
           }
 
           // send itip reply to organizer
           $invitation['event']['comment'] = rcube_utils::get_input_value('_comment', rcube_utils::INPUT_POST);
           if ($status && $itip->update_invitation($invitation, $invitation['attendee'], strtoupper($status))) {
             $this->invitestatus = html::div('rsvp-status ' . strtolower($status), $itip->gettext('youhave'.strtolower($status)));
           }
           else
             $this->rc->output->command('display_message', $this->gettext('errorsaving'), 'error', -1);
 
           // if user is logged in...
           if ($this->rc->user->ID) {
             $this->load_driver();
             $invitation = $itip->get_invitation($token);
 
             // save the event to his/her default calendar if not yet present
             if (!$this->driver->get_event($this->event) && ($calendar = $this->get_default_calendar($invitation['event']['sensitivity']))) {
               $invitation['event']['calendar'] = $calendar['id'];
               if ($this->driver->new_event($invitation['event']))
                 $this->rc->output->command('display_message', $this->gettext(array('name' => 'importedsuccessfully', 'vars' => array('calendar' => $calendar['name']))), 'confirmation');
             }
           }
         }
         
         $this->register_handler('plugin.event_inviteform', array($this, 'itip_event_inviteform'));
         $this->register_handler('plugin.event_invitebox', array($this->ui, 'event_invitebox'));
         
         if (!$this->invitestatus) {
           $this->itip->set_rsvp_actions(array('accepted','tentative','declined'));
           $this->register_handler('plugin.event_rsvp_buttons', array($this->ui, 'event_rsvp_buttons'));
         }
         
         $this->rc->output->set_pagetitle($itip->gettext('itipinvitation') . ' ' . $this->event['title']);
       }
       else
         $this->rc->output->command('display_message', $this->gettext('itipinvalidrequest'), 'error', -1);
       
       $this->rc->output->send('calendar.itipattend');
     }
   }
   
   /**
    *
    */
   public function itip_event_inviteform($attrib)
   {
     $hidden = new html_hiddenfield(array('name' => "_t", 'value' => $this->token));
     return html::tag('form', array('action' => $this->rc->url(array('task' => 'calendar', 'action' => 'attend')), 'method' => 'post', 'noclose' => true) + $attrib) . $hidden->show();
   }
 
   /**
    * 
    */
   private function mail_agenda_event_row($event, $class = '')
   {
     $time = $event['allday'] ? $this->gettext('all-day') :
       $this->rc->format_date($event['start'], $this->rc->config->get('time_format')) . ' - ' .
         $this->rc->format_date($event['end'], $this->rc->config->get('time_format'));
 
     return html::div(rtrim('event-row ' . $class),
       html::span('event-date', $time) .
       html::span('event-title', rcube::Q($event['title']))
     );
   }
   
   /**
    * 
    */
   public function mail_messages_list($p)
   {
     if (in_array('attachment', (array)$p['cols']) && !empty($p['messages'])) {
       foreach ($p['messages'] as $header) {
         $part = new StdClass;
         $part->mimetype = $header->ctype;
         if (libcalendaring::part_is_vcalendar($part)) {
           $header->list_flags['attachmentClass'] = 'ical';
         }
         else if (in_array($header->ctype, array('multipart/alternative', 'multipart/mixed'))) {
           // TODO: fetch bodystructure and search for ical parts. Maybe too expensive?
 
           if (!empty($header->structure) && is_array($header->structure->parts)) {
             foreach ($header->structure->parts as $part) {
               if (libcalendaring::part_is_vcalendar($part) && !empty($part->ctype_parameters['method'])) {
                 $header->list_flags['attachmentClass'] = 'ical';
                 break;
               }
             }
           }
         }
       }
     }
   }
 
   /**
    * Add UI element to copy event invitations or updates to the calendar
    */
   public function mail_messagebody_html($p)
   {
     // load iCalendar functions (if necessary)
     if (!empty($this->lib->ical_parts)) {
       $this->get_ical();
       $this->load_itip();
     }
 
     $html = '';
     $has_events = false;
     $ical_objects = $this->lib->get_mail_ical_objects();
 
     // show a box for every event in the file
     foreach ($ical_objects as $idx => $event) {
       if ($event['_type'] != 'event')  // skip non-event objects (#2928)
         continue;
 
       $has_events = true;
 
       // get prepared inline UI for this event object
       if ($ical_objects->method) {
         $append = '';
 
         // prepare a small agenda preview to be filled with actual event data on async request
         if ($ical_objects->method == 'REQUEST') {
           $append = html::div('calendar-agenda-preview',
             html::tag('h3', 'preview-title', $this->gettext('agenda') . ' ' .
               html::span('date', $this->rc->format_date($event['start'], $this->rc->config->get('date_format')))
             ) . '%before%' . $this->mail_agenda_event_row($event, 'current') . '%after%');
         }
 
         $html .= html::div('calendar-invitebox',
           $this->itip->mail_itip_inline_ui(
             $event,
             $ical_objects->method,
             $ical_objects->mime_id . ':' . $idx,
             'calendar',
             rcube_utils::anytodatetime($ical_objects->message_date),
             $this->rc->url(array('task' => 'calendar')) . '&view=agendaDay&date=' . $event['start']->format('U')
           ) . $append
         );
       }
 
       // limit listing
       if ($idx >= 3)
         break;
     }
 
     // prepend event boxes to message body
     if ($html) {
       $this->ui->init();
       $p['content'] = $html . $p['content'];
       $this->rc->output->add_label('calendar.savingdata','calendar.deleteventconfirm','calendar.declinedeleteconfirm');
     }
 
     // add "Save to calendar" button into attachment menu
     if ($has_events) {
       $this->add_button(array(
         'id'         => 'attachmentsavecal',
         'name'       => 'attachmentsavecal',
         'type'       => 'link',
         'wrapper'    => 'li',
         'command'    => 'attachment-save-calendar',
         'class'      => 'icon calendarlink',
         'classact'   => 'icon calendarlink active',
         'innerclass' => 'icon calendar',
         'label'      => 'calendar.savetocalendar',
         ), 'attachmentmenu');
     }
 
     return $p;
   }
 
 
   /**
    * Handler for POST request to import an event attached to a mail message
    */
   public function mail_import_itip()
   {
     $itip_sending = $this->rc->config->get('calendar_itip_send_option', $this->defaults['calendar_itip_send_option']);
 
     $uid     = rcube_utils::get_input_value('_uid', rcube_utils::INPUT_POST);
     $mbox    = rcube_utils::get_input_value('_mbox', rcube_utils::INPUT_POST);
     $mime_id = rcube_utils::get_input_value('_part', rcube_utils::INPUT_POST);
     $status  = rcube_utils::get_input_value('_status', rcube_utils::INPUT_POST);
     $delete  = intval(rcube_utils::get_input_value('_del', rcube_utils::INPUT_POST));
     $noreply = intval(rcube_utils::get_input_value('_noreply', rcube_utils::INPUT_POST));
     $noreply = $noreply || $status == 'needs-action' || $itip_sending === 0;
     $instance = rcube_utils::get_input_value('_instance', rcube_utils::INPUT_POST);
     $savemode = rcube_utils::get_input_value('_savemode', rcube_utils::INPUT_POST);
 
     $error_msg = $this->gettext('errorimportingevent');
     $success = false;
     $delegate = null;
 
     if ($status == 'delegated') {
       $delegates = rcube_mime::decode_address_list(rcube_utils::get_input_value('_to', rcube_utils::INPUT_POST, true), 1, false);
       $delegate  = reset($delegates);
 
       if (empty($delegate) || empty($delegate['mailto'])) {
         $this->rc->output->command('display_message', $this->gettext('libcalendaring.delegateinvalidaddress'), 'error');
         return;
       }
     }
 
     // successfully parsed events?
     if ($event = $this->lib->mail_get_itip_object($mbox, $uid, $mime_id, 'event')) {
       // forward iTip request to delegatee
       if ($delegate) {
         $rsvpme  = (bool) intval(rcube_utils::get_input_value('_rsvp', rcube_utils::INPUT_POST));
         $comment = rcube_utils::get_input_value('_comment', rcube_utils::INPUT_POST);
 
         $d_event = $comment ? array_merge($event, array('comment' => $comment)) : $event;
         $itip    = $this->load_itip();
 
         if ($itip->delegate_to($d_event, $delegate, $rsvpme)) {
           $this->rc->output->show_message('calendar.itipsendsuccess', 'confirmation');
         }
         else {
           $this->rc->output->command('display_message', $this->gettext('itipresponseerror'), 'error');
         }
 
         // the delegator is set to non-participant, thus save as non-blocking
         $event['free_busy'] = 'free';
       }
 
       // find writeable calendar to store event
       $cal_id = !empty($_REQUEST['_folder']) ? rcube_utils::get_input_value('_folder', rcube_utils::INPUT_POST) : null;
       $dontsave = ($_REQUEST['_folder'] === '' && $event['_method'] == 'REQUEST');
       $calendars = $this->driver->list_calendars(calendar_driver::FILTER_PERSONAL);
       $calendar = $calendars[$cal_id];
 
       // select default calendar except user explicitly selected 'none'
       if (!$calendar && !$dontsave)
          $calendar = $this->get_default_calendar($event['sensitivity']);
 
       $metadata = array(
         'uid' => $event['uid'],
         '_instance' => $event['_instance'],
         'changed' => is_object($event['changed']) ? $event['changed']->format('U') : 0,
         'sequence' => intval($event['sequence']),
         'fallback' => strtoupper($status),
         'method' => $event['_method'],
         'task' => 'calendar',
       );
 
       // update my attendee status according to submitted method
       if (!empty($status)) {
         $organizer = null;
         $emails = $this->get_user_emails();
         foreach ($event['attendees'] as $i => $attendee) {
           if ($attendee['role'] == 'ORGANIZER') {
             $organizer = $attendee;
           }
           else if ($attendee['email'] && in_array(strtolower($attendee['email']), $emails)) {
             $event['attendees'][$i]['status'] = strtoupper($status);
             if (!in_array($event['attendees'][$i]['status'], array('NEEDS-ACTION','DELEGATED')))
               $event['attendees'][$i]['rsvp'] = false;  // unset RSVP attribute
 
             $metadata['attendee'] = $attendee['email'];
             $metadata['rsvp'] = $attendee['role'] != 'NON-PARTICIPANT';
             $reply_sender = $attendee['email'];
             $event_attendee = $attendee;
           }
         }
 
         // add attendee with this user's default identity if not listed
         if (!$reply_sender) {
           $sender_identity = $this->rc->user->list_emails(true);
           $event['attendees'][] = array(
             'name' => $sender_identity['name'],
             'email' => $sender_identity['email'],
             'role' => 'OPT-PARTICIPANT',
             'status' => strtoupper($status),
           );
           $metadata['attendee'] = $sender_identity['email'];
         }
       }
       
       // save to calendar
       if ($calendar && $calendar['editable']) {
         // check for existing event with the same UID
         $existing = $this->driver->get_event($event, calendar_driver::FILTER_WRITEABLE | calendar_driver::FILTER_PERSONAL);
 
         if ($existing) {
           // forward savemode for correct updates of recurring events
           $existing['_savemode'] = $savemode ?: $event['_savemode'];
 
           // only update attendee status
           if ($event['_method'] == 'REPLY') {
             // try to identify the attendee using the email sender address
             $existing_attendee = -1;
             $existing_attendee_emails = array();
             foreach ($existing['attendees'] as $i => $attendee) {
               $existing_attendee_emails[] = $attendee['email'];
               if ($event['_sender'] && ($attendee['email'] == $event['_sender'] || $attendee['email'] == $event['_sender_utf'])) {
                 $existing_attendee = $i;
               }
             }
             $event_attendee = null;
             $update_attendees = array();
             foreach ($event['attendees'] as $attendee) {
               if ($event['_sender'] && ($attendee['email'] == $event['_sender'] || $attendee['email'] == $event['_sender_utf'])) {
                 $event_attendee = $attendee;
                 $update_attendees[] = $attendee;
                 $metadata['fallback'] = $attendee['status'];
                 $metadata['attendee'] = $attendee['email'];
                 $metadata['rsvp'] = $attendee['rsvp'] || $attendee['role'] != 'NON-PARTICIPANT';
                 if ($attendee['status'] != 'DELEGATED') {
                   break;
                 }
               }
               // also copy delegate attendee
               else if (!empty($attendee['delegated-from']) &&
                        (stripos($attendee['delegated-from'], $event['_sender']) !== false ||
                         stripos($attendee['delegated-from'], $event['_sender_utf']) !== false)) {
                 $update_attendees[] = $attendee;
                 if (!in_array($attendee['email'], $existing_attendee_emails)) {
                   $existing['attendees'][] = $attendee;
                 }
               }
             }
 
             // if delegatee has declined, set delegator's RSVP=True
             if ($event_attendee && $event_attendee['status'] == 'DECLINED' && $event_attendee['delegated-from']) {
               foreach ($existing['attendees'] as $i => $attendee) {
                 if ($attendee['email'] == $event_attendee['delegated-from']) {
                   $existing['attendees'][$i]['rsvp'] = true;
                   break;
                 }
               }
             }
 
             // found matching attendee entry in both existing and new events
             if ($existing_attendee >= 0 && $event_attendee) {
               $existing['attendees'][$existing_attendee] = $event_attendee;
               $success = $this->driver->update_attendees($existing, $update_attendees);
             }
             // update the entire attendees block
             else if (($event['sequence'] >= $existing['sequence'] || $event['changed'] >= $existing['changed']) && $event_attendee) {
               $existing['attendees'][] = $event_attendee;
               $success = $this->driver->update_attendees($existing, $update_attendees);
             }
             else {
               $error_msg = $this->gettext('newerversionexists');
             }
           }
           // delete the event when declined (#1670)
           else if ($status == 'declined' && $delete) {
              $deleted = $this->driver->remove_event($existing, true);
              $success = true;
           }
           // import the (newer) event
           else if ($event['sequence'] >= $existing['sequence'] || $event['changed'] >= $existing['changed']) {
             $event['id'] = $existing['id'];
             $event['calendar'] = $existing['calendar'];
 
             // preserve my participant status for regular updates
             if (empty($status)) {
               $emails = $this->get_user_emails();
               foreach ($event['attendees'] as $i => $attendee) {
                 if ($attendee['email'] && in_array(strtolower($attendee['email']), $emails)) {
                   foreach ($existing['attendees'] as $j => $_attendee) {
                     if ($attendee['email'] == $_attendee['email']) {
                       $event['attendees'][$i] = $existing['attendees'][$j];
                       break;
                     }
                   }
                 }
               }
             }
 
             // set status=CANCELLED on CANCEL messages
             if ($event['_method'] == 'CANCEL')
               $event['status'] = 'CANCELLED';
             // show me as free when declined (#1670)
             if ($status == 'declined' || $event['status'] == 'CANCELLED' || $event_attendee['role'] == 'NON-PARTICIPANT')
               $event['free_busy'] = 'free';
 
             $success = $this->driver->edit_event($event);
           }
           else if (!empty($status)) {
             $existing['attendees'] = $event['attendees'];
             if ($status == 'declined' || $event_attendee['role'] == 'NON-PARTICIPANT')  // show me as free when declined (#1670)
               $existing['free_busy'] = 'free';
             $success = $this->driver->edit_event($existing);
           }
           else
             $error_msg = $this->gettext('newerversionexists');
         }
         else if (!$existing && ($status != 'declined' || $this->rc->config->get('kolab_invitation_calendars'))) {
           if ($status == 'declined' || $event['status'] == 'CANCELLED' || $event_attendee['role'] == 'NON-PARTICIPANT') {
             $event['free_busy'] = 'free';
           }
 
           // if the RSVP reply only refers to a single instance:
           // store unmodified master event with current instance as exception
           if (!empty($instance) && !empty($savemode) && $savemode != 'all') {
             $master = $this->lib->mail_get_itip_object($mbox, $uid, $mime_id, 'event');
             if ($master['recurrence'] && !$master['_instance']) {
               // compute recurring events until this instance's date
               if ($recurrence_date = rcube_utils::anytodatetime($instance, $master['start']->getTimezone())) {
                 $recurrence_date->setTime(23,59,59);
 
                 foreach ($this->driver->get_recurring_events($master, $master['start'], $recurrence_date) as $recurring) {
                   if ($recurring['_instance'] == $instance) {
                     // copy attendees block with my partstat to exception
                     $recurring['attendees'] = $event['attendees'];
                     $master['recurrence']['EXCEPTIONS'][] = $recurring;
                     $event = $recurring;  // set reference for iTip reply
                     break;
                   }
                 }
 
                 $master['calendar'] = $event['calendar'] = $calendar['id'];
                 $success = $this->driver->new_event($master);
               }
               else {
                 $master = null;
               }
             }
             else {
               $master = null;
             }
           }
 
           // save to the selected/default calendar
           if (!$master) {
             $event['calendar'] = $calendar['id'];
             $success = $this->driver->new_event($event);
           }
         }
         else if ($status == 'declined')
           $error_msg = null;
       }
       else if ($status == 'declined' || $dontsave)
         $error_msg = null;
       else
         $error_msg = $this->gettext('nowritecalendarfound');
     }
 
     if ($success) {
       $message = $event['_method'] == 'REPLY' ? 'attendeupdateesuccess' : ($deleted ? 'successremoval' : ($existing ? 'updatedsuccessfully' : 'importedsuccessfully'));
       $this->rc->output->command('display_message', $this->gettext(array('name' => $message, 'vars' => array('calendar' => $calendar['name']))), 'confirmation');
     }
 
     if ($success || $dontsave) {
       $metadata['calendar'] = $event['calendar'];
       $metadata['nosave'] = $dontsave;
       $metadata['rsvp'] = intval($metadata['rsvp']);
       $metadata['after_action'] = $this->rc->config->get('calendar_itip_after_action', $this->defaults['calendar_itip_after_action']);
       $this->rc->output->command('plugin.itip_message_processed', $metadata);
       $error_msg = null;
     }
     else if ($error_msg) {
       $this->rc->output->command('display_message', $error_msg, 'error');
     }
 
     // send iTip reply
     if ($event['_method'] == 'REQUEST' && $organizer && !$noreply && !in_array(strtolower($organizer['email']), $emails) && !$error_msg) {
       $event['comment'] = rcube_utils::get_input_value('_comment', rcube_utils::INPUT_POST);
       $itip = $this->load_itip();
       $itip->set_sender_email($reply_sender);
       if ($itip->send_itip_message($event, 'REPLY', $organizer, 'itipsubject' . $status, 'itipmailbody' . $status))
         $this->rc->output->command('display_message', $this->gettext(array('name' => 'sentresponseto', 'vars' => array('mailto' => $organizer['name'] ? $organizer['name'] : $organizer['email']))), 'confirmation');
       else
         $this->rc->output->command('display_message', $this->gettext('itipresponseerror'), 'error');
     }
 
     $this->rc->output->send();
   }
 
 
   /**
    * Handler for calendar/itip-remove requests
    */
   function mail_itip_decline_reply()
   {
     $uid     = rcube_utils::get_input_value('_uid', rcube_utils::INPUT_POST);
     $mbox    = rcube_utils::get_input_value('_mbox', rcube_utils::INPUT_POST);
     $mime_id = rcube_utils::get_input_value('_part', rcube_utils::INPUT_POST);
 
     if (($event = $this->lib->mail_get_itip_object($mbox, $uid, $mime_id, 'event')) && $event['_method'] == 'REPLY') {
       $event['comment'] = rcube_utils::get_input_value('_comment', rcube_utils::INPUT_POST);
 
       foreach ($event['attendees'] as $_attendee) {
         if ($_attendee['role'] != 'ORGANIZER') {
           $attendee = $_attendee;
           break;
         }
       }
 
       $itip = $this->load_itip();
       if ($itip->send_itip_message($event, 'CANCEL', $attendee, 'itipsubjectcancel', 'itipmailbodycancel'))
         $this->rc->output->command('display_message', $this->gettext(array('name' => 'sentresponseto', 'vars' => array('mailto' => $attendee['name'] ? $attendee['name'] : $attendee['email']))), 'confirmation');
       else
         $this->rc->output->command('display_message', $this->gettext('itipresponseerror'), 'error');
     }
     else {
       $this->rc->output->command('display_message', $this->gettext('itipresponseerror'), 'error');
     }
   }
 
   /**
    * Handler for calendar/itip-delegate requests
    */
   function mail_itip_delegate()
   {
     // forward request to mail_import_itip() with the right status
     $_POST['_status'] = $_REQUEST['_status'] = 'delegated';
     $this->mail_import_itip();
   }
 
   /**
    * Import the full payload from a mail message attachment
    */
   public function mail_import_attachment()
   {
     $uid     = rcube_utils::get_input_value('_uid', rcube_utils::INPUT_POST);
     $mbox    = rcube_utils::get_input_value('_mbox', rcube_utils::INPUT_POST);
     $mime_id = rcube_utils::get_input_value('_part', rcube_utils::INPUT_POST);
     $charset = RCUBE_CHARSET;
 
     // establish imap connection
     $imap = $this->rc->get_storage();
     $imap->set_folder($mbox);
 
     if ($uid && $mime_id) {
       $part = $imap->get_message_part($uid, $mime_id);
       if ($part->ctype_parameters['charset'])
         $charset = $part->ctype_parameters['charset'];
 //      $headers = $imap->get_message_headers($uid);
 
       if ($part) {
         $events = $this->get_ical()->import($part, $charset);
       }
     }
 
     $success = $existing = 0;
     if (!empty($events)) {
       // find writeable calendar to store event
       $cal_id = !empty($_REQUEST['_calendar']) ? rcube_utils::get_input_value('_calendar', rcube_utils::INPUT_POST) : null;
       $calendars = $this->driver->list_calendars(calendar_driver::FILTER_PERSONAL);
 
       foreach ($events as $event) {
         // save to calendar
         $calendar = $calendars[$cal_id] ?: $this->get_default_calendar($event['sensitivity']);
         if ($calendar && $calendar['editable'] && $event['_type'] == 'event') {
           $event['calendar'] = $calendar['id'];
 
           if (!$this->driver->get_event($event['uid'], calendar_driver::FILTER_WRITEABLE)) {
             $success += (bool)$this->driver->new_event($event);
           }
           else {
             $existing++;
           }
         }
       }
     }
 
     if ($success) {
       $this->rc->output->command('display_message', $this->gettext(array(
         'name' => 'importsuccess',
         'vars' => array('nr' => $success),
       )), 'confirmation');
     }
     else if ($existing) {
       $this->rc->output->command('display_message', $this->gettext('importwarningexists'), 'warning');
     }
     else {
       $this->rc->output->command('display_message', $this->gettext('errorimportingevent'), 'error');
     }
   }
 
   /**
    * Read email message and return contents for a new event based on that message
    */
   public function mail_message2event()
   {
     $uid   = rcube_utils::get_input_value('_uid', rcube_utils::INPUT_POST);
     $mbox  = rcube_utils::get_input_value('_mbox', rcube_utils::INPUT_POST);
     $event = array();
 
     // establish imap connection
     $imap = $this->rc->get_storage();
     $imap->set_folder($mbox);
     $message = new rcube_message($uid);
 
     if ($message->headers) {
       $event['title'] = trim($message->subject);
       $event['description'] = trim($message->first_text_part());
 
       $this->load_driver();
 
       // add a reference to the email message
       if ($msgref = $this->driver->get_message_reference($message->headers, $mbox)) {
         $event['links'] = array($msgref);
       }
       // copy mail attachments to event
       else if ($message->attachments) {
         $eventid = 'cal-';
         if (!is_array($_SESSION[self::SESSION_KEY]) || $_SESSION[self::SESSION_KEY]['id'] != $eventid) {
           $_SESSION[self::SESSION_KEY] = array();
           $_SESSION[self::SESSION_KEY]['id'] = $eventid;
           $_SESSION[self::SESSION_KEY]['attachments'] = array();
         }
 
         foreach ((array)$message->attachments as $part) {
           $attachment = array(
             'data' => $imap->get_message_part($uid, $part->mime_id, $part),
             'size' => $part->size,
             'name' => $part->filename,
             'mimetype' => $part->mimetype,
             'group' => $eventid,
           );
 
           $attachment = $this->rc->plugins->exec_hook('attachment_save', $attachment);
 
           if ($attachment['status'] && !$attachment['abort']) {
             $id = $attachment['id'];
             $attachment['classname'] = rcube_utils::file2class($attachment['mimetype'], $attachment['name']);
 
             // store new attachment in session
             unset($attachment['status'], $attachment['abort'], $attachment['data']);
             $_SESSION[self::SESSION_KEY]['attachments'][$id] = $attachment;
 
             $attachment['id'] = 'rcmfile' . $attachment['id'];  // add prefix to consider it 'new'
             $event['attachments'][] = $attachment;
           }
         }
       }
       
       $this->rc->output->command('plugin.mail2event_dialog', $event);
     }
     else {
       $this->rc->output->command('display_message', $this->gettext('messageopenerror'), 'error');
     }
     
     $this->rc->output->send();
   }
 
   /**
    * Handler for the 'message_compose' plugin hook. This will check for
    * a compose parameter 'calendar_event' and create an attachment with the
    * referenced event in iCal format
    */
   public function mail_message_compose($args)
   {
     // set the submitted event ID as attachment
     if (!empty($args['param']['calendar_event'])) {
       $this->load_driver();
 
       list($cal, $id) = explode(':', $args['param']['calendar_event'], 2);
       if ($event = $this->driver->get_event(array('id' => $id, 'calendar' => $cal))) {
         $filename = asciiwords($event['title']);
         if (empty($filename))
           $filename = 'event';
 
         // save ics to a temp file and register as attachment
         $tmp_path = tempnam($this->rc->config->get('temp_dir'), 'rcmAttmntCal');
         file_put_contents($tmp_path, $this->get_ical()->export(array($event), '', false, array($this->driver, 'get_attachment_body')));
 
         $args['attachments'][] = array('path' => $tmp_path, 'name' => $filename . '.ics', 'mimetype' => 'text/calendar');
         $args['param']['subject'] = $event['title'];
       }
     }
 
     return $args;
   }
 
 
   /**
    * Get a list of email addresses of the current user (from login and identities)
    */
   public function get_user_emails()
   {
     return $this->lib->get_user_emails();
   }
 
 
   /**
    * Build an absolute URL with the given parameters
    */
   public function get_url($param = array())
   {
     $param += array('task' => 'calendar');
     return $this->rc->url($param, true, true);
   }
 
 
   public function ical_feed_hash($source)
   {
     return base64_encode($this->rc->user->get_username() . ':' . $source);
   }
 
   /**
    * Handler for user_delete plugin hook
    */
   public function user_delete($args)
   {
      // delete itipinvitations entries related to this user
      $db = $this->rc->get_dbh();
      $table_itipinvitations = $db->table_name('itipinvitations', true);
      $db->query("DELETE FROM $table_itipinvitations WHERE `user_id` = ?", $args['user']->ID);
 
      $this->load_driver();
      return $this->driver->user_delete($args);
   }
 
   /**
    * Magic getter for public access to protected members
    */
   public function __get($name)
   {
     switch ($name) {
       case 'ical':
         return $this->get_ical();
 
       case 'itip':
         return $this->load_itip();
 
       case 'driver':
         $this->load_driver();
         return $this->driver;
     }
 
     return null;
   }
 
 }
diff --git a/plugins/calendar/drivers/kolab/kolab_calendar.php b/plugins/calendar/drivers/kolab/kolab_calendar.php
index 9043b4a9..3e13020d 100644
--- a/plugins/calendar/drivers/kolab/kolab_calendar.php
+++ b/plugins/calendar/drivers/kolab/kolab_calendar.php
@@ -1,838 +1,849 @@
 <?php
 
 /**
  * Kolab calendar storage class
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  * @author Aleksander Machniak <machniak@kolabsys.com>
  *
  * Copyright (C) 2012-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_calendar extends kolab_storage_folder_api
 {
   public $ready = false;
   public $rights = 'lrs';
   public $editable = false;
   public $attachments = true;
   public $alarms = false;
   public $history = false;
   public $subscriptions = true;
   public $categories = array();
   public $storage;
 
   public $type = 'event';
 
   protected $cal;
   protected $events = array();
   protected $search_fields = array('title', 'description', 'location', 'attendees');
 
   /**
    * Factory method to instantiate a kolab_calendar object
    *
    * @param string  Calendar ID (encoded IMAP folder name)
    * @param object  calendar plugin object
    * @return object kolab_calendar instance
    */
   public static function factory($id, $calendar)
   {
     $imap = $calendar->rc->get_storage();
     $imap_folder = kolab_storage::id_decode($id);
     $info = $imap->folder_info($imap_folder, true);
     if (empty($info) || $info['noselect'] || strpos(kolab_storage::folder_type($imap_folder), 'event') !== 0) {
       return new kolab_user_calendar($imap_folder, $calendar);
     }
     else {
       return new kolab_calendar($imap_folder, $calendar);
     }
   }
 
   /**
    * Default constructor
    */
   public function __construct($imap_folder, $calendar)
   {
     $this->cal = $calendar;
     $this->imap = $calendar->rc->get_storage();
     $this->name = $imap_folder;
 
     // ID is derrived from folder name
     $this->id = kolab_storage::folder_id($this->name, true);
     $old_id   = kolab_storage::folder_id($this->name, false);
 
     // fetch objects from the given IMAP folder
     $this->storage = kolab_storage::get_folder($this->name);
     $this->ready = $this->storage && $this->storage->valid;
 
     // Set writeable and alarms flags according to folder permissions
     if ($this->ready) {
       if ($this->storage->get_namespace() == 'personal') {
         $this->editable = true;
         $this->rights = 'lrswikxteav';
         $this->alarms = true;
       }
       else {
         $rights = $this->storage->get_myrights();
         if ($rights && !PEAR::isError($rights)) {
           $this->rights = $rights;
           if (strpos($rights, 't') !== false || strpos($rights, 'd') !== false)
             $this->editable = strpos($rights, 'i');;
         }
       }
       
       // user-specific alarms settings win
       $prefs = $this->cal->rc->config->get('kolab_calendars', array());
       if (isset($prefs[$this->id]['showalarms']))
         $this->alarms = $prefs[$this->id]['showalarms'];
       else if (isset($prefs[$old_id]['showalarms']))
         $this->alarms = $prefs[$old_id]['showalarms'];
     }
 
     $this->default = $this->storage->default;
     $this->subtype = $this->storage->subtype;
   }
 
 
   /**
    * Getter for the IMAP folder name
    *
    * @return string Name of the IMAP folder
    */
   public function get_realname()
   {
     return $this->name;
   }
 
   /**
    *
    */
   public function get_title()
   {
     return null;
   }
 
 
   /**
    * Return color to display this calendar
    */
   public function get_color()
   {
     // color is defined in folder METADATA
     if ($color = $this->storage->get_color()) {
       return $color;
     }
 
     // calendar color is stored in user prefs (temporary solution)
     $prefs = $this->cal->rc->config->get('kolab_calendars', array());
 
     if (!empty($prefs[$this->id]) && !empty($prefs[$this->id]['color']))
       return $prefs[$this->id]['color'];
 
     return 'cc0000';
   }
 
   /**
    * Compose an URL for CalDAV access to this calendar (if configured)
    */
   public function get_caldav_url()
   {
     if ($template = $this->cal->rc->config->get('calendar_caldav_url', null)) {
       return strtr($template, array(
         '%h' => $_SERVER['HTTP_HOST'],
         '%u' => urlencode($this->cal->rc->get_user_name()),
         '%i' => urlencode($this->storage->get_uid()),
         '%n' => urlencode($this->name),
       ));
     }
 
     return false;
   }
 
 
   /**
    * Update properties of this calendar folder
    *
    * @see calendar_driver::edit_calendar()
    */
   public function update(&$prop)
   {
     $prop['oldname'] = $this->get_realname();
     $newfolder = kolab_storage::folder_update($prop);
 
     if ($newfolder === false) {
       $this->cal->last_error = $this->cal->gettext(kolab_storage::$last_error);
       return false;
     }
 
     // create ID
     return kolab_storage::folder_id($newfolder);
   }
 
   /**
    * Getter for a single event object
    */
   public function get_event($id)
   {
+    // remove our occurrence identifier if it's there
+    $master_id = preg_replace('/-\d{8}(T\d{6})?$/', '', $id);
+
     // directly access storage object
-    if (!$this->events[$id] && ($record = $this->storage->get_object($id)))
-        $this->events[$id] = $this->_to_driver_event($record, true);
+    if (!$this->events[$id] && $master_id == $id && ($record = $this->storage->get_object($id))) {
+      $this->events[$id] = $this->_to_driver_event($record, true);
+    }
 
-    // event not found, maybe a recurring instance is requested
-    if (!$this->events[$id]) {
-      $master_id = preg_replace('/-\d+(T\d{6})?$/', '', $id);
+    // maybe a recurring instance is requested
+    if (!$this->events[$id] && $master_id != $id) {
       $instance_id = substr($id, strlen($master_id) + 1);
 
-      if ($master_id != $id && ($record = $this->storage->get_object($master_id))) {
-        $master = $this->_to_driver_event($record);
+      if ($record = $this->storage->get_object($master_id)) {
+        $master = $this->_to_driver_event($record, true);
+        $this->events[$master_id] = $master;
       }
 
-      // check for match in top-level exceptions (aka loose single occurrences)
-      if ($master && $master['_formatobj'] && ($instance = $master['_formatobj']->get_instance($instance_id))) {
-        $this->events[$id] = $this->_to_driver_event($instance);
-      }
-      // check for match on the first instance already
-      else if ($master['_instance'] && $master['_instance'] == $instance_id) {
-        $this->events[$id] = $master;
-      }
-      else if ($master && is_array($master['recurrence'])) {
-        $this->get_recurring_events($record, $master['start'], null, $id);
+      if ($master) {
+        // check for match in top-level exceptions (aka loose single occurrences)
+        if ($master['_formatobj'] && ($instance = $master['_formatobj']->get_instance($instance_id))) {
+          $this->events[$id] = $this->_to_driver_event($instance);
+        }
+        // check for match on the first instance already
+        else if ($master['_instance'] && $master['_instance'] == $instance_id) {
+          $this->events[$id] = $master;
+        }
+        else if (is_array($master['recurrence'])) {
+          $this->get_recurring_events($record, $master['start'], null, $id);
+        }
       }
     }
 
     return $this->events[$id];
   }
 
   /**
    * Get attachment body
    * @see calendar_driver::get_attachment_body()
    */
   public function get_attachment_body($id, $event)
   {
     if (!$this->ready)
         return false;
 
     $data = $this->storage->get_attachment($event['id'], $id);
 
     if ($data == null) {
         // try again with master UID
         $uid = preg_replace('/-\d+(T\d{6})?$/', '', $event['id']);
         if ($uid != $event['id']) {
             $data = $this->storage->get_attachment($uid, $id);
         }
     }
 
     return $data;
   }
 
   /**
    * @param  integer Event's new start (unix timestamp)
    * @param  integer Event's new end (unix timestamp)
    * @param  string  Search query (optional)
    * @param  boolean Include virtual events (optional)
    * @param  array   Additional parameters to query storage
    * @param  array   Additional query to filter events
    * @return array A list of event records
    */
   public function list_events($start, $end, $search = null, $virtual = 1, $query = array(), $filter_query = null)
   {
     // convert to DateTime for comparisons
     // #5190: make the range a little bit wider
     // to workaround possible timezone differences
     try {
       $start = new DateTime('@' . ($start - 12 * 3600));
     }
     catch (Exception $e) {
       $start = new DateTime('@0');
     }
     try {
       $end = new DateTime('@' . ($end + 12 * 3600));
     }
     catch (Exception $e) {
       $end = new DateTime('today +10 years');
     }
 
     // get email addresses of the current user
     $user_emails = $this->cal->get_user_emails();
 
     // query Kolab storage
     $query[] = array('dtstart', '<=', $end);
     $query[] = array('dtend',   '>=', $start);
 
     if (is_array($filter_query)) {
       $query = array_merge($query, $filter_query);
     }
 
     if (!empty($search)) {
         $search = mb_strtolower($search);
         $words = rcube_utils::tokenize_string($search, 1);
         foreach (rcube_utils::normalize_string($search, true) as $word) {
             $query[] = array('words', 'LIKE', $word);
         }
     }
     else {
       $words = array();
     }
 
     // set partstat filter to skip pending and declined invitations
     if (empty($filter_query) && $this->get_namespace() != 'other') {
       $partstat_exclude = array('NEEDS-ACTION','DECLINED');
     }
     else {
       $partstat_exclude = array();
     }
 
     $events = array();
     foreach ($this->storage->select($query) as $record) {
-      $event = $this->_to_driver_event($record, !$virtual);
+      $event = $this->_to_driver_event($record, !$virtual, false);
 
       // remember seen categories
       if ($event['categories']) {
         $cat = is_array($event['categories']) ? $event['categories'][0] : $event['categories'];
         $this->categories[$cat]++;
-    }
+      }
 
       // list events in requested time window
       if ($event['start'] <= $end && $event['end'] >= $start) {
         unset($event['_attendees']);
         $add = true;
 
         // skip the first instance of a recurring event if listed in exdate
         if ($virtual && !empty($event['recurrence']['EXDATE'])) {
           $event_date = $event['start']->format('Ymd');
           $exdates = (array)$event['recurrence']['EXDATE'];
 
           foreach ($exdates as $exdate) {
             if ($exdate->format('Ymd') == $event_date) {
               $add = false;
               break;
             }
           }
         }
 
         // find and merge exception for the first instance
         if ($virtual && !empty($event['recurrence']) && is_array($event['recurrence']['EXCEPTIONS'])) {
           foreach ($event['recurrence']['EXCEPTIONS'] as $exception) {
             if ($event['_instance'] == $exception['_instance']) {
               // clone date objects from main event before adjusting them with exception data
               if (is_object($event['start'])) $event['start'] = clone $record['start'];
               if (is_object($event['end']))   $event['end']   = clone $record['end'];
               kolab_driver::merge_exception_data($event, $exception);
             }
           }
         }
 
         if ($add)
           $events[] = $event;
       }
 
       // resolve recurring events
       if ($record['recurrence'] && $virtual == 1) {
         $events = array_merge($events, $this->get_recurring_events($record, $start, $end));
       }
       // add top-level exceptions (aka loose single occurrences)
       else if (is_array($record['exceptions'])) {
         foreach ($record['exceptions'] as $ex) {
-          $component = $this->_to_driver_event($ex);
+          $component = $this->_to_driver_event($ex, false, false);
           if ($component['start'] <= $end && $component['end'] >= $start) {
             $events[] = $component;
           }
         }
       }
     }
 
     // post-filter all events by fulltext search and partstat values
     $me = $this;
     $events = array_filter($events, function($event) use ($words, $partstat_exclude, $user_emails, $me) {
       // fulltext search
       if (count($words)) {
         $hits = 0;
         foreach ($words as $word) {
           $hits += $me->fulltext_match($event, $word, false);
         }
         if ($hits < count($words)) {
           return false;
         }
       }
 
       // partstat filter
       if (count($partstat_exclude) && is_array($event['attendees'])) {
         foreach ($event['attendees'] as $attendee) {
           if (in_array($attendee['email'], $user_emails) && in_array($attendee['status'], $partstat_exclude)) {
             return false;
           }
         }
       }
 
       return true;
     });
 
+    // Apply event-to-mail relations
+    $config = kolab_storage_config::get_instance();
+    $config->apply_links($events);
+
     // avoid session race conditions that will loose temporary subscriptions
     $this->cal->rc->session->nowrite = true;
 
     return $events;
   }
 
   /**
    *
    * @param  integer Date range start (unix timestamp)
    * @param  integer Date range end (unix timestamp)
    * @param  array   Additional query to filter events
    * @return integer Count
    */
   public function count_events($start, $end = null, $filter_query = null)
   {
     // convert to DateTime for comparisons
     try {
       $start = new DateTime('@'.$start);
     }
     catch (Exception $e) {
       $start = new DateTime('@0');
     }
     if ($end) {
       try {
         $end = new DateTime('@'.$end);
       }
       catch (Exception $e) {
         $end = null;
       }
     }
 
     // query Kolab storage
     $query[] = array('dtend',   '>=', $start);
     
     if ($end)
       $query[] = array('dtstart', '<=', $end);
 
     // add query to exclude pending/declined invitations
     if (empty($filter_query)) {
       foreach ($this->cal->get_user_emails() as $email) {
         $query[] = array('tags', '!=', 'x-partstat:' . $email . ':needs-action');
         $query[] = array('tags', '!=', 'x-partstat:' . $email . ':declined');
       }
     }
     else if (is_array($filter_query)) {
       $query = array_merge($query, $filter_query);
     }
 
     // we rely the Kolab storage query (no post-filtering)
     return $this->storage->count($query);
   }
 
   /**
    * Create a new event record
    *
    * @see calendar_driver::new_event()
    * 
    * @return mixed The created record ID on success, False on error
    */
   public function insert_event($event)
   {
     if (!is_array($event))
       return false;
 
     // email links are stored separately
     $links = $event['links'];
     unset($event['links']);
 
     //generate new event from RC input
     $object = $this->_from_driver_event($event);
-    $saved = $this->storage->save($object, 'event');
-    
+    $saved  = $this->storage->save($object, 'event');
+
     if (!$saved) {
       rcube::raise_error(array(
         'code' => 600, 'type' => 'php',
         'file' => __FILE__, 'line' => __LINE__,
         'message' => "Error saving event object to Kolab server"),
         true, false);
       $saved = false;
     }
     else {
       // save links in configuration.relation object
-      $this->save_links($event['uid'], $links);
+      if ($this->save_links($event['uid'], $links)) {
+        $object['links'] = $links;
+      }
 
       $this->events = array($event['uid'] => $this->_to_driver_event($object, true));
     }
-    
+
     return $saved;
   }
 
   /**
    * Update a specific event record
    *
    * @see calendar_driver::new_event()
    * @return boolean True on success, False on error
    */
 
   public function update_event($event, $exception_id = null)
   {
     $updated = false;
     $old = $this->storage->get_object($event['uid'] ?: $event['id']);
     if (!$old || PEAR::isError($old))
       return false;
 
     // email links are stored separately
     $links = $event['links'];
     unset($event['links']);
 
     $object = $this->_from_driver_event($event, $old);
-    $saved = $this->storage->save($object, 'event', $old['uid']);
+    $saved  = $this->storage->save($object, 'event', $old['uid']);
 
     if (!$saved) {
       rcube::raise_error(array(
         'code' => 600, 'type' => 'php',
         'file' => __FILE__, 'line' => __LINE__,
         'message' => "Error saving event object to Kolab server"),
         true, false);
     }
     else {
       // save links in configuration.relation object
-      $this->save_links($event['uid'], $links);
+      if ($this->save_links($event['uid'], $links)) {
+        $object['links'] = $links;
+      }
 
       $updated = true;
       $this->events = array($event['uid'] => $this->_to_driver_event($object, true));
 
       // refresh local cache with recurring instances
       if ($exception_id) {
         $this->get_recurring_events($object, $event['start'], $event['end'], $exception_id);
       }
     }
 
     return $updated;
   }
 
   /**
    * Delete an event record
    *
    * @see calendar_driver::remove_event()
    * @return boolean True on success, False on error
    */
   public function delete_event($event, $force = true)
   {
     $deleted = $this->storage->delete($event['uid'] ?: $event['id'], $force);
 
     if (!$deleted) {
       rcube::raise_error(array(
         'code' => 600, 'type' => 'php',
         'file' => __FILE__, 'line' => __LINE__,
         'message' => sprintf("Error deleting event object '%s' from Kolab server", $event['id'])),
         true, false);
     }
 
     return $deleted;
   }
 
   /**
    * Restore deleted event record
    *
    * @see calendar_driver::undelete_event()
    * @return boolean True on success, False on error
    */
   public function restore_event($event)
   {
     if ($this->storage->undelete($event['id'])) {
         return true;
     }
     else {
         rcube::raise_error(array(
           'code' => 600, 'type' => 'php',
           'file' => __FILE__, 'line' => __LINE__,
           'message' => "Error undeleting the event object $event[id] from the Kolab server"),
         true, false);
     }
 
     return false;
   }
 
   /**
    * Find messages linked with an event
    */
   protected function get_links($uid)
   {
     $storage = kolab_storage_config::get_instance();
     return $storage->get_object_links($uid);
   }
 
   /**
    *
    */
   protected function save_links($uid, $links)
   {
-    // make sure we have a valid array
-    if (empty($links)) {
-      $links = array();
-    }
-
     $storage = kolab_storage_config::get_instance();
-    $remove = array_diff($storage->get_object_links($uid), $links);
-    return $storage->save_object_links($uid, $links, $remove);
+    return $storage->save_object_links($uid, (array) $links);
   }
 
   /**
    * Create instances of a recurring event
    *
    * @param array  Hash array with event properties
    * @param object DateTime Start date of the recurrence window
    * @param object DateTime End date of the recurrence window
    * @param string ID of a specific recurring event instance
    * @return array List of recurring event instances
    */
   public function get_recurring_events($event, $start, $end = null, $event_id = null)
   {
     $object = $event['_formatobj'];
     if (!$object) {
       $rec = $this->storage->get_object($event['id']);
       $object = $rec['_formatobj'];
     }
     if (!is_object($object))
       return array();
 
     // determine a reasonable end date if none given
     if (!$end) {
       switch ($event['recurrence']['FREQ']) {
         case 'YEARLY':  $intvl = 'P100Y'; break;
         case 'MONTHLY': $intvl = 'P20Y';  break;
         default:        $intvl = 'P10Y';  break;
       }
 
       $end = clone $event['start'];
       $end->add(new DateInterval($intvl));
     }
 
     // copy the recurrence rule from the master event (to be used in the UI)
     $recurrence_rule = $event['recurrence'];
     unset($recurrence_rule['EXCEPTIONS'], $recurrence_rule['EXDATE']);
 
     // read recurrence exceptions first
     $events = array();
     $exdata = array();
     $futuredata = array();
     $recurrence_id_format = libcalendaring::recurrence_id_format($event);
 
     if (is_array($event['recurrence']['EXCEPTIONS'])) {
       foreach ($event['recurrence']['EXCEPTIONS'] as $exception) {
         if (!$exception['_instance'])
           $exception['_instance'] = libcalendaring::recurrence_instance_identifier($exception);
 
-        $rec_event = $this->_to_driver_event($exception);
+        $rec_event = $this->_to_driver_event($exception, false, false);
         $rec_event['id'] = $event['uid'] . '-' . $exception['_instance'];
         $rec_event['isexception'] = 1;
 
         // found the specifically requested instance: register exception (single occurrence wins)
         if ($rec_event['id'] == $event_id && (!$this->events[$event_id] || $this->events[$event_id]['thisandfuture'])) {
           $rec_event['recurrence'] = $recurrence_rule;
           $rec_event['recurrence_id'] = $event['uid'];
           $this->events[$rec_event['id']] = $rec_event;
         }
 
         // remember this exception's date
         $exdate = substr($exception['_instance'], 0, 8);
         if (!$exdata[$exdate] || $exdata[$exdate]['thisandfuture']) {
           $exdata[$exdate] = $rec_event;
         }
         if ($rec_event['thisandfuture']) {
           $futuredata[$exdate] = $rec_event;
         }
       }
     }
 
     // found the specifically requested instance, exiting...
     if ($event_id && !empty($this->events[$event_id])) {
       return array($this->events[$event_id]);
     }
 
     // use libkolab to compute recurring events
     if (class_exists('kolabcalendaring')) {
         $recurrence = new kolab_date_recurrence($object);
     }
     else {
       // fallback to local recurrence implementation
       require_once($this->cal->home . '/lib/calendar_recurrence.php');
       $recurrence = new calendar_recurrence($this->cal, $event);
     }
 
     $i = 0;
     while ($next_event = $recurrence->next_instance()) {
       $datestr = $next_event['start']->format('Ymd');
       $instance_id = $next_event['start']->format($recurrence_id_format);
 
       // use this event data for future recurring instances
       if ($futuredata[$datestr])
         $overlay_data = $futuredata[$datestr];
 
       // add to output if in range
       $rec_id = $event['uid'] . '-' . $instance_id;
       if (($next_event['start'] <= $end && $next_event['end'] >= $start) || ($event_id && $rec_id == $event_id)) {
-        $rec_event = $this->_to_driver_event($next_event);
+        $rec_event = $this->_to_driver_event($next_event, false, false);
         $rec_event['_instance'] = $instance_id;
         $rec_event['_count'] = $i + 1;
 
         if ($overlay_data || $exdata[$datestr])  // copy data from exception
           kolab_driver::merge_exception_data($rec_event, $exdata[$datestr] ?: $overlay_data);
 
         $rec_event['id'] = $rec_id;
         $rec_event['recurrence_id'] = $event['uid'];
         $rec_event['recurrence'] = $recurrence_rule;
         unset($rec_event['_attendees']);
         $events[] = $rec_event;
 
         if ($rec_id == $event_id) {
           $this->events[$rec_id] = $rec_event;
           break;
         }
       }
       else if ($next_event['start'] > $end)  // stop loop if out of range
         break;
 
       // avoid endless recursion loops
       if (++$i > 1000)
           break;
     }
     
     return $events;
   }
 
   /**
    * Convert from Kolab_Format to internal representation
    */
-  private function _to_driver_event($record, $noinst = false)
+  private function _to_driver_event($record, $noinst = false, $links = true)
   {
     $record['calendar'] = $this->id;
-    $record['links'] = $this->get_links($record['uid']);
+
+    if ($links && !array_key_exists('links', $record)) {
+      $record['links'] = $this->get_links($record['uid']);
+    }
 
     if ($this->get_namespace() == 'other') {
       $record['className'] = 'fc-event-ns-other';
       $record = kolab_driver::add_partstat_class($record, array('NEEDS-ACTION','DECLINED'), $this->get_owner());
     }
 
     // add instance identifier to first occurrence (master event)
     $recurrence_id_format = libcalendaring::recurrence_id_format($record);
     if (!$noinst && $record['recurrence'] && !$record['recurrence_id'] && !$record['_instance']) {
       $record['_instance'] = $record['start']->format($recurrence_id_format);
     }
     else if (is_a($record['recurrence_date'], 'DateTime')) {
       $record['_instance'] = $record['recurrence_date']->format($recurrence_id_format);
     }
 
     // clean up exception data
     if ($record['recurrence'] && is_array($record['recurrence']['EXCEPTIONS'])) {
       array_walk($record['recurrence']['EXCEPTIONS'], function(&$exception) {
         unset($exception['_mailbox'], $exception['_msguid'], $exception['_formatobj'], $exception['_attachments']);
       });
     }
 
     return $record;
   }
 
    /**
    * Convert the given event record into a data structure that can be passed to Kolab_Storage backend for saving
    * (opposite of self::_to_driver_event())
    */
   private function _from_driver_event($event, $old = array())
   {
     // set current user as ORGANIZER
     $identity = $this->cal->rc->user->list_emails(true);
     if (empty($event['attendees']) && $identity['email'])
       $event['attendees'] = array(array('role' => 'ORGANIZER', 'name' => $identity['name'], 'email' => $identity['email']));
 
     $event['_owner'] = $identity['email'];
 
     // remove EXDATE values if RDATE is given
     if (!empty($event['recurrence']['RDATE'])) {
       $event['recurrence']['EXDATE'] = array();
     }
 
     // remove recurrence information (e.g. EXDATES and EXCEPTIONS) entirely
     if ($event['recurrence'] && empty($event['recurrence']['FREQ']) && empty($event['recurrence']['RDATE'])) {
       $event['recurrence'] = array();
     }
 
     // keep 'comment' from initial itip invitation
     if (!empty($old['comment'])) {
       $event['comment'] = $old['comment'];
     }
 
     // clean up exception data
     if (is_array($event['exceptions'])) {
       array_walk($event['exceptions'], function(&$exception) {
         unset($exception['_mailbox'], $exception['_msguid'], $exception['_formatobj'], $exception['_attachments'],
           $event['attachments'], $event['deleted_attachments'], $event['recurrence_id']);
       });
     }
 
 
     // remove some internal properties which should not be saved
     unset($event['_savemode'], $event['_fromcalendar'], $event['_identity'], $event['_folder_id'],
       $event['recurrence_id'], $event['attachments'], $event['deleted_attachments'], $event['className']);
 
     // copy meta data (starting with _) from old object
     foreach ((array)$old as $key => $val) {
       if (!isset($event[$key]) && $key[0] == '_')
         $event[$key] = $val;
     }
 
     return $event;
   }
 
   /**
    * Match the given word in the event contents
    */
   public function fulltext_match($event, $word, $recursive = true)
   {
     $hits = 0;
     foreach ($this->search_fields as $col) {
       $sval = is_array($event[$col]) ? self::_complex2string($event[$col]) : $event[$col];
       if (empty($sval))
         continue;
 
       // do a simple substring matching (to be improved)
       $val = mb_strtolower($sval);
       if (strpos($val, $word) !== false) {
         $hits++;
         break;
       }
     }
 
     return $hits;
   }
 
   /**
    * Convert a complex event attribute to a string value
    */
   private static function _complex2string($prop)
   {
       static $ignorekeys = array('role','status','rsvp');
 
       $out = '';
       if (is_array($prop)) {
           foreach ($prop as $key => $val) {
               if (is_numeric($key)) {
                   $out .= self::_complex2string($val);
               }
               else if (!in_array($key, $ignorekeys)) {
                 $out .= $val . ' ';
             }
           }
       }
       else if (is_string($prop) || is_numeric($prop)) {
           $out .= $prop . ' ';
       }
 
       return rtrim($out);
   }
 
 }
diff --git a/plugins/calendar/drivers/kolab/kolab_driver.php b/plugins/calendar/drivers/kolab/kolab_driver.php
index 8f47a457..0eafc3bd 100644
--- a/plugins/calendar/drivers/kolab/kolab_driver.php
+++ b/plugins/calendar/drivers/kolab/kolab_driver.php
@@ -1,2525 +1,2546 @@
 <?php
 
 /**
  * Kolab driver for the Calendar plugin
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  * @author Aleksander Machniak <machniak@kolabsys.com>
  *
  * Copyright (C) 2012-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_driver extends calendar_driver
 {
   const INVITATIONS_CALENDAR_PENDING  = '--invitation--pending';
   const INVITATIONS_CALENDAR_DECLINED = '--invitation--declined';
 
   // features this backend supports
   public $alarms = true;
   public $attendees = true;
   public $freebusy = true;
   public $attachments = true;
   public $undelete = true;
   public $alarm_types = array('DISPLAY','AUDIO');
   public $categoriesimmutable = true;
 
   private $rc;
   private $cal;
   private $calendars;
   private $has_writeable = false;
   private $freebusy_trigger = false;
   private $bonnie_api = false;
 
   /**
    * Default constructor
    */
   public function __construct($cal)
   {
     $cal->require_plugin('libkolab');
 
     // load helper classes *after* libkolab has been loaded (#3248)
     require_once(dirname(__FILE__) . '/kolab_calendar.php');
     require_once(dirname(__FILE__) . '/kolab_user_calendar.php');
     require_once(dirname(__FILE__) . '/kolab_invitation_calendar.php');
 
     $this->cal = $cal;
-    $this->rc = $cal->rc;
-    $this->_read_calendars();
-    
+    $this->rc  = $cal->rc;
+
     $this->cal->register_action('push-freebusy', array($this, 'push_freebusy'));
     $this->cal->register_action('calendar-acl', array($this, 'calendar_acl'));
-    
+
     $this->freebusy_trigger = $this->rc->config->get('calendar_freebusy_trigger', false);
 
     if (kolab_storage::$version == '2.0') {
         $this->alarm_types = array('DISPLAY');
         $this->alarm_absolute = false;
     }
 
     // get configuration for the Bonnie API
     $this->bonnie_api = libkolab::get_bonnie_api();
 
     // calendar uses fully encoded identifiers
     kolab_storage::$encode_ids = true;
   }
 
 
   /**
    * Read available calendars from server
    */
   private function _read_calendars()
   {
     // already read sources
     if (isset($this->calendars))
       return $this->calendars;
 
     // get all folders that have "event" type, sorted by namespace/name
     $folders = kolab_storage::sort_folders(kolab_storage::get_folders('event') + kolab_storage::get_user_folders('event', true));
-    $this->calendars = array();
 
+    $this->calendars = array();
     foreach ($folders as $folder) {
       if ($folder instanceof kolab_storage_folder_user) {
-        $calendar = new kolab_user_calendar($folder->name, $this->cal);
+        $calendar = new kolab_user_calendar($folder, $this->cal);
         $calendar->subscriptions = count($folder->children) > 0;
       }
       else {
         $calendar = new kolab_calendar($folder->name, $this->cal);
       }
 
       if ($calendar->ready) {
         $this->calendars[$calendar->id] = $calendar;
         if ($calendar->editable)
           $this->has_writeable = true;
       }
     }
 
     return $this->calendars;
   }
 
   /**
    * Get a list of available calendars from this source
    *
    * @param integer $filter Bitmask defining filter criterias
    * @param object $tree   Reference to hierarchical folder tree object
    *
    * @return array List of calendars
    */
   public function list_calendars($filter = 0, &$tree = null)
   {
+    $this->_read_calendars();
+
     // attempt to create a default calendar for this user
     if (!$this->has_writeable) {
       if ($this->create_calendar(array('name' => 'Calendar', 'color' => 'cc0000'))) {
-         unset($this->calendars);
+        unset($this->calendars);
         $this->_read_calendars();
       }
     }
 
     $delim = $this->rc->get_storage()->get_hierarchy_delimiter();
     $folders = $this->filter_calendars($filter);
     $calendars = array();
 
     // include virtual folders for a full folder tree
     if (!is_null($tree))
       $folders = kolab_storage::folder_hierarchy($folders, $tree);
 
     foreach ($folders as $id => $cal) {
       $fullname = $cal->get_name();
       $listname = $cal->get_foldername();
       $imap_path = explode($delim, $cal->name);
 
       // find parent
       do {
         array_pop($imap_path);
         $parent_id = kolab_storage::folder_id(join($delim, $imap_path));
       }
       while (count($imap_path) > 1 && !$this->calendars[$parent_id]);
 
       // restore "real" parent ID
       if ($parent_id && !$this->calendars[$parent_id]) {
           $parent_id = kolab_storage::folder_id($cal->get_parent());
       }
 
       // turn a kolab_storage_folder object into a kolab_calendar
       if ($cal instanceof kolab_storage_folder) {
           $cal = new kolab_calendar($cal->name, $this->cal);
           $this->calendars[$cal->id] = $cal;
       }
 
       // special handling for user or virtual folders
       if ($cal instanceof kolab_storage_folder_user) {
         $calendars[$cal->id] = array(
-          'id' => $cal->id,
-          'name' => kolab_storage::object_name($fullname),
+          'id'       => $cal->id,
+          'name'     => $fullname,
           'listname' => $listname,
           'editname' => $cal->get_foldername(),
           'color'    => $cal->get_color(),
           'active'   => $cal->is_active(),
           'title'    => $cal->get_owner(),
           'owner'    => $cal->get_owner(),
           'history'  => false,
           'virtual'  => false,
           'editable' => false,
           'group'     => 'other',
           'class'     => 'user',
           'removable' => true,
         );
       }
       else if ($cal->virtual) {
         $calendars[$cal->id] = array(
           'id' => $cal->id,
           'name' => $fullname,
           'listname' => $listname,
           'editname' => $cal->get_foldername(),
           'virtual'  => true,
           'editable' => false,
           'group'     => $cal->get_namespace(),
           'class'     => 'folder',
         );
       }
       else {
         $calendars[$cal->id] = array(
           'id'       => $cal->id,
           'name'     => $fullname,
           'listname' => $listname,
           'editname' => $cal->get_foldername(),
           'title'    => $cal->get_title(),
           'color'    => $cal->get_color(),
           'editable' => $cal->editable,
           'rights'    => $cal->rights,
           'showalarms' => $cal->alarms,
           'history'  => !empty($this->bonnie_api),
           'group'    => $cal->get_namespace(),
           'default'  => $cal->default,
           'active'   => $cal->is_active(),
           'owner'    => $cal->get_owner(),
           'children' => true,  // TODO: determine if that folder indeed has child folders
           'parent'   => $parent_id,
           'subtype'  => $cal->subtype,
           'caldavurl' => $cal->get_caldav_url(),
           'removable' => !$cal->default,
         );
       }
 
       if ($cal->subscriptions) {
         $calendars[$cal->id]['subscribed'] = $cal->is_subscribed();
       }
     }
 
     // list virtual calendars showing invitations
     if ($this->rc->config->get('kolab_invitation_calendars')) {
       foreach (array(self::INVITATIONS_CALENDAR_PENDING, self::INVITATIONS_CALENDAR_DECLINED) as $id) {
         $cal = new kolab_invitation_calendar($id, $this->cal);
         $this->calendars[$cal->id] = $cal;
         if (!($filter & self::FILTER_ACTIVE) || $cal->is_active()) {
           $calendars[$id] = array(
             'id'       => $cal->id,
             'name'     => $cal->get_name(),
             'listname' => $cal->get_name(),
             'editname' => $cal->get_foldername(),
             'title'    => $cal->get_title(),
             'color'    => $cal->get_color(),
             'editable' => $cal->editable,
             'rights'    => $cal->rights,
             'showalarms' => $cal->alarms,
             'history'  => !empty($this->bonnie_api),
             'group'    => 'x-invitations',
             'default'  => false,
             'active'   => $cal->is_active(),
             'owner'    => $cal->get_owner(),
             'children' => false,
           );
 
           if ($id == self::INVITATIONS_CALENDAR_PENDING) {
             $calendars[$id]['counts'] = true;
           }
 
           if (is_object($tree)) {
             $tree->children[] = $cal;
           }
         }
       }
     }
 
     // append the virtual birthdays calendar
     if ($this->rc->config->get('calendar_contact_birthdays', false)) {
       $id = self::BIRTHDAY_CALENDAR_ID;
       $prefs = $this->rc->config->get('kolab_calendars', array());  // read local prefs
       if (!($filter & self::FILTER_ACTIVE) || $prefs[$id]['active']) {
         $calendars[$id] = array(
           'id'         => $id,
           'name'       => $this->cal->gettext('birthdays'),
           'listname'   => $this->cal->gettext('birthdays'),
           'color'      => $prefs[$id]['color'] ?: '87CEFA',
           'active'     => (bool)$prefs[$id]['active'],
           'showalarms' => (bool)$this->rc->config->get('calendar_birthdays_alarm_type'),
           'group'      => 'x-birthdays',
           'editable'  => false,
           'default'    => false,
           'children'   => false,
           'history'    => false,
         );
       }
     }
 
     return $calendars;
   }
 
   /**
    * Get list of calendars according to specified filters
    *
    * @param integer Bitmask defining restrictions. See FILTER_* constants for possible values.
    *
    * @return array List of calendars
    */
   protected function filter_calendars($filter)
   {
+    $this->_read_calendars();
+
     $calendars = array();
 
     $plugin = $this->rc->plugins->exec_hook('calendar_list_filter', array(
       'list'      => $this->calendars,
       'calendars' => $calendars,
       'filter'    => $filter,
       'editable'  => ($filter & self::FILTER_WRITEABLE),
       'insert'    => ($filter & self::FILTER_INSERTABLE),
       'active'    => ($filter & self::FILTER_ACTIVE),
       'personal'  => ($filter & self::FILTER_PERSONAL)
     ));
 
     if ($plugin['abort']) {
       return $plugin['calendars'];
     }
 
     foreach ($this->calendars as $cal) {
       if (!$cal->ready) {
         continue;
       }
       if (($filter & self::FILTER_WRITEABLE) && !$cal->editable) {
         continue;
       }
       if (($filter & self::FILTER_INSERTABLE) && !$cal->insert) {
         continue;
       }
       if (($filter & self::FILTER_ACTIVE) && !$cal->is_active()) {
         continue;
       }
       if (($filter & self::FILTER_PRIVATE) && $cal->subtype != 'private') {
         continue;
       }
       if (($filter & self::FILTER_CONFIDENTIAL) && $cal->subtype != 'confidential') {
         continue;
       }
       if (($filter & self::FILTER_PERSONAL) && $cal->get_namespace() != 'personal') {
         continue;
       }
       $calendars[$cal->id] = $cal;
     }
 
     return $calendars;
   }
 
 
   /**
    * Get the kolab_calendar instance for the given calendar ID
    *
    * @param string Calendar identifier (encoded imap folder name)
    * @return object kolab_calendar Object nor null if calendar doesn't exist
    */
   public function get_calendar($id)
   {
+    $this->_read_calendars();
+
     // create calendar object if necesary
-    if (!$this->calendars[$id] && in_array($id, array(self::INVITATIONS_CALENDAR_PENDING, self::INVITATIONS_CALENDAR_DECLINED))) {
-      $this->calendars[$id] = new kolab_invitation_calendar($id, $this->cal);
-    }
-    else if (!$this->calendars[$id] && $id !== self::BIRTHDAY_CALENDAR_ID) {
-      $calendar = kolab_calendar::factory($id, $this->cal);
-      if ($calendar->ready)
-        $this->calendars[$calendar->id] = $calendar;
+    if (!$this->calendars[$id]) {
+      if (in_array($id, array(self::INVITATIONS_CALENDAR_PENDING, self::INVITATIONS_CALENDAR_DECLINED))) {
+        $this->calendars[$id] = new kolab_invitation_calendar($id, $this->cal);
+      }
+      else if ($id !== self::BIRTHDAY_CALENDAR_ID) {
+        $calendar = kolab_calendar::factory($id, $this->cal);
+        if ($calendar->ready) {
+          $this->calendars[$calendar->id] = $calendar;
+        }
+      }
     }
 
     return $this->calendars[$id];
   }
 
   /**
    * Create a new calendar assigned to the current user
    *
    * @param array Hash array with calendar properties
    *    name: Calendar name
    *   color: The color of the calendar
    * @return mixed ID of the calendar on success, False on error
    */
   public function create_calendar($prop)
   {
     $prop['type'] = 'event';
     $prop['active'] = true;
     $prop['subscribed'] = true;
     $folder = kolab_storage::folder_update($prop);
 
     if ($folder === false) {
       $this->last_error = $this->cal->gettext(kolab_storage::$last_error);
       return false;
     }
 
     // create ID
     $id = kolab_storage::folder_id($folder);
 
     // save color in user prefs (temp. solution)
     $prefs['kolab_calendars'] = $this->rc->config->get('kolab_calendars', array());
 
     if (isset($prop['color']))
       $prefs['kolab_calendars'][$id]['color'] = $prop['color'];
     if (isset($prop['showalarms']))
       $prefs['kolab_calendars'][$id]['showalarms'] = $prop['showalarms'] ? true : false;
 
     if ($prefs['kolab_calendars'][$id])
       $this->rc->user->save_prefs($prefs);
 
     return $id;
   }
 
 
   /**
    * Update properties of an existing calendar
    *
    * @see calendar_driver::edit_calendar()
    */
   public function edit_calendar($prop)
   {
     if ($prop['id'] && ($cal = $this->get_calendar($prop['id']))) {
       $id = $cal->update($prop);
     }
     else {
       $id = $prop['id'];
     }
 
     // fallback to local prefs
     $prefs['kolab_calendars'] = $this->rc->config->get('kolab_calendars', array());
     unset($prefs['kolab_calendars'][$prop['id']]['color'], $prefs['kolab_calendars'][$prop['id']]['showalarms']);
 
     if (isset($prop['color']))
       $prefs['kolab_calendars'][$id]['color'] = $prop['color'];
 
     if (isset($prop['showalarms']) && $id == self::BIRTHDAY_CALENDAR_ID)
       $prefs['calendar_birthdays_alarm_type'] = $prop['showalarms'] ? $this->alarm_types[0] : '';
     else if (isset($prop['showalarms']))
       $prefs['kolab_calendars'][$id]['showalarms'] = $prop['showalarms'] ? true : false;
 
     if (!empty($prefs['kolab_calendars'][$id]))
       $this->rc->user->save_prefs($prefs);
 
     return true;
   }
 
 
   /**
    * Set active/subscribed state of a calendar
    *
    * @see calendar_driver::subscribe_calendar()
    */
   public function subscribe_calendar($prop)
   {
     if ($prop['id'] && ($cal = $this->get_calendar($prop['id'])) && is_object($cal->storage)) {
       $ret = false;
       if (isset($prop['permanent']))
         $ret |= $cal->storage->subscribe(intval($prop['permanent']));
       if (isset($prop['active']))
         $ret |= $cal->storage->activate(intval($prop['active']));
 
       // apply to child folders, too
       if ($prop['recursive']) {
         foreach ((array)kolab_storage::list_folders($cal->storage->name, '*', 'event') as $subfolder) {
           if (isset($prop['permanent']))
             ($prop['permanent'] ? kolab_storage::folder_subscribe($subfolder) : kolab_storage::folder_unsubscribe($subfolder));
           if (isset($prop['active']))
             ($prop['active'] ? kolab_storage::folder_activate($subfolder) : kolab_storage::folder_deactivate($subfolder));
         }
       }
       return $ret;
     }
     else {
       // save state in local prefs
       $prefs['kolab_calendars'] = $this->rc->config->get('kolab_calendars', array());
       $prefs['kolab_calendars'][$prop['id']]['active'] = (bool)$prop['active'];
       $this->rc->user->save_prefs($prefs);
       return true;
     }
 
     return false;
   }
 
 
   /**
    * Delete the given calendar with all its contents
    *
    * @see calendar_driver::delete_calendar()
    */
   public function delete_calendar($prop)
   {
     if ($prop['id'] && ($cal = $this->get_calendar($prop['id']))) {
       $folder = $cal->get_realname();
       // TODO: unsubscribe if no admin rights
       if (kolab_storage::folder_delete($folder)) {
         // remove color in user prefs (temp. solution)
         $prefs['kolab_calendars'] = $this->rc->config->get('kolab_calendars', array());
         unset($prefs['kolab_calendars'][$prop['id']]);
 
         $this->rc->user->save_prefs($prefs);
         return true;
       }
       else
         $this->last_error = kolab_storage::$last_error;
     }
 
     return false;
   }
 
 
   /**
    * Search for shared or otherwise not listed calendars the user has access
    *
    * @param string Search string
    * @param string Section/source to search
    * @return array List of calendars
    */
   public function search_calendars($query, $source)
   {
     if (!kolab_storage::setup())
       return array();
 
     $this->calendars = array();
     $this->search_more_results = false;
 
     // find unsubscribed IMAP folders that have "event" type
     if ($source == 'folders') {
       foreach ((array)kolab_storage::search_folders('event', $query, array('other')) as $folder) {
         $calendar = new kolab_calendar($folder->name, $this->cal);
         $this->calendars[$calendar->id] = $calendar;
       }
     }
     // find other user's virtual calendars
     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, $count) as $user) {
         $calendar = new kolab_user_calendar($user, $this->cal);
         $this->calendars[$calendar->id] = $calendar;
 
         // search for calendar folders shared by this user
         foreach (kolab_storage::list_user_folders($user, 'event', false) as $foldername) {
           $cal = new kolab_calendar($foldername, $this->cal);
           $this->calendars[$cal->id] = $cal;
           $calendar->subscriptions = true;
         }
       }
 
       if ($count > $limit) {
         $this->search_more_results = true;
       }
     }
 
     // don't list the birthday calendar
     $this->rc->config->set('calendar_contact_birthdays', false);
     $this->rc->config->set('kolab_invitation_calendars', false);
 
     return $this->list_calendars();
   }
 
 
   /**
    * Fetch a single event
    *
    * @see calendar_driver::get_event()
    * @return array Hash array with event properties, false if not found
    */
   public function get_event($event, $scope = 0, $full = false)
   {
     if (is_array($event)) {
       $id = $event['id'] ?: $event['uid'];
       $cal = $event['calendar'];
 
       // we're looking for a recurring instance: expand the ID to our internal convention for recurring instances
       if (!$event['id'] && $event['_instance']) {
         $id .= '-' . $event['_instance'];
       }
     }
     else {
       $id = $event;
     }
 
     if ($cal) {
       if ($storage = $this->get_calendar($cal)) {
         $result = $storage->get_event($id);
         return self::to_rcube_event($result);
       }
       // get event from the address books birthday calendar
       else if ($cal == self::BIRTHDAY_CALENDAR_ID) {
         return $this->get_birthday_event($id);
       }
     }
     // iterate over all calendar folders and search for the event ID
     else {
       foreach ($this->filter_calendars($scope) as $calendar) {
         if ($result = $calendar->get_event($id)) {
           return self::to_rcube_event($result);
         }
       }
     }
 
     return false;
   }
 
   /**
    * Add a single event to the database
    *
    * @see calendar_driver::new_event()
    */
   public function new_event($event)
   {
     if (!$this->validate($event))
       return false;
 
     $event = self::from_rcube_event($event);
 
-    $cid = $event['calendar'] ? $event['calendar'] : reset(array_keys($this->calendars));
-    if ($storage = $this->get_calendar($cid)) {
+    if (!$event['calendar']) {
+      $this->_read_calendars();
+      $event['calendar'] = reset(array_keys($this->calendars));
+    }
+
+    if ($storage = $this->get_calendar($event['calendar'])) {
       // if this is a recurrence instance, append as exception to an already existing object for this UID
       if (!empty($event['recurrence_date']) && ($master = $storage->get_event($event['uid']))) {
         self::add_exception($master, $event);
         $success = $storage->update_event($master);
       }
       else {
         $success = $storage->insert_event($event);
       }
 
       if ($success && $this->freebusy_trigger) {
         $this->rc->output->command('plugin.ping_url', array('action' => 'calendar/push-freebusy', 'source' => $storage->id));
         $this->freebusy_trigger = false; // disable after first execution (#2355)
       }
       
       return $success;
     }
 
     return false;
   }
 
   /**
    * Update an event entry with the given data
    *
    * @see calendar_driver::new_event()
    * @return boolean True on success, False on error
    */
   public function edit_event($event)
   {
      if (!($storage = $this->get_calendar($event['calendar'])))
        return false;
 
     return $this->update_event(self::from_rcube_event($event, $storage->get_event($event['id'])));
   }
 
   /**
    * Extended event editing with possible changes to the argument
    *
    * @param array  Hash array with event properties
    * @param string New participant status
    * @param array  List of hash arrays with updated attendees
    * @return boolean True on success, False on error
    */
   public function edit_rsvp(&$event, $status, $attendees)
   {
     $update_event = $event;
 
     // apply changes to master (and all exceptions)
     if ($event['_savemode'] == 'all' && $event['recurrence_id']) {
       if ($storage = $this->get_calendar($event['calendar'])) {
         $update_event = $storage->get_event($event['recurrence_id']);
         $update_event['_savemode'] = $event['_savemode'];
         $update_event['id'] = $update_event['uid'];
         unset($update_event['recurrence_id']);
         calendar::merge_attendee_data($update_event, $attendees);
       }
     }
 
     if ($ret = $this->update_attendees($update_event, $attendees)) {
       // replace with master event (for iTip reply)
       $event = self::to_rcube_event($update_event);
 
       // re-assign to the according (virtual) calendar
       if ($this->rc->config->get('kolab_invitation_calendars')) {
         if (strtoupper($status) == 'DECLINED')
           $event['calendar'] = self::INVITATIONS_CALENDAR_DECLINED;
         else if (strtoupper($status) == 'NEEDS-ACTION')
           $event['calendar'] = self::INVITATIONS_CALENDAR_PENDING;
         else if ($event['_folder_id'])
           $event['calendar'] = $event['_folder_id'];
       }
     }
 
     return $ret;
   }
 
   /**
    * Update the participant status for the given attendees
    *
    * @see calendar_driver::update_attendees()
    */
   public function update_attendees(&$event, $attendees)
   {
     // for this-and-future updates, merge the updated attendees onto all exceptions in range
     if (($event['_savemode'] == 'future' && $event['recurrence_id']) || (!empty($event['recurrence']) && !$event['recurrence_id'])) {
       if (!($storage = $this->get_calendar($event['calendar'])))
         return false;
 
       // load master event
       $master = $event['recurrence_id'] ? $storage->get_event($event['recurrence_id']) : $event;
 
       // apply attendee update to each existing exception
       if ($master['recurrence'] && !empty($master['recurrence']['EXCEPTIONS'])) {
         $saved = false;
         foreach ($master['recurrence']['EXCEPTIONS'] as $i => $exception) {
           // merge the new event properties onto future exceptions
           if ($exception['_instance'] >= strval($event['_instance'])) {
             calendar::merge_attendee_data($master['recurrence']['EXCEPTIONS'][$i], $attendees);
           }
           // update a specific instance
           if ($exception['_instance'] == $event['_instance'] && $exception['thisandfuture']) {
             $saved = true;
           }
         }
 
         // add the given event as new exception
         if (!$saved && $event['id'] != $master['id']) {
           $event['thisandfuture'] = true;
           $master['recurrence']['EXCEPTIONS'][] = $event;
         }
 
         // set link to top-level exceptions
         $master['exceptions'] = &$master['recurrence']['EXCEPTIONS'];
 
         return $this->update_event($master);
       }
     }
 
     // just update the given event (instance)
     return $this->update_event($event);
   }
 
   /**
    * Move a single event
    *
    * @see calendar_driver::move_event()
    * @return boolean True on success, False on error
    */
   public function move_event($event)
   {
     if (($storage = $this->get_calendar($event['calendar'])) && ($ev = $storage->get_event($event['id']))) {
       unset($ev['sequence']);
       self::clear_attandee_noreply($ev);
       return $this->update_event($event + $ev);
     }
 
     return false;
   }
 
   /**
    * Resize a single event
    *
    * @see calendar_driver::resize_event()
    * @return boolean True on success, False on error
    */
   public function resize_event($event)
   {
     if (($storage = $this->get_calendar($event['calendar'])) && ($ev = $storage->get_event($event['id']))) {
       unset($ev['sequence']);
       self::clear_attandee_noreply($ev);
       return $this->update_event($event + $ev);
     }
 
     return false;
   }
 
   /**
    * Remove a single event
    *
    * @param array   Hash array with event properties:
    *      id: Event identifier
    * @param boolean Remove record(s) irreversible (mark as deleted otherwise)
    *
    * @return boolean True on success, False on error
    */
   public function remove_event($event, $force = true)
   {
     $ret = true;
     $success = false;
     $savemode = $event['_savemode'];
     $decline  = $event['_decline'];
 
     if (($storage = $this->get_calendar($event['calendar'])) && ($event = $storage->get_event($event['id']))) {
       $event['_savemode'] = $savemode;
       $savemode = 'all';
       $master = $event;
 
       $this->rc->session->remove('calendar_restore_event_data');
 
       // read master if deleting a recurring event
       if ($event['recurrence'] || $event['recurrence_id'] || $event['isexception']) {
         $master = $storage->get_event($event['uid']);
         $savemode = $event['_savemode'] ?: ($event['_instance'] || $event['isexception'] ? 'current' : 'all');
 
         // force 'current' mode for single occurrences stored as exception
         if (!$event['recurrence'] && !$event['recurrence_id'] && $event['isexception'])
           $savemode = 'current';
       }
 
       // removing an exception instance
       if (($event['recurrence_id'] || $event['isexception']) && is_array($master['exceptions'])) {
         foreach ($master['exceptions'] as $i => $exception) {
           if ($exception['_instance'] == $event['_instance']) {
             unset($master['exceptions'][$i]);
             // set event date back to the actual occurrence
             if ($exception['recurrence_date'])
               $event['start'] = $exception['recurrence_date'];
           }
         }
 
         if (is_array($master['recurrence'])) {
           $master['recurrence']['EXCEPTIONS'] = &$master['exceptions'];
         }
       }
 
       switch ($savemode) {
         case 'current':
           $_SESSION['calendar_restore_event_data'] = $master;
 
           // removing the first instance => just move to next occurence
           if ($master['recurrence'] && $event['_instance'] == libcalendaring::recurrence_instance_identifier($master)) {
             $recurring = reset($storage->get_recurring_events($event, $event['start'], null, $event['id'].'-1'));
 
             // no future instances found: delete the master event (bug #1677)
             if (!$recurring['start']) {
               $success = $storage->delete_event($master, $force);
               break;
             }
 
             $master['start'] = $recurring['start'];
             $master['end'] = $recurring['end'];
             if ($master['recurrence']['COUNT'])
               $master['recurrence']['COUNT']--;
           }
           // remove the matching RDATE entry
           else if ($master['recurrence']['RDATE']) {
             foreach ($master['recurrence']['RDATE'] as $j => $rdate) {
               if ($rdate->format('Ymd') == $event['start']->format('Ymd')) {
                 unset($master['recurrence']['RDATE'][$j]);
                 break;
               }
             }
           }
           else {  // add exception to master event
             $master['recurrence']['EXDATE'][] = $event['start'];
           }
           $success = $storage->update_event($master);
           break;
 
         case 'future':
           $master['_instance'] = libcalendaring::recurrence_instance_identifier($master);
           if ($master['_instance'] != $event['_instance']) {
             $_SESSION['calendar_restore_event_data'] = $master;
             
             // set until-date on master event
             $master['recurrence']['UNTIL'] = clone $event['start'];
             $master['recurrence']['UNTIL']->sub(new DateInterval('P1D'));
             unset($master['recurrence']['COUNT']);
 
             // if all future instances are deleted, remove recurrence rule entirely (bug #1677)
             if ($master['recurrence']['UNTIL']->format('Ymd') == $master['start']->format('Ymd')) {
               $master['recurrence'] = array();
             }
             // remove matching RDATE entries
             else if ($master['recurrence']['RDATE']) {
               foreach ($master['recurrence']['RDATE'] as $j => $rdate) {
                 if ($rdate->format('Ymd') == $event['start']->format('Ymd')) {
                   $master['recurrence']['RDATE'] = array_slice($master['recurrence']['RDATE'], 0, $j);
                   break;
                 }
               }
             }
 
             $success = $storage->update_event($master);
             $ret = $master['uid'];
             break;
           }
 
         default:  // 'all' is default
           // removing the master event with loose exceptions (not recurring though)
           if (!empty($event['recurrence_date']) && empty($master['recurrence']) && !empty($master['exceptions'])) {
             // make the first exception the new master
             $newmaster = array_shift($master['exceptions']);
             $newmaster['exceptions'] = $master['exceptions'];
             $newmaster['_attachments'] = $master['_attachments'];
             $newmaster['_mailbox'] = $master['_mailbox'];
             $newmaster['_msguid'] = $master['_msguid'];
 
             $success = $storage->update_event($newmaster);
           }
           else if ($decline && $this->rc->config->get('kolab_invitation_calendars')) {
             // don't delete but set PARTSTAT=DECLINED
             if ($this->cal->lib->set_partstat($master, 'DECLINED')) {
               $success = $storage->update_event($master);
             }
           }
 
           if (!$success)
             $success = $storage->delete_event($master, $force);
           break;
       }
     }
     
     if ($success && $this->freebusy_trigger)
       $this->rc->output->command('plugin.ping_url', array('action' => 'calendar/push-freebusy', 'source' => $storage->id));
 
     return $success ? $ret : false;
   }
 
   /**
    * Restore a single deleted event
    *
    * @param array Hash array with event properties:
    *      id: Event identifier
    * @return boolean True on success, False on error
    */
   public function restore_event($event)
   {
     if ($storage = $this->get_calendar($event['calendar'])) {
       if (!empty($_SESSION['calendar_restore_event_data']))
         $success = $storage->update_event($_SESSION['calendar_restore_event_data']);
       else
         $success = $storage->restore_event($event);
       
       if ($success && $this->freebusy_trigger)
         $this->rc->output->command('plugin.ping_url', array('action' => 'calendar/push-freebusy', 'source' => $storage->id));
       
       return $success;
     }
 
     return false;
   }
 
   /**
    * Wrapper to update an event object depending on the given savemode
    */
   private function update_event($event)
   {
     if (!($storage = $this->get_calendar($event['calendar'])))
       return false;
 
     // move event to another folder/calendar
     if ($event['_fromcalendar'] && $event['_fromcalendar'] != $event['calendar']) {
       if (!($fromcalendar = $this->get_calendar($event['_fromcalendar'])))
         return false;
 
       $old = $fromcalendar->get_event($event['id']);
 
       if ($event['_savemode'] != 'new') {
         if (!$fromcalendar->storage->move($old['uid'], $storage->storage)) {
           return false;
         }
 
         $fromcalendar = $storage;
       }
     }
     else
       $fromcalendar = $storage;
 
     $success = false;
     $savemode = 'all';
     $attachments = array();
     $old = $master = $storage->get_event($event['id']);
 
     if (!$old || !$old['start']) {
       rcube::raise_error(array(
         'code' => 600, 'type' => 'php',
         'file' => __FILE__, 'line' => __LINE__,
         'message' => "Failed to load event object to update: id=" . $event['id']),
         true, false);
       return false;
     }
 
     // modify a recurring event, check submitted savemode to do the right things
     if ($old['recurrence'] || $old['recurrence_id'] || $old['isexception']) {
       $master = $storage->get_event($old['uid']);
       $savemode = $event['_savemode'] ?: ($old['recurrence_id'] || $old['isexception'] ? 'current' : 'all');
 
       // this-and-future on the first instance equals to 'all'
       if ($savemode == 'future' && $master['start'] && $old['_instance'] == libcalendaring::recurrence_instance_identifier($master))
         $savemode = 'all';
       // force 'current' mode for single occurrences stored as exception
       else if (!$old['recurrence'] && !$old['recurrence_id'] && $old['isexception'])
         $savemode = 'current';
     }
 
     // check if update affects scheduling and update attendee status accordingly
     $reschedule = $this->check_scheduling($event, $old, true);
 
     // keep saved exceptions (not submitted by the client)
     if ($old['recurrence']['EXDATE'] && !isset($event['recurrence']['EXDATE']))
       $event['recurrence']['EXDATE'] = $old['recurrence']['EXDATE'];
     if (isset($event['recurrence']['EXCEPTIONS']))
       $with_exceptions = true;  // exceptions already provided (e.g. from iCal import)
     else if ($old['recurrence']['EXCEPTIONS'])
       $event['recurrence']['EXCEPTIONS'] = $old['recurrence']['EXCEPTIONS'];
     else if ($old['exceptions'])
       $event['exceptions'] = $old['exceptions'];
 
     // remove some internal properties which should not be saved
     unset($event['_savemode'], $event['_fromcalendar'], $event['_identity'], $event['_owner'],
         $event['_notify'], $event['_method'], $event['_sender'], $event['_sender_utf'], $event['_size']);
 
     switch ($savemode) {
       case 'new':
         // save submitted data as new (non-recurring) event
         $event['recurrence'] = array();
         $event['_copyfrom'] = $master['_msguid'];
         $event['_mailbox'] = $master['_mailbox'];
         $event['uid'] = $this->cal->generate_uid();
         unset($event['recurrence_id'], $event['recurrence_date'], $event['_instance'], $event['id']);
 
         // copy attachment metadata to new event
         $event = self::from_rcube_event($event, $master);
 
         self::clear_attandee_noreply($event);
         if ($success = $storage->insert_event($event))
           $success = $event['uid'];
         break;
 
       case 'future':
         // create a new recurring event
         $event['_copyfrom'] = $master['_msguid'];
         $event['_mailbox'] = $master['_mailbox'];
         $event['uid'] = $this->cal->generate_uid();
         unset($event['recurrence_id'], $event['recurrence_date'], $event['_instance'], $event['id']);
 
         // copy attachment metadata to new event
         $event = self::from_rcube_event($event, $master);
-  
+
         // remove recurrence exceptions on re-scheduling
         if ($reschedule) {
           unset($event['recurrence']['EXCEPTIONS'], $event['exceptions'], $master['recurrence']['EXDATE']);
         }
         else if (is_array($event['recurrence']['EXCEPTIONS'])) {
           // only keep relevant exceptions
           $event['recurrence']['EXCEPTIONS'] = array_filter($event['recurrence']['EXCEPTIONS'], function($exception) use ($event) {
             return $exception['start'] > $event['start'];
           });
           if (is_array($event['recurrence']['EXDATE'])) {
             $event['recurrence']['EXDATE'] = array_filter($event['recurrence']['EXDATE'], function($exdate) use ($event) {
               return $exdate > $event['start'];
             });
           }
           // set link to top-level exceptions
           $event['exceptions'] = &$event['recurrence']['EXCEPTIONS'];
         }
 
         // compute remaining occurrences
         if ($event['recurrence']['COUNT']) {
           if (!$old['_count'])
             $old['_count'] = $this->get_recurrence_count($master, $old['start']);
           $event['recurrence']['COUNT'] -= intval($old['_count']);
         }
 
         // remove fixed weekday when date changed
         if ($old['start']->format('Y-m-d') != $event['start']->format('Y-m-d')) {
           if (strlen($event['recurrence']['BYDAY']) == 2)
             unset($event['recurrence']['BYDAY']);
           if ($old['recurrence']['BYMONTH'] == $old['start']->format('n'))
             unset($event['recurrence']['BYMONTH']);
         }
 
         // set until-date on master event
         $master['recurrence']['UNTIL'] = clone $old['start'];
         $master['recurrence']['UNTIL']->sub(new DateInterval('P1D'));
         unset($master['recurrence']['COUNT']);
 
         // remove all exceptions after $event['start']
         if (is_array($master['recurrence']['EXCEPTIONS'])) {
           $master['recurrence']['EXCEPTIONS'] = array_filter($master['recurrence']['EXCEPTIONS'], function($exception) use ($event) {
             return $exception['start'] < $event['start'];
           });
           // set link to top-level exceptions
           $master['exceptions'] = &$master['recurrence']['EXCEPTIONS'];
         }
         if (is_array($master['recurrence']['EXDATE'])) {
           $master['recurrence']['EXDATE'] = array_filter($master['recurrence']['EXDATE'], function($exdate) use ($event) {
             return $exdate < $event['start'];
           });
         }
 
         // save new event
         if ($success = $storage->insert_event($event)) {
           $success = $event['uid'];
 
           // update master event (no rescheduling!)
           self::clear_attandee_noreply($master);
           $storage->update_event($master);
         }
         break;
 
       case 'current':
         // recurring instances shall not store recurrence rules and attachments
         $event['recurrence'] = array();
         $event['thisandfuture'] = $savemode == 'future';
         unset($event['attachments'], $event['id']);
 
         // increment sequence of this instance if scheduling is affected
         if ($reschedule) {
           $event['sequence'] = max($old['sequence'], $master['sequence']) + 1;
         }
         else if (!isset($event['sequence'])) {
           $event['sequence'] = $old['sequence'] ?: $master['sequence'];
         }
 
         // save properties to a recurrence exception instance
         if ($old['_instance'] && is_array($master['recurrence']['EXCEPTIONS'])) {
           if ($this->update_recurrence_exceptions($master, $event, $old, $savemode)) {
             $success = $storage->update_event($master, $old['id']);
             break;
           }
         }
 
         $add_exception = true;
 
         // adjust matching RDATE entry if dates changed
         if (is_array($master['recurrence']['RDATE']) && ($old_date = $old['start']->format('Ymd')) != $event['start']->format('Ymd')) {
           foreach ($master['recurrence']['RDATE'] as $j => $rdate) {
             if ($rdate->format('Ymd') == $old_date) {
               $master['recurrence']['RDATE'][$j] = $event['start'];
               sort($master['recurrence']['RDATE']);
               $add_exception = false;
               break;
             }
           }
         }
 
         // save as new exception to master event
         if ($add_exception) {
           self::add_exception($master, $event, $old);
         }
 
         $success = $storage->update_event($master);
         break;
 
       default:  // 'all' is default
         $event['id'] = $master['uid'];
         $event['uid'] = $master['uid'];
 
         // use start date from master but try to be smart on time or duration changes
         $old_start_date = $old['start']->format('Y-m-d');
         $old_start_time = $old['allday'] ? '' : $old['start']->format('H:i');
         $old_duration = $old['end']->format('U') - $old['start']->format('U');
         
         $new_start_date = $event['start']->format('Y-m-d');
         $new_start_time = $event['allday'] ? '' : $event['start']->format('H:i');
         $new_duration = $event['end']->format('U') - $event['start']->format('U');
         
         $diff = $old_start_date != $new_start_date || $old_start_time != $new_start_time || $old_duration != $new_duration;
         $date_shift = $old['start']->diff($event['start']);
         
         // shifted or resized
         if ($diff && ($old_start_date == $new_start_date || $old_duration == $new_duration)) {
           $event['start'] = $master['start']->add($date_shift);
           $event['end'] = clone $event['start'];
           $event['end']->add(new DateInterval('PT'.$new_duration.'S'));
           
           // remove fixed weekday, will be re-set to the new weekday in kolab_calendar::update_event()
           if ($old_start_date != $new_start_date) {
             if (strlen($event['recurrence']['BYDAY']) == 2)
               unset($event['recurrence']['BYDAY']);
             if ($old['recurrence']['BYMONTH'] == $old['start']->format('n'))
               unset($event['recurrence']['BYMONTH']);
           }
         }
         // dates did not change, use the ones from master
         else if ($new_start_date . $new_start_time == $old_start_date . $old_start_time) {
           $event['start'] = $master['start'];
           $event['end'] = $master['end'];
         }
 
         // when saving an instance in 'all' mode, copy recurrence exceptions over
         if ($old['recurrence_id']) {
           $event['recurrence']['EXCEPTIONS'] = $master['recurrence']['EXCEPTIONS'];
         }
         else if ($master['_instance']) {
           $event['_instance'] = $master['_instance'];
           $event['recurrence_date'] = $master['recurrence_date'];
         }
 
         // TODO: forward changes to exceptions (which do not yet have differing values stored)
         if (is_array($event['recurrence']) && is_array($event['recurrence']['EXCEPTIONS']) && !$with_exceptions) {
           // determine added and removed attendees
           $old_attendees = $current_attendees = $added_attendees = array();
           foreach ((array)$old['attendees'] as $attendee) {
             $old_attendees[] = $attendee['email'];
           }
           foreach ((array)$event['attendees'] as $attendee) {
             $current_attendees[] = $attendee['email'];
             if (!in_array($attendee['email'], $old_attendees)) {
               $added_attendees[] = $attendee;
             }
           }
           $removed_attendees = array_diff($old_attendees, $current_attendees);
 
           foreach ($event['recurrence']['EXCEPTIONS'] as $i => $exception) {
             calendar::merge_attendee_data($event['recurrence']['EXCEPTIONS'][$i], $added_attendees, $removed_attendees);
           }
 
           // adjust recurrence-id when start changed and therefore the entire recurrence chain changes
           if ($old_start_date != $new_start_date || $old_start_time != $new_start_time) {
             $recurrence_id_format = libcalendaring::recurrence_id_format($event);
             foreach ($event['recurrence']['EXCEPTIONS'] as $i => $exception) {
               $recurrence_id = is_a($exception['recurrence_date'], 'DateTime') ? $exception['recurrence_date'] :
                   rcube_utils::anytodatetime($exception['_instance'], $old['start']->getTimezone());
               if (is_a($recurrence_id, 'DateTime')) {
                 $recurrence_id->add($date_shift);
                 $event['recurrence']['EXCEPTIONS'][$i]['recurrence_date'] = $recurrence_id;
                 $event['recurrence']['EXCEPTIONS'][$i]['_instance'] = $recurrence_id->format($recurrence_id_format);
               }
             }
           }
 
           // set link to top-level exceptions
           $event['exceptions'] = &$event['recurrence']['EXCEPTIONS'];
         }
 
         // unset _dateonly flags in (cached) date objects
         unset($event['start']->_dateonly, $event['end']->_dateonly);
 
         $success = $storage->update_event($event) ? $event['id'] : false;  // return master UID
         break;
     }
 
     if ($success && $this->freebusy_trigger)
       $this->rc->output->command('plugin.ping_url', array('action' => 'calendar/push-freebusy', 'source' => $storage->id));
     
     return $success;
   }
 
   /**
    * Determine whether the current change affects scheduling and reset attendee status accordingly
    */
   public function check_scheduling(&$event, $old, $update = true)
   {
     // skip this check when importing iCal/iTip events
     if (isset($event['sequence']) || !empty($event['_method'])) {
       return false;
     }
 
     // iterate through the list of properties considered 'significant' for scheduling
     $kolab_event = $old['_formatobj'] ?: new kolab_format_event();
     $reschedule = $kolab_event->check_rescheduling($event, $old);
 
     // reset all attendee status to needs-action (#4360)
     if ($update && $reschedule && is_array($event['attendees'])) {
       $is_organizer = false;
       $emails = $this->cal->get_user_emails();
       $attendees = $event['attendees'];
       foreach ($attendees as $i => $attendee) {
         if ($attendee['role'] == 'ORGANIZER' && $attendee['email'] && in_array(strtolower($attendee['email']), $emails)) {
           $is_organizer = true;
         }
         else if ($attendee['role'] != 'ORGANIZER' && $attendee['role'] != 'NON-PARTICIPANT' && $attendee['status'] != 'DELEGATED') {
           $attendees[$i]['status'] = 'NEEDS-ACTION';
           $attendees[$i]['rsvp'] = true;
         }
       }
 
       // update attendees only if I'm the organizer
       if ($is_organizer || ($event['organizer'] && in_array(strtolower($event['organizer']['email']), $emails))) {
         $event['attendees'] = $attendees;
       }
     }
 
     return $reschedule;
   }
 
   /**
    * Apply the given changes to already existing exceptions
    */
   protected function update_recurrence_exceptions(&$master, $event, $old, $savemode)
   {
     $saved = false;
     $existing = null;
 
     // determine added and removed attendees
     $added_attendees = $removed_attendees = array();
     if ($savemode == 'future') {
       $old_attendees = $current_attendees = array();
       foreach ((array)$old['attendees'] as $attendee) {
         $old_attendees[] = $attendee['email'];
       }
       foreach ((array)$event['attendees'] as $attendee) {
         $current_attendees[] = $attendee['email'];
         if (!in_array($attendee['email'], $old_attendees)) {
           $added_attendees[] = $attendee;
         }
       }
       $removed_attendees = array_diff($old_attendees, $current_attendees);
     }
 
     foreach ($master['recurrence']['EXCEPTIONS'] as $i => $exception) {
       // update a specific instance
       if ($exception['_instance'] == $old['_instance']) {
         $existing = $i;
 
         // check savemode against existing exception mode.
         // if matches, we can update this existing exception
         if ((bool)$exception['thisandfuture'] === ($savemode == 'future')) {
           $event['_instance'] = $old['_instance'];
           $event['thisandfuture'] = $old['thisandfuture'];
           $event['recurrence_date'] = $old['recurrence_date'];
           $master['recurrence']['EXCEPTIONS'][$i] = $event;
           $saved = true;
         }
       }
       // merge the new event properties onto future exceptions
       if ($savemode == 'future' && $exception['_instance'] >= $old['_instance']) {
         unset($event['thisandfuture']);
         self::merge_exception_data($master['recurrence']['EXCEPTIONS'][$i], $event, array('attendees'));
 
         if (!empty($added_attendees) || !empty($removed_attendees)) {
           calendar::merge_attendee_data($master['recurrence']['EXCEPTIONS'][$i], $added_attendees, $removed_attendees);
         }
       }
     }
 /*
     // we could not update the existing exception due to savemode mismatch...
     if (!$saved && $existing !== null && $master['recurrence']['EXCEPTIONS'][$existing]['thisandfuture']) {
       // ... try to move the existing this-and-future exception to the next occurrence
       foreach ($this->get_recurring_events($master, $existing['start']) as $candidate) {
         // our old this-and-future exception is obsolete
         if ($candidate['thisandfuture']) {
           unset($master['recurrence']['EXCEPTIONS'][$existing]);
           $saved = true;
           break;
         }
         // this occurrence doesn't yet have an exception
         else if (!$candidate['isexception']) {
           $event['_instance'] = $candidate['_instance'];
           $event['recurrence_date'] = $candidate['recurrence_date'];
           $master['recurrence']['EXCEPTIONS'][$i] = $event;
           $saved = true;
           break;
         }
       }
     }
 */
 
     // set link to top-level exceptions
     $master['exceptions'] = &$master['recurrence']['EXCEPTIONS'];
 
     // returning false here will add a new exception
     return $saved;
   }
 
   /**
    * Add or update the given event as an exception to $master
    */
   public static function add_exception(&$master, $event, $old = null)
   {
     if ($old) {
       $event['_instance'] = $old['_instance'];
       if (!$event['recurrence_date'])
         $event['recurrence_date'] = $old['recurrence_date'] ?: $old['start'];
     }
     else if (!$event['recurrence_date']) {
       $event['recurrence_date'] = $event['start'];
     }
 
     if (!$event['_instance'] && is_a($event['recurrence_date'], 'DateTime')) {
       $event['_instance'] = libcalendaring::recurrence_instance_identifier($event);
     }
 
     if (!is_array($master['exceptions']) && is_array($master['recurrence']['EXCEPTIONS'])) {
       $master['exceptions'] = &$master['recurrence']['EXCEPTIONS'];
     }
 
     $existing = false;
     foreach ((array)$master['exceptions'] as $i => $exception) {
       if ($exception['_instance'] == $event['_instance']) {
         $master['exceptions'][$i] = $event;
         $existing = true;
       }
     }
 
     if (!$existing) {
       $master['exceptions'][] = $event;
     }
 
     return true;
   }
 
   /**
    * Remove the noreply flags from attendees
    */
   public static function clear_attandee_noreply(&$event)
   {
     foreach ((array)$event['attendees'] as $i => $attendee) {
       unset($event['attendees'][$i]['noreply']);
     }
   }
 
 
   /**
    * Merge certain properties from the overlay event to the base event object
    *
    * @param array The event object to be altered
    * @param array The overlay event object to be merged over $event
    * @param array List of properties not allowed to be overwritten
    */
   public static function merge_exception_data(&$event, $overlay, $blacklist = null)
   {
     $forbidden = array('id','uid','recurrence','recurrence_date','thisandfuture','organizer','_attachments');
 
     if (is_array($blacklist))
       $forbidden = array_merge($forbidden, $blacklist);
 
     // compute date offset from the exception
     if ($overlay['start'] instanceof DateTime && $overlay['recurrence_date'] instanceof DateTime) {
       $date_offset = $overlay['recurrence_date']->diff($overlay['start']);
     }
 
     foreach ($overlay as $prop => $value) {
       if ($prop == 'start' || $prop == 'end') {
         if (is_object($event[$prop]) && $event[$prop] instanceof DateTime) {
           // set date value if overlay is an exception of the current instance
           if (substr($overlay['_instance'], 0, 8) == substr($event['_instance'], 0, 8)) {
             $event[$prop]->setDate(intval($value->format('Y')), intval($value->format('n')), intval($value->format('j')));
           }
           // apply date offset
           else if ($date_offset) {
             $event[$prop]->add($date_offset);
           }
           // adjust time of the recurring event instance
           $event[$prop]->setTime($value->format('G'), intval($value->format('i')), intval($value->format('s')));
         }
       }
       else if ($prop == 'thisandfuture' && $overlay['_instance'] == $event['_instance']) {
         $event[$prop] = $value;
       }
       else if ($prop[0] != '_' && !in_array($prop, $forbidden))
         $event[$prop] = $value;
     }
   }
 
   /**
    * Get events from source.
    *
    * @param  integer Event's new start (unix timestamp)
    * @param  integer Event's new end (unix timestamp)
    * @param  string  Search query (optional)
    * @param  mixed   List of calendar IDs to load events from (either as array or comma-separated string)
    * @param  boolean Include virtual events (optional)
    * @param  integer Only list events modified since this time (unix timestamp)
    * @return array A list of event records
    */
   public function load_events($start, $end, $search = null, $calendars = null, $virtual = 1, $modifiedsince = null)
   {
     if ($calendars && is_string($calendars))
       $calendars = explode(',', $calendars);
-    else if (!$calendars)
+    else if (!$calendars) {
+      $this->_read_calendars();
       $calendars = array_keys($this->calendars);
+    }
 
     $query = array();
     if ($modifiedsince)
       $query[] = array('changed', '>=', $modifiedsince);
 
     $events = $categories = array();
     foreach ($calendars as $cid) {
       if ($storage = $this->get_calendar($cid)) {
         $events = array_merge($events, $storage->list_events($start, $end, $search, $virtual, $query));
         $categories += $storage->categories;
       }
     }
 
     // add events from the address books birthday calendar
     if (in_array(self::BIRTHDAY_CALENDAR_ID, $calendars)) {
       $events = array_merge($events, $this->load_birthday_events($start, $end, $search, $modifiedsince));
     }
 
     // add new categories to user prefs
     $old_categories = $this->rc->config->get('calendar_categories', $this->default_categories);
     if ($newcats = array_udiff(array_keys($categories), array_keys($old_categories), function($a, $b){ return strcasecmp($a, $b); })) {
       foreach ($newcats as $category)
         $old_categories[$category] = '';  // no color set yet
       $this->rc->user->save_prefs(array('calendar_categories' => $old_categories));
     }
 
     array_walk($events, 'kolab_driver::to_rcube_event');
     return $events;
   }
 
   /**
    * Get number of events in the given calendar
    *
    * @param  mixed   List of calendar IDs to count events (either as array or comma-separated string)
    * @param  integer Date range start (unix timestamp)
    * @param  integer Date range end (unix timestamp)
    * @return array   Hash array with counts grouped by calendar ID
    */
   public function count_events($calendars, $start, $end = null)
   {
       $counts = array();
 
       if ($calendars && is_string($calendars))
         $calendars = explode(',', $calendars);
-      else if (!$calendars)
+      else if (!$calendars) {
+        $this->_read_calendars();
         $calendars = array_keys($this->calendars);
+      }
 
       foreach ($calendars as $cid) {
         if ($storage = $this->get_calendar($cid)) {
             $counts[$cid] = $storage->count_events($start, $end);
         }
       }
 
       return $counts;
   }
 
   /**
    * Get a list of pending alarms to be displayed to the user
    *
    * @see calendar_driver::pending_alarms()
    */
   public function pending_alarms($time, $calendars = null)
   {
     $interval = 300;
     $time -= $time % 60;
     
     $slot = $time;
     $slot -= $slot % $interval;
     
     $last = $time - max(60, $this->rc->config->get('refresh_interval', 0));
     $last -= $last % $interval;
     
     // only check for alerts once in 5 minutes
     if ($last == $slot)
       return array();
     
     if ($calendars && is_string($calendars))
       $calendars = explode(',', $calendars);
     
     $time = $slot + $interval;
     
     $candidates = array();
     $query = array(array('tags', '=', 'x-has-alarms'));
+
+    $this->_read_calendars();
+
     foreach ($this->calendars as $cid => $calendar) {
       // skip calendars with alarms disabled
       if (!$calendar->alarms || ($calendars && !in_array($cid, $calendars)))
         continue;
 
       foreach ($calendar->list_events($time, $time + 86400 * 365, null, 1, $query) as $e) {
         // add to list if alarm is set
         $alarm = libcalendaring::get_next_alarm($e);
         if ($alarm && $alarm['time'] && $alarm['time'] >= $last && in_array($alarm['action'], $this->alarm_types)) {
           $id = $alarm['id'];  // use alarm-id as primary identifier
           $candidates[$id] = array(
             'id'       => $id,
             'title'    => $e['title'],
             'location' => $e['location'],
             'start'    => $e['start'],
             'end'      => $e['end'],
             'notifyat' => $alarm['time'],
             'action'   => $alarm['action'],
           );
         }
       }
     }
 
     // get alarm information stored in local database
     if (!empty($candidates)) {
       $alarm_ids = array_map(array($this->rc->db, 'quote'), array_keys($candidates));
       $result = $this->rc->db->query("SELECT *"
         . " FROM " . $this->rc->db->table_name('kolab_alarms', true)
         . " WHERE `alarm_id` IN (" . join(',', $alarm_ids) . ")"
           . " AND `user_id` = ?",
         $this->rc->user->ID
       );
 
       while ($result && ($e = $this->rc->db->fetch_assoc($result))) {
         $dbdata[$e['alarm_id']] = $e;
       }
     }
     
     $alarms = array();
     foreach ($candidates as $id => $alarm) {
       // skip dismissed alarms
       if ($dbdata[$id]['dismissed'])
         continue;
       
       // snooze function may have shifted alarm time
       $notifyat = $dbdata[$id]['notifyat'] ? strtotime($dbdata[$id]['notifyat']) : $alarm['notifyat'];
       if ($notifyat <= $time)
         $alarms[] = $alarm;
     }
     
     return $alarms;
   }
 
   /**
    * Feedback after showing/sending an alarm notification
    *
    * @see calendar_driver::dismiss_alarm()
    */
   public function dismiss_alarm($alarm_id, $snooze = 0)
   {
     $alarms_table = $this->rc->db->table_name('kolab_alarms', true);
     // delete old alarm entry
     $this->rc->db->query("DELETE FROM $alarms_table"
       . " WHERE `alarm_id` = ? AND `user_id` = ?",
       $alarm_id,
       $this->rc->user->ID
     );
 
     // set new notifyat time or unset if not snoozed
     $notifyat = $snooze > 0 ? date('Y-m-d H:i:s', time() + $snooze) : null;
 
     $query = $this->rc->db->query("INSERT INTO $alarms_table"
       . " (`alarm_id`, `user_id`, `dismissed`, `notifyat`)"
       . " VALUES (?, ?, ?, ?)",
       $alarm_id,
       $this->rc->user->ID,
       $snooze > 0 ? 0 : 1,
       $notifyat
     );
 
     return $this->rc->db->affected_rows($query);
   }
 
   /**
    * List attachments from the given event
    */
   public function list_attachments($event)
   {
     if (!($storage = $this->get_calendar($event['calendar'])))
       return false;
 
     $event = $storage->get_event($event['id']);
 
     return $event['attachments'];
   }
 
   /**
    * Get attachment properties
    */
   public function get_attachment($id, $event)
   {
     if (!($storage = $this->get_calendar($event['calendar'])))
       return false;
 
     // get old revision of event
     if ($event['rev']) {
       $event = $this->get_event_revison($event, $event['rev'], true);
     }
     else {
       $event = $storage->get_event($event['id']);
     }
 
     if ($event && !empty($event['_attachments'])) {
       foreach ($event['_attachments'] as $att) {
         if ($att['id'] == $id) {
           return $att;
         }
       }
     }
 
     return null;
   }
 
   /**
    * Get attachment body
    * @see calendar_driver::get_attachment_body()
    */
   public function get_attachment_body($id, $event)
   {
     if (!($cal = $this->get_calendar($event['calendar'])))
       return false;
 
     // get old revision of event
     if ($event['rev']) {
       if (empty($this->bonnie_api)) {
         return false;
       }
 
       $cid = substr($id, 4);
 
       // call Bonnie API and get the raw mime message
       list($uid, $mailbox, $msguid) = $this->_resolve_event_identity($event);
       if ($msg_raw = $this->bonnie_api->rawdata('event', $uid, $event['rev'], $mailbox, $msguid)) {
         // parse the message and find the part with the matching content-id
         $message = rcube_mime::parse_message($msg_raw);
         foreach ((array)$message->parts as $part) {
           if ($part->headers['content-id'] && trim($part->headers['content-id'], '<>') == $cid) {
             return $part->body;
           }
         }
       }
 
       return false;
     }
 
     return $cal->get_attachment_body($id, $event);
   }
 
   /**
    * Build a struct representing the given message reference
    *
    * @see calendar_driver::get_message_reference()
    */
   public function get_message_reference($uri_or_headers, $folder = null)
   {
       if (is_object($uri_or_headers)) {
           $uri_or_headers = kolab_storage_config::get_message_uri($uri_or_headers, $folder);
       }
 
       if (is_string($uri_or_headers)) {
           return kolab_storage_config::get_message_reference($uri_or_headers, 'event');
       }
 
       return false;
   }
 
   /**
    * List availabale categories
    * The default implementation reads them from config/user prefs
    */
   public function list_categories()
   {
     // FIXME: complete list with categories saved in config objects (KEP:12)
     return $this->rc->config->get('calendar_categories', $this->default_categories);
   }
 
   /**
    * Create instances of a recurring event
    *
    * @param array  Hash array with event properties
    * @param object DateTime Start date of the recurrence window
    * @param object DateTime End date of the recurrence window
    * @return array List of recurring event instances
    */
   public function get_recurring_events($event, $start, $end = null)
   {
     // load the given event data into a libkolabxml container
     if (!$event['_formatobj']) {
       $event_xml = new kolab_format_event();
       $event_xml->set($event);
       $event['_formatobj'] = $event_xml;
     }
 
     $this->_read_calendars();
     $storage = reset($this->calendars);
     return $storage->get_recurring_events($event, $start, $end);
   }
 
   /**
    *
    */
   private function get_recurrence_count($event, $dtstart)
   {
     // use libkolab to compute recurring events
     if (class_exists('kolabcalendaring') && $event['_formatobj']) {
         $recurrence = new kolab_date_recurrence($event['_formatobj']);
     }
     else {
       // fallback to local recurrence implementation
       require_once($this->cal->home . '/lib/calendar_recurrence.php');
       $recurrence = new calendar_recurrence($this->cal, $event);
     }
 
     $count = 0;
     while (($next_event = $recurrence->next_instance()) && $next_event['start'] <= $dtstart && $count < 1000) {
       $count++;
     }
 
     return $count;
   }
 
   /**
    * Fetch free/busy information from a person within the given range
    */
   public function get_freebusy_list($email, $start, $end)
   {
     if (empty($email)/* || $end < time()*/)
       return false;
 
     // map vcalendar fbtypes to internal values
     $fbtypemap = array(
       'FREE' => calendar::FREEBUSY_FREE,
       'BUSY-TENTATIVE' => calendar::FREEBUSY_TENTATIVE,
       'X-OUT-OF-OFFICE' => calendar::FREEBUSY_OOF,
       'OOF' => calendar::FREEBUSY_OOF);
 
     // ask kolab server first
     try {
       $request_config = array(
         'store_body'       => true,
         'follow_redirects' => true,
       );
       $request  = libkolab::http_request(kolab_storage::get_freebusy_url($email), 'GET', $request_config);
       $response = $request->send();
 
       // authentication required
       if ($response->getStatus() == 401) {
         $request->setAuth($this->rc->user->get_username(), $this->rc->decrypt($_SESSION['password']));
         $response = $request->send();
       }
 
       if ($response->getStatus() == 200)
         $fbdata = $response->getBody();
 
       unset($request, $response);
     }
     catch (Exception $e) {
       PEAR::raiseError("Error fetching free/busy information: " . $e->getMessage());
     }
 
     // get free-busy url from contacts
     if (!$fbdata) {
       $fburl = null;
       foreach ((array)$this->rc->config->get('autocomplete_addressbooks', 'sql') as $book) {
         $abook = $this->rc->get_address_book($book);
 
         if ($result = $abook->search(array('email'), $email, true, true, true/*, 'freebusyurl'*/)) {
           while ($contact = $result->iterate()) {
             if ($fburl = $contact['freebusyurl']) {
               $fbdata = @file_get_contents($fburl);
               break;
             }
           }
         }
 
         if ($fbdata)
           break;
       }
     }
 
     // parse free-busy information using Horde classes
     if ($fbdata) {
       $ical = $this->cal->get_ical();
       $ical->import($fbdata);
       if ($fb = $ical->freebusy) {
         $result = array();
         foreach ($fb['periods'] as $tuple) {
           list($from, $to, $type) = $tuple;
           $result[] = array($from->format('U'), $to->format('U'), isset($fbtypemap[$type]) ? $fbtypemap[$type] : calendar::FREEBUSY_BUSY);
         }
 
         // we take 'dummy' free-busy lists as "unknown"
         if (empty($result) && !empty($fb['comment']) && stripos($fb['comment'], 'dummy'))
           return false;
 
         // set period from $start till the begin of the free-busy information as 'unknown'
         if ($fb['start'] && ($fbstart = $fb['start']->format('U')) && $start < $fbstart) {
           array_unshift($result, array($start, $fbstart, calendar::FREEBUSY_UNKNOWN));
         }
         // pad period till $end with status 'unknown'
         if ($fb['end'] && ($fbend = $fb['end']->format('U')) && $fbend < $end) {
           $result[] = array($fbend, $end, calendar::FREEBUSY_UNKNOWN);
         }
 
         return $result;
       }
     }
 
     return false;
   }
 
   /**
    * Handler to push folder triggers when sent from client.
    * Used to push free-busy changes asynchronously after updating an event
    */
   public function push_freebusy()
   {
     // make shure triggering completes
     set_time_limit(0);
     ignore_user_abort(true);
 
     $cal = rcube_utils::get_input_value('source', rcube_utils::INPUT_GPC);
     if (!($cal = $this->get_calendar($cal)))
       return false;
 
     // trigger updates on folder
     $trigger = $cal->storage->trigger();
     if (is_object($trigger) && is_a($trigger, 'PEAR_Error')) {
       rcube::raise_error(array(
         'code' => 900, 'type' => 'php',
         'file' => __FILE__, 'line' => __LINE__,
         'message' => "Failed triggering folder. Error was " . $trigger->getMessage()),
         true, false);
     }
 
     exit;
   }
 
 
   /**
    * Convert from driver format to external caledar app data
    */
   public static function to_rcube_event(&$record)
   {
     if (!is_array($record))
       return $record;
 
     $record['id'] = $record['uid'];
 
     if ($record['_instance']) {
       $record['id'] .= '-' . $record['_instance'];
 
       if (!$record['recurrence_id'] && !empty($record['recurrence']))
         $record['recurrence_id'] = $record['uid'];
     }
 
     // all-day events go from 12:00 - 13:00
     if (is_a($record['start'], 'DateTime') && $record['end'] <= $record['start'] && $record['allday']) {
       $record['end'] = clone $record['start'];
       $record['end']->add(new DateInterval('PT1H'));
     }
 
     // translate internal '_attachments' to external 'attachments' list
     if (!empty($record['_attachments'])) {
       foreach ($record['_attachments'] as $key => $attachment) {
         if ($attachment !== false) {
           if (!$attachment['name'])
             $attachment['name'] = $key;
 
           unset($attachment['path'], $attachment['content']);
           $attachments[] = $attachment;
         }
       }
 
       $record['attachments'] = $attachments;
     }
 
     if (!empty($record['attendees'])) {
       foreach ((array)$record['attendees'] as $i => $attendee) {
         if (is_array($attendee['delegated-from'])) {
           $record['attendees'][$i]['delegated-from'] = join(', ', $attendee['delegated-from']);
         }
         if (is_array($attendee['delegated-to'])) {
           $record['attendees'][$i]['delegated-to'] = join(', ', $attendee['delegated-to']);
         }
       }
     }
 
     // Roundcube only supports one category assignment
     if (is_array($record['categories']))
       $record['categories'] = $record['categories'][0];
 
     // the cancelled flag transltes into status=CANCELLED
     if ($record['cancelled'])
       $record['status'] = 'CANCELLED';
 
     // The web client only supports DISPLAY type of alarms
     if (!empty($record['alarms']))
       $record['alarms'] = preg_replace('/:[A-Z]+$/', ':DISPLAY', $record['alarms']);
 
     // remove empty recurrence array
     if (empty($record['recurrence']))
       unset($record['recurrence']);
 
     // clean up exception data
     if (is_array($record['recurrence']['EXCEPTIONS'])) {
       array_walk($record['recurrence']['EXCEPTIONS'], function(&$exception) {
         unset($exception['_mailbox'], $exception['_msguid'], $exception['_formatobj'], $exception['_attachments']);
       });
     }
 
     unset($record['_mailbox'], $record['_msguid'], $record['_type'], $record['_size'],
       $record['_formatobj'], $record['_attachments'], $record['exceptions'], $record['x-custom']);
 
     return $record;
   }
 
   /**
    *
    */
   public static function from_rcube_event($event, $old = array())
   {
     // in kolab_storage attachments are indexed by content-id
     if (is_array($event['attachments']) || !empty($event['deleted_attachments'])) {
       $event['_attachments'] = array();
 
       foreach ($event['attachments'] as $attachment) {
         $key = null;
         // Roundcube ID has nothing to do with the storage ID, remove it
         if ($attachment['content'] || $attachment['path']) {
           unset($attachment['id']);
         }
         else {
           foreach ((array)$old['_attachments'] as $cid => $oldatt) {
             if ($attachment['id'] == $oldatt['id'])
               $key = $cid;
           }
         }
 
         // flagged for deletion => set to false
         if ($attachment['_deleted'] || in_array($attachment['id'], (array)$event['deleted_attachments'])) {
           $event['_attachments'][$key] = false;
         }
         // replace existing entry
         else if ($key) {
           $event['_attachments'][$key] = $attachment;
         }
         // append as new attachment
         else {
           $event['_attachments'][] = $attachment;
         }
       }
 
       $event['_attachments'] = array_merge((array)$old['_attachments'], $event['_attachments']);
 
       // attachments flagged for deletion => set to false
       foreach ($event['_attachments'] as $key => $attachment) {
         if ($attachment['_deleted'] || in_array($attachment['id'], (array)$event['deleted_attachments'])) {
           $event['_attachments'][$key] = false;
         }
       }
     }
 
     return $event;
   }
 
 
   /**
    * Set CSS class according to the event's attendde partstat
    */
   public static function add_partstat_class($event, $partstats, $user = null)
   {
     // set classes according to PARTSTAT
     if (is_array($event['attendees'])) {
       $user_emails = libcalendaring::get_instance()->get_user_emails($user);
       $partstat = 'UNKNOWN';
       foreach ($event['attendees'] as $attendee) {
         if (in_array($attendee['email'], $user_emails)) {
           $partstat = $attendee['status'];
           break;
         }
       }
 
       if (in_array($partstat, $partstats)) {
         $event['className'] = trim($event['className'] . ' fc-invitation-' . strtolower($partstat));
       }
     }
 
     return $event;
   }
 
   /**
    * Provide a list of revisions for the given event
    *
    * @param array  $event Hash array with event properties
    *
    * @return array List of changes, each as a hash array
    * @see calendar_driver::get_event_changelog()
    */
   public function get_event_changelog($event)
   {
     if (empty($this->bonnie_api)) {
       return false;
     }
 
     list($uid, $mailbox, $msguid) = $this->_resolve_event_identity($event);
 
     $result = $this->bonnie_api->changelog('event', $uid, $mailbox, $msguid);
     if (is_array($result) && $result['uid'] == $uid) {
       return $result['changes'];
     }
 
     return false;
   }
 
   /**
    * Get a list of property changes beteen two revisions of an event
    *
    * @param array  $event Hash array with event properties
    * @param mixed  $rev1  Old Revision
    * @param mixed  $rev2  New Revision
    *
    * @return array List of property changes, each as a hash array
    * @see calendar_driver::get_event_diff()
    */
   public function get_event_diff($event, $rev1, $rev2)
   {
     if (empty($this->bonnie_api)) {
       return false;
     }
 
     list($uid, $mailbox, $msguid) = $this->_resolve_event_identity($event);
 
     // get diff for the requested recurrence instance
     $instance_id = $event['id'] != $uid ? substr($event['id'], strlen($uid) + 1) : null;
 
     // call Bonnie API
     $result = $this->bonnie_api->diff('event', $uid, $rev1, $rev2, $mailbox, $msguid, $instance_id);
     if (is_array($result) && $result['uid'] == $uid) {
       $result['rev1'] = $rev1;
       $result['rev2'] = $rev2;
 
       $keymap = array(
         'dtstart'  => 'start',
         'dtend'    => 'end',
         'dstamp'   => 'changed',
         'summary'  => 'title',
         'alarm'    => 'alarms',
         'attendee' => 'attendees',
         'attach'   => 'attachments',
         'rrule'    => 'recurrence',
         'transparency' => 'free_busy',
         'classification' => 'sensitivity',
         'lastmodified-date' => 'changed',
       );
       $prop_keymaps = array(
         'attachments' => array('fmttype' => 'mimetype', 'label' => 'name'),
         'attendees'   => array('partstat' => 'status'),
       );
       $special_changes = array();
 
       // map kolab event properties to keys the client expects
       array_walk($result['changes'], function(&$change, $i) use ($keymap, $prop_keymaps, $special_changes) {
         if (array_key_exists($change['property'], $keymap)) {
           $change['property'] = $keymap[$change['property']];
         }
         // translate free_busy values
         if ($change['property'] == 'free_busy') {
           $change['old'] = $old['old'] ? 'free' : 'busy';
           $change['new'] = $old['new'] ? 'free' : 'busy';
         }
         // map alarms trigger value
         if ($change['property'] == 'alarms') {
           if (is_array($change['old']) && is_array($change['old']['trigger']))
             $change['old']['trigger'] = $change['old']['trigger']['value'];
           if (is_array($change['new']) && is_array($change['new']['trigger']))
             $change['new']['trigger'] = $change['new']['trigger']['value'];
         }
         // make all property keys uppercase
         if ($change['property'] == 'recurrence') {
           $special_changes['recurrence'] = $i;
           foreach (array('old','new') as $m) {
             if (is_array($change[$m])) {
               $props = array();
               foreach ($change[$m] as $k => $v)
                 $props[strtoupper($k)] = $v;
               $change[$m] = $props;
             }
           }
         }
         // map property keys names
         if (is_array($prop_keymaps[$change['property']])) {
           foreach ($prop_keymaps[$change['property']] as $k => $dest) {
             if (is_array($change['old']) && array_key_exists($k, $change['old'])) {
               $change['old'][$dest] = $change['old'][$k];
               unset($change['old'][$k]);
             }
             if (is_array($change['new']) && array_key_exists($k, $change['new'])) {
               $change['new'][$dest] = $change['new'][$k];
               unset($change['new'][$k]);
             }
           }
         }
 
         if ($change['property'] == 'exdate') {
           $special_changes['exdate'] = $i;
         }
         else if ($change['property'] == 'rdate') {
           $special_changes['rdate'] = $i;
         }
       });
 
       // merge some recurrence changes
       foreach (array('exdate','rdate') as $prop) {
         if (array_key_exists($prop, $special_changes)) {
           $exdate = $result['changes'][$special_changes[$prop]];
           if (array_key_exists('recurrence', $special_changes)) {
             $recurrence = &$result['changes'][$special_changes['recurrence']];
           }
           else {
             $i = count($result['changes']);
             $result['changes'][$i] = array('property' => 'recurrence', 'old' => array(), 'new' => array());
             $recurrence = &$result['changes'][$i]['recurrence'];
           }
           $key = strtoupper($prop);
           $recurrence['old'][$key] = $exdate['old'];
           $recurrence['new'][$key] = $exdate['new'];
           unset($result['changes'][$special_changes[$prop]]);
         }
       }
 
       return $result;
     }
 
     return false;
   }
 
   /**
    * Return full data of a specific revision of an event
    *
    * @param array  Hash array with event properties
    * @param mixed  $rev Revision number
    *
    * @return array Event object as hash array
    * @see calendar_driver::get_event_revison()
    */
   public function get_event_revison($event, $rev, $internal = false)
   {
     if (empty($this->bonnie_api)) {
       return false;
     }
 
     $eventid = $event['id'];
     $calid = $event['calendar'];
     list($uid, $mailbox, $msguid) = $this->_resolve_event_identity($event);
 
     // call Bonnie API
     $result = $this->bonnie_api->get('event', $uid, $rev, $mailbox, $msguid);
     if (is_array($result) && $result['uid'] == $uid && !empty($result['xml'])) {
       $format = kolab_format::factory('event');
       $format->load($result['xml']);
       $event = $format->to_array();
       $format->get_attachments($event, true);
 
       // get the right instance from a recurring event
       if ($eventid != $event['uid']) {
         $instance_id = substr($eventid, strlen($event['uid']) + 1);
 
         // check for recurrence exception first
         if ($instance = $format->get_instance($instance_id)) {
           $event = $instance;
         }
         else {
           // not a exception, compute recurrence...
           $event['_formatobj'] = $format;
           $recurrence_date = rcube_utils::anytodatetime($instance_id, $event['start']->getTimezone());
           foreach ($this->get_recurring_events($event, $event['start'], $recurrence_date) as $instance) {
             if ($instance['id'] == $eventid) {
               $event = $instance;
               break;
             }
           }
         }
       }
 
       if ($format->is_valid()) {
         $event['calendar'] = $calid;
         $event['rev'] = $result['rev'];
         return $internal ? $event : self::to_rcube_event($event);
       }
     }
 
     return false;
   }
 
   /**
    * Command the backend to restore a certain revision of an event.
    * This shall replace the current event with an older version.
    *
    * @param mixed  UID string or hash array with event properties:
    *        id: Event identifier
    *  calendar: Calendar identifier
    * @param mixed  $rev Revision number
    *
    * @return boolean True on success, False on failure
    */
   public function restore_event_revision($event, $rev)
   {
     if (empty($this->bonnie_api)) {
       return false;
     }
 
     list($uid, $mailbox, $msguid) = $this->_resolve_event_identity($event);
     $calendar = $this->get_calendar($event['calendar']);
     $success = false;
 
     if ($calendar && $calendar->storage && $calendar->editable) {
       if ($raw_msg = $this->bonnie_api->rawdata('event', $uid, $rev, $mailbox)) {
         $imap = $this->rc->get_storage();
 
         // insert $raw_msg as new message
         if ($imap->save_message($calendar->storage->name, $raw_msg, null, false)) {
           $success = true;
 
           // delete old revision from imap and cache
           $imap->delete_message($msguid, $calendar->storage->name);
           $calendar->storage->cache->set($msguid, false);
         }
       }
     }
 
     return $success;
   }
 
   /**
    * Helper method to resolved the given event identifier into uid and folder
    *
    * @return array (uid,folder,msguid) tuple
    */
   private function _resolve_event_identity($event)
   {
     $mailbox = $msguid = null;
     if (is_array($event)) {
       $uid = $event['uid'] ?: $event['id'];
       if (($cal = $this->get_calendar($event['calendar'])) && !($cal instanceof kolab_invitation_calendar)) {
         $mailbox = $cal->get_mailbox_id();
 
         // get event object from storage in order to get the real object uid an msguid
         if ($ev = $cal->get_event($event['id'])) {
           $msguid = $ev['_msguid'];
           $uid = $ev['uid'];
         }
       }
     }
     else {
       $uid = $event;
 
       // get event object from storage in order to get the real object uid an msguid
       if ($ev = $this->get_event($event)) {
         $mailbox = $ev['_mailbox'];
         $msguid = $ev['_msguid'];
         $uid = $ev['uid'];
       }
     }
 
     return array($uid, $mailbox, $msguid);
   }
 
   /**
    * Callback function to produce driver-specific calendar create/edit form
    *
    * @param string Request action 'form-edit|form-new'
    * @param array  Calendar properties (e.g. id, color)
    * @param array  Edit form fields
    *
    * @return string HTML content of the form
    */
   public function calendar_form($action, $calendar, $formfields)
   {
     // show default dialog for birthday calendar
     if (in_array($calendar['id'], array(self::BIRTHDAY_CALENDAR_ID, self::INVITATIONS_CALENDAR_PENDING, self::INVITATIONS_CALENDAR_DECLINED))) {
       if ($calendar['id'] != self::BIRTHDAY_CALENDAR_ID)
         unset($formfields['showalarms']);
       return parent::calendar_form($action, $calendar, $formfields);
     }
 
+    $this->_read_calendars();
+
     if ($calendar['id'] && ($cal = $this->calendars[$calendar['id']])) {
       $folder = $cal->get_realname(); // UTF7
       $color  = $cal->get_color();
     }
     else {
       $folder = '';
       $color  = '';
     }
 
     $hidden_fields[] = array('name' => 'oldname', 'value' => $folder);
 
     $storage = $this->rc->get_storage();
     $delim   = $storage->get_hierarchy_delimiter();
     $form   = array();
 
     if (strlen($folder)) {
       $path_imap = explode($delim, $folder);
       array_pop($path_imap);  // pop off name part
       $path_imap = implode($path_imap, $delim);
 
       $options = $storage->folder_info($folder);
     }
     else {
       $path_imap = '';
     }
 
     // General tab
     $form['props'] = array(
       'name' => $this->rc->gettext('properties'),
     );
 
     // Disable folder name input
     if (!empty($options) && ($options['norename'] || $options['protected'])) {
       $input_name = new html_hiddenfield(array('name' => 'name', 'id' => 'calendar-name'));
       $formfields['name']['value'] = kolab_storage::object_name($folder)
         . $input_name->show($folder);
     }
 
     // calendar name (default field)
     $form['props']['fieldsets']['location'] = array(
       'name'  => $this->rc->gettext('location'),
       'content' => array(
         'name' => $formfields['name']
       ),
     );
 
     if (!empty($options) && ($options['norename'] || $options['protected'])) {
       // prevent user from moving folder
       $hidden_fields[] = array('name' => 'parent', 'value' => $path_imap);
     }
     else {
       $select = kolab_storage::folder_selector('event', array('name' => 'parent', 'id' => 'calendar-parent'), $folder);
       $form['props']['fieldsets']['location']['content']['path'] = array(
         'id' => 'calendar-parent',
         'label' => $this->cal->gettext('parentcalendar'),
         'value' => $select->show(strlen($folder) ? $path_imap : ''),
       );
     }
 
     // calendar color (default field)
     $form['props']['fieldsets']['settings'] = array(
       'name'  => $this->rc->gettext('settings'),
       'content' => array(
         'color' => $formfields['color'],
         'showalarms' => $formfields['showalarms'],
       ),
     );
     
     
     if ($action != 'form-new') {
       $form['sharing'] = array(
           'name'    => rcube::Q($this->cal->gettext('tabsharing')),
           'content' => html::tag('iframe', array(
             'src' => $this->cal->rc->url(array('_action' => 'calendar-acl', 'id' => $calendar['id'], 'framed' => 1)),
             'width' => '100%',
             'height' => 350,
             'border' => 0,
             'style' => 'border:0'),
         ''),
       );
     }
 
     $this->form_html = '';
     if (is_array($hidden_fields)) {
         foreach ($hidden_fields as $field) {
             $hiddenfield = new html_hiddenfield($field);
             $this->form_html .= $hiddenfield->show() . "\n";
         }
     }
 
     // Create form output
     foreach ($form as $tab) {
       if (!empty($tab['fieldsets']) && is_array($tab['fieldsets'])) {
         $content = '';
         foreach ($tab['fieldsets'] as $fieldset) {
           $subcontent = $this->get_form_part($fieldset);
           if ($subcontent) {
             $content .= html::tag('fieldset', null, html::tag('legend', null, rcube::Q($fieldset['name'])) . $subcontent) ."\n";
           }
         }
       }
       else {
         $content = $this->get_form_part($tab);
       }
 
       if ($content) {
         $this->form_html .= html::tag('fieldset', null, html::tag('legend', null, rcube::Q($tab['name'])) . $content) ."\n";
       }
     }
 
     // Parse form template for skin-dependent stuff
     $this->rc->output->add_handler('calendarform', array($this, 'calendar_form_html'));
     return $this->rc->output->parse('calendar.kolabform', false, false);
   }
 
   /**
    * Handler for template object
    */
   public function calendar_form_html()
   {
     return $this->form_html;
   }
 
   /**
    * Helper function used in calendar_form_content(). Creates a part of the form.
    */
   private function get_form_part($form)
   {
     $content = '';
 
     if (is_array($form['content']) && !empty($form['content'])) {
       $table = new html_table(array('cols' => 2));
       foreach ($form['content'] as $col => $colprop) {
         $label = !empty($colprop['label']) ? $colprop['label'] : $this->cal->gettext($col);
 
         $table->add('title', html::label($colprop['id'], rcube::Q($label)));
         $table->add(null, $colprop['value']);
       }
       $content = $table->show();
     }
     else {
       $content = $form['content'];
     }
 
     return $content;
   }
 
 
   /**
    * Handler to render ACL form for a calendar folder
    */
   public function calendar_acl()
   {
     $this->rc->output->add_handler('folderacl', array($this, 'calendar_acl_form'));
     $this->rc->output->send('calendar.kolabacl');
   }
 
   /**
    * Handler for ACL form template object
    */
   public function calendar_acl_form()
   {
     $calid = rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC);
     if ($calid && ($cal = $this->get_calendar($calid))) {
       $folder = $cal->get_realname(); // UTF7
       $color  = $cal->get_color();
     }
     else {
       $folder = '';
       $color  = '';
     }
 
     $storage = $this->rc->get_storage();
     $delim   = $storage->get_hierarchy_delimiter();
     $form   = array();
 
     if (strlen($folder)) {
       $path_imap = explode($delim, $folder);
       array_pop($path_imap);  // pop off name part
       $path_imap = implode($path_imap, $delim);
 
       $options = $storage->folder_info($folder);
 
       // Allow plugins to modify the form content (e.g. with ACL form)
       $plugin = $this->rc->plugins->exec_hook('calendar_form_kolab',
         array('form' => $form, 'options' => $options, 'name' => $folder));
     }
 
     if (!$plugin['form']['sharing']['content'])
         $plugin['form']['sharing']['content'] = html::div('hint', $this->cal->gettext('aclnorights'));
 
     return $plugin['form']['sharing']['content'];
   }
 
   /**
    * Handler for user_delete plugin hook
    */
   public function user_delete($args)
   {
     $db = $this->rc->get_dbh();
     foreach (array('kolab_alarms', 'itipinvitations') as $table) {
       $db->query("DELETE FROM " . $this->rc->db->table_name($table, true)
         . " WHERE `user_id` = ?", $args['user']->ID);
     }
   }
 }
diff --git a/plugins/calendar/drivers/kolab/kolab_invitation_calendar.php b/plugins/calendar/drivers/kolab/kolab_invitation_calendar.php
index 4a440747..b41e2964 100644
--- a/plugins/calendar/drivers/kolab/kolab_invitation_calendar.php
+++ b/plugins/calendar/drivers/kolab/kolab_invitation_calendar.php
@@ -1,377 +1,376 @@
 <?php
 
 /**
  * Kolab calendar storage class simulating a virtual calendar listing pedning/declined invitations
  *
  * @author Thomas Bruederli <bruederli@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_invitation_calendar
 {
   public $id = '__invitation__';
   public $ready = true;
   public $alarms = false;
   public $rights = 'lrsv';
   public $editable = false;
   public $attachments = false;
   public $subscriptions = false;
   public $partstats = array('unknown');
   public $categories = array();
   public $name = 'Invitations';
 
+
   /**
    * Default constructor
    */
   public function __construct($id, $calendar)
   {
     $this->cal = $calendar;
     $this->id = $id;
 
     switch ($this->id) {
       case kolab_driver::INVITATIONS_CALENDAR_PENDING:
         $this->partstats = array('NEEDS-ACTION');
         $this->name = $this->cal->gettext('invitationspending');
         if (!empty($_REQUEST['_quickview']))
           $this->partstats[] = 'TENTATIVE';
         break;
 
       case kolab_driver::INVITATIONS_CALENDAR_DECLINED:
         $this->partstats = array('DECLINED');
         $this->name = $this->cal->gettext('invitationsdeclined');
         break;
     }
 
     // user-specific alarms settings win
     $prefs = $this->cal->rc->config->get('kolab_calendars', array());
     if (isset($prefs[$this->id]['showalarms']))
       $this->alarms = $prefs[$this->id]['showalarms'];
   }
 
-
   /**
    * Getter for a nice and human readable name for this calendar
    *
    * @return string Name of this calendar
    */
   public function get_name()
   {
     return $this->name;
   }
 
-
   /**
    * Getter for the IMAP folder owner
    *
    * @return string Name of the folder owner
    */
   public function get_owner()
   {
     return $this->cal->rc->get_user_name();
   }
 
-
   /**
    *
    */
   public function get_title()
   {
     return $this->get_name();
   }
 
-
   /**
    * Getter for the name of the namespace to which the IMAP folder belongs
    *
    * @return string Name of the namespace (personal, other, shared)
    */
   public function get_namespace()
   {
     return 'x-special';
   }
 
-
   /**
    * Getter for the top-end calendar folder name (not the entire path)
    *
    * @return string Name of this calendar
    */
   public function get_foldername()
   {
     return $this->get_name();
   }
 
   /**
    * Getter for the Cyrus mailbox identifier corresponding to this folder
    *
    * @return string Mailbox ID
    */
   public function get_mailbox_id()
   {
     // this is a virtual collection and has no concrete mailbox ID
     return null;
   }
 
   /**
    * Return color to display this calendar
    */
   public function get_color()
   {
     // calendar color is stored in local user prefs
     $prefs = $this->cal->rc->config->get('kolab_calendars', array());
 
     if (!empty($prefs[$this->id]) && !empty($prefs[$this->id]['color']))
       return $prefs[$this->id]['color'];
 
     return 'ffffff';
   }
 
   /**
    * Compose an URL for CalDAV access to this calendar (if configured)
    */
   public function get_caldav_url()
   {
     return false;
   }
 
   /**
    * Check activation status of this folder
    *
    * @return boolean True if enabled, false if not
    */
   public function is_active()
   {
     $prefs = $this->cal->rc->config->get('kolab_calendars', array());  // read local prefs
     return (bool)$prefs[$this->id]['active'];
   }
 
   /**
    * Update properties of this calendar folder
    *
    * @see calendar_driver::edit_calendar()
    */
   public function update(&$prop)
   {
     // don't change anything.
     // let kolab_driver save props in local prefs
     return $prop['id'];
   }
 
-
   /**
    * Getter for a single event object
    */
   public function get_event($id)
   {
     // redirect call to kolab_driver::get_event()
     $event = $this->cal->driver->get_event($id, calendar_driver::FILTER_WRITEABLE);
 
     if (is_array($event)) {
       // add pointer to original calendar folder
       $event['_folder_id'] = $event['calendar'];
       $event = $this->_mod_event($event);
     }
 
     return $event;
   }
 
   /**
    * Get attachment body
    * @see calendar_driver::get_attachment_body()
    */
   public function get_attachment_body($id, $event)
   {
     // find the actual folder this event resides in
     if (!empty($event['_folder_id'])) {
       $cal = $this->cal->driver->get_calendar($event['_folder_id']);
     }
     else {
       $cal = null;
       foreach (kolab_storage::list_folders('', '*', 'event', null) as $foldername) {
-        $cal = new kolab_calendar($foldername, $this->cal);
+        $cal = $this->_get_calendar($foldername);
         if ($cal->ready && $cal->storage && $cal->get_event($event['id'])) {
           break;
         }
       }
     }
 
     if ($cal && $cal->storage) {
       return $cal->get_attachment_body($id, $event);
     }
 
     return false;
   }
 
-
   /**
    * @param  integer Event's new start (unix timestamp)
    * @param  integer Event's new end (unix timestamp)
    * @param  string  Search query (optional)
    * @param  boolean Include virtual events (optional)
    * @param  array   Additional parameters to query storage
    * @return array A list of event records
    */
   public function list_events($start, $end, $search = null, $virtual = 1, $query = array())
   {
     // get email addresses of the current user
     $user_emails = $this->cal->get_user_emails();
     $subquery = array();
     foreach ($user_emails as $email) {
       foreach ($this->partstats as $partstat) {
         $subquery[] = array('tags', '=', 'x-partstat:' . $email . ':' . strtolower($partstat));
       }
     }
 
     // aggregate events from all calendar folders
     $events = array();
     foreach (kolab_storage::list_folders('', '*', 'event', null) as $foldername) {
-      $cal = new kolab_calendar($foldername, $this->cal);
+      $cal = $this->_get_calendar($foldername);
       if ($cal->get_namespace() == 'other')
         continue;
 
       foreach ($cal->list_events($start, $end, $search, 1, $query, array(array($subquery, 'OR'))) as $event) {
         $match = false;
 
         // post-filter events to match out partstats
         if (is_array($event['attendees'])) {
           foreach ($event['attendees'] as $attendee) {
             if (in_array($attendee['email'], $user_emails) && in_array($attendee['status'], $this->partstats)) {
               $match = true;
               break;
             }
           }
         }
 
         if ($match) {
           $events[$event['id'] ?: $event['uid']] = $this->_mod_event($event);
         }
       }
 
       // merge list of event categories (really?)
       $this->categories += $cal->categories;
     }
 
     return $events;
   }
 
   /**
    *
    * @param  integer Date range start (unix timestamp)
    * @param  integer Date range end (unix timestamp)
    * @return integer Count
    */
   public function count_events($start, $end = null)
   {
     // get email addresses of the current user
     $user_emails = $this->cal->get_user_emails();
     $subquery = array();
     foreach ($user_emails as $email) {
       foreach ($this->partstats as $partstat) {
         $subquery[] = array('tags', '=', 'x-partstat:' . $email . ':' . strtolower($partstat));
       }
     }
 
     $filter = array(
       array('tags','!=','x-status:cancelled'),
       array($subquery, 'OR')
     );
 
     // aggregate counts from all calendar folders
     $count = 0;
     foreach (kolab_storage::list_folders('', '*', 'event', null) as $foldername) {
-      $cal = new kolab_calendar($foldername, $this->cal);
+      $cal = $this->_get_calendar($foldername);
       if ($cal->get_namespace() == 'other')
         continue;
 
       $count += $cal->count_events($start, $end, $filter);
     }
 
     return $count;
   }
 
+  /**
+   * Get calendar object instance (that maybe already initialized)
+   */
+  private function _get_calendar($folder_name)
+  {
+    $id = kolab_storage::folder_id($folder_name, true);
+    return $this->cal->driver->get_calendar($id);
+  }
+
   /**
    * Helper method to modify some event properties
    */
   private function _mod_event($event)
   {
     // set classes according to PARTSTAT
     $event = kolab_driver::add_partstat_class($event, $this->partstats);
 
     if (strpos($event['className'], 'fc-invitation-') !== false) {
       $event['calendar'] = $this->id;
     }
 
     return $event;
   }
 
-
   /**
    * Create a new event record
    *
    * @see calendar_driver::new_event()
    * 
    * @return mixed The created record ID on success, False on error
    */
   public function insert_event($event)
   {
     return false;
   }
 
   /**
    * Update a specific event record
    *
    * @see calendar_driver::new_event()
    * @return boolean True on success, False on error
    */
-
   public function update_event($event, $exception_id = null)
   {
     // forward call to the actual storage folder
     if ($event['_folder_id']) {
       $cal = $this->cal->driver->get_calendar($event['_folder_id']);
       if ($cal && $cal->ready) {
         return $cal->update_event($event, $exception_id);
       }
     }
 
     return false;
   }
 
   /**
    * Delete an event record
    *
    * @see calendar_driver::remove_event()
    * @return boolean True on success, False on error
    */
   public function delete_event($event, $force = true)
   {
     return false;
   }
 
   /**
    * Restore deleted event record
    *
    * @see calendar_driver::undelete_event()
    * @return boolean True on success, False on error
    */
   public function restore_event($event)
   {
     return false;
   }
-
-
 }
diff --git a/plugins/calendar/drivers/kolab/kolab_user_calendar.php b/plugins/calendar/drivers/kolab/kolab_user_calendar.php
index 00f1dfc4..84f159bf 100644
--- a/plugins/calendar/drivers/kolab/kolab_user_calendar.php
+++ b/plugins/calendar/drivers/kolab/kolab_user_calendar.php
@@ -1,432 +1,426 @@
 <?php
 
 /**
  * Kolab calendar storage class simulating a virtual user calendar
  *
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
- * Copyright (C) 2014-2015, Kolab Systems AG <contact@kolabsys.com>
+ * Copyright (C) 2014-2016, 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_user_calendar extends kolab_calendar
 {
   public $id = 'unknown';
   public $ready = false;
   public $editable = false;
   public $attachments = false;
   public $subscriptions = false;
 
   protected $userdata = array();
   protected $timeindex = array();
 
 
   /**
    * Default constructor
    */
   public function __construct($user_or_folder, $calendar)
   {
     $this->cal = $calendar;
 
     // full user record is provided
     if (is_array($user_or_folder)) {
       $this->userdata = $user_or_folder;
       $this->storage = new kolab_storage_folder_user($this->userdata['kolabtargetfolder'], '', $this->userdata);
     }
+    else if ($user_or_folder instanceof kolab_storage_folder_user) {
+      $this->storage  = $user_or_folder;
+      $this->userdata = $this->storage->ldaprec;
+    }
     else {  // get user record from LDAP
-      $this->storage = new kolab_storage_folder_user($user_or_folder);
+      $this->storage  = new kolab_storage_folder_user($user_or_folder);
       $this->userdata = $this->storage->ldaprec;
     }
 
     $this->ready = !empty($this->userdata['kolabtargetfolder']);
     $this->storage->type = 'event';
 
     if ($this->ready) {
       // ID is derrived from the user's kolabtargetfolder attribute
       $this->id = kolab_storage::folder_id($this->userdata['kolabtargetfolder'], true);
       $this->imap_folder = $this->userdata['kolabtargetfolder'];
-      $this->name = $this->storage->get_name();
+      $this->name = $this->storage->name;
       $this->parent = '';  // user calendars are top level
 
       // user-specific alarms settings win
       $prefs = $this->cal->rc->config->get('kolab_calendars', array());
       if (isset($prefs[$this->id]['showalarms']))
         $this->alarms = $prefs[$this->id]['showalarms'];
     }
   }
 
-
   /**
    * Getter for a nice and human readable name for this calendar
    *
    * @return string Name of this calendar
    */
   public function get_name()
   {
     return $this->userdata['displayname'] ?: ($this->userdata['name'] ?: $this->userdata['mail']);
   }
 
-
   /**
    * Getter for the IMAP folder owner
    *
    * @return string Name of the folder owner
    */
   public function get_owner()
   {
     return $this->userdata['mail'];
   }
 
-
   /**
    *
    */
   public function get_title()
   {
     return trim($this->userdata['displayname'] . '; ' . $this->userdata['mail'], '; ');
   }
 
-
   /**
    * Getter for the name of the namespace to which the IMAP folder belongs
    *
    * @return string Name of the namespace (personal, other, shared)
    */
   public function get_namespace()
   {
     return 'other user';
   }
 
-
   /**
    * Getter for the top-end calendar folder name (not the entire path)
    *
    * @return string Name of this calendar
    */
   public function get_foldername()
   {
     return $this->get_name();
   }
 
   /**
    * Return color to display this calendar
    */
   public function get_color()
   {
     // calendar color is stored in local user prefs
     $prefs = $this->cal->rc->config->get('kolab_calendars', array());
 
     if (!empty($prefs[$this->id]) && !empty($prefs[$this->id]['color']))
       return $prefs[$this->id]['color'];
 
     return 'cc0000';
   }
 
   /**
    * Compose an URL for CalDAV access to this calendar (if configured)
    */
   public function get_caldav_url()
   {
     return false;
   }
 
   /**
    * Check subscription status of this folder
    *
    * @return boolean True if subscribed, false if not
    */
   public function is_subscribed()
   {
     return $this->storage->is_subscribed();
   }
 
   /**
    * Update properties of this calendar folder
    *
    * @see calendar_driver::edit_calendar()
    */
   public function update(&$prop)
   {
     // don't change anything.
     // let kolab_driver save props in local prefs
     return $prop['id'];
   }
 
-
   /**
    * Getter for a single event object
    */
   public function get_event($id)
   {
     // TODO: implement this
     return $this->events[$id];
   }
 
   /**
    * Get attachment body
    * @see calendar_driver::get_attachment_body()
    */
   public function get_attachment_body($id, $event)
   {
     if (!$event['calendar'] && ($ev = $this->get_event($event['id']))) {
       $event['calendar'] = $ev['calendar'];
     }
 
     if ($event['calendar'] && ($cal = $this->cal->get_calendar($event['calendar']))) {
       return $cal->get_attachment_body($id, $event);
     }
 
     return false;
   }
 
   /**
    * @param  integer Event's new start (unix timestamp)
    * @param  integer Event's new end (unix timestamp)
    * @param  string  Search query (optional)
    * @param  boolean Include virtual events (optional)
    * @param  array   Additional parameters to query storage
    * @return array A list of event records
    */
   public function list_events($start, $end, $search = null, $virtual = 1, $query = array())
   {
     // convert to DateTime for comparisons
     try {
       $start_dt = new DateTime('@'.$start);
     }
     catch (Exception $e) {
       $start_dt = new DateTime('@0');
     }
     try {
       $end_dt = new DateTime('@'.$end);
     }
     catch (Exception $e) {
       $end_dt = new DateTime('today +10 years');
     }
 
     $limit_changed = null;
     if (!empty($query)) {
       foreach ($query as $q) {
         if ($q[0] == 'changed' && $q[1] == '>=') {
           try { $limit_changed = new DateTime('@'.$q[2]); }
           catch (Exception $e) { /* ignore */ }
         }
       }
     }
 
     // aggregate all calendar folders the user shares (but are not subscribed)
     foreach (kolab_storage::list_user_folders($this->userdata, 'event', false) as $foldername) {
       $cal = new kolab_calendar($foldername, $this->cal);
       foreach ($cal->list_events($start, $end, $search, 1) as $event) {
         $this->events[$event['id']] = $event;
         $this->timeindex[$this->time_key($event)] = $event['id'];
       }
     }
 
     // get events from the user's free/busy feed (for quickview only)
     $fbview = $this->cal->rc->config->get('calendar_include_freebusy_data', 1);
     if ($fbview && ($fbview == 1 || !empty($_REQUEST['_quickview'])) && empty($search)) {
       $this->fetch_freebusy($limit_changed);
     }
 
     $events = array();
     foreach ($this->events as $event) {
       // list events in requested time window
       if ($event['start'] <= $end_dt && $event['end'] >= $start_dt &&
            (!$limit_changed || !$event['changed'] || $event['changed'] >= $limit_changed)) {
         $events[] = $event;
       }
     }
 
     // avoid session race conditions that will loose temporary subscriptions
     $this->cal->rc->session->nowrite = true;
 
     return $events;
   }
 
   /**
    *
    * @param  integer Date range start (unix timestamp)
    * @param  integer Date range end (unix timestamp)
    * @return integer Count
    */
   public function count_events($start, $end = null)
   {
     // not implemented
     return 0;
   }
 
   /**
    * Helper method to fetch free/busy data for the user and turn it into calendar data
    */
   private function fetch_freebusy($limit_changed = null)
   {
     // ask kolab server first
     try {
       $request_config = array(
         'store_body'       => true,
         'follow_redirects' => true,
       );
       $request  = libkolab::http_request(kolab_storage::get_freebusy_url($this->userdata['mail']), 'GET', $request_config);
       $response = $request->send();
 
       // authentication required
       if ($response->getStatus() == 401) {
         $request->setAuth($this->cal->rc->user->get_username(), $this->cal->rc->decrypt($_SESSION['password']));
         $response = $request->send();
       }
 
       if ($response->getStatus() == 200)
         $fbdata = $response->getBody();
 
       unset($request, $response);
     }
     catch (Exception $e) {
       rcube::raise_error(array(
         'code' => 900,
         'type' => 'php',
         'file' => __FILE__,
         'line' => __LINE__,
         'message' => "Error fetching free/busy information: " . $e->getMessage()),
         true, false);
 
       return false;
     }
 
     $statusmap = array(
       'FREE' => 'free',
       'BUSY' => 'busy',
       'BUSY-TENTATIVE' => 'tentative',
       'X-OUT-OF-OFFICE' => 'outofoffice',
       'OOF' => 'outofoffice',
     );
     $titlemap = array(
       'FREE' => $this->cal->gettext('availfree'),
       'BUSY' => $this->cal->gettext('availbusy'),
       'BUSY-TENTATIVE' => $this->cal->gettext('availtentative'),
       'X-OUT-OF-OFFICE' => $this->cal->gettext('availoutofoffice'),
     );
 
     // console('_fetch_freebusy', kolab_storage::get_freebusy_url($this->userdata['mail']), $fbdata);
 
     // parse free-busy information
     $count = 0;
     if ($fbdata) {
       $ical = $this->cal->get_ical();
       $ical->import($fbdata);
       if ($fb = $ical->freebusy) {
         // consider 'changed >= X' queries
         if ($limit_changed && $fb['created'] && $fb['created'] < $limit_changed) {
           return 0;
         }
 
         foreach ($fb['periods'] as $tuple) {
           list($from, $to, $type) = $tuple;
           $event = array(
             'id'        => md5($this->id . $from->format('U') . '/' . $to->format('U')),
             'calendar'  => $this->id,
             'changed'   => $fb['created'] ?: new DateTime(),
             'title'     => $this->get_name() . ' ' . ($titlemap[$type] ?: $type),
             'start'     => $from,
             'end'       => $to,
             'free_busy' => $statusmap[$type] ?: 'busy',
             'className' => 'fc-type-freebusy',
             'organizer' => array(
               'email' => $this->userdata['mail'],
               'name'  => $this->userdata['displayname'],
             ),
           );
 
           // avoid duplicate entries
           $key = $this->time_key($event);
           if (!$this->timeindex[$key]) {
             $this->events[$event['id']] = $event;
             $this->timeindex[$key] = $event['id'];
             $count++;
           }
         }
       }
     }
 
     return $count;
   }
 
   /**
    * Helper to build a key for the absolute time slot the given event convers
    */
   private function time_key($event)
   {
     return sprintf('%s/%s', $event['start']->format('U'), is_object($event['end']->format('U')) ?: '0');
   }
 
-
   /**
    * Create a new event record
    *
    * @see calendar_driver::new_event()
    * 
    * @return mixed The created record ID on success, False on error
    */
   public function insert_event($event)
   {
     return false;
   }
 
   /**
    * Update a specific event record
    *
    * @see calendar_driver::new_event()
    * @return boolean True on success, False on error
    */
-
   public function update_event($event, $exception_id = null)
   {
     return false;
   }
 
   /**
    * Delete an event record
    *
    * @see calendar_driver::remove_event()
    * @return boolean True on success, False on error
    */
   public function delete_event($event, $force = true)
   {
     return false;
   }
 
   /**
    * Restore deleted event record
    *
    * @see calendar_driver::undelete_event()
    * @return boolean True on success, False on error
    */
   public function restore_event($event)
   {
     return false;
   }
 
-
   /**
    * Convert from Kolab_Format to internal representation
    */
   private function _to_rcube_event($record)
   {
     $record['id'] = $record['uid'];
     $record['calendar'] = $this->id;
 
     return kolab_driver::to_rcube_event($record);
   }
-
 }
diff --git a/plugins/kolab_addressbook/lib/rcube_kolab_contacts.php b/plugins/kolab_addressbook/lib/rcube_kolab_contacts.php
index 7ed91cac..b53f8f5f 100644
--- a/plugins/kolab_addressbook/lib/rcube_kolab_contacts.php
+++ b/plugins/kolab_addressbook/lib/rcube_kolab_contacts.php
@@ -1,1323 +1,1319 @@
 <?php
 
 /**
  * Backend class for a custom address book
  *
  * This part of the Roundcube+Kolab integration and connects the
  * rcube_addressbook interface with the kolab_storage wrapper from libkolab
  *
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  * @author Aleksander Machniak <machniak@kolabsys.com>
  *
  * Copyright (C) 2011, 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/>.
  *
  * @see rcube_addressbook
  */
 class rcube_kolab_contacts extends rcube_addressbook
 {
     public $primary_key = 'ID';
     public $rights   = 'lrs';
     public $readonly = true;
     public $undelete = true;
     public $groups = true;
     public $coltypes = array(
       'name'         => array('limit' => 1),
       'firstname'    => array('limit' => 1),
       'surname'      => array('limit' => 1),
       'middlename'   => array('limit' => 1),
       'prefix'       => array('limit' => 1),
       'suffix'       => array('limit' => 1),
       'nickname'     => array('limit' => 1),
       'jobtitle'     => array('limit' => 1),
       'organization' => array('limit' => 1),
       'department'   => array('limit' => 1),
       'email'        => array('subtypes' => array('home','work','other')),
       'phone'        => array(),
       'address'      => array('subtypes' => array('home','work','office')),
       'website'      => array('subtypes' => array('homepage','blog')),
       'im'           => array('subtypes' => null),
       'gender'       => array('limit' => 1),
       'birthday'     => array('limit' => 1),
       'anniversary'  => array('limit' => 1),
       'profession'   => array('type' => 'text', 'size' => 40, 'maxlength' => 80, 'limit' => 1,
                                 'label' => 'kolab_addressbook.profession', 'category' => 'personal'),
       'manager'      => array('limit' => null),
       'assistant'    => array('limit' => null),
       'spouse'       => array('limit' => 1),
       'children'     => array('type' => 'text', 'size' => 40, 'maxlength' => 80, 'limit' => null,
                                 'label' => 'kolab_addressbook.children', 'category' => 'personal'),
       'freebusyurl'  => array('type' => 'text', 'size' => 40, 'limit' => 1,
                                 'label' => 'kolab_addressbook.freebusyurl'),
       'pgppublickey' => array('type' => 'textarea', 'size' => 70, 'rows' => 10, 'limit' => 1,
                                 'label' => 'kolab_addressbook.pgppublickey'),
       'pkcs7publickey' => array('type' => 'textarea', 'size' => 70, 'rows' => 10, 'limit' => 1,
                                 'label' => 'kolab_addressbook.pkcs7publickey'),
       'notes'        => array('limit' => 1),
       'photo'        => array('limit' => 1),
       // TODO: define more Kolab-specific fields such as: language, latitude, longitude, crypto settings
     );
 
     /**
      * vCard additional fields mapping
      */
     public $vcard_map = array(
       'profession'     => 'X-PROFESSION',
       'officelocation' => 'X-OFFICE-LOCATION',
       'initials'       => 'X-INITIALS',
       'children'       => 'X-CHILDREN',
       'freebusyurl'    => 'X-FREEBUSY-URL',
       'pgppublickey'   => 'KEY',
     );
 
     /**
      * List of date type fields
      */
     public $date_cols = array('birthday', 'anniversary');
 
     private $gid;
     private $storagefolder;
     private $dataset;
     private $sortindex;
     private $contacts;
     private $distlists;
     private $groupmembers;
     private $filter;
     private $result;
     private $namespace;
     private $imap_folder = 'INBOX/Contacts';
     private $action;
 
     // list of fields used for searching in "All fields" mode
     private $search_fields = array(
       'name',
       'firstname',
       'surname',
       'middlename',
       'prefix',
       'suffix',
       'nickname',
       'jobtitle',
       'organization',
       'department',
       'email',
       'phone',
       'address',
       'profession',
       'manager',
       'assistant',
       'spouse',
       'children',
       'notes',
     );
 
 
     public function __construct($imap_folder = null)
     {
         if ($imap_folder) {
             $this->imap_folder = $imap_folder;
         }
 
         // extend coltypes configuration 
         $format = kolab_format::factory('contact');
         $this->coltypes['phone']['subtypes'] = array_keys($format->phonetypes);
         $this->coltypes['address']['subtypes'] = array_keys($format->addresstypes);
 
         $rcube = rcube::get_instance();
 
         // set localized labels for proprietary cols
         foreach ($this->coltypes as $col => $prop) {
             if (is_string($prop['label']))
                 $this->coltypes[$col]['label'] = $rcube->gettext($prop['label']);
         }
 
         // fetch objects from the given IMAP folder
         $this->storagefolder = kolab_storage::get_folder($this->imap_folder);
         $this->ready = $this->storagefolder && !PEAR::isError($this->storagefolder);
 
         // Set readonly and rights flags according to folder permissions
         if ($this->ready) {
             if ($this->storagefolder->get_owner() == $_SESSION['username']) {
                 $this->readonly = false;
                 $this->rights = 'lrswikxtea';
             }
             else {
                 $rights = $this->storagefolder->get_myrights();
                 if ($rights && !PEAR::isError($rights)) {
                     $this->rights = $rights;
                     if (strpos($rights, 'i') !== false && strpos($rights, 't') !== false)
                         $this->readonly = false;
                 }
             }
         }
 
         $this->action = rcube::get_instance()->action;
     }
 
-
     /**
      * Getter for the address book name to be displayed
      *
      * @return string Name of this address book
      */
     public function get_name()
     {
-        $folder = kolab_storage::object_name($this->imap_folder, $this->namespace);
-        return $folder;
+        return $this->storagefolder->get_name();
     }
 
     /**
      * Wrapper for kolab_storage_folder::get_foldername()
      */
     public function get_foldername()
     {
         return $this->storagefolder->get_foldername();
     }
 
-
     /**
      * Getter for the IMAP folder name
      *
      * @return string Name of the IMAP folder
      */
     public function get_realname()
     {
         return $this->imap_folder;
     }
 
-
     /**
      * Getter for the name of the namespace to which the IMAP folder belongs
      *
      * @return string Name of the namespace (personal, other, shared)
      */
     public function get_namespace()
     {
         if ($this->namespace === null && $this->ready) {
             $this->namespace = $this->storagefolder->get_namespace();
         }
 
         return $this->namespace;
     }
 
     /**
      * Getter for parent folder path
      *
      * @return string Full path to parent folder
      */
     public function get_parent()
     {
         return $this->storagefolder->get_parent();
     }
 
     /**
      * Check subscription status of this folder
      *
      * @return boolean True if subscribed, false if not
      */
     public function is_subscribed()
     {
         return kolab_storage::folder_is_subscribed($this->imap_folder);
     }
 
     /**
      * Compose an URL for CardDAV access to this address book (if configured)
      */
     public function get_carddav_url()
     {
       $rcmail = rcmail::get_instance();
       if ($template = $rcmail->config->get('kolab_addressbook_carddav_url', null)) {
         return strtr($template, array(
           '%h' => $_SERVER['HTTP_HOST'],
           '%u' => urlencode($rcmail->get_user_name()),
           '%i' => urlencode($this->storagefolder->get_uid()),
           '%n' => urlencode($this->imap_folder),
         ));
       }
 
       return false;
     }
 
     /**
      * Setter for the current group
      */
     public function set_group($gid)
     {
         $this->gid = $gid;
     }
 
 
     /**
      * Save a search string for future listings
      *
      * @param mixed Search params to use in listing method, obtained by get_search_set()
      */
     public function set_search_set($filter)
     {
         $this->filter = $filter;
     }
 
 
     /**
      * Getter for saved search properties
      *
      * @return mixed Search properties used by this class
      */
     public function get_search_set()
     {
         return $this->filter;
     }
 
 
     /**
      * Reset saved results and search parameters
      */
     public function reset()
     {
         $this->result = null;
         $this->filter = null;
     }
 
 
     /**
      * List all active contact groups of this source
      *
      * @param string  Optional search string to match group name
      * @return array  Indexed list of contact groups, each a hash array
      */
     function list_groups($search = null)
     {
         $this->_fetch_groups();
         $groups = array();
 
         foreach ((array)$this->distlists as $group) {
             if (!$search || strstr(strtolower($group['name']), strtolower($search)))
                 $groups[$group['name']] = array('ID' => $group['ID'], 'name' => $group['name']);
         }
 
         // sort groups
         ksort($groups, SORT_LOCALE_STRING);
 
         return array_values($groups);
     }
 
 
     /**
      * List the current set of contact records
      *
      * @param array List of cols to show
      * @param  int  Only return this number of records, use negative values for tail
      * @param  boolean True to skip the count query (select only)
      *
      * @return array  Indexed list of contact records, each a hash array
      */
     public function list_records($cols = null, $subset = 0, $nocount = false)
     {
         $this->result = new rcube_result_set(0, ($this->list_page-1) * $this->page_size);
         $fetch_all = false;
 
         // list member of the selected group
         if ($this->gid) {
             $this->_fetch_groups();
 
             $this->sortindex = array();
             $this->contacts  = array();
             $local_sortindex = array();
             $uids            = array();
 
             // get members with email specified
             foreach ((array)$this->distlists[$this->gid]['member'] as $member) {
                 // skip member that don't match the search filter
                 if (!empty($this->filter['ids']) && array_search($member['ID'], $this->filter['ids']) === false) {
                     continue;
                 }
 
                 if (!empty($member['uid'])) {
                     $uids[] = $member['uid'];
                 }
                 else if (!empty($member['email'])) {
                     $this->contacts[$member['ID']] = $member;
                     $local_sortindex[$member['ID']] = $this->_sort_string($member);
                     $fetch_all = true;
                 }
             }
 
             // get members by UID
             if (!empty($uids)) {
                 $this->_fetch_contacts($query = array(array('uid', '=', $uids)), !$fetch_all);
                 $this->sortindex = array_merge($this->sortindex, $local_sortindex);
             }
         }
         else if (is_array($this->filter['ids'])) {
             $ids = $this->filter['ids'];
             if (count($ids)) {
                 $uids = array_map(array($this, 'id2uid'), $this->filter['ids']);
                 $this->_fetch_contacts($query = array(array('uid', '=', $uids)), true);
             }
         }
         else {
             $this->_fetch_contacts($query = 'contact', true);
         }
 
         if ($fetch_all) {
             // sort results (index only)
             asort($this->sortindex, SORT_LOCALE_STRING);
             $ids = array_keys($this->sortindex);
 
             // fill contact data into the current result set
             $this->result->count = count($ids);
             $start_row = $subset < 0 ? $this->result->first + $this->page_size + $subset : $this->result->first;
             $last_row = min($subset != 0 ? $start_row + abs($subset) : $this->result->first + $this->page_size, $this->result->count);
 
             for ($i = $start_row; $i < $last_row; $i++) {
                 if (array_key_exists($i, $ids)) {
                     $idx = $ids[$i];
                     $this->result->add($this->contacts[$idx] ?: $this->_to_rcube_contact($this->dataset[$idx]));
                 }
             }
         }
         else if (!empty($this->dataset)) {
             // get all records count, skip the query if possible
             if (!isset($query) || count($this->dataset) < $this->page_size) {
                 $this->result->count = count($this->dataset) + $this->page_size * ($this->list_page - 1);
             }
             else {
                 $this->result->count = $this->storagefolder->count($query);
             }
 
             $start_row = $subset < 0 ? $this->page_size + $subset : 0;
             $last_row  = min($subset != 0 ? $start_row + abs($subset) : $this->page_size, $this->result->count);
 
             for ($i = $start_row; $i < $last_row; $i++) {
                 $this->result->add($this->_to_rcube_contact($this->dataset[$i]));
             }
         }
 
         return $this->result;
     }
 
 
     /**
      * Search records
      *
      * @param mixed   $fields   The field name of array of field names to search in
      * @param mixed   $value    Search value (or array of values when $fields is array)
      * @param int     $mode     Matching mode:
      *                          0 - partial (*abc*),
      *                          1 - strict (=),
      *                          2 - prefix (abc*)
      * @param boolean $select   True if results are requested, False if count only
      * @param boolean $nocount  True to skip the count query (select only)
      * @param array   $required List of fields that cannot be empty
      *
      * @return object rcube_result_set List of contact records and 'count' value
      */
     public function search($fields, $value, $mode=0, $select=true, $nocount=false, $required=array())
     {
         // search by ID
         if ($fields == $this->primary_key) {
             $ids    = !is_array($value) ? explode(',', $value) : $value;
             $result = new rcube_result_set();
 
             foreach ($ids as $id) {
                 if ($rec = $this->get_record($id, true)) {
                     $result->add($rec);
                     $result->count++;
                 }
             }
             return $result;
         }
         else if ($fields == '*') {
           $fields = $this->search_fields;
         }
 
         if (!is_array($fields))
             $fields = array($fields);
         if (!is_array($required) && !empty($required))
             $required = array($required);
 
         // advanced search
         if (is_array($value)) {
             $advanced = true;
             $value = array_map('mb_strtolower', $value);
         }
         else
             $value = mb_strtolower($value);
 
         $scount = count($fields);
         // build key name regexp
         $regexp = '/^(' . implode($fields, '|') . ')(?:.*)$/';
 
         // pass query to storage if only indexed cols are involved
         // NOTE: this is only some rough pre-filtering but probably includes false positives
         $squery = $this->_search_query($fields, $value, $mode);
 
         // add magic selector to select contacts with birthday dates only
         if (in_array('birthday', $required)) {
             $squery[] = array('tags', '=', 'x-has-birthday');
         }
 
         // get all/matching records
         $this->_fetch_contacts($squery);
 
         // save searching conditions
         $this->filter = array('fields' => $fields, 'value' => $value, 'mode' => $mode, 'ids' => array());
 
         // search by iterating over all records in dataset
         foreach ($this->dataset as $record) {
             $contact = $this->_to_rcube_contact($record);
             $id = $contact['ID'];
 
             // check if current contact has required values, otherwise skip it
             if ($required) {
                 foreach ($required as $f) {
                     // required field might be 'email', but contact might contain 'email:home'
                     if (!($v = rcube_addressbook::get_col_values($f, $contact, true)) || empty($v)) {
                         continue 2;
                     }
                 }
             }
 
             $found = array();
             $contents = '';
             foreach (preg_grep($regexp, array_keys($contact)) as $col) {
                 $pos     = strpos($col, ':');
                 $colname = $pos ? substr($col, 0, $pos) : $col;
 
                 foreach ((array)$contact[$col] as $val) {
                     if ($advanced) {
                         $found[$colname] = $this->compare_search_value($colname, $val, $value[array_search($colname, $fields)], $mode);
                     }
                     else {
                         $contents .= ' ' . join(' ', (array)$val);
                     }
                 }
             }
 
             // compare matches
             if (($advanced && count($found) >= $scount) ||
                 (!$advanced && rcube_utils::words_match(mb_strtolower($contents), $value))) {
                 $this->filter['ids'][] = $id;
             }
         }
 
         // dummy result with contacts count
         if (!$select) {
             return new rcube_result_set(count($this->filter['ids']), ($this->list_page-1) * $this->page_size);
         }
 
         // list records (now limited by $this->filter)
         return $this->list_records();
     }
 
 
     /**
      * Refresh saved search results after data has changed
      */
     public function refresh_search()
     {
         if ($this->filter)
             $this->search($this->filter['fields'], $this->filter['value'], $this->filter['mode']);
 
         return $this->get_search_set();
     }
 
 
     /**
      * Count number of available contacts in database
      *
      * @return rcube_result_set Result set with values for 'count' and 'first'
      */
     public function count()
     {
         if ($this->gid) {
             $this->_fetch_groups();
             $count = count($this->distlists[$this->gid]['member']);
         }
         else if (is_array($this->filter['ids'])) {
             $count = count($this->filter['ids']);
         }
         else {
             $count = $this->storagefolder->count('contact');
         }
 
         return new rcube_result_set($count, ($this->list_page-1) * $this->page_size);
     }
 
 
     /**
      * Return the last result set
      *
      * @return rcube_result_set Current result set or NULL if nothing selected yet
      */
     public function get_result()
     {
         return $this->result;
     }
 
 
     /**
      * Get a specific contact record
      *
      * @param mixed record identifier(s)
      * @param boolean True to return record as associative array, otherwise a result set is returned
      * @return mixed Result object with all record fields or False if not found
      */
     public function get_record($id, $assoc=false)
     {
         $rec = null;
         $uid = $this->id2uid($id);
         $rev = rcube_utils::get_input_value('_rev', rcube_utils::INPUT_GPC);
 
         if (strpos($uid, 'mailto:') === 0) {
             $this->_fetch_groups(true);
             $rec = $this->contacts[$id];
             $this->readonly = true;  // set source to read-only
         }
         else if (!empty($rev)) {
             $rcmail = rcube::get_instance();
             $plugin = $rcmail->plugins->get_plugin('kolab_addressbook');
             if ($plugin && ($object = $plugin->get_revision($id, kolab_storage::id_encode($this->imap_folder), $rev))) {
                 $rec = $this->_to_rcube_contact($object);
                 $rec['rev'] = $rev;
             }
             $this->readonly = true;  // set source to read-only
         }
         else if ($object = $this->storagefolder->get_object($uid)) {
             $rec = $this->_to_rcube_contact($object);
         }
 
         if ($rec) {
             $this->result = new rcube_result_set(1);
             $this->result->add($rec);
             return $assoc ? $rec : $this->result;
         }
 
         return false;
     }
 
 
     /**
      * Get group assignments of a specific contact record
      *
      * @param mixed Record identifier
      * @return array List of assigned groups as ID=>Name pairs
      */
     public function get_record_groups($id)
     {
         $out = array();
         $this->_fetch_groups();
 
         foreach ((array)$this->groupmembers[$id] as $gid) {
             if ($group = $this->distlists[$gid])
                 $out[$gid] = $group['name'];
         }
 
         return $out;
     }
 
 
     /**
      * Create a new contact record
      *
      * @param array Assoziative array with save data
      *  Keys:   Field name with optional section in the form FIELD:SECTION
      *  Values: Field value. Can be either a string or an array of strings for multiple values
      * @param boolean True to check for duplicates first
      * @return mixed The created record ID on success, False on error
      */
     public function insert($save_data, $check=false)
     {
         if (!is_array($save_data))
             return false;
 
         $insert_id = $existing = false;
 
         // check for existing records by e-mail comparison
         if ($check) {
             foreach ($this->get_col_values('email', $save_data, true) as $email) {
                 if (($res = $this->search('email', $email, true, false)) && $res->count) {
                     $existing = true;
                     break;
                 }
             }
         }
 
         if (!$existing) {
             // remove existing id attributes (#1101)
             unset($save_data['ID'], $save_data['uid']);
 
             // generate new Kolab contact item
             $object = $this->_from_rcube_contact($save_data);
             $saved  = $this->storagefolder->save($object, 'contact');
 
             if (!$saved) {
                 rcube::raise_error(array(
                   'code' => 600, 'type' => 'php',
                   'file' => __FILE__, 'line' => __LINE__,
                   'message' => "Error saving contact object to Kolab server"),
                 true, false);
             }
             else {
                 $insert_id = $this->uid2id($object['uid']);
             }
         }
 
         return $insert_id;
     }
 
 
     /**
      * Update a specific contact record
      *
      * @param mixed Record identifier
      * @param array Assoziative array with save data
      *  Keys:   Field name with optional section in the form FIELD:SECTION
      *  Values: Field value. Can be either a string or an array of strings for multiple values
      * @return boolean True on success, False on error
      */
     public function update($id, $save_data)
     {
         $updated = false;
         if ($old = $this->storagefolder->get_object($this->id2uid($id))) {
             $object = $this->_from_rcube_contact($save_data, $old);
 
             if (!$this->storagefolder->save($object, 'contact', $old['uid'])) {
                 rcube::raise_error(array(
                   'code' => 600, 'type' => 'php',
                   'file' => __FILE__, 'line' => __LINE__,
                   'message' => "Error saving contact object to Kolab server"),
                 true, false);
             }
             else {
                 $updated = true;
 
                 // TODO: update data in groups this contact is member of
             }
         }
 
         return $updated;
     }
 
 
     /**
      * Mark one or more contact records as deleted
      *
      * @param array   Record identifiers
      * @param boolean Remove record(s) irreversible (mark as deleted otherwise)
      *
      * @return int Number of records deleted
      */
     public function delete($ids, $force=true)
     {
         $this->_fetch_groups();
 
         if (!is_array($ids))
             $ids = explode(',', $ids);
 
         $count = 0;
         foreach ($ids as $id) {
             if ($uid = $this->id2uid($id)) {
                 $is_mailto = strpos($uid, 'mailto:') === 0;
                 $deleted = $is_mailto || $this->storagefolder->delete($uid, $force);
 
                 if (!$deleted) {
                     rcube::raise_error(array(
                       'code' => 600, 'type' => 'php',
                       'file' => __FILE__, 'line' => __LINE__,
                       'message' => "Error deleting a contact object $uid from the Kolab server"),
                     true, false);
                 }
                 else {
                     // remove from distribution lists
                     foreach ((array)$this->groupmembers[$id] as $gid) {
                         if (!$is_mailto || $gid == $this->gid)
                             $this->remove_from_group($gid, $id);
                     }
 
                     // clear internal cache
                     unset($this->groupmembers[$id]);
                     $count++;
                 }
             }
         }
 
         return $count;
     }
 
 
     /**
      * Undelete one or more contact records.
      * Only possible just after delete (see 2nd argument of delete() method).
      *
      * @param array  Record identifiers
      *
      * @return int Number of records restored
      */
     public function undelete($ids)
     {
         if (!is_array($ids))
             $ids = explode(',', $ids);
 
         $count = 0;
         foreach ($ids as $id) {
             $uid = $this->id2uid($id);
             if ($this->storagefolder->undelete($uid)) {
                 $count++;
             }
             else {
                 rcube::raise_error(array(
                   'code' => 600, 'type' => 'php',
                   'file' => __FILE__, 'line' => __LINE__,
                   'message' => "Error undeleting a contact object $uid from the Kolab server"),
                 true, false);
             }
         }
 
         return $count;
     }
 
 
     /**
      * Remove all records from the database
      */
     public function delete_all()
     {
         if ($this->storagefolder->delete_all()) {
             $this->contacts = array();
             $this->sortindex = array();
             $this->dataset = null;
             $this->result = null;
         }
     }
 
 
     /**
      * Close connection to source
      * Called on script shutdown
      */
     public function close()
     {
     }
 
 
     /**
      * Create a contact group with the given name
      *
      * @param string The group name
      * @return mixed False on error, array with record props in success
      */
     function create_group($name)
     {
         $this->_fetch_groups();
         $result = false;
 
         $list = array(
             'name' => $name,
             'member' => array(),
         );
         $saved = $this->storagefolder->save($list, 'distribution-list');
 
         if (!$saved) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error saving distribution-list object to Kolab server"),
             true, false);
             return false;
         }
         else {
             $id = $this->uid2id($list['uid']);
             $this->distlists[$id] = $list;
             $result = array('id' => $id, 'name' => $name);
         }
 
         return $result;
     }
 
     /**
      * Delete the given group and all linked group members
      *
      * @param string Group identifier
      * @return boolean True on success, false if no data was changed
      */
     function delete_group($gid)
     {
         $this->_fetch_groups();
         $result = false;
 
         if ($list = $this->distlists[$gid]) {
             $deleted = $this->storagefolder->delete($list['uid']);
         }
 
         if (!$deleted) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error deleting distribution-list object from the Kolab server"),
             true, false);
         }
         else {
             $result = true;
         }
 
         return $result;
     }
 
     /**
      * Rename a specific contact group
      *
      * @param string Group identifier
      * @param string New name to set for this group
      * @return boolean New name on success, false if no data was changed
      */
     function rename_group($gid, $newname)
     {
         $this->_fetch_groups();
         $list = $this->distlists[$gid];
 
         if ($newname != $list['name']) {
             $list['name'] = $newname;
             $saved = $this->storagefolder->save($list, 'distribution-list', $list['uid']);
         }
 
         if (!$saved) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error saving distribution-list object to Kolab server"),
             true, false);
             return false;
         }
 
         return $newname;
     }
 
     /**
      * Add the given contact records the a certain group
      *
      * @param string  Group identifier
      * @param array   List of contact identifiers to be added
      * @return int    Number of contacts added
      */
     function add_to_group($gid, $ids)
     {
         if (!is_array($ids)) {
             $ids = explode(',', $ids);
         }
 
         $this->_fetch_groups(true);
 
         $list   = $this->distlists[$gid];
         $added  = 0;
         $uids   = array();
         $exists = array();
 
         foreach ((array)$list['member'] as $member) {
             $exists[] = $member['ID'];
         }
 
         // substract existing assignments from list
         $ids = array_unique(array_diff($ids, $exists));
 
         // add mailto: members
         foreach ($ids as $contact_id) {
             $uid = $this->id2uid($contact_id);
             if (strpos($uid, 'mailto:') === 0 && ($contact = $this->contacts[$contact_id])) {
                 $list['member'][] = array(
                     'email' => $contact['email'],
                     'name'  => $contact['name'],
                 );
                 $this->groupmembers[$contact_id][] = $gid;
                 $added++;
             }
             else {
                 $uids[$uid] = $contact_id;
             }
         }
 
         // add members with UID
         if (!empty($uids)) {
             foreach ($uids as $uid => $contact_id) {
                 $list['member'][] = array('uid' => $uid);
                 $this->groupmembers[$contact_id][] = $gid;
                 $added++;
             }
         }
 
         if ($added)
             $saved = $this->storagefolder->save($list, 'distribution-list', $list['uid']);
         else
             $saved = true;
 
         if (!$saved) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error saving distribution-list to Kolab server"),
             true, false);
             $added = false;
             $this->set_error(self::ERROR_SAVING, 'errorsaving');
         }
         else {
             $this->distlists[$gid] = $list;
         }
 
         return $added;
     }
 
     /**
      * Remove the given contact records from a certain group
      *
      * @param string  Group identifier
      * @param array   List of contact identifiers to be removed
      * @return int    Number of deleted group members
      */
     function remove_from_group($gid, $ids)
     {
         if (!is_array($ids))
             $ids = explode(',', $ids);
 
         $this->_fetch_groups();
         if (!($list = $this->distlists[$gid]))
             return false;
 
         $new_member = array();
         foreach ((array)$list['member'] as $member) {
             if (!in_array($member['ID'], $ids))
                 $new_member[] = $member;
         }
 
         // write distribution list back to server
         $list['member'] = $new_member;
         $saved = $this->storagefolder->save($list, 'distribution-list', $list['uid']);
 
         if (!$saved) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error saving distribution-list object to Kolab server"),
             true, false);
         }
         else {
             // remove group assigments in local cache
             foreach ($ids as $id) {
                 $j = array_search($gid, $this->groupmembers[$id]);
                 unset($this->groupmembers[$id][$j]);
             }
             $this->distlists[$gid] = $list;
             return true;
         }
 
         return false;
     }
 
     /**
      * Check the given data before saving.
      * If input not valid, the message to display can be fetched using get_error()
      *
      * @param array Associative array with contact data to save
      *
      * @return boolean True if input is valid, False if not.
      */
     public function validate(&$save_data)
     {
         // validate e-mail addresses
         $valid = parent::validate($save_data);
 
         // require at least one e-mail address if there's no name
         // (syntax check is already done)
         if ($valid) {
             if (!strlen($save_data['name'])
                 && !strlen($save_data['organization'])
                 && !array_filter($this->get_col_values('email', $save_data, true))
             ) {
                 $this->set_error('warning', 'kolab_addressbook.noemailnamewarning');
                 $valid = false;
             }
         }
 
         return $valid;
     }
 
     /**
      * Query storage layer and store records in private member var
      */
     private function _fetch_contacts($query = array(), $limit = false)
     {
         if (!isset($this->dataset) || !empty($query)) {
             if ($limit) {
                 $this->storagefolder->set_order_and_limit($this->_sort_columns(), $this->page_size, ($this->list_page-1) * $this->page_size);
             }
             $this->sortindex = array();
             $this->dataset = $this->storagefolder->select($query);
             foreach ($this->dataset as $idx => $record) {
                 $contact = $this->_to_rcube_contact($record);
                 $this->sortindex[$idx] = $this->_sort_string($contact);
             }
         }
     }
 
     /**
      * Extract a string for sorting from the given contact record
      */
     private function _sort_string($rec)
     {
         $str = '';
 
         switch ($this->sort_col) {
         case 'name':
             $str = $rec['name'] . $rec['prefix'];
         case 'firstname':
             $str .= $rec['firstname'] . $rec['middlename'] . $rec['surname'];
             break;
 
         case 'surname':
             $str = $rec['surname'] . $rec['firstname'] . $rec['middlename'];
             break;
 
         default:
             $str = $rec[$this->sort_col];
             break;
         }
 
         $str .= is_array($rec['email']) ? $rec['email'][0] : $rec['email'];
         return mb_strtolower($str);
     }
 
     /**
      * Return the cache table columns to order by
      */
     private function _sort_columns()
     {
         $sortcols = array();
 
         switch ($this->sort_col) {
         case 'name':
             $sortcols[] = 'name';
         case 'firstname':
             $sortcols[] = 'firstname';
             break;
 
         case 'surname':
             $sortcols[] = 'surname';
             break;
         }
 
         $sortcols[] = 'email';
         return $sortcols;
     }
 
     /**
      * Read distribution-lists AKA groups from server
      */
     private function _fetch_groups($with_contacts = false)
     {
         if (!isset($this->distlists)) {
             $this->distlists = $this->groupmembers = array();
             foreach ($this->storagefolder->get_objects('distribution-list') as $record) {
                 $record['ID'] = $this->uid2id($record['uid']);
                 foreach ((array)$record['member'] as $i => $member) {
                     $mid = $this->uid2id($member['uid'] ? $member['uid'] : 'mailto:' . $member['email']);
                     $record['member'][$i]['ID'] = $mid;
                     $record['member'][$i]['readonly'] = empty($member['uid']);
                     $this->groupmembers[$mid][] = $record['ID'];
 
                     if ($with_contacts && empty($member['uid']))
                         $this->contacts[$mid] = $record['member'][$i];
                 }
                 $this->distlists[$record['ID']] = $record;
             }
         }
     }
 
     /**
      * Encode object UID into a safe identifier
      */
     public function uid2id($uid)
     {
         return rtrim(strtr(base64_encode($uid), '+/', '-_'), '=');
     }
 
     /**
      * Convert Roundcube object identifier back into the original UID
      */
     public function id2uid($id)
     {
         return base64_decode(str_pad(strtr($id, '-_', '+/'), strlen($id) % 4, '=', STR_PAD_RIGHT));
     }
 
     /**
      * Build SQL query for fulltext matches
      */
     private function _search_query($fields, $value, $mode)
     {
         $query = array();
         $cols  = array();
 
         // $fulltext_cols might contain composite field names e.g. 'email:address' while $fields not
         foreach (kolab_format_contact::$fulltext_cols as $col) {
             if ($pos = strpos($col, ':')) {
                 $col = substr($col, 0, $pos);
             }
             if (in_array($col, $fields)) {
                 $cols[] = $col;
             }
         }
 
         if (count($cols) == count($fields)) {
             switch ($mode) {
                 case 1:  $prefix = '^'; $suffix = '$'; break;  // strict
                 case 2:  $prefix = '^'; $suffix = '';  break;  // prefix
                 default: $prefix = '';  $suffix = '';  break;  // substring
             }
 
             $search_string = is_array($value) ? join(' ', $value) : $value;
             foreach (rcube_utils::normalize_string($search_string, true) as $word) {
                 $query[] = array('words', 'LIKE', $prefix . $word . $suffix);
             }
         }
 
         return $query;
     }
 
     /**
      * Map fields from internal Kolab_Format to Roundcube contact format
      */
     private function _to_rcube_contact($record)
     {
         $record['ID'] = $this->uid2id($record['uid']);
 
         // convert email, website, phone values
         foreach (array('email'=>'address', 'website'=>'url', 'phone'=>'number') as $col => $propname) {
             if (is_array($record[$col])) {
                 $values = $record[$col];
                 unset($record[$col]);
                 foreach ((array)$values as $i => $val) {
                     $key = $col . ($val['type'] ? ':' . $val['type'] : '');
                     $record[$key][] = $val[$propname];
                 }
             }
         }
 
         if (is_array($record['address'])) {
             $addresses = $record['address'];
             unset($record['address']);
             foreach ($addresses as $i => $adr) {
                 $key = 'address' . ($adr['type'] ? ':' . $adr['type'] : '');
                 $record[$key][] = array(
                     'street'   => $adr['street'],
                     'locality' => $adr['locality'],
                     'zipcode'  => $adr['code'],
                     'region'   => $adr['region'],
                     'country'  => $adr['country'],
                 );
             }
         }
 
         // photo is stored as separate attachment
         if ($record['photo'] && strlen($record['photo']) < 255 && ($att = $record['_attachments'][$record['photo']])) {
             // only fetch photo content if requested
             if ($this->action == 'photo')
                 $record['photo'] = $att['content'] ? $att['content'] : $this->storagefolder->get_attachment($record['uid'], $att['id']);
         }
 
         // truncate publickey value for display
         if ($record['pgppublickey'] && $this->action == 'show')
             $record['pgppublickey'] = substr($record['pgppublickey'], 0, 140) . '...';
 
         // remove empty fields
         $record = array_filter($record);
 
         // remove kolab_storage internal data
         unset($record['_msguid'], $record['_formatobj'], $record['_mailbox'], $record['_type'], $record['_size']);
 
         return $record;
     }
 
     /**
      * Map fields from Roundcube format to internal kolab_format_contact properties
      */
     private function _from_rcube_contact($contact, $old = array())
     {
         if (!$contact['uid'] && $contact['ID'])
             $contact['uid'] = $this->id2uid($contact['ID']);
         else if (!$contact['uid'] && $old['uid'])
             $contact['uid'] = $old['uid'];
 
         $contact['im'] = array_filter($this->get_col_values('im', $contact, true));
 
         // convert email, website, phone values
         foreach (array('email'=>'address', 'website'=>'url', 'phone'=>'number') as $col => $propname) {
             $col_values = $this->get_col_values($col, $contact);
             $contact[$col] = array();
             foreach ($col_values as $type => $values) {
                 foreach ((array)$values as $val) {
                     if (!empty($val)) {
                         $contact[$col][] = array($propname => $val, 'type' => $type);
                     }
                 }
                 unset($contact[$col.':'.$type]);
             }
         }
 
         $addresses = array();
         foreach ($this->get_col_values('address', $contact) as $type => $values) {
             foreach ((array)$values as $adr) {
                 // skip empty address
                 $adr = array_filter($adr);
                 if (empty($adr))
                     continue;
 
                 $addresses[] = array(
                     'type' => $type,
                     'street' => $adr['street'],
                     'locality' => $adr['locality'],
                     'code' => $adr['zipcode'],
                     'region' => $adr['region'],
                     'country' => $adr['country'],
                 );
             }
 
             unset($contact['address:'.$type]);
         }
 
         $contact['address'] = $addresses;
 
         // categories are not supported in the web client but should be preserved (#2608)
         $contact['categories'] = $old['categories'];
 
         // copy meta data (starting with _) from old object
         foreach ((array)$old as $key => $val) {
             if (!isset($contact[$key]) && $key[0] == '_')
                 $contact[$key] = $val;
         }
 
         // convert one-item-array elements into string element
         // this is needed e.g. to properly import birthday field
         foreach ($this->coltypes as $type => $col_def) {
             if ($col_def['limit'] == 1 && is_array($contact[$type])) {
                 $contact[$type] = array_shift(array_filter($contact[$type]));
             }
         }
 
         // When importing contacts 'vcard' data is added, we don't need it (Bug #1711)
         unset($contact['vcard']);
 
         // add empty values for some fields which can be removed in the UI
         return array_filter($contact) + array('nickname' => '', 'birthday' => '', 'anniversary' => '', 'freebusyurl' => '', 'photo' => $contact['photo']);
     }
 
 }
diff --git a/plugins/kolab_notes/kolab_notes.php b/plugins/kolab_notes/kolab_notes.php
index bbac42dc..7faee11c 100644
--- a/plugins/kolab_notes/kolab_notes.php
+++ b/plugins/kolab_notes/kolab_notes.php
@@ -1,1423 +1,1426 @@
 <?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-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
         $this->bonnie_api = libkolab::get_bonnie_api();
 
         // 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),
+                    '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);
+        $config->apply_links($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']);
+            // get note links
+            $result['links'] = $this->get_links($result['uid']);
         }
 
         return $result;
     }
 
     /**
      * Helper method to encode the given note record for use in the client
      */
-    private function _client_encode(&$note, $resolve = false)
+    private function _client_encode(&$note)
     {
         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']));
+        // convert link URIs references into structs
+        if (array_key_exists('links', $note)) {
+            foreach ((array)$note['links'] as $i => $link) {
+                if (strpos($link, 'imap://') === 0 && ($msgref = kolab_storage_config::get_message_reference($link, 'note'))) {
+                    $note['links'][$i] = $msgref;
+                }
+            }
+        }
 
         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 = $silent = false;
         switch ($action) {
             case 'new':
             case 'edit':
                 if ($success = $this->save_note($note)) {
                     $refresh = $this->get_note($note);
                 }
                 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)) {
                     $rcmail = $this->rc;
                     $dtformat = $rcmail->config->get('date_format') . ' ' . $this->rc->config->get('time_format');
                     array_walk($data, function(&$change) use ($lib, $rcmail, $dtformat) {
                       if ($change['date']) {
                           $dt = rcube_utils::anytodatetime($change['date']);
                           if ($dt instanceof DateTime) {
                               $change['date'] = $rcmail->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 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) {
             rcube::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);
+                    $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['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',
             ), rcube::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);
+        return $config->save_object_links($uid, (array) $links);
     }
 
     /**
      * 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_tags/kolab_tags.php b/plugins/kolab_tags/kolab_tags.php
index c3a18469..b9be9b86 100644
--- a/plugins/kolab_tags/kolab_tags.php
+++ b/plugins/kolab_tags/kolab_tags.php
@@ -1,154 +1,158 @@
 <?php
 
 /**
  * Kolab Tags
  *
  * @author Aleksander Machniak <machniak@kolabsys.com>
  *
  * Copyright (C) 2014, 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_tags extends rcube_plugin
 {
     public $task = 'mail';
     public $rc;
     public $home;
 
     private $engine;
 
     public function init()
     {
         $this->rc = rcube::get_instance();
 
         // Register hooks to display tags in message subject
         $this->add_hook('messages_list', array($this, 'messages_list'));
         $this->add_hook('message_headers_output', array($this, 'message_headers_output'));
 
         // Searching by tags
         $this->add_hook('imap_search_before', array($this, 'imap_search_before'));
 
         // Plugin actions for tag management
         $this->register_action('plugin.kolab_tags', array($this, 'actions'));
 
         // Load UI from startup hook
         $this->add_hook('startup', array($this, 'startup'));
     }
 
     /**
      * Creates kolab_files_engine instance
      */
     private function engine()
     {
         if ($this->engine === null) {
             // the files module can be enabled/disabled by the kolab_auth plugin
             if ($this->rc->config->get('kolab_tags_disabled') || !$this->rc->config->get('kolab_tags_enabled', true)) {
                 return $this->engine = false;
             }
 
 //            $this->load_config();
 
             require_once $this->home . DIRECTORY_SEPARATOR . 'lib' . DIRECTORY_SEPARATOR . 'kolab_tags_engine.php';
 
             $this->engine = new kolab_tags_engine($this);
         }
 
         return $this->engine;
     }
 
     /**
      * Startup hook handler, initializes/enables Files UI
      */
     public function startup($args)
     {
         // call this from startup to give a chance to set
         // kolab_files_enabled/disabled in kolab_auth plugin
         if ($this->rc->output->type != 'html') {
             return;
         }
 
         if ($this->rc->action == 'print') {
             return;
         }
 
         if ($engine = $this->engine()) {
             $engine->ui();
         }
     }
 
     /**
      * Engine actions handler
      */
     public function actions()
     {
         if ($engine = $this->engine()) {
             $engine->actions();
         }
     }
 
     /**
      * Handler for messages list
      */
     public function messages_list($args)
     {
         if ($engine = $this->engine()) {
             $args = $engine->messages_list_handler($args);
         }
 
         return $args;
     }
 
     /**
      * Handler for message headers
      */
     public function message_headers_output($args)
     {
         // this hook can be executed many times
         if ($this->mail_headers_done) {
             return $args;
         }
 
+        if ($this->rc->action == 'print') {
+            return;
+        }
+
         $this->mail_headers_done = true;
 
         if ($engine = $this->engine()) {
             $args = $engine->message_headers_handler($args);
         }
 
         return $args;
     }
 
     /**
      * Handler for messages searching
      */
     public function imap_search_before($args)
     {
         // if search filter contains tag mark
         if (preg_match('/^(kolab_tags_[0-9]{10,}:([^:]+):)/', $args['search'], $m) && ($engine = $this->engine())) {
             $this->current_tags   = $args['search_tags'] = explode(',', $m[2]);
             $this->current_filter = $args['search']      = substr($args['search'], strlen($m[1]));
 
             // modify search arguments
             $args = $engine->imap_search_handler($args);
 
             unset($args['search_tags']);
 
             // send current search properties to the browser
             $this->rc->output->set_env('search_filter_selected', $this->current_filter);
             $this->rc->output->set_env('selected_tags', $this->current_tags);
         }
 
         return $args;
     }
 }
diff --git a/plugins/kolab_tags/lib/kolab_tags_engine.php b/plugins/kolab_tags/lib/kolab_tags_engine.php
index b1158fc7..8f881851 100644
--- a/plugins/kolab_tags/lib/kolab_tags_engine.php
+++ b/plugins/kolab_tags/lib/kolab_tags_engine.php
@@ -1,495 +1,501 @@
 <?php
 
 /**
  * Kolab Tags engine
  *
  * @author Aleksander Machniak <machniak@kolabsys.com>
  *
  * Copyright (C) 2014, 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_tags_engine
 {
     private $backend;
     private $plugin;
     private $rc;
 
     /**
      * Class constructor
      */
     public function __construct($plugin)
     {
         $plugin->require_plugin('libkolab');
 
         require_once $plugin->home . DIRECTORY_SEPARATOR . 'lib' . DIRECTORY_SEPARATOR . 'kolab_tags_backend.php';
 
         $this->backend = new kolab_tags_backend;
         $this->plugin  = $plugin;
         $this->rc      = $plugin->rc;
     }
 
     /**
      * User interface initialization
      */
     public function ui()
     {
         // set templates of Files UI and widgets
         if ($this->rc->task == 'mail') {
             $this->plugin->add_texts('localization/');
 
             $this->plugin->include_stylesheet($this->plugin->local_skin_path().'/style.css');
             $this->plugin->include_script('kolab_tags.js');
             $this->rc->output->add_label('cancel', 'save');
             $this->plugin->add_label('tags', 'add', 'edit', 'delete', 'saving',
                 'nameempty', 'nameexists', 'colorinvalid', 'untag', 'tagname',
                 'tagcolor', 'tagsearchnew', 'newtag');
 
             $this->rc->output->add_handlers(array(
                 'plugin.taglist' => array($this, 'taglist'),
             ));
 
             $ui = $this->rc->output->parse('kolab_tags.ui', false, false);
             $this->rc->output->add_footer($ui);
 
             // load miniColors
             jqueryui::miniColors();
         }
     }
 
     /**
      * Engine actions handler (managing tag objects)
      */
     public function actions()
     {
         $this->plugin->add_texts('localization/');
 
         $action = rcube_utils::get_input_value('_act', rcube_utils::INPUT_POST);
 
         if ($action) {
             $this->{'action_' . $action}();
         }
         // manage tag objects
         else {
             $delete   = (array) rcube_utils::get_input_value('delete', rcube_utils::INPUT_POST);
             $update   = (array) rcube_utils::get_input_value('update', rcube_utils::INPUT_POST, true);
             $add      = (array) rcube_utils::get_input_value('add', rcube_utils::INPUT_POST, true);
             $response = array();
 
             // tags deletion
             foreach ($delete as $uid) {
                 if ($this->backend->remove($uid)) {
                     $response['delete'][] = $uid;
                 }
                 else {
                     $error = true;
                 }
             }
 
             // tags creation
             foreach ($add as $tag) {
                 if ($tag = $this->backend->create($tag)) {
                     $response['add'][] = $this->parse_tag($tag);
                 }
                 else {
                     $error = true;
                 }
             }
 
             // tags update
             foreach ($update as $tag) {
                 if ($this->backend->update($tag)) {
                     $response['update'][] = $this->parse_tag($tag);
                 }
                 else {
                     $error = true;
                 }
             }
 
             if (!empty($error)) {
                 $this->rc->output->show_message($this->plugin->gettext('updateerror'), 'error');
             }
             else {
                 $this->rc->output->show_message($this->plugin->gettext('updatesuccess'), 'confirmation');
             }
 
             $this->rc->output->command('plugin.kolab_tags', $response);
         }
 
 
         $this->rc->output->send();
     }
 
     /**
      * Remove tag from message(s)
      */
     public function action_remove()
     {
         $tag     = rcube_utils::get_input_value('_tag', rcube_utils::INPUT_POST);
         $filter  = $tag == '*' ? array() : array(array('uid', '=', explode(',', $tag)));
         $taglist = $this->backend->list_tags($filter);
         $filter  = array();
         $tags    = array();
 
         foreach (rcmail::get_uids() as $mbox => $uids) {
             if ($uids === '*') {
                 $filter[$mbox] = $this->build_member_url(array('folder' => $mbox));
             }
             else {
                 foreach ((array)$uids as $uid) {
                     $filter[$mbox][] = $this->build_member_url(array(
                             'folder' => $mbox,
                             'uid'    => $uid
                     ));
                 }
             }
         }
 
         // for every tag...
         foreach ($taglist as $tag) {
             $updated = false;
 
             // @todo: make sure members list is up-to-date (UIDs are up-to-date)
 
             // ...filter members by folder/uid prefix
             foreach ((array) $tag['members'] as $idx => $member) {
                 foreach ($filter as $members) {
                     // list of prefixes
                     if (is_array($members)) {
                         foreach ($members as $message) {
                             if ($member == $message || strpos($member, $message . '?') === 0) {
                                 unset($tag['members'][$idx]);
                                 $updated = true;
                             }
                         }
                     }
                     // one prefix (all messages in a folder)
                     else {
                         if (preg_match('/^' . preg_quote($members, '/') . '\/[0-9]+(\?|$)/', $member)) {
                             unset($tag['members'][$idx]);
                             $updated = true;
                         }
                     }
                 }
             }
 
             // update tag object
             if ($updated) {
                 if (!$this->backend->update($tag)) {
                     $error = true;
                 }
             }
 
             $tags[] = $tag['uid'];
         }
 
         if ($error) {
             if ($_POST['_from'] != 'show') {
                 $this->rc->output->show_message($this->plugin->gettext('untaggingerror'), 'error');
                 $this->rc->output->command('list_mailbox');
             }
         }
         else {
             $this->rc->output->show_message($this->plugin->gettext('untaggingsuccess'), 'confirmation');
             $this->rc->output->command('plugin.kolab_tags', array('mark' => 1, 'delete' => $tags));
         }
     }
 
     /**
      * Add tag to message(s)
      */
     public function action_add()
     {
         $tag     = rcube_utils::get_input_value('_tag', rcube_utils::INPUT_POST);
         $storage = $this->rc->get_storage();
         $members = array();
 
         // build list of members
         foreach (rcmail::get_uids() as $mbox => $uids) {
             if ($uids === '*') {
                 $index = $storage->index($mbox, null, null, true);
                 $uids  = $index->get();
                 $msgs  = $storage->fetch_headers($mbox, $uids, false);
             }
             else {
                 $msgs = $storage->fetch_headers($mbox, $uids, false);
             }
 
             $members = array_merge($members, $this->build_members($mbox, $msgs));
         }
 
         // create a new tag?
         if (!empty($_POST['_new'])) {
             $object = array(
                 'name'    => $tag,
                 'members' => $members,
             );
 
             $object = $this->backend->create($object);
             $error  = $object === false;
         }
         // use existing tags (by UID)
         else {
             $filter  = array(array('uid', '=', explode(',', $tag)));
             $taglist = $this->backend->list_tags($filter);
 
             // for every tag...
             foreach ($taglist as $tag) {
                 $tag['members'] = array_unique(array_merge((array) $tag['members'], $members));
 
                 // update tag object
                 if (!$this->backend->update($tag)) {
                     $error = true;
                 }
             }
         }
 
         if ($error) {
             $this->rc->output->show_message($this->plugin->gettext('taggingerror'), 'error');
 
             if ($_POST['_from'] != 'show') {
                 $this->rc->output->command('list_mailbox');
             }
         }
         else {
             $this->rc->output->show_message($this->plugin->gettext('taggingsuccess'), 'confirmation');
 
             if (isset($object)) {
                 $this->rc->output->command('plugin.kolab_tags', array('mark' => 1, 'add' => array($this->parse_tag($object))));
             }
         }
     }
 
     /**
      * Template object building tags list/cloud
      */
     public function taglist($attrib)
     {
         $taglist = $this->backend->list_tags();
+
+        // Performance: Save the list for later
+        if ($this->rc->action == 'show' || $this->rc->action == 'preview') {
+            $this->taglist = $taglist;
+        }
+
         $taglist = array_map(array($this, 'parse_tag'), $taglist);
 
         $this->rc->output->set_env('tags', $taglist);
         $this->rc->output->add_gui_object('taglist', $attrib['id']);
 
         return html::tag('ul', $attrib, '', html::$common_attrib);
     }
 
     /**
      * Handler for messages list (add tag-boxes in subject line on the list)
      */
     public function messages_list_handler($args)
     {
         if (empty($args['messages'])) {
             return;
         }
 
         // get tags list
         $taglist = $this->backend->list_tags();
 
         // get message UIDs
         foreach ($args['messages'] as $msg) {
             $message_tags[$msg->uid . '-' . $msg->folder] = null;
         }
 
         $uids = array_keys($message_tags);
 
         foreach ($taglist as $tag) {
             $tag = $this->parse_tag($tag, true);
 
             foreach ((array) $tag['uids'] as $folder => $_uids) {
                 array_walk($_uids, function(&$uid, $key, $folder) { $uid .= '-' . $folder; }, $folder);
 
                 foreach (array_intersect($uids, $_uids) as $uid) {
                     $message_tags[$uid][] = $tag['uid'];
                 }
             }
         }
 
         $this->rc->output->set_env('message_tags', array_filter($message_tags));
 
         // @TODO: tag counters for the whole folder (search result)
 
         return $args;
     }
 
     /**
      * Handler for a single message (add tag-boxes in subject line)
      */
     public function message_headers_handler($args)
     {
-        $taglist = $this->backend->list_tags();
+        $taglist = $this->taglist ?: $this->backend->list_tags();
         $uid     = $args['uid'];
         $folder  = $args['folder'];
         $tags    = array();
 
         foreach ($taglist as $tag) {
             $tag = $this->parse_tag($tag, true);
             if (in_array($uid, (array)$tag['uids'][$folder])) {
                 unset($tag['uids']);
                 $tags[] = $tag;
             }
         }
 
         if (!empty($tags)) {
             $this->rc->output->set_env('message_tags', $tags);
         }
 
         return $args;
     }
 
     /**
      * Handler for messages searching requests
      */
     public function imap_search_handler($args)
     {
         if (empty($args['search_tags'])) {
             return $args;
         }
 
         // we'll reset to current folder to fix issues when searching in multi-folder mode
         $storage     = $this->rc->get_storage();
         $orig_folder = $storage->get_folder();
 
         // get tags
         $tags = $this->backend->list_tags(array(array('uid', '=', $args['search_tags'])));
 
         // sanity check (that should not happen)
         if (empty($tags)) {
             if ($orig_folder) {
                 $storage->set_folder($orig_folder);
             }
 
             return $args;
         }
 
         $search  = array();
         $folders = (array) $args['folder'];
 
         // collect folders and uids
         foreach ($tags as $tag) {
             $tag = $this->parse_tag($tag, true);
 
             // tag has no members -> empty search result
             if (empty($tag['uids'])) {
                 goto empty_result;
             }
 
             foreach ($tag['uids'] as $folder => $uid_list) {
                 $search[$folder] = array_merge((array)$search[$folder], $uid_list);
             }
         }
 
         $search   = array_map('array_unique', $search);
         $criteria = array();
 
         // modify search folders/criteria
         $args['folder'] = array_intersect($folders, array_keys($search));
 
         foreach ($args['folder'] as $folder) {
             $criteria[$folder] = ($args['search'] != 'ALL' ? trim($args['search']).' ' : '')
                 . 'UID ' . rcube_imap_generic::compressMessageSet($search[$folder]);
         }
 
         if (!empty($args['folder'])) {
             $args['search'] = $criteria;
         }
         else {
             // return empty result
             empty_result:
 
             if (count($folders) > 1) {
                 $args['result'] = new rcube_result_multifolder($args['folder']);
                 foreach ($args['folder'] as $folder) {
                     $index = new rcube_result_index($folder, '* SORT');
                     $args['result']->add($index);
                 }
             }
             else {
                 $class  = 'rcube_result_' . ($args['threading'] ? 'thread' : 'index');
                 $result = $args['threading'] ? '* THREAD' : '* SORT';
 
                 $args['result'] = new $class($folder, $result);
             }
         }
 
         if ($orig_folder) {
             $storage->set_folder($orig_folder);
         }
 
         return $args;
     }
 
     /**
      * "Convert" tag object to simple array for use in javascript
      */
     private function parse_tag($tag, $list = false)
     {
         $result = array(
             'uid'   => $tag['uid'],
             'name'  => $tag['name'],
             'color' => $tag['color'],
         );
 
         if ($list) {
             $result['uids'] = $this->get_tag_messages($tag);
         }
 
         return $result;
     }
 
     /**
      * Resolve members to folder/UID
      *
      * @param array $tag Tag object
      *
      * @return array Folder/UID list
      */
     protected function get_tag_messages(&$tag, $force = true)
     {
         return kolab_storage_config::resolve_members($tag, $force);
     }
 
     /**
      * Build array of member URIs from set of messages
      */
     protected function build_members($folder, $messages)
     {
         return kolab_storage_config::build_members($folder, $messages);
     }
 
     /**
      * Parses tag member string
      *
      * @param string $url Member URI
      *
      * @return array Message folder, UID, Search headers (Message-Id, Date)
      */
     protected function parse_member_url($url)
     {
         return kolab_storage_config::parse_member_url($url);
     }
 
     /**
      * Builds member URI
      *
      * @param array Message folder, UID, Search headers (Message-Id, Date)
      *
      * @return string $url Member URI
      */
     protected function build_member_url($params)
     {
         return kolab_storage_config::build_member_url($params);
     }
 }
diff --git a/plugins/libkolab/lib/kolab_storage.php b/plugins/libkolab/lib/kolab_storage.php
index 9bafbe99..db7e0ba3 100644
--- a/plugins/libkolab/lib/kolab_storage.php
+++ b/plugins/libkolab/lib/kolab_storage.php
@@ -1,1603 +1,1654 @@
 <?php
 
 /**
  * Kolab storage class providing static methods to access groupware objects on a Kolab server.
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  * @author Aleksander Machniak <machniak@kolabsys.com>
  *
  * Copyright (C) 2012-2014, 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_storage
 {
-    const CTYPE_KEY = '/shared/vendor/kolab/folder-type';
+    const CTYPE_KEY         = '/shared/vendor/kolab/folder-type';
     const CTYPE_KEY_PRIVATE = '/private/vendor/kolab/folder-type';
     const COLOR_KEY_SHARED  = '/shared/vendor/kolab/color';
     const COLOR_KEY_PRIVATE = '/private/vendor/kolab/color';
     const NAME_KEY_SHARED   = '/shared/vendor/kolab/displayname';
     const NAME_KEY_PRIVATE  = '/private/vendor/kolab/displayname';
     const UID_KEY_SHARED    = '/shared/vendor/kolab/uniqueid';
     const UID_KEY_CYRUS     = '/shared/vendor/cmu/cyrus-imapd/uniqueid';
 
     const ERROR_IMAP_CONN      = 1;
     const ERROR_CACHE_DB       = 2;
     const ERROR_NO_PERMISSION  = 3;
     const ERROR_INVALID_FOLDER = 4;
 
     public static $version = '3.0';
     public static $last_error;
     public static $encode_ids = false;
 
     private static $ready = false;
     private static $with_tempsubs = true;
     private static $subscriptions;
     private static $typedata = array();
     private static $states;
     private static $config;
     private static $imap;
     private static $ldap;
 
     // Default folder names
     private static $default_folders = array(
         'event'         => 'Calendar',
         'contact'       => 'Contacts',
         'task'          => 'Tasks',
         'note'          => 'Notes',
         'file'          => 'Files',
         'configuration' => 'Configuration',
         'journal'       => 'Journal',
         'mail.inbox'       => 'INBOX',
         'mail.drafts'      => 'Drafts',
         'mail.sentitems'   => 'Sent',
         'mail.wastebasket' => 'Trash',
         'mail.outbox'      => 'Outbox',
         'mail.junkemail'   => 'Junk',
     );
 
 
     /**
      * Setup the environment needed by the libs
      */
     public static function setup()
     {
         if (self::$ready)
             return true;
 
         $rcmail = rcube::get_instance();
         self::$config = $rcmail->config;
         self::$version = strval($rcmail->config->get('kolab_format_version', self::$version));
         self::$imap = $rcmail->get_storage();
         self::$ready = class_exists('kolabformat') &&
             (self::$imap->get_capability('METADATA') || self::$imap->get_capability('ANNOTATEMORE') || self::$imap->get_capability('ANNOTATEMORE2'));
 
         if (self::$ready) {
             // set imap options
             self::$imap->set_options(array(
                 'skip_deleted' => true,
                 'threading' => false,
             ));
         }
         else if (!class_exists('kolabformat')) {
             rcube::raise_error(array(
                 'code' => 900, 'type' => 'php',
                 'message' => "required kolabformat module not found"
             ), true);
         }
         else {
             rcube::raise_error(array(
                 'code' => 900, 'type' => 'php',
                 'message' => "IMAP server doesn't support METADATA or ANNOTATEMORE"
             ), true);
         }
 
         // adjust some configurable settings
         if ($event_scheduling_prop = $rcmail->config->get('kolab_event_scheduling_properties', null)) {
             kolab_format_event::$scheduling_properties = (array)$event_scheduling_prop;
         }
         // adjust some configurable settings
         if ($task_scheduling_prop = $rcmail->config->get('kolab_task_scheduling_properties', null)) {
             kolab_format_task::$scheduling_properties = (array)$task_scheduling_prop;
         }
 
         return self::$ready;
     }
 
     /**
      * Initializes LDAP object to resolve Kolab users
      */
     public static function ldap()
     {
         if (self::$ldap) {
             return self::$ldap;
         }
 
         self::setup();
 
         $config = self::$config->get('kolab_users_directory', self::$config->get('kolab_auth_addressbook'));
 
         if (!is_array($config)) {
             $ldap_config = (array)self::$config->get('ldap_public');
             $config = $ldap_config[$config];
         }
 
         if (empty($config)) {
             return null;
         }
 
         // overwrite filter option
         if ($filter = self::$config->get('kolab_users_filter')) {
             self::$config->set('kolab_auth_filter', $filter);
         }
 
         // re-use the LDAP wrapper class from kolab_auth plugin
         require_once rtrim(RCUBE_PLUGINS_DIR, '/') . '/kolab_auth/kolab_auth_ldap.php';
 
         self::$ldap = new kolab_auth_ldap($config);
 
         return self::$ldap;
     }
 
     /**
      * Get a list of storage folders for the given data type
      *
      * @param string Data type to list folders for (contact,distribution-list,event,task,note)
      * @param boolean Enable to return subscribed folders only (null to use configured subscription mode)
      *
      * @return array List of Kolab_Folder objects (folder names in UTF7-IMAP)
      */
     public static function get_folders($type, $subscribed = null)
     {
         $folders = $folderdata = array();
 
         if (self::setup()) {
             foreach ((array)self::list_folders('', '*', $type, $subscribed, $folderdata) as $foldername) {
                 $folders[$foldername] = new kolab_storage_folder($foldername, $type, $folderdata[$foldername]);
             }
         }
 
         return $folders;
     }
 
     /**
      * Getter for the storage folder for the given type
      *
      * @param string Data type to list folders for (contact,distribution-list,event,task,note)
      * @return object kolab_storage_folder  The folder object
      */
     public static function get_default_folder($type)
     {
         if (self::setup()) {
             foreach ((array)self::list_folders('', '*', $type . '.default', false, $folderdata) as $foldername) {
                 return new kolab_storage_folder($foldername, $type, $folderdata[$foldername]);
             }
         }
 
         return null;
     }
 
     /**
      * Getter for a specific storage folder
      *
      * @param string IMAP folder to access (UTF7-IMAP)
      * @param string Expected folder type
      *
      * @return object kolab_storage_folder  The folder object
      */
     public static function get_folder($folder, $type = null)
     {
         return self::setup() ? new kolab_storage_folder($folder, $type) : null;
     }
 
     /**
      * Getter for a single Kolab object, identified by its UID.
      * This will search all folders storing objects of the given type.
      *
      * @param string Object UID
      * @param string Object type (contact,event,task,journal,file,note,configuration)
      * @return array The Kolab object represented as hash array or false if not found
      */
     public static function get_object($uid, $type)
     {
         self::setup();
         $folder = null;
         foreach ((array)self::list_folders('', '*', $type, null, $folderdata) as $foldername) {
             if (!$folder)
                 $folder = new kolab_storage_folder($foldername, $type, $folderdata[$foldername]);
             else
                 $folder->set_folder($foldername, $type, $folderdata[$foldername]);
 
             if ($object = $folder->get_object($uid, '*'))
                 return $object;
         }
 
         return false;
     }
 
     /**
      * Execute cross-folder searches with the given query.
      *
      * @param array  Pseudo-SQL query as list of filter parameter triplets
      * @param string Object type (contact,event,task,journal,file,note,configuration)
+     * @param int    Expected number of records or limit (for performance reasons)
+     *
      * @return array List of Kolab data objects (each represented as hash array)
      * @see kolab_storage_format::select()
      */
-    public static function select($query, $type)
+    public static function select($query, $type, $limit = null)
     {
         self::setup();
         $folder = null;
         $result = array();
 
         foreach ((array)self::list_folders('', '*', $type, null, $folderdata) as $foldername) {
-            if (!$folder)
-                $folder = new kolab_storage_folder($foldername, $type, $folderdata[$foldername]);
-            else
-                $folder->set_folder($foldername, $type, $folderdata[$foldername]);
+            $folder = new kolab_storage_folder($foldername, $type, $folderdata[$foldername]);
+
+            if ($limit) {
+                $folder->set_order_and_limit(null, $limit);
+            }
 
             foreach ($folder->select($query, '*') as $object) {
                 $result[] = $object;
             }
         }
 
         return $result;
     }
 
     /**
      * Returns Free-busy server URL
      */
     public static function get_freebusy_server()
     {
         self::setup();
 
         $url = 'https://' . $_SESSION['imap_host'] . '/freebusy';
         $url = self::$config->get('kolab_freebusy_server', $url);
         $url = rcube_utils::resolve_url($url);
 
         return unslashify($url);
     }
 
     /**
      * Compose an URL to query the free/busy status for the given user
      *
      * @param string Email address of the user to get free/busy data for
      * @param object DateTime Start of the query range (optional)
      * @param object DateTime End of the query range (optional)
      *
      * @return string Fully qualified URL to query free/busy data
      */
     public static function get_freebusy_url($email, $start = null, $end = null)
     {
         $query = '';
         $param = array();
         $utc = new \DateTimeZone('UTC');
 
         if ($start instanceof \DateTime) {
             $start->setTimezone($utc);
             $param['dtstart'] = $start->format('Ymd\THis\Z');
         }
         if ($end instanceof \DateTime) {
             $end->setTimezone($utc);
             $param['dtend'] = $end->format('Ymd\THis\Z');
         }
         if (!empty($param)) {
             $query = '?' . http_build_query($param);
         }
 
         return self::get_freebusy_server() . '/' . $email . '.ifb' . $query;
     }
 
     /**
      * Creates folder ID from folder name
      *
      * @param string  $folder Folder name (UTF7-IMAP)
      * @param boolean $enc    Use lossless encoding
      * @return string Folder ID string
      */
     public static function folder_id($folder, $enc = null)
     {
         return $enc == true || ($enc === null && self::$encode_ids) ?
             self::id_encode($folder) :
             asciiwords(strtr($folder, '/.-', '___'));
     }
 
     /**
      * Encode the given ID to a safe ascii representation
      *
      * @param string $id Arbitrary identifier string
      *
      * @return string Ascii representation
      */
     public static function id_encode($id)
     {
         return rtrim(strtr(base64_encode($id), '+/', '-_'), '=');
     }
 
     /**
      * Convert the given identifier back to it's raw value
      *
      * @param string $id Ascii identifier
      * @return string Raw identifier string
      */
     public static function id_decode($id)
     {
       return base64_decode(str_pad(strtr($id, '-_', '+/'), strlen($id) % 4, '=', STR_PAD_RIGHT));
     }
 
     /**
      * Return the (first) path of the requested IMAP namespace
      *
      * @param string  Namespace name (personal, shared, other)
      * @return string IMAP root path for that namespace
      */
     public static function namespace_root($name)
     {
         foreach ((array)self::$imap->get_namespace($name) as $paths) {
             if (strlen($paths[0]) > 1) {
                 return $paths[0];
             }
         }
 
         return '';
     }
 
 
     /**
      * Deletes IMAP folder
      *
      * @param string $name Folder name (UTF7-IMAP)
      *
      * @return bool True on success, false on failure
      */
     public static function folder_delete($name)
     {
         // clear cached entries first
         if ($folder = self::get_folder($name))
             $folder->cache->purge();
 
         $rcmail = rcube::get_instance();
         $plugin = $rcmail->plugins->exec_hook('folder_delete', array('name' => $name));
 
         $success = self::$imap->delete_folder($name);
         self::$last_error = self::$imap->get_error_str();
 
         return $success;
     }
 
     /**
      * Creates IMAP folder
      *
      * @param string $name       Folder name (UTF7-IMAP)
      * @param string $type       Folder type
      * @param bool   $subscribed Sets folder subscription
      * @param bool   $active     Sets folder state (client-side subscription)
      *
      * @return bool True on success, false on failure
      */
     public static function folder_create($name, $type = null, $subscribed = false, $active = false)
     {
         self::setup();
 
         $rcmail = rcube::get_instance();
         $plugin = $rcmail->plugins->exec_hook('folder_create', array('record' => array(
             'name' => $name,
             'subscribe' => $subscribed,
         )));
 
         if ($saved = self::$imap->create_folder($name, $subscribed)) {
             // set metadata for folder type
             if ($type) {
                 $saved = self::set_folder_type($name, $type);
 
                 // revert if metadata could not be set
                 if (!$saved) {
                     self::$imap->delete_folder($name);
                 }
                 // activate folder
                 else if ($active) {
                     self::set_state($name, true);
                 }
             }
         }
 
         if ($saved) {
             return true;
         }
 
         self::$last_error = self::$imap->get_error_str();
         return false;
     }
 
 
     /**
      * Renames IMAP folder
      *
      * @param string $oldname Old folder name (UTF7-IMAP)
      * @param string $newname New folder name (UTF7-IMAP)
      *
      * @return bool True on success, false on failure
      */
     public static function folder_rename($oldname, $newname)
     {
         self::setup();
 
         $rcmail = rcube::get_instance();
         $plugin = $rcmail->plugins->exec_hook('folder_rename', array(
             'oldname' => $oldname, 'newname' => $newname));
 
         $oldfolder = self::get_folder($oldname);
         $active    = self::folder_is_active($oldname);
         $success   = self::$imap->rename_folder($oldname, $newname);
         self::$last_error = self::$imap->get_error_str();
 
         // pass active state to new folder name
         if ($success && $active) {
             self::set_state($oldname, false);
             self::set_state($newname, true);
         }
 
         // assign existing cache entries to new resource uri
         if ($success && $oldfolder) {
             $oldfolder->cache->rename($newname);
         }
 
         return $success;
     }
 
 
     /**
      * Rename or Create a new IMAP folder.
      *
      * Does additional checks for permissions and folder name restrictions
      *
      * @param array Hash array with folder properties and metadata
      *  - name:       Folder name
      *  - oldname:    Old folder name when changed
      *  - parent:     Parent folder to create the new one in
      *  - type:       Folder type to create
      *  - subscribed: Subscribed flag (IMAP subscription)
      *  - active:     Activation flag (client-side subscription)
      * @return mixed New folder name or False on failure
      */
     public static function folder_update(&$prop)
     {
         self::setup();
 
         $folder    = rcube_charset::convert($prop['name'], RCUBE_CHARSET, 'UTF7-IMAP');
         $oldfolder = $prop['oldname']; // UTF7
         $parent    = $prop['parent']; // UTF7
         $delimiter = self::$imap->get_hierarchy_delimiter();
 
         if (strlen($oldfolder)) {
             $options = self::$imap->folder_info($oldfolder);
         }
 
         if (!empty($options) && ($options['norename'] || $options['protected'])) {
         }
         // sanity checks (from steps/settings/save_folder.inc)
         else if (!strlen($folder)) {
             self::$last_error = 'cannotbeempty';
             return false;
         }
         else if (strlen($folder) > 128) {
             self::$last_error = 'nametoolong';
             return false;
         }
         else {
             // these characters are problematic e.g. when used in LIST/LSUB
             foreach (array($delimiter, '%', '*') as $char) {
                 if (strpos($folder, $char) !== false) {
                     self::$last_error = 'forbiddencharacter';
                     return false;
                 }
             }
         }
 
         if (!empty($options) && ($options['protected'] || $options['norename'])) {
             $folder = $oldfolder;
         }
         else if (strlen($parent)) {
             $folder = $parent . $delimiter . $folder;
         }
         else {
             // add namespace prefix (when needed)
             $folder = self::$imap->mod_folder($folder, 'in');
         }
 
         // Check access rights to the parent folder
         if (strlen($parent) && (!strlen($oldfolder) || $oldfolder != $folder)) {
             $parent_opts = self::$imap->folder_info($parent);
             if ($parent_opts['namespace'] != 'personal'
                 && (empty($parent_opts['rights']) || !preg_match('/[ck]/', implode($parent_opts['rights'])))
             ) {
                 self::$last_error = 'No permission to create folder';
                 return false;
           }
         }
 
         // update the folder name
         if (strlen($oldfolder)) {
             if ($oldfolder != $folder) {
                 $result = self::folder_rename($oldfolder, $folder);
           }
           else
               $result = true;
         }
         // create new folder
         else {
             $result = self::folder_create($folder, $prop['type'], $prop['subscribed'], $prop['active']);
         }
 
         if ($result) {
             self::set_folder_props($folder, $prop);
         }
 
         return $result ? $folder : false;
     }
 
 
     /**
      * Getter for human-readable name of Kolab object (folder)
+     * with kolab_custom_display_names support.
      * See http://wiki.kolab.org/UI-Concepts/Folder-Listing for reference
      *
      * @param string $folder    IMAP folder name (UTF7-IMAP)
      * @param string $folder_ns Will be set to namespace name of the folder
      *
      * @return string Name of the folder-object
      */
     public static function object_name($folder, &$folder_ns=null)
     {
-        self::setup();
-
         // find custom display name in folder METADATA
         if ($name = self::custom_displayname($folder)) {
             return $name;
         }
 
+        return self::object_prettyname($folder, $folder_ns);
+    }
+
+    /**
+     * Get custom display name (saved in metadata) for the given folder
+     */
+    public static function custom_displayname($folder)
+    {
+        // find custom display name in folder METADATA
+        if (self::$config->get('kolab_custom_display_names', true) && self::setup()) {
+            // For performance reasons ask for all folders, it will be cached as one cache entry
+            $metadata = self::$imap->get_metadata("*", array(self::NAME_KEY_PRIVATE, self::NAME_KEY_SHARED));
+
+            if ($data = $metadata[$folder]) {
+                if (($name = $data[self::NAME_KEY_PRIVATE]) || ($name = $data[self::NAME_KEY_SHARED])) {
+                    return $name;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Getter for human-readable name of Kolab object (folder)
+     * See http://wiki.kolab.org/UI-Concepts/Folder-Listing for reference
+     *
+     * @param string $folder    IMAP folder name (UTF7-IMAP)
+     * @param string $folder_ns Will be set to namespace name of the folder
+     *
+     * @return string Name of the folder-object
+     */
+    public static function object_prettyname($folder, &$folder_ns=null)
+    {
+        self::setup();
+
         $found     = false;
         $namespace = self::$imap->get_namespace();
 
         if (!empty($namespace['shared'])) {
             foreach ($namespace['shared'] as $ns) {
                 if (strlen($ns[0]) && strpos($folder, $ns[0]) === 0) {
                     $prefix = '';
                     $folder = substr($folder, strlen($ns[0]));
                     $delim  = $ns[1];
                     $found  = true;
                     $folder_ns = 'shared';
                     break;
                 }
             }
         }
+
         if (!$found && !empty($namespace['other'])) {
             foreach ($namespace['other'] as $ns) {
                 if (strlen($ns[0]) && strpos($folder, $ns[0]) === 0) {
                     // remove namespace prefix
                     $folder = substr($folder, strlen($ns[0]));
                     $delim  = $ns[1];
                     // get username
                     $pos    = strpos($folder, $delim);
                     if ($pos) {
                         $prefix = '('.substr($folder, 0, $pos).')';
                         $folder = substr($folder, $pos+1);
                     }
                     else {
                         $prefix = '('.$folder.')';
                         $folder = '';
                     }
 
                     $found  = true;
                     $folder_ns = 'other';
                     break;
                 }
             }
         }
+
         if (!$found && !empty($namespace['personal'])) {
             foreach ($namespace['personal'] as $ns) {
                 if (strlen($ns[0]) && strpos($folder, $ns[0]) === 0) {
                     // remove namespace prefix
                     $folder = substr($folder, strlen($ns[0]));
                     $prefix = '';
                     $delim  = $ns[1];
                     $found  = true;
                     break;
                 }
             }
         }
 
         if (empty($delim))
             $delim = self::$imap->get_hierarchy_delimiter();
 
         $folder = rcube_charset::convert($folder, 'UTF7-IMAP');
         $folder = html::quote($folder);
         $folder = str_replace(html::quote($delim), ' &raquo; ', $folder);
 
         if ($prefix)
             $folder = html::quote($prefix) . ($folder !== '' ? ' ' . $folder : '');
 
         if (!$folder_ns)
             $folder_ns = 'personal';
 
         return $folder;
     }
 
-    /**
-     * Get custom display name (saved in metadata) for the given folder
-     */
-    public static function custom_displayname($folder)
-    {
-      // find custom display name in folder METADATA
-      if (self::$config->get('kolab_custom_display_names', true)) {
-          $metadata = self::$imap->get_metadata($folder, array(self::NAME_KEY_PRIVATE, self::NAME_KEY_SHARED));
-          if (($name = $metadata[$folder][self::NAME_KEY_PRIVATE]) || ($name = $metadata[$folder][self::NAME_KEY_SHARED])) {
-              return $name;
-          }
-      }
-
-      return false;
-    }
-
     /**
      * Helper method to generate a truncated folder name to display.
      * Note: $origname is a string returned by self::object_name()
      */
     public static function folder_displayname($origname, &$names)
     {
         $name = $origname;
 
         // find folder prefix to truncate
         for ($i = count($names)-1; $i >= 0; $i--) {
             if (strpos($name, $names[$i] . ' &raquo; ') === 0) {
                 $length = strlen($names[$i] . ' &raquo; ');
                 $prefix = substr($name, 0, $length);
                 $count  = count(explode(' &raquo; ', $prefix));
                 $diff   = 1;
 
                 // check if prefix folder is in other users namespace
                 for ($n = count($names)-1; $n >= 0; $n--) {
                     if (strpos($prefix, '(' . $names[$n] . ') ') === 0) {
                         $diff = 0;
                         break;
                     }
                 }
 
                 $name = str_repeat('&nbsp;&nbsp;&nbsp;', $count - $diff) . '&raquo; ' . substr($name, $length);
                 break;
             }
             // other users namespace and parent folder exists
             else if (strpos($name, '(' . $names[$i] . ') ') === 0) {
                 $length = strlen('(' . $names[$i] . ') ');
                 $prefix = substr($name, 0, $length);
                 $count  = count(explode(' &raquo; ', $prefix));
                 $name   = str_repeat('&nbsp;&nbsp;&nbsp;', $count) . '&raquo; ' . substr($name, $length);
                 break;
             }
         }
 
         $names[] = $origname;
 
         return $name;
     }
 
 
     /**
      * Creates a SELECT field with folders list
      *
      * @param string $type    Folder type
      * @param array  $attrs   SELECT field attributes (e.g. name)
      * @param string $current The name of current folder (to skip it)
      *
      * @return html_select SELECT object
      */
     public static function folder_selector($type, $attrs, $current = '')
     {
         // get all folders of specified type (sorted)
         $folders = self::get_folders($type, true);
 
         $delim = self::$imap->get_hierarchy_delimiter();
         $names = array();
         $len   = strlen($current);
 
         if ($len && ($rpos = strrpos($current, $delim))) {
             $parent = substr($current, 0, $rpos);
             $p_len  = strlen($parent);
         }
 
         // Filter folders list
         foreach ($folders as $c_folder) {
             $name = $c_folder->name;
 
             // skip current folder and it's subfolders
             if ($len) {
                 if ($name == $current) {
                     // Make sure parent folder is listed (might be skipped e.g. if it's namespace root)
                     if ($p_len && !isset($names[$parent])) {
                         $names[$parent] = self::object_name($parent);
                     }
                     continue;
                 }
                 if (strpos($name, $current.$delim) === 0) {
                     continue;
                 }
             }
 
             // always show the parent of current folder
             if ($p_len && $name == $parent) {
             }
             // skip folders where user have no rights to create subfolders
             else if ($c_folder->get_owner() != $_SESSION['username']) {
                 $rights = $c_folder->get_myrights();
                 if (!preg_match('/[ck]/', $rights)) {
                     continue;
                 }
             }
 
-            $names[$name] = self::object_name($name);
+            $names[$name] = $c_folder->get_name();
         }
 
         // Build SELECT field of parent folder
         $attrs['is_escaped'] = true;
         $select = new html_select($attrs);
         $select->add('---', '');
 
         $listnames = array();
         foreach (array_keys($names) as $imap_name) {
             $name = $origname = $names[$imap_name];
 
             // find folder prefix to truncate
             for ($i = count($listnames)-1; $i >= 0; $i--) {
                 if (strpos($name, $listnames[$i].' &raquo; ') === 0) {
                     $length = strlen($listnames[$i].' &raquo; ');
                     $prefix = substr($name, 0, $length);
                     $count  = count(explode(' &raquo; ', $prefix));
                     $name   = str_repeat('&nbsp;&nbsp;', $count-1) . '&raquo; ' . substr($name, $length);
                     break;
                 }
             }
 
             $listnames[] = $origname;
             $select->add($name, $imap_name);
         }
 
         return $select;
     }
 
 
     /**
      * Returns a list of folder names
      *
      * @param string  Optional root folder
      * @param string  Optional name pattern
      * @param string  Data type to list folders for (contact,event,task,journal,file,note,mail,configuration)
      * @param boolean Enable to return subscribed folders only (null to use configured subscription mode)
      * @param array   Will be filled with folder-types data
      *
      * @return array List of folders
      */
     public static function list_folders($root = '', $mbox = '*', $filter = null, $subscribed = null, &$folderdata = array())
     {
         if (!self::setup()) {
             return null;
         }
 
         // use IMAP subscriptions
         if ($subscribed === null && self::$config->get('kolab_use_subscriptions')) {
             $subscribed = true;
         }
 
         if (!$filter) {
             // Get ALL folders list, standard way
             if ($subscribed) {
                 $folders = self::$imap->list_folders_subscribed($root, $mbox);
                 // add temporarily subscribed folders
                 if (self::$with_tempsubs && is_array($_SESSION['kolab_subscribed_folders'])) {
                     $folders = array_unique(array_merge($folders, $_SESSION['kolab_subscribed_folders']));
                 }
             }
             else {
                 $folders = self::_imap_list_folders($root, $mbox);
             }
 
             return $folders;
         }
         $prefix = $root . $mbox;
         $regexp = '/^' . preg_quote($filter, '/') . '(\..+)?$/';
 
         // get folders types for all folders
         if (!$subscribed || $prefix == '*' || !self::$config->get('kolab_skip_namespace')) {
             $folderdata = self::folders_typedata($prefix);
         }
         else {
             // fetch folder types for the effective list of (subscribed) folders when post-filtering
             $folderdata = array();
         }
 
         if (!is_array($folderdata)) {
             return array();
         }
 
         // In some conditions we can skip LIST command (?)
         if (!$subscribed && $filter != 'mail' && $prefix == '*') {
             foreach ($folderdata as $folder => $type) {
                 if (!preg_match($regexp, $type)) {
                     unset($folderdata[$folder]);
                 }
             }
 
             return self::$imap->sort_folder_list(array_keys($folderdata), true);
         }
 
         // Get folders list
         if ($subscribed) {
             $folders = self::$imap->list_folders_subscribed($root, $mbox);
 
             // add temporarily subscribed folders
             if (self::$with_tempsubs && is_array($_SESSION['kolab_subscribed_folders'])) {
                 $folders = array_unique(array_merge($folders, $_SESSION['kolab_subscribed_folders']));
             }
         }
         else {
             $folders = self::_imap_list_folders($root, $mbox);
         }
 
         // In case of an error, return empty list (?)
         if (!is_array($folders)) {
             return array();
         }
 
         // Filter folders list
         foreach ($folders as $idx => $folder) {
             // lookup folder type
             if (!array_key_exists($folder, $folderdata)) {
                 $folderdata[$folder] = self::folder_type($folder);
             }
 
             $type = $folderdata[$folder];
 
             if ($filter == 'mail' && empty($type)) {
                 continue;
             }
             if (empty($type) || !preg_match($regexp, $type)) {
                 unset($folders[$idx]);
             }
         }
 
         return $folders;
     }
 
     /**
      * Wrapper for rcube_imap::list_folders() with optional post-filtering
      */
     protected static function _imap_list_folders($root, $mbox)
     {
         $postfilter = null;
 
         // compose a post-filter expression for the excluded namespaces
         if ($root . $mbox == '*' && ($skip_ns = self::$config->get('kolab_skip_namespace'))) {
             $excludes = array();
             foreach ((array)$skip_ns as $ns) {
                 if ($ns_root = self::namespace_root($ns)) {
                     $excludes[] = $ns_root;
                 }
             }
 
             if (count($excludes)) {
                 $postfilter = '!^(' . join(')|(', array_map('preg_quote', $excludes)) . ')!';
             }
         }
 
         // use normal LIST command to return all folders, it's fast enough
         $folders = self::$imap->list_folders($root, $mbox, null, null, !empty($postfilter));
 
         if (!empty($postfilter)) {
             $folders = array_filter($folders, function($folder) use ($postfilter) { return !preg_match($postfilter, $folder); });
             $folders = self::$imap->sort_folder_list($folders);
         }
 
         return $folders;
     }
 
 
     /**
      * Search for shared or otherwise not listed groupware folders the user has access
      *
      * @param string Folder type of folders to search for
      * @param string Search string
      * @param array  Namespace(s) to exclude results from
      *
      * @return array List of matching kolab_storage_folder objects
      */
     public static function search_folders($type, $query, $exclude_ns = array())
     {
         if (!self::setup()) {
             return array();
         }
 
         $folders = array();
         $query = str_replace('*', '', $query);
 
         // find unsubscribed IMAP folders of the given type
         foreach ((array)self::list_folders('', '*', $type, false, $folderdata) as $foldername) {
             // FIXME: only consider the last part of the folder path for searching?
             $realname = strtolower(rcube_charset::convert($foldername, 'UTF7-IMAP'));
             if (($query == '' || strpos($realname, $query) !== false) &&
                 !self::folder_is_subscribed($foldername, true) &&
                 !in_array(self::$imap->folder_namespace($foldername), (array)$exclude_ns)
               ) {
                 $folders[] = new kolab_storage_folder($foldername, $type, $folderdata[$foldername]);
             }
         }
 
         return $folders;
     }
 
 
     /**
      * Sort the given list of kolab folders by namespace/name
      *
      * @param array List of kolab_storage_folder objects
      * @return array Sorted list of folders
      */
     public static function sort_folders($folders)
     {
         $pad     = '  ';
         $out     = array();
         $nsnames = array('personal' => array(), 'shared' => array(), 'other' => array());
 
         foreach ($folders as $folder) {
-            $folders[$folder->name] = $folder;
+            $_folders[$folder->name] = $folder;
             $ns = $folder->get_namespace();
-            $nsnames[$ns][$folder->name] = strtolower(html_entity_decode(self::object_name($folder->name, $ns), ENT_COMPAT, RCUBE_CHARSET)) . $pad;  // decode &raquo;
+            $nsnames[$ns][$folder->name] = strtolower(html_entity_decode($folder->get_name(), ENT_COMPAT, RCUBE_CHARSET)) . $pad;  // decode &raquo;
         }
 
         // $folders is a result of get_folders() we can assume folders were already sorted
         foreach (array_keys($nsnames) as $ns) {
             asort($nsnames[$ns], SORT_LOCALE_STRING);
             foreach (array_keys($nsnames[$ns]) as $utf7name) {
-                $out[] = $folders[$utf7name];
+                $out[] = $_folders[$utf7name];
             }
         }
 
         return $out;
     }
 
 
     /**
      * Check the folder tree and add the missing parents as virtual folders
      *
      * @param array $folders Folders list
      * @param object $tree   Reference to the root node of the folder tree
      *
      * @return array Flat folders list
      */
     public static function folder_hierarchy($folders, &$tree = null)
     {
         $_folders = array();
         $delim    = self::$imap->get_hierarchy_delimiter();
         $other_ns = rtrim(self::namespace_root('other'), $delim);
         $tree     = new kolab_storage_folder_virtual('', '<root>', '');  // create tree root
         $refs     = array('' => $tree);
 
         foreach ($folders as $idx => $folder) {
             $path = explode($delim, $folder->name);
             array_pop($path);
             $folder->parent = join($delim, $path);
             $folder->children = array();  // reset list
 
             // skip top folders or ones with a custom displayname
             if (count($path) < 1 || kolab_storage::custom_displayname($folder->name)) {
                 $tree->children[] = $folder;
             }
             else {
                 $parents = array();
                 $depth = $folder->get_namespace() == 'personal' ? 1 : 2;
 
                 while (count($path) >= $depth && ($parent = join($delim, $path))) {
                     array_pop($path);
                     $parent_parent = join($delim, $path);
+
                     if (!$refs[$parent]) {
                         if ($folder->type && self::folder_type($parent) == $folder->type) {
                             $refs[$parent] = new kolab_storage_folder($parent, $folder->type, $folder->type);
                             $refs[$parent]->parent = $parent_parent;
                         }
                         else if ($parent_parent == $other_ns) {
                             $refs[$parent] = new kolab_storage_folder_user($parent, $parent_parent);
                         }
                         else {
-                            $name = kolab_storage::object_name($parent, $folder->get_namespace());
+                            $name = kolab_storage::object_name($parent);
                             $refs[$parent] = new kolab_storage_folder_virtual($parent, $name, $folder->get_namespace(), $parent_parent);
                         }
                         $parents[] = $refs[$parent];
                     }
                 }
 
                 if (!empty($parents)) {
                     $parents = array_reverse($parents);
                     foreach ($parents as $parent) {
                         $parent_node = $refs[$parent->parent] ?: $tree;
                         $parent_node->children[] = $parent;
                         $_folders[] = $parent;
                     }
                 }
 
                 $parent_node = $refs[$folder->parent] ?: $tree;
                 $parent_node->children[] = $folder;
             }
 
             $refs[$folder->name] = $folder;
             $_folders[] = $folder;
             unset($folders[$idx]);
         }
 
         return $_folders;
     }
 
 
     /**
      * Returns folder types indexed by folder name
      *
      * @param string $prefix Folder prefix (Default '*' for all folders)
      *
      * @return array|bool List of folders, False on failure
      */
     public static function folders_typedata($prefix = '*')
     {
         if (!self::setup()) {
             return false;
         }
 
         // return cached result
         if (is_array(self::$typedata[$prefix])) {
             return self::$typedata[$prefix];
         }
 
         $type_keys = array(self::CTYPE_KEY, self::CTYPE_KEY_PRIVATE);
 
         // fetch metadata from *some* folders only
         if (($prefix == '*' || $prefix == '') && ($skip_ns = self::$config->get('kolab_skip_namespace'))) {
             $delimiter = self::$imap->get_hierarchy_delimiter();
             $folderdata = $blacklist = array();
             foreach ((array)$skip_ns as $ns) {
                 if ($ns_root = rtrim(self::namespace_root($ns), $delimiter)) {
                     $blacklist[] = $ns_root;
                 }
             }
             foreach (array('personal','other','shared') as $ns) {
                 if (!in_array($ns, (array)$skip_ns)) {
                     $ns_root = rtrim(self::namespace_root($ns), $delimiter);
 
                     // list top-level folders and their childs one by one
                     // GETMETADATA "%" doesn't list shared or other namespace folders but "*" would
                     if ($ns_root == '') {
                         foreach ((array)self::$imap->get_metadata('%', $type_keys) as $folder => $metadata) {
                             if (!in_array($folder, $blacklist)) {
                                 $folderdata[$folder] = $metadata;
                                 $opts = self::$imap->folder_attributes($folder);
                                 if (!in_array('\\HasNoChildren', $opts) && ($data = self::$imap->get_metadata($folder.$delimiter.'*', $type_keys))) {
                                     $folderdata += $data;
                                 }
                             }
                         }
                     }
                     else if ($data = self::$imap->get_metadata($ns_root.$delimiter.'*', $type_keys)) {
                         $folderdata += $data;
                     }
                 }
             }
         }
         else {
             $folderdata = self::$imap->get_metadata($prefix, $type_keys);
         }
 
         if (!is_array($folderdata)) {
             return false;
         }
 
         // keep list in memory
         self::$typedata[$prefix] = array_map(array('kolab_storage', 'folder_select_metadata'), $folderdata);
 
         return self::$typedata[$prefix];
     }
 
 
     /**
      * Callback for array_map to select the correct annotation value
      */
     public static function folder_select_metadata($types)
     {
         if (!empty($types[self::CTYPE_KEY_PRIVATE])) {
             return $types[self::CTYPE_KEY_PRIVATE];
         }
         else if (!empty($types[self::CTYPE_KEY])) {
             list($ctype, ) = explode('.', $types[self::CTYPE_KEY]);
             return $ctype;
         }
         return null;
     }
 
 
     /**
      * Returns type of IMAP folder
      *
      * @param string $folder Folder name (UTF7-IMAP)
      *
      * @return string Folder type
      */
     public static function folder_type($folder)
     {
         self::setup();
 
         // return in-memory cached result
         foreach (self::$typedata as $typedata) {
             if (array_key_exists($folder, $typedata)) {
                 return $typedata[$folder];
             }
         }
 
         $metadata = self::$imap->get_metadata($folder, array(self::CTYPE_KEY, self::CTYPE_KEY_PRIVATE));
 
         if (!is_array($metadata)) {
             return null;
         }
 
         if (!empty($metadata[$folder])) {
             return self::folder_select_metadata($metadata[$folder]);
         }
 
         return 'mail';
     }
 
 
     /**
      * Sets folder content-type.
      *
      * @param string $folder Folder name
      * @param string $type   Content type
      *
      * @return boolean True on success
      */
     public static function set_folder_type($folder, $type='mail')
     {
         self::setup();
 
         list($ctype, $subtype) = explode('.', $type);
 
         $success = self::$imap->set_metadata($folder, array(self::CTYPE_KEY => $ctype, self::CTYPE_KEY_PRIVATE => $subtype ? $type : null));
 
         if (!$success)  // fallback: only set private annotation
             $success |= self::$imap->set_metadata($folder, array(self::CTYPE_KEY_PRIVATE => $type));
 
         return $success;
     }
 
 
     /**
      * Check subscription status of this folder
      *
      * @param string $folder Folder name
      * @param boolean $temp  Include temporary/session subscriptions
      *
      * @return boolean True if subscribed, false if not
      */
     public static function folder_is_subscribed($folder, $temp = false)
     {
         if (self::$subscriptions === null) {
             self::setup();
             self::$with_tempsubs = false;
             self::$subscriptions = self::$imap->list_folders_subscribed();
             self::$with_tempsubs = true;
         }
 
         return in_array($folder, self::$subscriptions) ||
             ($temp && in_array($folder, (array)$_SESSION['kolab_subscribed_folders']));
     }
 
 
     /**
      * Change subscription status of this folder
      *
      * @param string $folder Folder name
      * @param boolean $temp  Only subscribe temporarily for the current session
      *
      * @return True on success, false on error
      */
     public static function folder_subscribe($folder, $temp = false)
     {
         self::setup();
 
         // temporary/session subscription
         if ($temp) {
             if (self::folder_is_subscribed($folder)) {
                 return true;
             }
             else if (!is_array($_SESSION['kolab_subscribed_folders']) || !in_array($folder, $_SESSION['kolab_subscribed_folders'])) {
                 $_SESSION['kolab_subscribed_folders'][] = $folder;
                 return true;
             }
         }
         else if (self::$imap->subscribe($folder)) {
             self::$subscriptions = null;
             return true;
         }
 
         return false;
     }
 
 
     /**
      * Change subscription status of this folder
      *
      * @param string $folder Folder name
      * @param boolean $temp  Only remove temporary subscription
      *
      * @return True on success, false on error
      */
     public static function folder_unsubscribe($folder, $temp = false)
     {
         self::setup();
 
         // temporary/session subscription
         if ($temp) {
             if (is_array($_SESSION['kolab_subscribed_folders']) && ($i = array_search($folder, $_SESSION['kolab_subscribed_folders'])) !== false) {
                 unset($_SESSION['kolab_subscribed_folders'][$i]);
             }
             return true;
         }
         else if (self::$imap->unsubscribe($folder)) {
             self::$subscriptions = null;
             return true;
         }
 
         return false;
     }
 
 
     /**
      * Check activation status of this folder
      *
      * @param string $folder Folder name
      *
      * @return boolean True if active, false if not
      */
     public static function folder_is_active($folder)
     {
         $active_folders = self::get_states();
 
         return in_array($folder, $active_folders);
     }
 
 
     /**
      * Change activation status of this folder
      *
      * @param string $folder Folder name
      *
      * @return True on success, false on error
      */
     public static function folder_activate($folder)
     {
         // activation implies temporary subscription
         self::folder_subscribe($folder, true);
         return self::set_state($folder, true);
     }
 
 
     /**
      * Change activation status of this folder
      *
      * @param string $folder Folder name
      *
      * @return True on success, false on error
      */
     public static function folder_deactivate($folder)
     {
         // remove from temp subscriptions, really?
         self::folder_unsubscribe($folder, true);
 
         return self::set_state($folder, false);
     }
 
 
     /**
      * Return list of active folders
      */
     private static function get_states()
     {
         if (self::$states !== null) {
             return self::$states;
         }
 
         $rcube   = rcube::get_instance();
         $folders = $rcube->config->get('kolab_active_folders');
 
         if ($folders !== null) {
             self::$states = !empty($folders) ? explode('**', $folders) : array();
         }
         // for backward-compatibility copy server-side subscriptions to activation states
         else {
             self::setup();
             if (self::$subscriptions === null) {
                 self::$with_tempsubs = false;
                 self::$subscriptions = self::$imap->list_folders_subscribed();
                 self::$with_tempsubs = true;
             }
             self::$states = self::$subscriptions;
             $folders = implode(self::$states, '**');
             $rcube->user->save_prefs(array('kolab_active_folders' => $folders));
         }
 
         return self::$states;
     }
 
 
     /**
      * Update list of active folders
      */
     private static function set_state($folder, $state)
     {
         self::get_states();
 
         // update in-memory list
         $idx = array_search($folder, self::$states);
         if ($state && $idx === false) {
             self::$states[] = $folder;
         }
         else if (!$state && $idx !== false) {
             unset(self::$states[$idx]);
         }
 
         // update user preferences
         $folders = implode(self::$states, '**');
         $rcube   = rcube::get_instance();
         return $rcube->user->save_prefs(array('kolab_active_folders' => $folders));
     }
 
     /**
      * Creates default folder of specified type
      * To be run when none of subscribed folders (of specified type) is found
      *
      * @param string $type  Folder type
      * @param string $props Folder properties (color, etc)
      *
      * @return string Folder name
      */
     public static function create_default_folder($type, $props = array())
     {
         if (!self::setup()) {
             return;
         }
 
         $folders = self::$imap->get_metadata('*', array(kolab_storage::CTYPE_KEY_PRIVATE));
 
         // from kolab_folders config
         $folder_type  = strpos($type, '.') ? str_replace('.', '_', $type) : $type . '_default';
         $default_name = self::$config->get('kolab_folders_' . $folder_type);
         $folder_type  = str_replace('_', '.', $folder_type);
 
         // check if we have any folder in personal namespace
         // folder(s) may exist but not subscribed
         foreach ((array)$folders as $f => $data) {
             if (strpos($data[self::CTYPE_KEY_PRIVATE], $type) === 0) {
                 $folder = $f;
                 break;
             }
         }
 
         if (!$folder) {
             if (!$default_name) {
                 $default_name = self::$default_folders[$type];
             }
 
             if (!$default_name) {
                 return;
             }
 
             $folder = rcube_charset::convert($default_name, RCUBE_CHARSET, 'UTF7-IMAP');
             $prefix = self::$imap->get_namespace('prefix');
 
             // add personal namespace prefix if needed
             if ($prefix && strpos($folder, $prefix) !== 0 && $folder != 'INBOX') {
                 $folder = $prefix . $folder;
             }
 
             if (!self::$imap->folder_exists($folder)) {
                 if (!self::$imap->create_folder($folder)) {
                     return;
                 }
             }
 
             self::set_folder_type($folder, $folder_type);
         }
 
         self::folder_subscribe($folder);
 
         if ($props['active']) {
             self::set_state($folder, true);
         }
 
         if (!empty($props)) {
             self::set_folder_props($folder, $props);
         }
 
         return $folder;
     }
 
     /**
      * Sets folder metadata properties
      *
      * @param string $folder Folder name
      * @param array  $prop   Folder properties
      */
     public static function set_folder_props($folder, &$prop)
     {
         if (!self::setup()) {
             return;
         }
 
         // TODO: also save 'showalarams' and other properties here
         $ns        = self::$imap->folder_namespace($folder);
         $supported = array(
             'color'       => array(self::COLOR_KEY_SHARED, self::COLOR_KEY_PRIVATE),
             'displayname' => array(self::NAME_KEY_SHARED, self::NAME_KEY_PRIVATE),
         );
 
         foreach ($supported as $key => $metakeys) {
             if (array_key_exists($key, $prop)) {
                 $meta_saved = false;
                 if ($ns == 'personal')  // save in shared namespace for personal folders
                     $meta_saved = self::$imap->set_metadata($folder, array($metakeys[0] => $prop[$key]));
                 if (!$meta_saved)    // try in private namespace
                     $meta_saved = self::$imap->set_metadata($folder, array($metakeys[1] => $prop[$key]));
                 if ($meta_saved)
                     unset($prop[$key]);  // unsetting will prevent fallback to local user prefs
             }
         }
     }
 
 
     /**
      *
      * @param mixed   $query    Search value (or array of field => value pairs)
      * @param int     $mode     Matching mode: 0 - partial (*abc*), 1 - strict (=), 2 - prefix (abc*)
      * @param array   $required List of fields that shall ot be empty
      * @param int     $limit    Maximum number of records
      * @param int     $count    Returns the number of records found
      *
      * @return array List or false on error
      */
     public static function search_users($query, $mode = 1, $required = array(), $limit = 0, &$count = 0)
     {
         $query = str_replace('*', '', $query);
 
         // requires a working LDAP setup
         if (!self::ldap() || strlen($query) == 0) {
             return array();
         }
 
         // search users using the configured attributes
         $results = self::$ldap->dosearch(self::$config->get('kolab_users_search_attrib', array('cn','mail','alias')), $query, $mode, $required, $limit, $count);
 
         // exclude myself
         if ($_SESSION['kolab_dn']) {
             unset($results[$_SESSION['kolab_dn']]);
         }
 
         // resolve to IMAP folder name
         $root = self::namespace_root('other');
         $user_attrib = self::$config->get('kolab_users_id_attrib', self::$config->get('kolab_auth_login', 'mail'));
 
         array_walk($results, function(&$user, $dn) use ($root, $user_attrib) {
             list($localpart, ) = explode('@', $user[$user_attrib]);
             $user['kolabtargetfolder'] = $root . $localpart;
         });
 
         return $results;
     }
 
 
     /**
      * Returns a list of IMAP folders shared by the given user
      *
      * @param array   User entry from LDAP
      * @param string  Data type to list folders for (contact,event,task,journal,file,note,mail,configuration)
      * @param boolean Return subscribed folders only (null to use configured subscription mode)
      * @param array   Will be filled with folder-types data
      *
      * @return array List of folders
      */
     public static function list_user_folders($user, $type, $subscribed = null, &$folderdata = array())
     {
         self::setup();
 
         $folders = array();
 
         // use localpart of user attribute as root for folder listing
         $user_attrib = self::$config->get('kolab_users_id_attrib', self::$config->get('kolab_auth_login', 'mail'));
         if (!empty($user[$user_attrib])) {
             list($mbox) = explode('@', $user[$user_attrib]);
 
             $delimiter = self::$imap->get_hierarchy_delimiter();
             $other_ns = self::namespace_root('other');
             $folders = self::list_folders($other_ns . $mbox . $delimiter, '*', $type, $subscribed, $folderdata);
         }
 
         return $folders;
     }
 
 
     /**
      * Get a list of (virtual) top-level folders from the other users namespace
      *
      * @param string  Data type to list folders for (contact,event,task,journal,file,note,mail,configuration)
      * @param boolean Enable to return subscribed folders only (null to use configured subscription mode)
      *
      * @return array List of kolab_storage_folder_user objects
      */
     public static function get_user_folders($type, $subscribed)
     {
         $folders = $folderdata = array();
 
         if (self::setup()) {
             $delimiter = self::$imap->get_hierarchy_delimiter();
             $other_ns = rtrim(self::namespace_root('other'), $delimiter);
             $path_len = count(explode($delimiter, $other_ns));
 
             foreach ((array)self::list_folders($other_ns . $delimiter, '*', '', $subscribed) as $foldername) {
                 if ($foldername == 'INBOX')  // skip INBOX which is added by default
                     continue;
 
                 $path = explode($delimiter, $foldername);
 
                 // compare folder type if a subfolder is listed
                 if ($type && count($path) > $path_len + 1 && $type != self::folder_type($foldername)) {
                     continue;
                 }
 
                 // truncate folder path to top-level folders of the 'other' namespace
                 $foldername = join($delimiter, array_slice($path, 0, $path_len + 1));
 
                 if (!$folders[$foldername]) {
                     $folders[$foldername] = new kolab_storage_folder_user($foldername, $other_ns);
                 }
             }
 
             // for every (subscribed) user folder, list all (unsubscribed) subfolders
             foreach ($folders as $userfolder) {
                 foreach ((array)self::list_folders($userfolder->name . $delimiter, '*', $type, false, $folderdata) as $foldername) {
                     if (!$folders[$foldername]) {
                         $folders[$foldername] = new kolab_storage_folder($foldername, $type, $folderdata[$foldername]);
                         $userfolder->children[] = $folders[$foldername];
                     }
                 }
             }
         }
 
         return $folders;
     }
 
 
     /**
      * Handler for user_delete plugin hooks
      *
      * Remove all cache data from the local database related to the given user.
      */
     public static function delete_user_folders($args)
     {
         $db = rcmail::get_instance()->get_dbh();
         $prefix = 'imap://' . urlencode($args['username']) . '@' . $args['host'] . '/%';
         $db->query("DELETE FROM " . $db->table_name('kolab_folders', true) . " WHERE `resource` LIKE ?", $prefix);
+
+    }
+
+    /**
+     * Get folder METADATA for all supported keys
+     * Do this in one go for better caching performance
+     */
+    public static function folder_metadata($folder)
+    {
+        if (self::setup()) {
+            $keys = array(
+                // For better performance we skip displayname here, see (self::custom_displayname())
+                // self::NAME_KEY_PRIVATE,
+                // self::NAME_KEY_SHARED,
+                self::CTYPE_KEY,
+                self::CTYPE_KEY_PRIVATE,
+                self::COLOR_KEY_PRIVATE,
+                self::COLOR_KEY_SHARED,
+                self::UID_KEY_SHARED,
+                self::UID_KEY_CYRUS,
+            );
+
+            $metadata = self::$imap->get_metadata($folder, $keys);
+
+            return $metadata[$folder];
+        }
     }
 }
diff --git a/plugins/libkolab/lib/kolab_storage_cache.php b/plugins/libkolab/lib/kolab_storage_cache.php
index 162c220d..41984702 100644
--- a/plugins/libkolab/lib/kolab_storage_cache.php
+++ b/plugins/libkolab/lib/kolab_storage_cache.php
@@ -1,1171 +1,1182 @@
 <?php
 
 /**
  * Kolab storage cache class providing a local caching layer for Kolab groupware objects.
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2012-2013, 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_storage_cache
 {
     const DB_DATE_FORMAT = 'Y-m-d H:i:s';
+    const MAX_RECORDS    = 500;
 
     public $sync_complete = false;
 
     protected $db;
     protected $imap;
     protected $folder;
     protected $uid2msg;
     protected $objects;
     protected $metadata = array();
     protected $folder_id;
     protected $resource_uri;
     protected $enabled = true;
     protected $synched = false;
     protected $synclock = false;
     protected $ready = false;
     protected $cache_table;
     protected $cache_refresh = 3600;
     protected $folders_table;
     protected $max_sql_packet;
     protected $max_sync_lock_time = 600;
     protected $binary_items = array();
     protected $extra_cols = array();
     protected $order_by = null;
     protected $limit = null;
     protected $error = 0;
     protected $server_timezone;
 
 
     /**
      * Factory constructor
      */
     public static function factory(kolab_storage_folder $storage_folder)
     {
         $subclass = 'kolab_storage_cache_' . $storage_folder->type;
         if (class_exists($subclass)) {
             return new $subclass($storage_folder);
         }
         else {
             rcube::raise_error(array(
                 'code' => 900,
                 'type' => 'php',
                 'message' => "No kolab_storage_cache class found for folder '$storage_folder->name' of type '$storage_folder->type'"
             ), true);
 
             return new kolab_storage_cache($storage_folder);
         }
     }
 
 
     /**
      * Default constructor
      */
     public function __construct(kolab_storage_folder $storage_folder = null)
     {
         $rcmail = rcube::get_instance();
         $this->db = $rcmail->get_dbh();
         $this->imap = $rcmail->get_storage();
         $this->enabled = $rcmail->config->get('kolab_cache', false);
         $this->folders_table = $this->db->table_name('kolab_folders');
         $this->cache_refresh = get_offset_sec($rcmail->config->get('kolab_cache_refresh', '12h'));
         $this->server_timezone = new DateTimeZone(date_default_timezone_get());
 
         if ($this->enabled) {
             // always read folder cache and lock state from DB master
             $this->db->set_table_dsn('kolab_folders', 'w');
             // remove sync-lock on script termination
             $rcmail->add_shutdown_function(array($this, '_sync_unlock'));
         }
 
         if ($storage_folder)
             $this->set_folder($storage_folder);
     }
 
     /**
      * Direct access to cache by folder_id
      * (only for internal use)
      */
     public function select_by_id($folder_id)
     {
         $sql_arr = $this->db->fetch_assoc($this->db->query("SELECT * FROM `{$this->folders_table}` WHERE `folder_id` = ?", $folder_id));
         if ($sql_arr) {
             $this->metadata = $sql_arr;
             $this->folder_id = $sql_arr['folder_id'];
             $this->folder = new StdClass;
             $this->folder->type = $sql_arr['type'];
             $this->resource_uri = $sql_arr['resource'];
             $this->cache_table = $this->db->table_name('kolab_cache_' . $sql_arr['type']);
             $this->ready = true;
         }
     }
 
     /**
      * Connect cache with a storage folder
      *
      * @param kolab_storage_folder The storage folder instance to connect with
      */
     public function set_folder(kolab_storage_folder $storage_folder)
     {
         $this->folder = $storage_folder;
 
         if (empty($this->folder->name) || !$this->folder->valid) {
             $this->ready = false;
             return;
         }
 
         // compose fully qualified ressource uri for this instance
         $this->resource_uri = $this->folder->get_resource_uri();
         $this->cache_table = $this->db->table_name('kolab_cache_' . $this->folder->type);
         $this->ready = $this->enabled && !empty($this->folder->type);
         $this->folder_id = null;
     }
 
     /**
      * Returns true if this cache supports query by type
      */
     public function has_type_col()
     {
         return in_array('type', $this->extra_cols);
     }
 
     /**
      * Getter for the numeric ID used in cache tables
      */
     public function get_folder_id()
     {
         $this->_read_folder_data();
         return $this->folder_id;
     }
 
     /**
      * Returns code of last error
      *
      * @return int Error code
      */
     public function get_error()
     {
         return $this->error;
     }
 
     /**
      * Synchronize local cache data with remote
      */
     public function synchronize()
     {
         // only sync once per request cycle
         if ($this->synched)
             return;
 
         // increase time limit
         @set_time_limit($this->max_sync_lock_time - 60);
 
         // get effective time limit we have for synchronization (~70% of the execution time)
         $time_limit = ini_get('max_execution_time') * 0.7;
         $sync_start = time();
 
         // assume sync will be completed
         $this->sync_complete = true;
 
         if (!$this->ready) {
             // kolab cache is disabled, synchronize IMAP mailbox cache only
             $this->imap->folder_sync($this->folder->name);
         }
         else {
             // read cached folder metadata
             $this->_read_folder_data();
 
             // check cache status ($this->metadata is set in _read_folder_data())
             if (  empty($this->metadata['ctag']) ||
                   empty($this->metadata['changed']) ||
                   $this->metadata['objectcount'] === null ||
                   $this->metadata['changed'] < date(self::DB_DATE_FORMAT, time() - $this->cache_refresh) ||
                   $this->metadata['ctag'] != $this->folder->get_ctag() ||
                   intval($this->metadata['objectcount']) !== $this->count()
                 ) {
                 // lock synchronization for this folder or wait if locked
                 $this->_sync_lock();
 
                 // disable messages cache if configured to do so
                 $this->bypass(true);
 
                 // synchronize IMAP mailbox cache
                 $this->imap->folder_sync($this->folder->name);
 
                 // compare IMAP index with object cache index
                 $imap_index = $this->imap->index($this->folder->name, null, null, true, true);
 
                 // determine objects to fetch or to invalidate
                 if (!$imap_index->is_error()) {
                     $imap_index = $imap_index->get();
 
                     // read cache index
                     $sql_result = $this->db->query(
                         "SELECT `msguid`, `uid` FROM `{$this->cache_table}` WHERE `folder_id` = ?",
                         $this->folder_id
                     );
 
                     $old_index = array();
                     while ($sql_arr = $this->db->fetch_assoc($sql_result)) {
                         $old_index[] = $sql_arr['msguid'];
                     }
 
                     // fetch new objects from imap
                     $i = 0;
                     foreach (array_diff($imap_index, $old_index) as $msguid) {
                         if ($object = $this->folder->read_object($msguid, '*')) {
                             $this->_extended_insert($msguid, $object);
 
                             // check time limit and abort sync if running too long
                             if (++$i % 50 == 0 && time() - $sync_start > $time_limit) {
                                 $this->sync_complete = false;
                                 break;
                             }
                         }
                     }
                     $this->_extended_insert(0, null);
 
                     // delete invalid entries from local DB
                     $del_index = array_diff($old_index, $imap_index);
                     if (!empty($del_index)) {
                         $quoted_ids = join(',', array_map(array($this->db, 'quote'), $del_index));
                         $this->db->query(
                             "DELETE FROM `{$this->cache_table}` WHERE `folder_id` = ? AND `msguid` IN ($quoted_ids)",
                             $this->folder_id
                         );
                     }
 
                     // update ctag value (will be written to database in _sync_unlock())
                     if ($this->sync_complete) {
                         $this->metadata['ctag'] = $this->folder->get_ctag();
                         $this->metadata['changed'] = date(self::DB_DATE_FORMAT, time());
                         // remember the number of cache entries linked to this folder
                         $this->metadata['objectcount'] = $this->count();
                     }
                 }
 
                 $this->bypass(false);
 
                 // remove lock
                 $this->_sync_unlock();
             }
         }
 
         $this->check_error();
         $this->synched = time();
     }
 
 
     /**
      * Read a single entry from cache or from IMAP directly
      *
      * @param string Related IMAP message UID
      * @param string Object type to read
      * @param string IMAP folder name the entry relates to
      * @param array  Hash array with object properties or null if not found
      */
     public function get($msguid, $type = null, $foldername = null)
     {
         // delegate to another cache instance
         if ($foldername && $foldername != $this->folder->name) {
             $success = false;
             if ($targetfolder = kolab_storage::get_folder($foldername)) {
                 $success = $targetfolder->cache->get($msguid, $type);
                 $this->error = $targetfolder->cache->get_error();
             }
             return $success;
         }
 
         // load object if not in memory
         if (!isset($this->objects[$msguid])) {
             if ($this->ready) {
                 $this->_read_folder_data();
 
                 $sql_result = $this->db->query(
                     "SELECT * FROM `{$this->cache_table}` ".
                     "WHERE `folder_id` = ? AND `msguid` = ?",
                     $this->folder_id,
                     $msguid
                 );
 
                 if ($sql_arr = $this->db->fetch_assoc($sql_result)) {
                     $this->objects = array($msguid => $this->_unserialize($sql_arr));  // store only this object in memory (#2827)
                 }
             }
 
             // fetch from IMAP if not present in cache
             if (empty($this->objects[$msguid])) {
                 if ($object = $this->folder->read_object($msguid, $type ?: '*', $foldername)) {
                     $this->objects = array($msguid => $object);
                     $this->set($msguid, $object);
                 }
             }
         }
 
         $this->check_error();
         return $this->objects[$msguid];
     }
 
 
     /**
      * Insert/Update a cache entry
      *
      * @param string Related IMAP message UID
      * @param mixed  Hash array with object properties to save or false to delete the cache entry
      * @param string IMAP folder name the entry relates to
      */
     public function set($msguid, $object, $foldername = null)
     {
         if (!$msguid) {
             return;
         }
 
         // delegate to another cache instance
         if ($foldername && $foldername != $this->folder->name) {
           if ($targetfolder = kolab_storage::get_folder($foldername)) {
               $targetfolder->cache->set($msguid, $object);
               $this->error = $targetfolder->cache->get_error();
           }
           return;
         }
 
         // remove old entry
         if ($this->ready) {
             $this->_read_folder_data();
             $this->db->query("DELETE FROM `{$this->cache_table}` WHERE `folder_id` = ? AND `msguid` = ?",
                 $this->folder_id, $msguid);
         }
 
         if ($object) {
             // insert new object data...
             $this->save($msguid, $object);
         }
         else {
             // ...or set in-memory cache to false
             $this->objects[$msguid] = $object;
         }
 
         $this->check_error();
     }
 
 
     /**
      * Insert (or update) a cache entry
      *
      * @param int    Related IMAP message UID
      * @param mixed  Hash array with object properties to save or false to delete the cache entry
      * @param int    Optional old message UID (for update)
      */
     public function save($msguid, $object, $olduid = null)
     {
         // write to cache
         if ($this->ready) {
             $this->_read_folder_data();
 
             $sql_data = $this->_serialize($object);
             $sql_data['folder_id'] = $this->folder_id;
             $sql_data['msguid']    = $msguid;
             $sql_data['uid']       = $object['uid'];
 
             $args = array();
             $cols = array('folder_id', 'msguid', 'uid', 'changed', 'data', 'xml', 'tags', 'words');
             $cols = array_merge($cols, $this->extra_cols);
 
             foreach ($cols as $idx => $col) {
                 $cols[$idx] = $this->db->quote_identifier($col);
                 $args[]     = $sql_data[$col];
             }
 
             if ($olduid) {
                 foreach ($cols as $idx => $col) {
                     $cols[$idx] = "$col = ?";
                 }
 
                 $query = "UPDATE `{$this->cache_table}` SET " . implode(', ', $cols)
                     . " WHERE `folder_id` = ? AND `msguid` = ?";
                 $args[] = $this->folder_id;
                 $args[] = $olduid;
             }
             else {
                 $query = "INSERT INTO `{$this->cache_table}` (`created`, " . implode(', ', $cols)
                     . ") VALUES (" . $this->db->now() . str_repeat(', ?', count($cols)) . ")";
             }
 
             $result = $this->db->query($query, $args);
 
             if (!$this->db->affected_rows($result)) {
                 rcube::raise_error(array(
                     'code' => 900, 'type' => 'php',
                     'message' => "Failed to write to kolab cache"
                 ), true);
             }
         }
 
         // keep a copy in memory for fast access
         $this->objects = array($msguid => $object);
         $this->uid2msg = array($object['uid'] => $msguid);
 
         $this->check_error();
     }
 
 
     /**
      * Move an existing cache entry to a new resource
      *
-     * @param string Entry's IMAP message UID
-     * @param string Entry's Object UID
-     * @param object kolab_storage_folder Target storage folder instance
+     * @param string               Entry's IMAP message UID
+     * @param string               Entry's Object UID
+     * @param kolab_storage_folder Target storage folder instance
+     * @param string               Target entry's IMAP message UID
      */
-    public function move($msguid, $uid, $target)
+    public function move($msguid, $uid, $target, $new_msguid = null)
     {
-        if ($this->ready) {
+        if ($this->ready && $target) {
             // clear cached uid mapping and force new lookup
             unset($target->cache->uid2msg[$uid]);
 
             // resolve new message UID in target folder
-            if ($new_msguid = $target->cache->uid2msguid($uid)) {
+            if (!$new_msguid) {
+                $new_msguid = $target->cache->uid2msguid($uid);
+            }
+
+            if ($new_msguid) {
                 $this->_read_folder_data();
 
                 $this->db->query(
                     "UPDATE `{$this->cache_table}` SET `folder_id` = ?, `msguid` = ? ".
                     "WHERE `folder_id` = ? AND `msguid` = ?",
                     $target->cache->get_folder_id(),
                     $new_msguid,
                     $this->folder_id,
                     $msguid
                 );
 
                 $result = $this->db->affected_rows();
             }
         }
 
         if (empty($result)) {
             // just clear cache entry
             $this->set($msguid, false);
         }
 
         unset($this->uid2msg[$uid]);
         $this->check_error();
     }
 
 
     /**
      * Remove all objects from local cache
      */
     public function purge()
     {
         if (!$this->ready) {
             return true;
         }
 
         $this->_read_folder_data();
 
         $result = $this->db->query(
             "DELETE FROM `{$this->cache_table}` WHERE `folder_id` = ?",
             $this->folder_id
         );
 
         return $this->db->affected_rows($result);
     }
 
     /**
      * Update resource URI for existing cache entries
      *
      * @param string Target IMAP folder to move it to
      */
     public function rename($new_folder)
     {
         if (!$this->ready) {
             return;
         }
 
         if ($target = kolab_storage::get_folder($new_folder)) {
             // resolve new message UID in target folder
             $this->db->query(
                 "UPDATE `{$this->folders_table}` SET `resource` = ? ".
                 "WHERE `resource` = ?",
                 $target->get_resource_uri(),
                 $this->resource_uri
             );
 
             $this->check_error();
         }
         else {
             $this->error = kolab_storage::ERROR_IMAP_CONN;
         }
     }
 
     /**
      * Select Kolab objects filtered by the given query
      *
      * @param array Pseudo-SQL query as list of filter parameter triplets
      *   triplet: array('<colname>', '<comparator>', '<value>')
      * @param boolean Set true to only return UIDs instead of complete objects
      * @return array List of Kolab data objects (each represented as hash array) or UIDs
      */
     public function select($query = array(), $uids = false)
     {
         $result = $uids ? array() : new kolab_storage_dataset($this);
 
         // read from local cache DB (assume it to be synchronized)
         if ($this->ready) {
             $this->_read_folder_data();
 
             // fetch full object data on one query if a small result set is expected
-            $fetchall = !$uids && ($this->limit ? $this->limit[0] : ($count = $this->count($query))) < 500;
+            $fetchall = !$uids && ($this->limit ? $this->limit[0] : ($count = $this->count($query))) < self::MAX_RECORDS;
 
             // skip SELECT if we know it will return nothing
             if ($count === 0) {
                 return $result;
             }
 
             $sql_query = "SELECT " . ($fetchall ? '*' : "`msguid` AS `_msguid`, `uid`")
                 . " FROM `{$this->cache_table}` WHERE `folder_id` = ?"
                 . $this->_sql_where($query)
                 . (!empty($this->order_by) ? " ORDER BY " . $this->order_by : '');
 
             $sql_result = $this->limit ?
                 $this->db->limitquery($sql_query, $this->limit[1], $this->limit[0], $this->folder_id) :
                 $this->db->query($sql_query, $this->folder_id);
 
             if ($this->db->is_error($sql_result)) {
                 if ($uids) {
                     return null;
                 }
                 $result->set_error(true);
                 return $result;
             }
 
             while ($sql_arr = $this->db->fetch_assoc($sql_result)) {
                 if ($uids) {
                     $this->uid2msg[$sql_arr['uid']] = $sql_arr['_msguid'];
                     $result[] = $sql_arr['uid'];
                 }
                 else if ($fetchall && ($object = $this->_unserialize($sql_arr))) {
                     $result[] = $object;
                 }
                 else if (!$fetchall) {
                     // only add msguid to dataset index
                     $result[] = $sql_arr;
                 }
             }
         }
         // use IMAP
         else {
             $filter = $this->_query2assoc($query);
 
             if ($filter['type']) {
                 $search = 'UNDELETED HEADER X-Kolab-Type ' . kolab_format::KTYPE_PREFIX . $filter['type'];
                 $index  = $this->imap->search_once($this->folder->name, $search);
             }
             else {
                 $index = $this->imap->index($this->folder->name, null, null, true, true);
             }
 
             if ($index->is_error()) {
                 $this->check_error();
                 if ($uids) {
                     return null;
                 }
                 $result->set_error(true);
                 return $result;
             }
 
             $index  = $index->get();
             $result = $uids ? $index : $this->_fetch($index, $filter['type']);
 
             // TODO: post-filter result according to query
         }
 
         // We don't want to cache big results in-memory, however
         // if we select only one object here, there's a big chance we will need it later
         if (!$uids && count($result) == 1) {
             if ($msguid = $result[0]['_msguid']) {
                 $this->uid2msg[$result[0]['uid']] = $msguid;
                 $this->objects = array($msguid => $result[0]);
             }
         }
 
         $this->check_error();
 
         return $result;
     }
 
 
     /**
      * Get number of objects mathing the given query
      *
      * @param array  $query Pseudo-SQL query as list of filter parameter triplets
      * @return integer The number of objects of the given type
      */
     public function count($query = array())
     {
         // read from local cache DB (assume it to be synchronized)
         if ($this->ready) {
             $this->_read_folder_data();
 
             $sql_result = $this->db->query(
                 "SELECT COUNT(*) AS `numrows` FROM `{$this->cache_table}` ".
                 "WHERE `folder_id` = ?" . $this->_sql_where($query),
                 $this->folder_id
             );
 
             if ($this->db->is_error($sql_result)) {
                 return null;
             }
 
             $sql_arr = $this->db->fetch_assoc($sql_result);
             $count   = intval($sql_arr['numrows']);
         }
         // use IMAP
         else {
             $filter = $this->_query2assoc($query);
 
             if ($filter['type']) {
                 $search = 'UNDELETED HEADER X-Kolab-Type ' . kolab_format::KTYPE_PREFIX . $filter['type'];
                 $index  = $this->imap->search_once($this->folder->name, $search);
             }
             else {
                 $index = $this->imap->index($this->folder->name, null, null, true, true);
             }
 
             if ($index->is_error()) {
                 $this->check_error();
                 return null;
             }
 
             // TODO: post-filter result according to query
 
             $count = $index->count();
         }
 
         $this->check_error();
         return $count;
     }
 
     /**
      * Define ORDER BY clause for cache queries
      */
     public function set_order_by($sortcols)
     {
         if (!empty($sortcols)) {
-            $this->order_by = '`' . join('`, `', (array)$sortcols) . '`';
+            $sortcols = array_map(function($v) {
+                list($column, $order) = explode(' ', $v, 2);
+                return "`$column`" . ($order ? " $order" : '');
+            }, (array) $sortcols);
+
+            $this->order_by = join(', ', $sortcols);
         }
         else {
             $this->order_by = null;
         }
     }
 
     /**
      * Define LIMIT clause for cache queries
      */
     public function set_limit($length, $offset = 0)
     {
         $this->limit = array($length, $offset);
     }
 
     /**
      * Helper method to compose a valid SQL query from pseudo filter triplets
      */
     protected function _sql_where($query)
     {
         $sql_where = '';
         foreach ((array) $query as $param) {
             if (is_array($param[0])) {
                 $subq = array();
                 foreach ($param[0] as $q) {
                     $subq[] = preg_replace('/^\s*AND\s+/i', '', $this->_sql_where(array($q)));
                 }
                 if (!empty($subq)) {
                     $sql_where .= ' AND (' . implode($param[1] == 'OR' ? ' OR ' : ' AND ', $subq) . ')';
                 }
                 continue;
             }
             else if ($param[1] == '=' && is_array($param[2])) {
                 $qvalue = '(' . join(',', array_map(array($this->db, 'quote'), $param[2])) . ')';
                 $param[1] = 'IN';
             }
             else if ($param[1] == '~' || $param[1] == 'LIKE' || $param[1] == '!~' || $param[1] == '!LIKE') {
                 $not = ($param[1] == '!~' || $param[1] == '!LIKE') ? 'NOT ' : '';
                 $param[1] = $not . 'LIKE';
                 $qvalue = $this->db->quote('%'.preg_replace('/(^\^|\$$)/', ' ', $param[2]).'%');
             }
             else if ($param[0] == 'tags') {
                 $param[1] = ($param[1] == '!=' ? 'NOT ' : '' ) . 'LIKE';
                 $qvalue = $this->db->quote('% '.$param[2].' %');
             }
             else {
                 $qvalue = $this->db->quote($param[2]);
             }
 
             $sql_where .= sprintf(' AND %s %s %s',
                 $this->db->quote_identifier($param[0]),
                 $param[1],
                 $qvalue
             );
         }
 
         return $sql_where;
     }
 
     /**
      * Helper method to convert the given pseudo-query triplets into
      * an associative filter array with 'equals' values only
      */
     protected function _query2assoc($query)
     {
         // extract object type from query parameter
         $filter = array();
         foreach ($query as $param) {
             if ($param[1] == '=')
                 $filter[$param[0]] = $param[2];
         }
         return $filter;
     }
 
     /**
      * Fetch messages from IMAP
      *
      * @param array  List of message UIDs to fetch
      * @param string Requested object type or * for all
      * @param string IMAP folder to read from
      * @return array List of parsed Kolab objects
      */
     protected function _fetch($index, $type = null, $folder = null)
     {
         $results = new kolab_storage_dataset($this);
         foreach ((array)$index as $msguid) {
             if ($object = $this->folder->read_object($msguid, $type, $folder)) {
                 $results[] = $object;
                 $this->set($msguid, $object);
             }
         }
 
         return $results;
     }
 
     /**
      * Helper method to convert the given Kolab object into a dataset to be written to cache
      */
     protected function _serialize($object)
     {
         $sql_data = array('changed' => null, 'xml' => '', 'tags' => '', 'words' => '');
 
         if ($object['changed']) {
             $sql_data['changed'] = date(self::DB_DATE_FORMAT, is_object($object['changed']) ? $object['changed']->format('U') : $object['changed']);
         }
 
         if ($object['_formatobj']) {
             $sql_data['xml']   = preg_replace('!(</?[a-z0-9:-]+>)[\n\r\t\s]+!ms', '$1', (string)$object['_formatobj']->write(3.0));
             $sql_data['tags']  = ' ' . join(' ', $object['_formatobj']->get_tags()) . ' ';  // pad with spaces for strict/prefix search
             $sql_data['words'] = ' ' . join(' ', $object['_formatobj']->get_words()) . ' ';
         }
 
         // extract object data
         $data = array();
         foreach ($object as $key => $val) {
             // skip empty properties
             if ($val === "" || $val === null) {
                 continue;
             }
             // mark binary data to be extracted from xml on unserialize()
             if (isset($this->binary_items[$key])) {
                 $data[$key] = true;
             }
             else if ($key[0] != '_') {
                 $data[$key] = $val;
             }
             else if ($key == '_attachments') {
                 foreach ($val as $k => $att) {
                     unset($att['content'], $att['path']);
                     if ($att['id'])
                         $data[$key][$k] = $att;
                 }
             }
         }
 
         // use base64 encoding (Bug #1912, #2662)
         $sql_data['data'] = base64_encode(serialize($data));
 
         return $sql_data;
     }
 
     /**
      * Helper method to turn stored cache data into a valid storage object
      */
     protected function _unserialize($sql_arr)
     {
         // check if data is a base64-encoded string, for backward compat.
         if (strpos(substr($sql_arr['data'], 0, 64), ':') === false) {
             $sql_arr['data'] = base64_decode($sql_arr['data']);
         }
 
         $object = unserialize($sql_arr['data']);
 
         // de-serialization failed
         if ($object === false) {
             rcube::raise_error(array(
                 'code' => 900, 'type' => 'php',
                 'message' => "Malformed data for {$this->resource_uri}/{$sql_arr['msguid']} object."
             ), true);
 
             return null;
         }
 
         // decode binary properties
         foreach ($this->binary_items as $key => $regexp) {
             if (!empty($object[$key]) && preg_match($regexp, $sql_arr['xml'], $m)) {
                 $object[$key] = base64_decode($m[1]);
             }
         }
 
         $object_type = $sql_arr['type'] ?: $this->folder->type;
         $format_type = $this->folder->type == 'configuration' ? 'configuration' : $object_type;
 
         // add meta data
         $object['_type']      = $object_type;
         $object['_msguid']    = $sql_arr['msguid'];
         $object['_mailbox']   = $this->folder->name;
         $object['_size']      = strlen($sql_arr['xml']);
         $object['_formatobj'] = kolab_format::factory($format_type, 3.0, $sql_arr['xml']);
 
         return $object;
     }
 
     /**
      * Write records into cache using extended inserts to reduce the number of queries to be executed
      *
      * @param int  Message UID. Set 0 to commit buffered inserts
      * @param array Kolab object to cache
      */
     protected function _extended_insert($msguid, $object)
     {
         static $buffer = '';
 
         $line = '';
         if ($object) {
             $sql_data = $this->_serialize($object);
 
             // Skip multifolder insert for Oracle, we can't put long data inline
             if ($this->db->db_provider == 'oracle') {
                 $extra_cols = '';
                 if ($this->extra_cols) {
                     $extra_cols = array_map(function($n) { return "`{$n}`"; }, $this->extra_cols);
                     $extra_cols = ', ' . join(', ', $extra_cols);
                     $extra_args = str_repeat(', ?', count($this->extra_cols));
                 }
 
                 $params = array($this->folder_id, $msguid, $object['uid'], $sql_data['changed'],
                     $sql_data['data'], $sql_data['xml'], $sql_data['tags'], $sql_data['words']);
 
                 foreach ($this->extra_cols as $col) {
                     $params[] = $sql_data[$col];
                 }
 
                 $result = $this->db->query(
                     "INSERT INTO `{$this->cache_table}` "
                     . " (`folder_id`, `msguid`, `uid`, `created`, `changed`, `data`, `xml`, `tags`, `words` $extra_cols)"
                     . " VALUES (?, ?, ?, " . $this->db->now() . ", ?, ?, ?, ?, ? $extra_args)",
                     $params
                 );
 
                 if (!$this->db->affected_rows($result)) {
                     rcube::raise_error(array(
                         'code' => 900, 'type' => 'php',
                         'message' => "Failed to write to kolab cache"
                     ), true);
                 }
 
                 return;
             }
 
             $values = array(
                 $this->db->quote($this->folder_id),
                 $this->db->quote($msguid),
                 $this->db->quote($object['uid']),
                 $this->db->now(),
                 $this->db->quote($sql_data['changed']),
                 $this->db->quote($sql_data['data']),
                 $this->db->quote($sql_data['xml']),
                 $this->db->quote($sql_data['tags']),
                 $this->db->quote($sql_data['words']),
             );
             foreach ($this->extra_cols as $col) {
                 $values[] = $this->db->quote($sql_data[$col]);
             }
             $line = '(' . join(',', $values) . ')';
         }
 
         if ($buffer && (!$msguid || (strlen($buffer) + strlen($line) > $this->max_sql_packet()))) {
             $extra_cols = '';
             if ($this->extra_cols) {
                 $extra_cols = array_map(function($n) { return "`{$n}`"; }, $this->extra_cols);
                 $extra_cols = ', ' . join(', ', $extra_cols);
             }
 
             $result = $this->db->query(
                 "INSERT INTO `{$this->cache_table}` ".
                 " (`folder_id`, `msguid`, `uid`, `created`, `changed`, `data`, `xml`, `tags`, `words` $extra_cols)".
                 " VALUES $buffer"
             );
 
             if (!$this->db->affected_rows($result)) {
                 rcube::raise_error(array(
                     'code' => 900, 'type' => 'php',
                     'message' => "Failed to write to kolab cache"
                 ), true);
             }
 
             $buffer = '';
         }
 
         $buffer .= ($buffer ? ',' : '') . $line;
     }
 
     /**
      * Returns max_allowed_packet from mysql config
      */
     protected function max_sql_packet()
     {
         if (!$this->max_sql_packet) {
             // mysql limit or max 4 MB
             $value = $this->db->get_variable('max_allowed_packet', 1048500);
             $this->max_sql_packet = min($value, 4*1024*1024) - 2000;
         }
 
         return $this->max_sql_packet;
     }
 
     /**
      * Read this folder's ID and cache metadata
      */
     protected function _read_folder_data()
     {
         // already done
         if (!empty($this->folder_id) || !$this->ready)
             return;
 
         $sql_arr = $this->db->fetch_assoc($this->db->query(
                 "SELECT `folder_id`, `synclock`, `ctag`, `changed`, `objectcount`"
                 . " FROM `{$this->folders_table}` WHERE `resource` = ?",
                 $this->resource_uri
         ));
 
         if ($sql_arr) {
             $this->metadata = $sql_arr;
             $this->folder_id = $sql_arr['folder_id'];
         }
         else {
             $this->db->query("INSERT INTO `{$this->folders_table}` (`resource`, `type`)"
                 . " VALUES (?, ?)", $this->resource_uri, $this->folder->type);
 
             $this->folder_id = $this->db->insert_id('kolab_folders');
             $this->metadata = array();
         }
     }
 
     /**
      * Check lock record for this folder and wait if locked or set lock
      */
     protected function _sync_lock()
     {
         if (!$this->ready)
             return;
 
         $this->_read_folder_data();
 
         // abort if database is not set-up
         if ($this->db->is_error()) {
             $this->check_error();
             $this->ready = false;
             return;
         }
 
         $read_query  = "SELECT `synclock`, `ctag` FROM `{$this->folders_table}` WHERE `folder_id` = ?";
         $write_query = "UPDATE `{$this->folders_table}` SET `synclock` = ? WHERE `folder_id` = ? AND `synclock` = ?";
 
         // wait if locked (expire locks after 10 minutes) ...
         // ... or if setting lock fails (another process meanwhile set it)
         while (
             (intval($this->metadata['synclock']) + $this->max_sync_lock_time > time()) ||
             (($res = $this->db->query($write_query, time(), $this->folder_id, intval($this->metadata['synclock']))) &&
                 !($affected = $this->db->affected_rows($res)))
         ) {
             usleep(500000);
             $this->metadata = $this->db->fetch_assoc($this->db->query($read_query, $this->folder_id));
         }
 
         $this->synclock = $affected > 0;
     }
 
     /**
      * Remove lock for this folder
      */
     public function _sync_unlock()
     {
         if (!$this->ready || !$this->synclock)
             return;
 
         $this->db->query(
             "UPDATE `{$this->folders_table}` SET `synclock` = 0, `ctag` = ?, `changed` = ?, `objectcount` = ? WHERE `folder_id` = ?",
             $this->metadata['ctag'],
             $this->metadata['changed'],
             $this->metadata['objectcount'],
             $this->folder_id
         );
 
         $this->synclock = false;
     }
 
     /**
      * Check IMAP connection error state
      */
     protected function check_error()
     {
         if (($err_code = $this->imap->get_error_code()) < 0) {
             $this->error = kolab_storage::ERROR_IMAP_CONN;
             if (($res_code = $this->imap->get_response_code()) !== 0 && in_array($res_code, array(rcube_storage::NOPERM, rcube_storage::READONLY))) {
                 $this->error = kolab_storage::ERROR_NO_PERMISSION;
             }
         }
         else if ($this->db->is_error()) {
             $this->error = kolab_storage::ERROR_CACHE_DB;
         }
     }
 
     /**
      * Resolve an object UID into an IMAP message UID
      *
      * @param string  Kolab object UID
      * @param boolean Include deleted objects
      * @return int The resolved IMAP message UID
      */
     public function uid2msguid($uid, $deleted = false)
     {
         // query local database if available
         if (!isset($this->uid2msg[$uid]) && $this->ready) {
             $this->_read_folder_data();
 
             $sql_result = $this->db->query(
                 "SELECT `msguid` FROM `{$this->cache_table}` ".
                 "WHERE `folder_id` = ? AND `uid` = ? ORDER BY `msguid` DESC",
                 $this->folder_id,
                 $uid
             );
 
             if ($sql_arr = $this->db->fetch_assoc($sql_result)) {
                 $this->uid2msg[$uid] = $sql_arr['msguid'];
             }
         }
 
         if (!isset($this->uid2msg[$uid])) {
             // use IMAP SEARCH to get the right message
             $index = $this->imap->search_once($this->folder->name, ($deleted ? '' : 'UNDELETED ') .
                 'HEADER SUBJECT ' . rcube_imap_generic::escape($uid));
             $results = $index->get();
             $this->uid2msg[$uid] = end($results);
         }
 
         return $this->uid2msg[$uid];
     }
 
     /**
      * Getter for protected member variables
      */
     public function __get($name)
     {
         if ($name == 'folder_id') {
             $this->_read_folder_data();
         }
 
         return $this->$name;
     }
 
     /**
      * Bypass Roundcube messages cache.
      * Roundcube cache duplicates information already stored in kolab_cache.
      *
      * @param bool $disable True disables, False enables messages cache
      */
     public function bypass($disable = false)
     {
         // if kolab cache is disabled do nothing
         if (!$this->enabled) {
             return;
         }
 
         static $messages_cache, $cache_bypass;
 
         if ($messages_cache === null) {
             $rcmail = rcube::get_instance();
             $messages_cache = (bool) $rcmail->config->get('messages_cache');
             $cache_bypass   = (int) $rcmail->config->get('kolab_messages_cache_bypass');
         }
 
         if ($messages_cache) {
             // handle recurrent (multilevel) bypass() calls
             if ($disable) {
                 $this->cache_bypassed += 1;
                 if ($this->cache_bypassed > 1) {
                     return;
                 }
             }
             else {
                 $this->cache_bypassed -= 1;
                 if ($this->cache_bypassed > 0) {
                     return;
                 }
             }
 
             switch ($cache_bypass) {
                 case 2:
                     // Disable messages cache completely
                     $this->imap->set_messages_caching(!$disable);
                     break;
 
                 case 1:
                     // We'll disable messages cache, but keep index cache.
                     // Default mode is both (MODE_INDEX | MODE_MESSAGE)
                     $mode = rcube_imap_cache::MODE_INDEX;
 
                     if (!$disable) {
                         $mode |= rcube_imap_cache::MODE_MESSAGE;
                     }
 
                     $this->imap->set_messages_caching(true, $mode);
             }
         }
     }
 
     /**
      * Converts DateTime or unix timestamp into sql date format
      * using server timezone.
      */
     protected function _convert_datetime($datetime)
     {
         if (is_object($datetime)) {
             $dt = clone $datetime;
             $dt->setTimeZone($this->server_timezone);
             return $dt->format(self::DB_DATE_FORMAT);
         }
         else if ($datetime) {
             return date(self::DB_DATE_FORMAT, $datetime);
         }
     }
 }
diff --git a/plugins/libkolab/lib/kolab_storage_config.php b/plugins/libkolab/lib/kolab_storage_config.php
index e843e976..771b9ff1 100644
--- a/plugins/libkolab/lib/kolab_storage_config.php
+++ b/plugins/libkolab/lib/kolab_storage_config.php
@@ -1,918 +1,1013 @@
 <?php
 
 /**
  * Kolab storage class providing access to configuration objects on a Kolab server.
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  * @author Aleksander Machniak <machniak@kolabsys.com>
  *
  * Copyright (C) 2012-2014, 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_storage_config
 {
-    const FOLDER_TYPE = 'configuration';
-
+    const FOLDER_TYPE   = 'configuration';
+    const MAX_RELATIONS = 499; // should be less than kolab_storage_cache::MAX_RECORDS
 
     /**
      * Singleton instace of kolab_storage_config
      *
      * @var kolab_storage_config
      */
     static protected $instance;
 
     private $folders;
     private $default;
     private $enabled;
     private $tags;
 
 
     /**
      * This implements the 'singleton' design pattern
      *
      * @return kolab_storage_config The one and only instance
      */
     static function get_instance()
     {
         if (!self::$instance) {
             self::$instance = new kolab_storage_config();
         }
 
         return self::$instance;
     }
 
     /**
      * Private constructor (finds default configuration folder as a config source)
      */
-    private function __construct()
+    private function _init()
     {
+        if ($this->enabled !== null) {
+            return $this->enabled;
+        }
+
         // get all configuration folders
         $this->folders = kolab_storage::get_folders(self::FOLDER_TYPE, false);
 
         foreach ($this->folders as $folder) {
             if ($folder->default) {
                 $this->default = $folder;
                 break;
             }
         }
 
         // if no folder is set as default, choose the first one
         if (!$this->default) {
             $this->default = reset($this->folders);
         }
 
         // attempt to create a default folder if it does not exist
         if (!$this->default) {
             $folder_name = 'Configuration';
             $folder_type = self::FOLDER_TYPE . '.default';
 
             if (kolab_storage::folder_create($folder_name, $folder_type, true)) {
                 $this->default = new kolab_storage_folder($folder_name, $folder_type);
             }
         }
 
         // check if configuration folder exist
-        if ($this->default && $this->default->name) {
-            $this->enabled = true;
-        }
+        return $this->enabled = $this->default && $this->default->name;
     }
 
     /**
      * Check wether any configuration storage (folder) exists
      *
      * @return bool
      */
     public function is_enabled()
     {
-        return $this->enabled;
+        return $this->_init();
     }
 
     /**
      * Get configuration objects
      *
      * @param array $filter  Search filter
      * @param bool  $default Enable to get objects only from default folder
      * @param int   $limit   Max. number of records (per-folder)
      *
      * @return array List of objects
      */
     public function get_objects($filter = array(), $default = false, $limit = 0)
     {
         $list = array();
 
+        if (!$this->is_enabled()) {
+            return $list;
+        }
+
         foreach ($this->folders as $folder) {
             // we only want to read from default folder
             if ($default && !$folder->default) {
                 continue;
             }
 
             // for better performance it's good to assume max. number of records
             if ($limit) {
                 $folder->set_order_and_limit(null, $limit);
             }
 
             foreach ($folder->select($filter) as $object) {
                 unset($object['_formatobj']);
                 $list[] = $object;
             }
         }
 
         return $list;
     }
 
     /**
      * Get configuration object
      *
      * @param string $uid     Object UID
      * @param bool   $default Enable to get objects only from default folder
      *
      * @return array Object data
      */
     public function get_object($uid, $default = false)
     {
+        if (!$this->is_enabled()) {
+            return;
+        }
+
         foreach ($this->folders as $folder) {
             // we only want to read from default folder
             if ($default && !$folder->default) {
                 continue;
             }
 
             if ($object = $folder->get_object($uid)) {
                 return $object;
             }
         }
     }
 
     /**
      * Create/update configuration object
      *
      * @param array  $object Object data
      * @param string $type   Object type
      *
      * @return bool True on success, False on failure
      */
     public function save(&$object, $type)
     {
-        if (!$this->enabled) {
+        if (!$this->is_enabled()) {
             return false;
         }
 
         $folder = $this->find_folder($object);
 
         if ($type) {
             $object['type'] = $type;
         }
 
         $status = $folder->save($object, self::FOLDER_TYPE . '.' . $object['type'], $object['uid']);
 
         // on success, update cached tags list
         if ($status && is_array($this->tags)) {
             $found = false;
             unset($object['_formatobj']); // we don't need it anymore
 
             foreach ($this->tags as $idx => $tag) {
                 if ($tag['uid'] == $object['uid']) {
                     $found = true;
                     $this->tags[$idx] = $object;
                 }
             }
 
             if (!$found) {
                 $this->tags[] = $object;
             }
         }
 
         return !empty($status);
     }
 
     /**
      * Remove configuration object
      *
-     * @param string $uid Object UID
+     * @param string|array $object Object array or its UID
      *
      * @return bool True on success, False on failure
      */
-    public function delete($uid)
+    public function delete($object)
     {
-        if (!$this->enabled) {
+        if (!$this->is_enabled()) {
             return false;
         }
 
         // fetch the object to find folder
-        $object = $this->get_object($uid);
+        if (!is_array($object)) {
+            $object = $this->get_object($object);
+        }
 
         if (!$object) {
             return false;
         }
 
         $folder = $this->find_folder($object);
-        $status = $folder->delete($uid);
+        $status = $folder->delete($object);
 
         // on success, update cached tags list
         if ($status && is_array($this->tags)) {
             foreach ($this->tags as $idx => $tag) {
                 if ($tag['uid'] == $uid) {
                     unset($this->tags[$idx]);
                     break;
                 }
             }
         }
 
         return $status;
     }
 
     /**
      * Find folder
      */
     public function find_folder($object = array())
     {
+        if (!$this->is_enabled()) {
+            return;
+        }
+
         // find folder object
         if ($object['_mailbox']) {
             foreach ($this->folders as $folder) {
                 if ($folder->name == $object['_mailbox']) {
                     break;
                 }
             }
         }
         else {
             $folder = $this->default;
         }
 
         return $folder;
     }
 
     /**
      * Builds relation member URI
      *
      * @param string|array Object UUID or Message folder, UID, Search headers (Message-Id, Date)
      *
      * @return string $url Member URI
      */
     public static function build_member_url($params)
     {
         // param is object UUID
         if (is_string($params) && !empty($params)) {
             return 'urn:uuid:' . $params;
         }
 
         if (empty($params) || !strlen($params['folder'])) {
             return null;
         }
 
         $rcube   = rcube::get_instance();
         $storage = $rcube->get_storage();
         list($username, $domain) = explode('@', $rcube->get_user_name());
 
         if (strlen($domain)) {
             $domain = '@' . $domain;
         }
 
         // modify folder spec. according to namespace
         $folder = $params['folder'];
         $ns     = $storage->folder_namespace($folder);
 
         if ($ns == 'shared') {
             // Note: this assumes there's only one shared namespace root
             if ($ns = $storage->get_namespace('shared')) {
                 if ($prefix = $ns[0][0]) {
                     $folder = substr($folder, strlen($prefix));
                 }
             }
         }
         else {
             if ($ns == 'other') {
                 // Note: this assumes there's only one other users namespace root
                 if ($ns = $storage->get_namespace('other')) {
                     if ($prefix = $ns[0][0]) {
                         list($otheruser, $path) = explode('/', substr($folder, strlen($prefix)), 2);
                         $folder = 'user/' . $otheruser . $domain . '/' . $path;
                     }
                 }
             }
             else {
                 $folder = 'user/' . $username . $domain . '/' . $folder;
             }
         }
 
         $folder = implode('/', array_map('rawurlencode', explode('/', $folder)));
 
         // build URI
         $url = 'imap:///' . $folder;
 
         // UID is optional here because sometimes we want
         // to build just a member uri prefix
         if ($params['uid']) {
             $url .= '/' . $params['uid'];
         }
 
         unset($params['folder']);
         unset($params['uid']);
 
         if (!empty($params)) {
             $url .= '?' . http_build_query($params, '', '&');
         }
 
         return $url;
     }
 
     /**
      * Parses relation member string
      *
      * @param string $url Member URI
      *
      * @return array Message folder, UID, Search headers (Message-Id, Date)
      */
     public static function parse_member_url($url)
     {
         // Look for IMAP URI:
         // imap:///(user/username@domain|shared)/<folder>/<UID>?<search_params>
         if (strpos($url, 'imap:///') === 0) {
             $rcube   = rcube::get_instance();
             $storage = $rcube->get_storage();
 
             // parse_url does not work with imap:/// prefix
             $url   = parse_url(substr($url, 8));
             $path  = explode('/', $url['path']);
             parse_str($url['query'], $params);
 
             $uid  = array_pop($path);
             $ns   = array_shift($path);
             $path = array_map('rawurldecode', $path);
 
             // resolve folder name
             if ($ns == 'user') {
                 $username = array_shift($path);
                 $folder   = implode('/', $path);
 
                 if ($username != $rcube->get_user_name()) {
                     list($user, $domain) = explode('@', $username);
 
                     // Note: this assumes there's only one other users namespace root
                     if ($ns = $storage->get_namespace('other')) {
                         if ($prefix = $ns[0][0]) {
                             $folder = $prefix . $user . '/' . $folder;
                         }
                     }
                 }
                 else if (!strlen($folder)) {
                     $folder = 'INBOX';
                 }
             }
             else {
                 $folder = $ns . '/' . implode('/', $path);
                 // Note: this assumes there's only one shared namespace root
                 if ($ns = $storage->get_namespace('shared')) {
                     if ($prefix = $ns[0][0]) {
                         $folder = $prefix . $folder;
                     }
                 }
             }
 
             return array(
                 'folder' => $folder,
                 'uid'    => $uid,
                 'params' => $params,
             );
         }
 
         return false;
     }
 
     /**
      * Build array of member URIs from set of messages
      *
      * @param string $folder   Folder name
      * @param array  $messages Array of rcube_message objects
      *
      * @return array List of members (IMAP URIs)
      */
     public static function build_members($folder, $messages)
     {
         $members = array();
 
         foreach ((array) $messages as $msg) {
             $params = array(
                 'folder' => $folder,
                 'uid'    => $msg->uid,
             );
 
             // add search parameters:
             // we don't want to build "invalid" searches e.g. that
             // will return false positives (more or wrong messages)
             if (($messageid = $msg->get('message-id', false)) && ($date = $msg->get('date', false))) {
                 $params['message-id'] = $messageid;
                 $params['date']       = $date;
 
                 if ($subject = $msg->get('subject', false)) {
                     $params['subject'] = substr($subject, 0, 256);
                 }
             }
 
             $members[] = self::build_member_url($params);
         }
 
         return $members;
     }
 
     /**
      * Resolve/validate/update members (which are IMAP URIs) of relation object.
      *
      * @param array $tag   Tag object
      * @param bool  $force Force members list update
      *
      * @return array Folder/UIDs list
      */
     public static function resolve_members(&$tag, $force = true)
     {
         $result = array();
 
         foreach ((array) $tag['members'] as $member) {
             // IMAP URI members
             if ($url = self::parse_member_url($member)) {
                 $folder = $url['folder'];
 
                 if (!$force) {
                     $result[$folder][] = $url['uid'];
                 }
                 else {
                     $result[$folder]['uid'][]    = $url['uid'];
                     $result[$folder]['params'][] = $url['params'];
                     $result[$folder]['member'][] = $member;
                 }
             }
         }
 
         if (empty($result) || !$force) {
             return $result;
         }
 
         $rcube   = rcube::get_instance();
         $storage = $rcube->get_storage();
         $search  = array();
         $missing = array();
 
         // first we search messages by Folder+UID
         foreach ($result as $folder => $data) {
             // @FIXME: maybe better use index() which is cached?
             // @TODO: consider skip_deleted option
             $index = $storage->search_once($folder, 'UID ' . rcube_imap_generic::compressMessageSet($data['uid']));
             $uids  = $index->get();
 
             // messages that were not found need to be searched by search parameters
             $not_found = array_diff($data['uid'], $uids);
             if (!empty($not_found)) {
                 foreach ($not_found as $uid) {
                     $idx = array_search($uid, $data['uid']);
 
                     if ($p = $data['params'][$idx]) {
                         $search[] = $p;
                     }
 
                     $missing[] = $result[$folder]['member'][$idx];
 
                     unset($result[$folder]['uid'][$idx]);
                     unset($result[$folder]['params'][$idx]);
                     unset($result[$folder]['member'][$idx]);
                 }
             }
 
             $result[$folder] = $uids;
         }
 
         // search in all subscribed mail folders using search parameters
         if (!empty($search)) {
             // remove not found members from the members list
             $tag['members'] = array_diff($tag['members'], $missing);
 
             // get subscribed folders
             $folders = $storage->list_folders_subscribed('', '*', 'mail', null, true);
 
             // @TODO: do this search in chunks (for e.g. 10 messages)?
             $search_str = '';
 
             foreach ($search as $p) {
                 $search_params = array();
                 foreach ($p as $key => $val) {
                     $key = strtoupper($key);
                     // don't search by subject, we don't want false-positives
                     if ($key != 'SUBJECT') {
                         $search_params[] = 'HEADER ' . $key . ' ' . rcube_imap_generic::escape($val);
                     }
                 }
 
                 $search_str .= ' (' . implode(' ', $search_params) . ')';
             }
 
             $search_str = trim(str_repeat(' OR', count($search)-1) . $search_str);
 
             // search
             $search = $storage->search_once($folders, $search_str);
 
             // handle search result
             $folders = (array) $search->get_parameters('MAILBOX');
 
             foreach ($folders as $folder) {
                 $set  = $search->get_set($folder);
                 $uids = $set->get();
 
                 if (!empty($uids)) {
                     $msgs    = $storage->fetch_headers($folder, $uids, false);
                     $members = self::build_members($folder, $msgs);
 
                     // merge new members into the tag members list
                     $tag['members'] = array_merge($tag['members'], $members);
 
                     // add UIDs into the result
                     $result[$folder] = array_unique(array_merge((array)$result[$folder], $uids));
                 }
             }
 
             // update tag object with new members list
             $tag['members'] = array_unique($tag['members']);
             kolab_storage_config::get_instance()->save($tag, 'relation', false);
         }
 
         return $result;
     }
 
     /**
      * Assign tags to kolab objects
      *
-     * @param array $records List of kolab objects
+     * @param array $records   List of kolab objects
+     * @param bool  $no_return Don't return anything
      *
      * @return array List of tags
      */
-    public function apply_tags(&$records)
+    public function apply_tags(&$records, $no_return = false)
     {
+        if (empty($records) && $no_return) {
+            return;
+        }
+
         // first convert categories into tags
         foreach ($records as $i => $rec) {
             if (!empty($rec['categories'])) {
                 $folder = new kolab_storage_folder($rec['_mailbox']);
                 if ($object = $folder->get_object($rec['uid'])) {
                     $tags = $rec['categories'];
 
                     unset($object['categories']);
                     unset($records[$i]['categories']);
 
                     $this->save_tags($rec['uid'], $tags);
                     $folder->save($object, $rec['_type'], $rec['uid']);
                 }
             }
         }
 
         $tags = array();
 
         // assign tags to objects
         foreach ($this->get_tags() as $tag) {
             foreach ($records as $idx => $rec) {
                 $uid = self::build_member_url($rec['uid']);
                 if (in_array($uid, (array) $tag['members'])) {
                     $records[$idx]['tags'][] = $tag['name'];
                 }
             }
 
             $tags[] = $tag['name'];
         }
 
-        $tags = array_unique($tags);
+        $tags = $no_return ? null : array_unique($tags);
 
         return $tags;
     }
 
+    /**
+     * Assign links (relations) to kolab objects
+     *
+     * @param array $records List of kolab objects
+     */
+    public function apply_links(&$records)
+    {
+        $links = array();
+        $uids  = array();
+        $ids   = array();
+        $limit = 25;
+
+        // get list of object UIDs and UIRs map
+        foreach ($records as $i => $rec) {
+            $uids[] = $rec['uid'];
+            // there can be many objects with the same uid (recurring events)
+            $ids[self::build_member_url($rec['uid'])][] = $i;
+            $records[$i]['links'] = array();
+        }
+
+        if (!empty($uids)) {
+            $uids = array_unique($uids);
+        }
+
+        // The whole story here is to not do SELECT for every object.
+        // We'll build one SELECT for many (limit above) objects at once
+
+        while (!empty($uids)) {
+            $chunk = array_splice($uids, 0, $limit);
+            $chunk = array_map(function($v) { return array('member', '=', $v); }, $chunk);
+
+            $filter = array(
+                array('type', '=', 'relation'),
+                array('category', '=', 'generic'),
+                array($chunk, 'OR'),
+            );
+
+            $relations = $this->get_objects($filter, true, self::MAX_RELATIONS);
+
+            foreach ($relations as $relation) {
+                $links[$relation['uid']] = $relation;
+            }
+        }
+
+        if (empty($links)) {
+            return;
+        }
+
+        // assign links of related messages
+        foreach ($links as $relation) {
+            // make relation members up-to-date
+            kolab_storage_config::resolve_members($relation);
+
+            $members = array();
+            foreach ((array) $relation['members'] as $member) {
+                if (strpos($member, 'imap://') === 0) {
+                    $members[$member] = $member;
+                }
+            }
+            $members = array_values($members);
+
+            // assign links to objects
+            foreach ((array) $relation['members'] as $member) {
+                if (($id = $ids[$member]) !== null) {
+                    foreach ($id as $i) {
+                        $records[$i]['links'] = array_unique(array_merge($records[$i]['links'], $members));
+                    }
+                }
+            }
+        }
+    }
+
     /**
      * Update object tags
      *
      * @param string $uid  Kolab object UID
      * @param array  $tags List of tag names
      */
     public function save_tags($uid, $tags)
     {
         $url       = self::build_member_url($uid);
         $relations = $this->get_tags();
 
         foreach ($relations as $idx => $relation) {
             $selected = !empty($tags) && in_array($relation['name'], $tags);
             $found    = !empty($relation['members']) && in_array($url, $relation['members']);
             $update   = false;
 
             // remove member from the relation
             if ($found && !$selected) {
                 $relation['members'] = array_diff($relation['members'], (array) $url);
                 $update = true;
             }
             // add member to the relation
             else if (!$found && $selected) {
                 $relation['members'][] = $url;
                 $update = true;
             }
 
             if ($update) {
                 if ($this->save($relation, 'relation')) {
                     $this->tags[$idx] = $relation; // update in-memory cache
                 }
             }
 
             if ($selected) {
                 $tags = array_diff($tags, (array)$relation['name']);
             }
         }
 
         // create new relations
         if (!empty($tags)) {
             foreach ($tags as $tag) {
                 $relation = array(
                     'name'     => $tag,
                     'members'  => (array) $url,
                     'category' => 'tag',
                 );
 
                 if ($this->save($relation, 'relation')) {
                     $this->tags[] = $relation; // update in-memory cache
                 }
             }
         }
     }
 
     /**
      * Get tags (all or referring to specified object)
      *
      * @param string $member Optional object UID or mail message-id
-     * @param int    $limit  Max. number of records (per-folder)
-     *                       Used when searching by member
      *
      * @return array List of Relation objects
      */
-    public function get_tags($member = '*', $limit = 0)
+    public function get_tags($member = '*')
     {
         if (!isset($this->tags)) {
             $default = true;
             $filter  = array(
                 array('type', '=', 'relation'),
                 array('category', '=', 'tag')
             );
 
             // use faster method
             if ($member && $member != '*') {
                 $filter[] = array('member', '=', $member);
-                $tags = $this->get_objects($filter, $default, $limit);
+                $tags = $this->get_objects($filter, $default, self::MAX_RELATIONS);
             }
             else {
-                $this->tags = $tags = $this->get_objects($filter, $default);
+                $this->tags = $tags = $this->get_objects($filter, $default, self::MAX_RELATIONS);
             }
         }
         else {
             $tags = $this->tags;
         }
 
         if ($member === '*') {
             return $tags;
         }
 
         $result = array();
 
         if ($member[0] == '<') {
             $search_msg = urlencode($member);
         }
         else {
             $search_uid = self::build_member_url($member);
         }
 
         foreach ($tags as $tag) {
             if ($search_uid && in_array($search_uid, (array) $tag['members'])) {
                 $result[] = $tag;
             }
             else if ($search_msg) {
                 foreach ($tag['members'] as $m) {
                     if (strpos($m, $search_msg) !== false) {
                         $result[] = $tag;
                         break;
                     }
                 }
             }
         }
 
         return $result;
     }
 
     /**
      * Find objects linked with the given groupware object through a relation
      *
      * @param string Object UUID
-     * @param array List of related URIs
+     *
+     * @return array List of related URIs
      */
     public function get_object_links($uid)
     {
         $links = array();
         $object_uri = self::build_member_url($uid);
 
         foreach ($this->get_relations_for_member($uid) as $relation) {
             if (in_array($object_uri, (array) $relation['members'])) {
                 // make relation members up-to-date
                 kolab_storage_config::resolve_members($relation);
 
                 foreach ($relation['members'] as $member) {
                     if ($member != $object_uri) {
                         $links[] = $member;
                     }
                 }
             }
         }
 
         return array_unique($links);
     }
 
     /**
+     * Save relations of an object.
+     * Note, that we already support only one-to-one relations.
+     * So, all relations to the object that are not provided in $links
+     * argument will be removed.
+     *
+     * @param string $uid   Object UUID
+     * @param array  $links List of related-object URIs
      *
+     * @return bool True on success, False on failure
      */
-    public function save_object_links($uid, $links, $remove = array())
+    public function save_object_links($uid, $links)
     {
         $object_uri = self::build_member_url($uid);
-        $relations = $this->get_relations_for_member($uid);
-        $done = false;
+        $relations  = $this->get_relations_for_member($uid);
+        $done       = false;
 
         foreach ($relations as $relation) {
             // make relation members up-to-date
             kolab_storage_config::resolve_members($relation);
 
             // remove and add links
-            $members = array_diff($relation['members'], (array)$remove);
+            $members = array($object_uri);
             $members = array_unique(array_merge($members, $links));
 
-            // make sure the object_uri is still a member
-            if (!in_array($object_uri, $members)) {
-                $members[$object_uri];
-            }
-
             // remove relation if no other members remain
             if (count($members) <= 1) {
-                $done = $this->delete($relation['uid']);
+                $done = $this->delete($relation);
             }
             // update relation object if members changed
             else if (count(array_diff($members, $relation['members'])) || count(array_diff($relation['members'], $members))) {
                 $relation['members'] = $members;
                 $done = $this->save($relation, 'relation');
                 $links = array();
             }
             // no changes, we're happy
             else {
-                $done = true;
+                $done  = true;
                 $links = array();
             }
         }
 
         // create a new relation
         if (!$done && !empty($links)) {
             $relation = array(
                 'members'  => array_merge($links, array($object_uri)),
                 'category' => 'generic',
             );
 
-            $ret = $this->save($relation, 'relation');
+            $done = $this->save($relation, 'relation');
         }
 
-        return $ret;
+        return $done;
     }
 
     /**
      * Find relation objects referring to specified note
      */
     public function get_relations_for_member($uid, $reltype = 'generic')
     {
         $default = true;
         $filter  = array(
             array('type', '=', 'relation'),
             array('category', '=', $reltype),
             array('member', '=', $uid),
         );
 
-        return $this->get_objects($filter, $default, 100);
+        return $this->get_objects($filter, $default, self::MAX_RELATIONS);
     }
 
     /**
      * Find kolab objects assigned to specified e-mail message
      *
      * @param rcube_message $message E-mail message
      * @param string        $folder  Folder name
      * @param string        $type    Result objects type
      *
      * @return array List of kolab objects
      */
     public function get_message_relations($message, $folder, $type)
     {
         static $_cache = array();
 
         $result  = array();
         $uids    = array();
         $default = true;
         $uri     = self::get_message_uri($message, $folder);
         $filter  = array(
             array('type', '=', 'relation'),
             array('category', '=', 'generic'),
         );
 
         // query by message-id
         $member_id = $message->get('message-id', false);
         if (empty($member_id)) {
             // derive message identifier from URI
             $member_id = md5($uri);
         }
         $filter[] = array('member', '=', $member_id);
 
         if (!isset($_cache[$uri])) {
             // get UIDs of related groupware objects
             foreach ($this->get_objects($filter, $default) as $relation) {
                 // we don't need to update members if the URI is found
                 if (!in_array($uri, $relation['members'])) {
                     // update members...
                     $messages = kolab_storage_config::resolve_members($relation);
                     // ...and check again
                     if (empty($messages[$folder]) || !in_array($message->uid, $messages[$folder])) {
                         continue;
                     }
                 }
 
                 // find groupware object UID(s)
                 foreach ($relation['members'] as $member) {
                     if (strpos($member, 'urn:uuid:') === 0) {
                         $uids[] = substr($member, 9);
                     }
                 }
             }
 
             // remember this lookup
             $_cache[$uri] = $uids;
         }
         else {
             $uids = $_cache[$uri];
         }
 
         // get kolab objects of specified type
         if (!empty($uids)) {
             $query  = array(array('uid', '=', array_unique($uids)));
-            $result = kolab_storage::select($query, $type);
+            $result = kolab_storage::select($query, $type, count($uids));
         }
 
         return $result;
     }
 
     /**
      * Build a URI representing the given message reference
      */
     public static function get_message_uri($headers, $folder)
     {
         $params = array(
             'folder' => $headers->folder ?: $folder,
             'uid'    => $headers->uid,
         );
 
         if (($messageid = $headers->get('message-id', false)) && ($date = $headers->get('date', false))) {
             $params['message-id'] = $messageid;
             $params['date']       = $date;
 
             if ($subject = $headers->get('subject')) {
                 $params['subject'] = $subject;
             }
         }
 
         return self::build_member_url($params);
     }
 
     /**
      * Resolve the email message reference from the given URI
      */
-    public function get_message_reference($uri, $rel = null)
+    public static function get_message_reference($uri, $rel = null)
     {
         if ($linkref = self::parse_member_url($uri)) {
             $linkref['subject'] = $linkref['params']['subject'];
             $linkref['uri']     = $uri;
 
             $rcmail = rcube::get_instance();
             if (method_exists($rcmail, 'url')) {
                 $linkref['mailurl'] = $rcmail->url(array(
                     'task'   => 'mail',
                     'action' => 'show',
                     'mbox'   => $linkref['folder'],
                     'uid'    => $linkref['uid'],
                     'rel'    => $rel,
                 ));
             }
 
             unset($linkref['params']);
         }
 
         return $linkref;
     }
 }
diff --git a/plugins/libkolab/lib/kolab_storage_folder.php b/plugins/libkolab/lib/kolab_storage_folder.php
index 822c4d97..00d02efc 100644
--- a/plugins/libkolab/lib/kolab_storage_folder.php
+++ b/plugins/libkolab/lib/kolab_storage_folder.php
@@ -1,1173 +1,1196 @@
 <?php
 
 /**
  * The kolab_storage_folder class represents an IMAP folder on the Kolab server.
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  * @author Aleksander Machniak <machniak@kolabsys.com>
  *
  * Copyright (C) 2012-2013, 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_storage_folder extends kolab_storage_folder_api
 {
     /**
      * The kolab_storage_cache instance for caching operations
      * @var object
      */
     public $cache;
 
     /**
      * Indicate validity status
      * @var boolean
      */
     public $valid = false;
 
     protected $error = 0;
 
     protected $resource_uri;
 
 
     /**
      * Default constructor
      *
      * @param string The folder name/path
      * @param string Expected folder type
      */
     function __construct($name, $type = null, $type_annotation = null)
     {
         parent::__construct($name);
         $this->imap->set_options(array('skip_deleted' => true));
         $this->set_folder($name, $type, $type_annotation);
     }
 
 
     /**
      * Set the IMAP folder this instance connects to
      *
      * @param string The folder name/path
      * @param string Expected folder type
      * @param string Optional folder type if known
      */
     public function set_folder($name, $type = null, $type_annotation = null)
     {
+        $this->name = $name;
+
         if (empty($type_annotation)) {
-            $type_annotation = kolab_storage::folder_type($name);
+            $type_annotation = $this->get_type();
         }
 
         $oldtype = $this->type;
         list($this->type, $suffix) = explode('.', $type_annotation);
         $this->default      = $suffix == 'default';
         $this->subtype      = $this->default ? '' : $suffix;
-        $this->name         = $name;
         $this->id           = kolab_storage::folder_id($name);
         $this->valid        = !empty($this->type) && $this->type != 'mail' && (!$type || $this->type == $type);
 
         if (!$this->valid) {
             $this->error = $this->imap->get_error_code() < 0 ? kolab_storage::ERROR_IMAP_CONN : kolab_storage::ERROR_INVALID_FOLDER;
         }
 
         // reset cached object properties
         $this->owner = $this->namespace = $this->resource_uri = $this->info = $this->idata = null;
 
         // get a new cache instance if folder type changed
         if (!$this->cache || $this->type != $oldtype)
             $this->cache = kolab_storage_cache::factory($this);
         else
             $this->cache->set_folder($this);
 
         $this->imap->set_folder($this->name);
     }
 
     /**
      * Returns code of last error
      *
      * @return int Error code
      */
     public function get_error()
     {
         return $this->error ?: $this->cache->get_error();
     }
 
     /**
      * Check IMAP connection error state
      */
     public function check_error()
     {
         if (($err_code = $this->imap->get_error_code()) < 0) {
             $this->error = kolab_storage::ERROR_IMAP_CONN;
             if (($res_code = $this->imap->get_response_code()) !== 0 && in_array($res_code, array(rcube_storage::NOPERM, rcube_storage::READONLY))) {
                 $this->error = kolab_storage::ERROR_NO_PERMISSION;
             }
         }
 
         return $this->error;
     }
 
     /**
      * Compose a unique resource URI for this IMAP folder
      */
     public function get_resource_uri()
     {
         if (!empty($this->resource_uri)) {
             return $this->resource_uri;
         }
 
         // strip namespace prefix from folder name
         $ns     = $this->get_namespace();
         $nsdata = $this->imap->get_namespace($ns);
 
         if (is_array($nsdata[0]) && strlen($nsdata[0][0]) && strpos($this->name, $nsdata[0][0]) === 0) {
             $subpath = substr($this->name, strlen($nsdata[0][0]));
             if ($ns == 'other') {
                 list($user, $suffix) = explode($nsdata[0][1], $subpath, 2);
                 $subpath = $suffix;
             }
         }
         else {
             $subpath = $this->name;
         }
 
         // compose fully qualified ressource uri for this instance
         $this->resource_uri = 'imap://' . urlencode($this->get_owner(true)) . '@' . $this->imap->options['host'] . '/' . $subpath;
         return $this->resource_uri;
     }
 
     /**
      * Helper method to extract folder UID metadata
      *
      * @return string Folder's UID
      */
     public function get_uid()
     {
         // UID is defined in folder METADATA
         $metakeys = array(kolab_storage::UID_KEY_SHARED, kolab_storage::UID_KEY_CYRUS);
-        $metadata = $this->get_metadata($metakeys);
+        $metadata = $this->get_metadata();
 
         if ($metadata !== null) {
             foreach ($metakeys as $key) {
                 if ($uid = $metadata[$key]) {
                     return $uid;
                 }
             }
 
             // generate a folder UID and set it to IMAP
             $uid = rtrim(chunk_split(md5($this->name . $this->get_owner() . uniqid('-', true)), 12, '-'), '-');
             if ($this->set_uid($uid)) {
                 return $uid;
             }
         }
 
         $this->check_error();
 
         // create hash from folder name if we can't write the UID metadata
         return md5($this->name . $this->get_owner());
     }
 
     /**
      * Helper method to set an UID value to the given IMAP folder instance
      *
      * @param string Folder's UID
      * @return boolean True on succes, False on failure
      */
     public function set_uid($uid)
     {
         $success = $this->set_metadata(array(kolab_storage::UID_KEY_SHARED => $uid));
 
         $this->check_error();
         return $success;
     }
 
     /**
      * Compose a folder Etag identifier
      */
     public function get_ctag()
     {
         $fdata = $this->get_imap_data();
         $this->check_error();
         return sprintf('%d-%d-%d', $fdata['UIDVALIDITY'], $fdata['HIGHESTMODSEQ'], $fdata['UIDNEXT']);
     }
 
     /**
      * Check activation status of this folder
      *
      * @return boolean True if enabled, false if not
      */
     public function is_active()
     {
         return kolab_storage::folder_is_active($this->name);
     }
 
     /**
      * Change activation status of this folder
      *
      * @param boolean The desired subscription status: true = active, false = not active
      *
      * @return True on success, false on error
      */
     public function activate($active)
     {
         return $active ? kolab_storage::folder_activate($this->name) : kolab_storage::folder_deactivate($this->name);
     }
 
     /**
      * Check subscription status of this folder
      *
      * @return boolean True if subscribed, false if not
      */
     public function is_subscribed()
     {
         return kolab_storage::folder_is_subscribed($this->name);
     }
 
     /**
      * Change subscription status of this folder
      *
      * @param boolean The desired subscription status: true = subscribed, false = not subscribed
      *
      * @return True on success, false on error
      */
     public function subscribe($subscribed)
     {
         return $subscribed ? kolab_storage::folder_subscribe($this->name) : kolab_storage::folder_unsubscribe($this->name);
     }
 
     /**
      * Get number of objects stored in this folder
      *
      * @param mixed  Pseudo-SQL query as list of filter parameter triplets
      *    or string with object type (e.g. contact, event, todo, journal, note, configuration)
      * @return integer The number of objects of the given type
      * @see self::select()
      */
     public function count($query = null)
     {
         if (!$this->valid) {
             return 0;
         }
 
         // synchronize cache first
         $this->cache->synchronize();
 
         return $this->cache->count($this->_prepare_query($query));
     }
 
 
     /**
      * List all Kolab objects of the given type
      *
      * @param string  $type Object type (e.g. contact, event, todo, journal, note, configuration)
      * @return array  List of Kolab data objects (each represented as hash array)
      */
     public function get_objects($type = null)
     {
         if (!$type) $type = $this->type;
 
         if (!$this->valid) {
             return array();
         }
 
         // synchronize caches
         $this->cache->synchronize();
 
         // fetch objects from cache
         return $this->cache->select($this->_prepare_query($type));
     }
 
 
     /**
      * Select *some* Kolab objects matching the given query
      *
      * @param array Pseudo-SQL query as list of filter parameter triplets
      *   triplet: array('<colname>', '<comparator>', '<value>')
      * @return array List of Kolab data objects (each represented as hash array)
      */
     public function select($query = array())
     {
         if (!$this->valid) {
             return array();
         }
 
         // check query argument
         if (empty($query)) {
             return $this->get_objects();
         }
 
         // synchronize caches
         $this->cache->synchronize();
 
         // fetch objects from cache
         return $this->cache->select($this->_prepare_query($query));
     }
 
 
     /**
      * Getter for object UIDs only
      *
      * @param array Pseudo-SQL query as list of filter parameter triplets
      * @return array List of Kolab object UIDs
      */
     public function get_uids($query = array())
     {
         if (!$this->valid) {
             return array();
         }
 
         // synchronize caches
         $this->cache->synchronize();
 
         // fetch UIDs from cache
         return $this->cache->select($this->_prepare_query($query), true);
     }
 
     /**
      * Setter for ORDER BY and LIMIT parameters for cache queries
      *
      * @param array   List of columns to order by
      * @param integer Limit result set to this length
      * @param integer Offset row
      */
     public function set_order_and_limit($sortcols, $length = null, $offset = 0)
     {
         $this->cache->set_order_by($sortcols);
 
         if ($length !== null) {
             $this->cache->set_limit($length, $offset);
         }
+
+        $this->order_and_limit = array(
+            'cols'   => $sortcols,
+            'limit'  => $length,
+            'offset' => $offset,
+        );
     }
 
     /**
      * Helper method to sanitize query arguments
      */
     private function _prepare_query($query)
     {
         // string equals type query
         // FIXME: should not be called this way!
         if (is_string($query)) {
             return $this->cache->has_type_col() && !empty($query) ? array(array('type','=',$query)) : array();
         }
 
         foreach ((array)$query as $i => $param) {
             if ($param[0] == 'type' && !$this->cache->has_type_col()) {
                 unset($query[$i]);
             }
             else if (($param[0] == 'dtstart' || $param[0] == 'dtend' || $param[0] == 'changed')) {
                 if (is_object($param[2]) && is_a($param[2], 'DateTime'))
                     $param[2] = $param[2]->format('U');
                 if (is_numeric($param[2]))
                     $query[$i][2] = date('Y-m-d H:i:s', $param[2]);
             }
         }
 
         return $query;
     }
 
-
     /**
      * Getter for a single Kolab object, identified by its UID
      *
      * @param string $uid  Object UID
      * @param string $type Object type (e.g. contact, event, todo, journal, note, configuration)
      *                     Defaults to folder type
      *
      * @return array The Kolab object represented as hash array
      */
     public function get_object($uid, $type = null)
     {
-        if (!$this->valid) {
+        if (!$this->valid || !$uid) {
             return false;
         }
 
+        $query = array(array('uid', '=', $uid));
+
+        if ($type) {
+            $query[] = array('type', '=', $type);
+        }
+
         // synchronize caches
         $this->cache->synchronize();
 
-        $msguid = $this->cache->uid2msguid($uid);
+        // we don't use cache->get() here because we don't have msguid
+        // yet, using select() is faster
 
-        if ($msguid && ($object = $this->cache->get($msguid, $type))) {
-            return $object;
+        // set order to make sure we get most recent object version
+        // set limit to skip count query
+        $this->cache->set_order_by('msguid DESC');
+        $this->cache->set_limit(1);
+
+        $list = $this->cache->select($this->_prepare_query($query));
+
+        // set the order/limit back to defined value
+        $this->cache->set_order_by($this->order_and_limit['order']);
+        $this->cache->set_limit($this->order_and_limit['limit'], $this->order_and_limit['offset']);
+
+        if (!empty($list) && !empty($list[0])) {
+            return $list[0];
         }
 
         return false;
     }
 
 
     /**
      * Fetch a Kolab object attachment which is stored in a separate part
      * of the mail MIME message that represents the Kolab record.
      *
      * @param string   Object's UID
      * @param string   The attachment's mime number
      * @param string   IMAP folder where message is stored;
      *                 If set, that also implies that the given UID is an IMAP UID
      * @param bool     True to print the part content
      * @param resource File pointer to save the message part
      * @param boolean  Disables charset conversion
      *
      * @return mixed  The attachment content as binary string
      */
     public function get_attachment($uid, $part, $mailbox = null, $print = false, $fp = null, $skip_charset_conv = false)
     {
         if ($this->valid && ($msguid = ($mailbox ? $uid : $this->cache->uid2msguid($uid)))) {
             $this->imap->set_folder($mailbox ? $mailbox : $this->name);
 
             if (substr($part, 0, 2) == 'i:') {
                 // attachment data is stored in XML
                 if ($object = $this->cache->get($msguid)) {
                     // load data from XML (attachment content is not stored in cache)
                     if ($object['_formatobj'] && isset($object['_size'])) {
                         $object['_attachments'] = array();
                         $object['_formatobj']->get_attachments($object);
                     }
 
                     foreach ($object['_attachments'] as $attach) {
                         if ($attach['id'] == $part) {
                             if ($print)   echo $attach['content'];
                             else if ($fp) fwrite($fp, $attach['content']);
                             else          return $attach['content'];
                             return true;
                         }
                     }
                 }
             }
             else {
                 // return message part from IMAP directly
                 return $this->imap->get_message_part($msguid, $part, null, $print, $fp, $skip_charset_conv);
             }
         }
 
         return null;
     }
 
 
     /**
      * Fetch the mime message from the storage server and extract
      * the Kolab groupware object from it
      *
      * @param string The IMAP message UID to fetch
      * @param string The object type expected (use wildcard '*' to accept all types)
      * @param string The folder name where the message is stored
      *
      * @return mixed Hash array representing the Kolab object, a kolab_format instance or false if not found
      */
     public function read_object($msguid, $type = null, $folder = null)
     {
         if (!$this->valid) {
             return false;
         }
 
         if (!$type) $type = $this->type;
         if (!$folder) $folder = $this->name;
 
         $this->imap->set_folder($folder);
 
         $this->cache->bypass(true);
         $message = new rcube_message($msguid);
         $this->cache->bypass(false);
 
         // Message doesn't exist?
         if (empty($message->headers)) {
             return false;
         }
 
         // extract the X-Kolab-Type header from the XML attachment part if missing
         if (empty($message->headers->others['x-kolab-type'])) {
             foreach ((array)$message->attachments as $part) {
                 if (strpos($part->mimetype, kolab_format::KTYPE_PREFIX) === 0) {
                     $message->headers->others['x-kolab-type'] = $part->mimetype;
                     break;
                 }
             }
         }
         // fix buggy messages stating the X-Kolab-Type header twice
         else if (is_array($message->headers->others['x-kolab-type'])) {
             $message->headers->others['x-kolab-type'] = reset($message->headers->others['x-kolab-type']);
         }
 
         // no object type header found: abort
         if (empty($message->headers->others['x-kolab-type'])) {
             rcube::raise_error(array(
                 'code' => 600,
                 'type' => 'php',
                 'file' => __FILE__,
                 'line' => __LINE__,
                 'message' => "No X-Kolab-Type information found in message $msguid ($this->name).",
             ), true);
             return false;
         }
 
         $object_type  = kolab_format::mime2object_type($message->headers->others['x-kolab-type']);
         $content_type = kolab_format::KTYPE_PREFIX . $object_type;
 
         // check object type header and abort on mismatch
         if ($type != '*' && $object_type != $type)
             return false;
 
         $attachments = array();
 
         // get XML part
         foreach ((array)$message->attachments as $part) {
             if (!$xml && ($part->mimetype == $content_type || preg_match('!application/([a-z.]+\+)?xml!i', $part->mimetype))) {
                 $xml = $message->get_part_body($part->mime_id, true);
             }
             else if ($part->filename || $part->content_id) {
                 $key  = $part->content_id ? trim($part->content_id, '<>') : $part->filename;
                 $size = null;
 
                 // Use Content-Disposition 'size' as for the Kolab Format spec.
                 if (isset($part->d_parameters['size'])) {
                     $size = $part->d_parameters['size'];
                 }
                 // we can trust part size only if it's not encoded
                 else if ($part->encoding == 'binary' || $part->encoding == '7bit' || $part->encoding == '8bit') {
                     $size = $part->size;
                 }
 
                 $attachments[$key] = array(
                     'id'       => $part->mime_id,
                     'name'     => $part->filename,
                     'mimetype' => $part->mimetype,
                     'size'     => $size,
                 );
             }
         }
 
         if (!$xml) {
             rcube::raise_error(array(
                 'code' => 600,
                 'type' => 'php',
                 'file' => __FILE__,
                 'line' => __LINE__,
                 'message' => "Could not find Kolab data part in message $msguid ($this->name).",
             ), true);
             return false;
         }
 
         // check kolab format version
         $format_version = $message->headers->others['x-kolab-mime-version'];
         if (empty($format_version)) {
             list($xmltype, $subtype) = explode('.', $object_type);
             $xmlhead = substr($xml, 0, 512);
 
             // detect old Kolab 2.0 format
             if (strpos($xmlhead, '<' . $xmltype) !== false && strpos($xmlhead, 'xmlns=') === false)
                 $format_version = '2.0';
             else
                 $format_version = '3.0'; // assume 3.0
         }
 
         // get Kolab format handler for the given type
         $format = kolab_format::factory($object_type, $format_version);
 
         if (is_a($format, 'PEAR_Error'))
             return false;
 
         // load Kolab object from XML part
         $format->load($xml);
 
         if ($format->is_valid()) {
             $object = $format->to_array(array('_attachments' => $attachments));
             $object['_type']      = $object_type;
             $object['_msguid']    = $msguid;
             $object['_mailbox']   = $this->name;
             $object['_formatobj'] = $format;
 
             return $object;
         }
         else {
             // try to extract object UID from XML block
             if (preg_match('!<uid>(.+)</uid>!Uims', $xml, $m))
                 $msgadd = " UID = " . trim(strip_tags($m[1]));
 
             rcube::raise_error(array(
                 'code' => 600,
                 'type' => 'php',
                 'file' => __FILE__,
                 'line' => __LINE__,
                 'message' => "Could not parse Kolab object data in message $msguid ($this->name)." . $msgadd,
             ), true);
         }
 
         return false;
     }
 
     /**
      * Save an object in this folder.
      *
      * @param array  $object The array that holds the data of the object.
      * @param string $type   The type of the kolab object.
      * @param string $uid    The UID of the old object if it existed before
      *
      * @return mixed False on error or IMAP message UID on success
      */
     public function save(&$object, $type = null, $uid = null)
     {
         if (!$this->valid) {
             return false;
         }
 
         if (!$type)
             $type = $this->type;
 
         // copy attachments from old message
         $copyfrom = $object['_copyfrom'] ?: $object['_msguid'];
         if (!empty($copyfrom) && ($old = $this->cache->get($copyfrom, $type, $object['_mailbox']))) {
             foreach ((array)$old['_attachments'] as $key => $att) {
                 if (!isset($object['_attachments'][$key])) {
                     $object['_attachments'][$key] = $old['_attachments'][$key];
                 }
                 // unset deleted attachment entries
                 if ($object['_attachments'][$key] == false) {
                     unset($object['_attachments'][$key]);
                 }
                 // load photo.attachment from old Kolab2 format to be directly embedded in xcard block
                 else if ($type == 'contact' && ($key == 'photo.attachment' || $key == 'kolab-picture.png') && $att['id']) {
                     if (!isset($object['photo']))
                         $object['photo'] = $this->get_attachment($copyfrom, $att['id'], $object['_mailbox']);
                     unset($object['_attachments'][$key]);
                 }
             }
         }
 
         // save contact photo to attachment for Kolab2 format
         if (kolab_storage::$version == '2.0' && $object['photo']) {
             $attkey = 'kolab-picture.png';  // this file name is hard-coded in libkolab/kolabformatV2/contact.cpp
             $object['_attachments'][$attkey] = array(
                 'mimetype'=> rcube_mime::image_content_type($object['photo']),
                 'content' => preg_match('![^a-z0-9/=+-]!i', $object['photo']) ? $object['photo'] : base64_decode($object['photo']),
             );
         }
 
         // process attachments
         if (is_array($object['_attachments'])) {
             $numatt = count($object['_attachments']);
             foreach ($object['_attachments'] as $key => $attachment) {
                 // FIXME: kolab_storage and Roundcube attachment hooks use different fields!
                 if (empty($attachment['content']) && !empty($attachment['data'])) {
                     $attachment['content'] = $attachment['data'];
                     unset($attachment['data'], $object['_attachments'][$key]['data']);
                 }
 
                 // make sure size is set, so object saved in cache contains this info
                 if (!isset($attachment['size'])) {
                     if (!empty($attachment['content'])) {
                         if (is_resource($attachment['content'])) {
                             // this need to be a seekable resource, otherwise
                             // fstat() failes and we're unable to determine size
                             // here nor in rcube_imap_generic before IMAP APPEND
                             $stat = fstat($attachment['content']);
                             $attachment['size'] = $stat ? $stat['size'] : 0;
                         }
                         else {
                             $attachment['size'] = strlen($attachment['content']);
                         }
                     }
                     else if (!empty($attachment['path'])) {
                         $attachment['size'] = filesize($attachment['path']);
                     }
                     $object['_attachments'][$key] = $attachment;
                 }
 
                 // generate unique keys (used as content-id) for attachments
                 if (is_numeric($key) && $key < $numatt) {
                     // derrive content-id from attachment file name
                     $ext = preg_match('/(\.[a-z0-9]{1,6})$/i', $attachment['name'], $m) ? $m[1] : null;
                     $basename = preg_replace('/[^a-z0-9_.-]/i', '', basename($attachment['name'], $ext));  // to 7bit ascii
                     if (!$basename) $basename = 'noname';
                     $cid = $basename . '.' . microtime(true) . $key . $ext;
 
                     $object['_attachments'][$cid] = $attachment;
                     unset($object['_attachments'][$key]);
                 }
             }
         }
 
         // save recurrence exceptions as individual objects due to lack of support in Kolab v2 format
         if (kolab_storage::$version == '2.0' && $object['recurrence']['EXCEPTIONS']) {
             $this->save_recurrence_exceptions($object, $type);
         }
 
         // check IMAP BINARY extension support for 'file' objects
         // allow configuration to workaround bug in Cyrus < 2.4.17
         $rcmail = rcube::get_instance();
         $binary = $type == 'file' && !$rcmail->config->get('kolab_binary_disable') && $this->imap->get_capability('BINARY');
 
         // generate and save object message
         if ($raw_msg = $this->build_message($object, $type, $binary, $body_file)) {
             // resolve old msguid before saving
             if ($uid && empty($object['_msguid']) && ($msguid = $this->cache->uid2msguid($uid))) {
                 $object['_msguid'] = $msguid;
                 $object['_mailbox'] = $this->name;
             }
 
             $result = $this->imap->save_message($this->name, $raw_msg, null, false, null, null, $binary);
 
             // update cache with new UID
             if ($result) {
                 $old_uid = $object['_msguid'];
 
                 $object['_msguid'] = $result;
                 $object['_mailbox'] = $this->name;
 
                 if ($old_uid) {
                     // delete old message
                     $this->cache->bypass(true);
                     $this->imap->delete_message($old_uid, $object['_mailbox']);
                     $this->cache->bypass(false);
                 }
 
                 // insert/update message in cache
                 $this->cache->save($result, $object, $old_uid);
             }
 
             // remove temp file
             if ($body_file) {
                 @unlink($body_file);
             }
         }
 
         return $result;
     }
 
     /**
      * Save recurrence exceptions as individual objects.
      * The Kolab v2 format doesn't allow us to save fully embedded exception objects.
      *
      * @param array Hash array with event properties
      * @param string Object type
      */
     private function save_recurrence_exceptions(&$object, $type = null)
     {
         if ($object['recurrence']['EXCEPTIONS']) {
             $exdates = array();
             foreach ((array)$object['recurrence']['EXDATE'] as $exdate) {
                 $key = is_a($exdate, 'DateTime') ? $exdate->format('Y-m-d') : strval($exdate);
                 $exdates[$key] = 1;
             }
 
             // save every exception as individual object
             foreach((array)$object['recurrence']['EXCEPTIONS'] as $exception) {
                 $exception['uid'] = self::recurrence_exception_uid($object['uid'], $exception['start']->format('Ymd'));
                 $exception['sequence'] = $object['sequence'] + 1;
 
                 if ($exception['thisandfuture']) {
                     $exception['recurrence'] = $object['recurrence'];
 
                     // adjust the recurrence duration of the exception
                     if ($object['recurrence']['COUNT']) {
                         $recurrence = new kolab_date_recurrence($object['_formatobj']);
                         if ($end = $recurrence->end()) {
                             unset($exception['recurrence']['COUNT']);
                             $exception['recurrence']['UNTIL'] = $end;
                         }
                     }
 
                     // set UNTIL date if we have a thisandfuture exception
                     $untildate = clone $exception['start'];
                     $untildate->sub(new DateInterval('P1D'));
                     $object['recurrence']['UNTIL'] = $untildate;
                     unset($object['recurrence']['COUNT']);
                 }
                 else {
                     if (!$exdates[$exception['start']->format('Y-m-d')])
                         $object['recurrence']['EXDATE'][] = clone $exception['start'];
                     unset($exception['recurrence']);
                 }
 
                 unset($exception['recurrence']['EXCEPTIONS'], $exception['_formatobj'], $exception['_msguid']);
                 $this->save($exception, $type, $exception['uid']);
             }
 
             unset($object['recurrence']['EXCEPTIONS']);
         }
     }
 
     /**
      * Generate an object UID with the given recurrence-ID in a way that it is
      * unique (the original UID is not a substring) but still recoverable.
      */
     private static function recurrence_exception_uid($uid, $recurrence_id)
     {
         $offset = -2;
         return substr($uid, 0, $offset) . '-' . $recurrence_id . '-' . substr($uid, $offset);
     }
 
     /**
      * Delete the specified object from this folder.
      *
      * @param  mixed   $object  The Kolab object to delete or object UID
      * @param  boolean $expunge Should the folder be expunged?
      *
      * @return boolean True if successful, false on error
      */
     public function delete($object, $expunge = true)
     {
         if (!$this->valid) {
             return false;
         }
 
         $msguid = is_array($object) ? $object['_msguid'] : $this->cache->uid2msguid($object);
         $success = false;
 
         $this->cache->bypass(true);
 
         if ($msguid && $expunge) {
             $success = $this->imap->delete_message($msguid, $this->name);
         }
         else if ($msguid) {
             $success = $this->imap->set_flag($msguid, 'DELETED', $this->name);
         }
 
         $this->cache->bypass(false);
 
         if ($success) {
             $this->cache->set($msguid, false);
         }
 
         return $success;
     }
 
 
     /**
      *
      */
     public function delete_all()
     {
         if (!$this->valid) {
             return false;
         }
 
         $this->cache->purge();
         $this->cache->bypass(true);
         $result = $this->imap->clear_folder($this->name);
         $this->cache->bypass(false);
 
         return $result;
     }
 
 
     /**
      * Restore a previously deleted object
      *
      * @param string Object UID
      * @return mixed Message UID on success, false on error
      */
     public function undelete($uid)
     {
         if (!$this->valid) {
             return false;
         }
 
         if ($msguid = $this->cache->uid2msguid($uid, true)) {
             $this->cache->bypass(true);
             $result = $this->imap->set_flag($msguid, 'UNDELETED', $this->name);
             $this->cache->bypass(false);
 
             if ($result) {
                 return $msguid;
             }
         }
 
         return false;
     }
 
 
     /**
      * Move a Kolab object message to another IMAP folder
      *
      * @param string Object UID
      * @param string IMAP folder to move object to
      * @return boolean True on success, false on failure
      */
     public function move($uid, $target_folder)
     {
         if (!$this->valid) {
             return false;
         }
 
         if (is_string($target_folder))
             $target_folder = kolab_storage::get_folder($target_folder);
 
         if ($msguid = $this->cache->uid2msguid($uid)) {
             $this->cache->bypass(true);
             $result = $this->imap->move_message($msguid, $target_folder->name, $this->name);
             $this->cache->bypass(false);
 
             if ($result) {
-                $this->cache->move($msguid, $uid, $target_folder);
+                $new_uid = ($copyuid = $this->imap->conn->data['COPYUID']) ? $copyuid[1] : null;
+                $this->cache->move($msguid, $uid, $target_folder, $new_uid);
                 return true;
             }
             else {
                 rcube::raise_error(array(
                     'code' => 600, 'type' => 'php',
                     'file' => __FILE__, 'line' => __LINE__,
                     'message' => "Failed to move message $msguid to $target_folder: " . $this->imap->get_error_str(),
                 ), true);
             }
         }
 
         return false;
     }
 
 
     /**
      * Creates source of the configuration object message
      *
      * @param array  $object    The array that holds the data of the object.
      * @param string $type      The type of the kolab object.
      * @param bool   $binary    Enables use of binary encoding of attachment(s)
      * @param string $body_file Reference to filename of message body
      *
      * @return mixed Message as string or array with two elements
      *               (one for message file path, second for message headers)
      */
     private function build_message(&$object, $type, $binary, &$body_file)
     {
         // load old object to preserve data we don't understand/process
         if (is_object($object['_formatobj']))
             $format = $object['_formatobj'];
         else if ($object['_msguid'] && ($old = $this->cache->get($object['_msguid'], $type, $object['_mailbox'])))
             $format = $old['_formatobj'];
 
         // create new kolab_format instance
         if (!$format)
             $format = kolab_format::factory($type, kolab_storage::$version);
 
         if (PEAR::isError($format))
             return false;
 
         $format->set($object);
         $xml = $format->write(kolab_storage::$version);
         $object['uid'] = $format->uid;  // read UID from format
         $object['_formatobj'] = $format;
 
         if (empty($xml) || !$format->is_valid() || empty($object['uid'])) {
             return false;
         }
 
         $mime     = new Mail_mime("\r\n");
         $rcmail   = rcube::get_instance();
         $headers  = array();
         $files    = array();
         $part_id  = 1;
         $encoding = $binary ? 'binary' : 'base64';
 
         if ($user_email = $rcmail->get_user_email()) {
             $headers['From'] = $user_email;
             $headers['To'] = $user_email;
         }
         $headers['Date'] = date('r');
         $headers['X-Kolab-Type'] = kolab_format::KTYPE_PREFIX . $type;
         $headers['X-Kolab-Mime-Version'] = kolab_storage::$version;
         $headers['Subject'] = $object['uid'];
 //        $headers['Message-ID'] = $rcmail->gen_message_id();
         $headers['User-Agent'] = $rcmail->config->get('useragent');
 
         // Check if we have enough memory to handle the message in it
         // It's faster than using files, so we'll do this if we only can
         if (!empty($object['_attachments']) && ($mem_limit = parse_bytes(ini_get('memory_limit'))) > 0) {
             $memory = function_exists('memory_get_usage') ? memory_get_usage() : 16*1024*1024; // safe value: 16MB
 
             foreach ($object['_attachments'] as $attachment) {
                 $memory += $attachment['size'];
             }
 
             // 1.33 is for base64, we need at least 4x more memory than the message size
             if ($memory * ($binary ? 1 : 1.33) * 4 > $mem_limit) {
                 $marker   = '%%%~~~' . md5(microtime(true) . $memory) . '~~~%%%';
                 $is_file  = true;
                 $temp_dir = unslashify($rcmail->config->get('temp_dir'));
                 $mime->setParam('delay_file_io', true);
             }
         }
 
         $mime->headers($headers);
         $mime->setTXTBody("This is a Kolab Groupware object. "
             . "To view this object you will need an email client that understands the Kolab Groupware format. "
             . "For a list of such email clients please visit http://www.kolab.org/\n\n");
 
         $ctype = kolab_storage::$version == '2.0' ? $format->CTYPEv2 : $format->CTYPE;
         // Convert new lines to \r\n, to wrokaround "NO Message contains bare newlines"
         // when APPENDing from temp file
         $xml = preg_replace('/\r?\n/', "\r\n", $xml);
 
         $mime->addAttachment($xml,  // file
             $ctype,                 // content-type
             'kolab.xml',            // filename
             false,                  // is_file
             '8bit',                 // encoding
             'attachment',           // disposition
             RCUBE_CHARSET           // charset
         );
         $part_id++;
 
         // save object attachments as separate parts
         foreach ((array)$object['_attachments'] as $key => $att) {
             if (empty($att['content']) && !empty($att['id'])) {
                 // @TODO: use IMAP CATENATE to skip attachment fetch+push operation
                 $msguid = $object['_copyfrom'] ?: ($object['_msguid'] ?: $object['uid']);
                 if ($is_file) {
                     $att['path'] = tempnam($temp_dir, 'rcmAttmnt');
                     if (($fp = fopen($att['path'], 'w')) && $this->get_attachment($msguid, $att['id'], $object['_mailbox'], false, $fp, true)) {
                         fclose($fp);
                     }
                     else {
                         return false;
                     }
                 }
                 else {
                     $att['content'] = $this->get_attachment($msguid, $att['id'], $object['_mailbox'], false, null, true);
                 }
             }
 
             $headers = array('Content-ID' => Mail_mimePart::encodeHeader('Content-ID', '<' . $key . '>', RCUBE_CHARSET, 'quoted-printable'));
             $name = !empty($att['name']) ? $att['name'] : $key;
 
             // To store binary files we can use faster method
             // without writting full message content to a temporary file but
             // directly to IMAP, see rcube_imap_generic::append().
             // I.e. use file handles where possible
             if (!empty($att['path'])) {
                 if ($is_file && $binary) {
                     $files[] = fopen($att['path'], 'r');
                     $mime->addAttachment($marker, $att['mimetype'], $name, false, $encoding, 'attachment', '', '', '', null, null, '', RCUBE_CHARSET, $headers);
                 }
                 else {
                     $mime->addAttachment($att['path'], $att['mimetype'], $name, true, $encoding, 'attachment', '', '', '', null, null, '', RCUBE_CHARSET, $headers);
                 }
             }
             else {
                 if (is_resource($att['content']) && $is_file && $binary) {
                     $files[] = $att['content'];
                     $mime->addAttachment($marker, $att['mimetype'], $name, false, $encoding, 'attachment', '', '', '', null, null, '', RCUBE_CHARSET, $headers);
                 }
                 else {
                     if (is_resource($att['content'])) {
                         @rewind($att['content']);
                         $att['content'] = stream_get_contents($att['content']);
                     }
                     $mime->addAttachment($att['content'], $att['mimetype'], $name, false, $encoding, 'attachment', '', '', '', null, null, '', RCUBE_CHARSET, $headers);
                 }
             }
 
             $object['_attachments'][$key]['id'] = ++$part_id;
         }
 
         if (!$is_file || !empty($files)) {
             $message = $mime->getMessage();
         }
 
         // parse message and build message array with
         // attachment file pointers in place of file markers
         if (!empty($files)) {
             $message = explode($marker, $message);
             $tmp     = array();
 
             foreach ($message as $msg_part) {
                 $tmp[] = $msg_part;
                 if ($file = array_shift($files)) {
                     $tmp[] = $file;
                 }
             }
             $message = $tmp;
         }
         // write complete message body into temp file
         else if ($is_file) {
             // use common temp dir
             $body_file = tempnam($temp_dir, 'rcmMsg');
 
             if (PEAR::isError($mime_result = $mime->saveMessageBody($body_file))) {
                 rcube::raise_error(array('code' => 650, 'type' => 'php',
                     'file' => __FILE__, 'line' => __LINE__,
                     'message' => "Could not create message: ".$mime_result->getMessage()),
                     true, false);
                 return false;
             }
 
             $message = array(trim($mime->txtHeaders()) . "\r\n\r\n", fopen($body_file, 'r'));
         }
 
         return $message;
     }
 
 
     /**
      * Triggers any required updates after changes within the
      * folder. This is currently only required for handling free/busy
      * information with Kolab.
      *
      * @return boolean|PEAR_Error True if successfull.
      */
     public function trigger()
     {
         $owner = $this->get_owner();
         $result = false;
 
         switch($this->type) {
         case 'event':
             if ($this->get_namespace() == 'personal') {
                 $result = $this->trigger_url(
                     sprintf('%s/trigger/%s/%s.pfb',
                         kolab_storage::get_freebusy_server(),
                         urlencode($owner),
                         urlencode($this->imap->mod_folder($this->name))
                     ),
                     $this->imap->options['user'],
                     $this->imap->options['password']
                 );
             }
             break;
 
         default:
             return true;
         }
 
         if ($result && is_object($result) && is_a($result, 'PEAR_Error')) {
             return PEAR::raiseError(sprintf("Failed triggering folder %s. Error was: %s",
                                             $this->name, $result->getMessage()));
         }
 
         return $result;
     }
 
     /**
      * Triggers a URL.
      *
      * @param string $url          The URL to be triggered.
      * @param string $auth_user    Username to authenticate with
      * @param string $auth_passwd  Password for basic auth
      * @return boolean|PEAR_Error  True if successfull.
      */
     private function trigger_url($url, $auth_user = null, $auth_passwd = null)
     {
         try {
             $request = libkolab::http_request($url);
 
             // set authentication credentials
             if ($auth_user && $auth_passwd)
                 $request->setAuth($auth_user, $auth_passwd);
 
             $result = $request->send();
             // rcube::write_log('trigger', $result->getBody());
         }
         catch (Exception $e) {
             return PEAR::raiseError($e->getMessage());
         }
 
         return true;
     }
-
 }
-
diff --git a/plugins/libkolab/lib/kolab_storage_folder_api.php b/plugins/libkolab/lib/kolab_storage_folder_api.php
index 0b9091f2..fd5b53e0 100644
--- a/plugins/libkolab/lib/kolab_storage_folder_api.php
+++ b/plugins/libkolab/lib/kolab_storage_folder_api.php
@@ -1,361 +1,376 @@
 <?php
 
 /**
  * Abstract interface class for Kolab storage IMAP folder objects
  *
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2014, 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/>.
  */
 abstract class kolab_storage_folder_api
 {
     /**
      * Folder identifier
      * @var string
      */
     public $id;
 
     /**
      * The folder name.
      * @var string
      */
     public $name;
 
     /**
      * The type of this folder.
      * @var string
      */
     public $type;
 
     /**
      * The subtype of this folder.
      * @var string
      */
     public $subtype;
 
     /**
      * Is this folder set to be the default for its type
      * @var boolean
      */
     public $default = false;
 
     /**
      * List of direct child folders
      * @var array
      */
     public $children = array();
-    
+
     /**
      * Name of the parent folder
      * @var string
      */
     public $parent = '';
 
     protected $imap;
     protected $owner;
     protected $info;
     protected $idata;
     protected $namespace;
+    protected $metadata;
 
 
     /**
      * Private constructor
      */
     protected function __construct($name)
     {
       $this->name = $name;
       $this->id   = kolab_storage::folder_id($name);
       $this->imap = rcube::get_instance()->get_storage();
     }
 
 
     /**
      * Returns the owner of the folder.
      *
      * @param boolean  Return a fully qualified owner name (i.e. including domain for shared folders)
      * @return string  The owner of this folder.
      */
     public function get_owner($fully_qualified = false)
     {
         // return cached value
         if (isset($this->owner))
             return $this->owner;
 
         $info = $this->get_folder_info();
         $rcmail = rcube::get_instance();
 
         switch ($info['namespace']) {
         case 'personal':
             $this->owner = $rcmail->get_user_name();
             break;
 
         case 'shared':
             $this->owner = 'anonymous';
             break;
 
         default:
             list($prefix, $this->owner) = explode($this->imap->get_hierarchy_delimiter(), $info['name']);
             $fully_qualified = true;  // enforce email addresses (backwards compatibility)
             break;
         }
 
         if ($fully_qualified && strpos($this->owner, '@') === false) {
             // extract domain from current user name
             $domain = strstr($rcmail->get_user_name(), '@');
             // fall back to mail_domain config option
             if (empty($domain) && ($mdomain = $rcmail->config->mail_domain($this->imap->options['host']))) {
                 $domain = '@' . $mdomain;
             }
             $this->owner .= $domain;
         }
 
         return $this->owner;
     }
 
 
     /**
      * Getter for the name of the namespace to which the IMAP folder belongs
      *
      * @return string Name of the namespace (personal, other, shared)
      */
     public function get_namespace()
     {
         if (!isset($this->namespace))
             $this->namespace = $this->imap->folder_namespace($this->name);
+
         return $this->namespace;
     }
 
-
     /**
      * Get the display name value of this folder
      *
      * @return string Folder name
      */
     public function get_name()
     {
-        return kolab_storage::object_name($this->name, $this->get_namespace());
+        return kolab_storage::object_name($this->name);
     }
 
-
     /**
      * Getter for the top-end folder name (not the entire path)
      *
      * @return string Name of this folder
      */
     public function get_foldername()
     {
         $parts = explode('/', $this->name);
         return rcube_charset::convert(end($parts), 'UTF7-IMAP');
     }
 
     /**
      * Getter for parent folder path
      *
      * @return string Full path to parent folder
      */
     public function get_parent()
     {
         $path = explode('/', $this->name);
         array_pop($path);
 
         // don't list top-level namespace folder
         if (count($path) == 1 && in_array($this->get_namespace(), array('other', 'shared'))) {
             $path = array();
         }
 
         return join('/', $path);
     }
 
     /**
      * Getter for the Cyrus mailbox identifier corresponding to this folder
      * (e.g. user/john.doe/Calendar/Personal@example.org)
      *
      * @return string Mailbox ID
      */
     public function get_mailbox_id()
     {
         $info = $this->get_folder_info();
         $owner = $this->get_owner();
         list($user, $domain) = explode('@', $owner);
 
         switch ($info['namespace']) {
         case 'personal':
             return sprintf('user/%s/%s@%s', $user, $this->name, $domain);
 
         case 'shared':
             $ns = $this->imap->get_namespace('shared');
             $prefix = is_array($ns) ? $ns[0][0] : '';
             list(, $domain) = explode('@', rcube::get_instance()->get_user_name());
             return substr($this->name, strlen($prefix)) . '@' . $domain;
 
         default:
             $ns = $this->imap->get_namespace('other');
             $prefix = is_array($ns) ? $ns[0][0] : '';
             list($user, $folder) = explode($this->imap->get_hierarchy_delimiter(), substr($info['name'], strlen($prefix)), 2);
             if (strpos($user, '@')) {
                 list($user, $domain) = explode('@', $user);
             }
             return sprintf('user/%s/%s@%s', $user, $folder, $domain);
         }
     }
 
     /**
      * Get the color value stored in metadata
      *
      * @param string Default color value to return if not set
      * @return mixed Color value from IMAP metadata or $default is not set
      */
     public function get_color($default = null)
     {
         // color is defined in folder METADATA
-        $metadata = $this->get_metadata(array(kolab_storage::COLOR_KEY_PRIVATE, kolab_storage::COLOR_KEY_SHARED));
+        $metadata = $this->get_metadata();
         if (($color = $metadata[kolab_storage::COLOR_KEY_PRIVATE]) || ($color = $metadata[kolab_storage::COLOR_KEY_SHARED])) {
             return $color;
         }
 
         return $default;
     }
 
-
     /**
      * Returns IMAP metadata/annotations (GETMETADATA/GETANNOTATION)
+     * supported by kolab_storage
      *
-     * @param array List of metadata keys to read
      * @return array Metadata entry-value hash array on success, NULL on error
      */
-    public function get_metadata($keys)
+    public function get_metadata()
     {
-        $metadata = rcube::get_instance()->get_storage()->get_metadata($this->name, (array)$keys);
-        return $metadata[$this->name];
-    }
+        if ($this->metadata === null) {
+            $this->metadata = kolab_storage::folder_metadata($this->name);
+        }
 
+        return $this->metadata;
+    }
 
     /**
      * Sets IMAP metadata/annotations (SETMETADATA/SETANNOTATION)
      *
      * @param array  $entries Entry-value array (use NULL value as NIL)
      * @return boolean True on success, False on failure
      */
     public function set_metadata($entries)
     {
+        $this->metadata = null;
         return $this->imap->set_metadata($this->name, $entries);
     }
 
-
     /**
      *
      */
     public function get_folder_info()
     {
         if (!isset($this->info))
             $this->info = $this->imap->folder_info($this->name);
 
         return $this->info;
     }
 
     /**
      * Make IMAP folder data available for this folder
      */
     public function get_imap_data()
     {
         if (!isset($this->idata))
             $this->idata = $this->imap->folder_data($this->name);
 
         return $this->idata;
     }
 
+    /**
+     * Returns (full) type of IMAP folder
+     *
+     * @return string Folder type
+     */
+    public function get_type()
+    {
+        $metadata = $this->get_metadata();
+
+        if (!empty($metadata)) {
+            return kolab_storage::folder_select_metadata($metadata);
+        }
+
+        return $this->type;
+    }
 
     /**
      * Get IMAP ACL information for this folder
      *
      * @return string  Permissions as string
      */
     public function get_myrights()
     {
         $rights = $this->info['rights'];
 
         if (!is_array($rights))
             $rights = $this->imap->my_rights($this->name);
 
         return join('', (array)$rights);
     }
 
     /**
      * Helper method to extract folder UID metadata
      *
      * @return string Folder's UID
      */
     public function get_uid()
     {
         // To be implemented by extending classes
         return false;
     }
 
     /**
      * Check activation status of this folder
      *
      * @return boolean True if enabled, false if not
      */
     public function is_active()
     {
         return kolab_storage::folder_is_active($this->name);
     }
 
     /**
      * Change activation status of this folder
      *
      * @param boolean The desired subscription status: true = active, false = not active
      *
      * @return True on success, false on error
      */
     public function activate($active)
     {
         return $active ? kolab_storage::folder_activate($this->name) : kolab_storage::folder_deactivate($this->name);
     }
 
     /**
      * Check subscription status of this folder
      *
      * @return boolean True if subscribed, false if not
      */
     public function is_subscribed()
     {
         return kolab_storage::folder_is_subscribed($this->name);
     }
 
     /**
      * Change subscription status of this folder
      *
      * @param boolean The desired subscription status: true = subscribed, false = not subscribed
      *
      * @return True on success, false on error
      */
     public function subscribe($subscribed)
     {
         return $subscribed ? kolab_storage::folder_subscribe($this->name) : kolab_storage::folder_unsubscribe($this->name);
     }
 
     /**
      * Return folder name as string representation of this object
      *
      * @return string Full IMAP folder name
      */
     public function __toString()
     {
         return $this->name;
     }
 }
-
diff --git a/plugins/libkolab/lib/kolab_storage_folder_user.php b/plugins/libkolab/lib/kolab_storage_folder_user.php
index 7c141c50..7e435002 100644
--- a/plugins/libkolab/lib/kolab_storage_folder_user.php
+++ b/plugins/libkolab/lib/kolab_storage_folder_user.php
@@ -1,135 +1,134 @@
 <?php
 
 /**
  * Class that represents a (virtual) folder in the 'other' namespace
  * implementing a subset of the kolab_storage_folder API.
  *
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2014, 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_storage_folder_user extends kolab_storage_folder_virtual
 {
     protected static $ldapcache = array();
 
     public $ldaprec;
     public $type;
 
     /**
      * Default constructor
      */
     public function __construct($name, $parent = '', $ldaprec = null)
     {
-        parent::__construct($name, $name, 'other', $parent);
+        parent::__construct($name, kolab_storage::object_prettyname($name), 'other', $parent);
 
         if (!empty($ldaprec)) {
             self::$ldapcache[$name] = $this->ldaprec = $ldaprec;
         }
         // use value cached in memory for repeated lookups
         else if (array_key_exists($name, self::$ldapcache)) {
             $this->ldaprec = self::$ldapcache[$name];
         }
         // lookup user in LDAP and set $this->ldaprec
         else if ($ldap = kolab_storage::ldap()) {
             // get domain from current user
             list(,$domain) = explode('@', rcube::get_instance()->get_user_name());
             $this->ldaprec = $ldap->get_user_record(parent::get_foldername($this->name) . '@' . $domain, $_SESSION['imap_host']);
             if (!empty($this->ldaprec)) {
                 $this->ldaprec['kolabtargetfolder'] = $name;
             }
             self::$ldapcache[$name] = $this->ldaprec;
         }
     }
 
     /**
      * Getter for the top-end folder name to be displayed
      *
      * @return string Name of this folder
      */
     public function get_foldername()
     {
         return $this->ldaprec ? ($this->ldaprec['displayname'] ?: $this->ldaprec['name']) :
             parent::get_foldername();
     }
 
     /**
      * Getter for a more informative title of this user folder
      *
      * @return string Title for the given user record
      */
     public function get_title()
     {
-      return trim($this->ldaprec['displayname'] . '; ' . $this->ldaprec['mail'], '; ');
+        return trim($this->ldaprec['displayname'] . '; ' . $this->ldaprec['mail'], '; ');
     }
 
     /**
      * Returns the owner of the folder.
      *
      * @return string  The owner of this folder.
      */
     public function get_owner()
     {
         return $this->ldaprec['mail'];
     }
 
     /**
      * Check subscription status of this folder.
      * Subscription of a virtual user folder depends on the subscriptions of subfolders.
      *
      * @return boolean True if subscribed, false if not
      */
     public function is_subscribed()
     {
         if (!empty($this->type)) {
             $children = $subscribed = 0;
             $delimiter = $this->imap->get_hierarchy_delimiter();
             foreach ((array)kolab_storage::list_folders($this->name . $delimiter, '*', $this->type, false) as $subfolder) {
                 if (kolab_storage::folder_is_subscribed($subfolder)) {
                     $subscribed++;
                 }
                 $children++;
             }
             if ($subscribed > 0) {
                 return $subscribed == $children ? true : 2;
             }
         }
 
         return false;
     }
 
     /**
      * Change subscription status of this folder
      *
      * @param boolean The desired subscription status: true = subscribed, false = not subscribed
      *
      * @return True on success, false on error
      */
     public function subscribe($subscribed)
     {
         $success = false;
 
         // (un)subscribe all subfolders of a given type
         if (!empty($this->type)) {
             $delimiter = $this->imap->get_hierarchy_delimiter();
             foreach ((array)kolab_storage::list_folders($this->name . $delimiter, '*', $this->type, false) as $subfolder) {
                 $success |= ($subscribed ? kolab_storage::folder_subscribe($subfolder) : kolab_storage::folder_unsubscribe($subfolder));
             }
         }
 
         return $success;
     }
-
-}
\ No newline at end of file
+}
diff --git a/plugins/libkolab/lib/kolab_storage_folder_virtual.php b/plugins/libkolab/lib/kolab_storage_folder_virtual.php
index e419ced9..bf3ba554 100644
--- a/plugins/libkolab/lib/kolab_storage_folder_virtual.php
+++ b/plugins/libkolab/lib/kolab_storage_folder_virtual.php
@@ -1,59 +1,59 @@
 <?php
 
 /**
  * Helper class that represents a virtual IMAP folder
  * with a subset of the kolab_storage_folder API.
  *
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2014, 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_storage_folder_virtual extends kolab_storage_folder_api
 {
     public $virtual = true;
 
     protected $displayname;
 
     public function __construct($name, $dispname, $ns, $parent = '')
     {
         parent::__construct($name);
 
         $this->namespace = $ns;
         $this->parent    = $parent;
         $this->displayname = $dispname;
     }
 
     /**
      * Get the display name value of this folder
      *
      * @return string Folder name
      */
     public function get_name()
     {
         return $this->displayname ?: parent::get_name();
     }
 
     /**
      * Get the color value stored in metadata
      *
      * @param string Default color value to return if not set
      * @return mixed Color value from IMAP metadata or $default is not set
      */
     public function get_color($default = null)
     {
         return $default;
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php b/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php
index 556fdc72..fe1af558 100644
--- a/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php
+++ b/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php
@@ -1,1731 +1,1754 @@
 <?php
 
 /**
  * Kolab Groupware driver for the Tasklist plugin
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2012-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 tasklist_kolab_driver extends tasklist_driver
 {
     // features supported by the backend
     public $alarms      = false;
     public $attachments = true;
     public $attendees   = true;
     public $undelete    = false; // task undelete action
     public $alarm_types = array('DISPLAY','AUDIO');
     public $search_more_results;
 
     private $rc;
     private $plugin;
     private $lists;
     private $folders = array();
     private $tasks   = array();
     private $tags    = array();
     private $bonnie_api = false;
 
 
     /**
      * Default constructor
      */
     public function __construct($plugin)
     {
-        $this->rc = $plugin->rc;
+        $this->rc     = $plugin->rc;
         $this->plugin = $plugin;
 
         if (kolab_storage::$version == '2.0') {
             $this->alarm_absolute = false;
         }
 
         // tasklist use fully encoded identifiers
         kolab_storage::$encode_ids = true;
 
         // get configuration for the Bonnie API
         $this->bonnie_api = libkolab::get_bonnie_api();
 
-        $this->_read_lists();
-
         $this->plugin->register_action('folder-acl', array($this, 'folder_acl'));
     }
 
     /**
      * 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)
+        if (isset($this->lists) && !$force) {
             return $this->lists;
+        }
 
         // get all folders that have type "task"
         $folders = kolab_storage::sort_folders(kolab_storage::get_folders('task'));
         $this->lists = $this->folders = array();
 
         $delim = $this->rc->get_storage()->get_hierarchy_delimiter();
 
         // find default folder
         $default_index = 0;
         foreach ($folders as $i => $folder) {
             if ($folder->default && strpos($folder->name, $delim) === false)
                 $default_index = $i;
         }
 
         // put default folder (aka INBOX) on top of the list
         if ($default_index > 0) {
             $default_folder = $folders[$default_index];
             unset($folders[$default_index]);
             array_unshift($folders, $default_folder);
         }
 
         $prefs = $this->rc->config->get('kolab_tasklists', array());
 
         foreach ($folders as $folder) {
             $tasklist = $this->folder_props($folder, $prefs);
 
             $this->lists[$tasklist['id']] = $tasklist;
             $this->folders[$tasklist['id']] = $folder;
             $this->folders[$folder->name] = $folder;
         }
+
+        return $this->lists;
     }
 
     /**
      * Derive list properties from the given kolab_storage_folder object
      */
     protected function folder_props($folder, $prefs)
     {
         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; #kolab_storage::folder_id($folder->name);
         $old_id = kolab_storage::folder_id($folder->name, false);
 
         if (!isset($prefs[$list_id]['showalarms']) && isset($prefs[$old_id]['showalarms'])) {
             $prefs[$list_id]['showalarms'] = $prefs[$old_id]['showalarms'];
         }
 
         return array(
             'id' => $list_id,
             'name' => $folder->get_name(),
             'listname' => $folder->get_foldername(),
             'editname' => $folder->get_foldername(),
             'color' => $folder->get_color('0000CC'),
             'showalarms' => isset($prefs[$list_id]['showalarms']) ? $prefs[$list_id]['showalarms'] : $alarms,
             'editable' => $editable,
             'rights'    => $rights,
             'norename' => $norename,
             'active' => $folder->is_active(),
             'parentfolder' => $folder->get_parent(),
             'default' => $folder->default,
             'virtual' => $folder->virtual,
             'children' => true,  // TODO: determine if that folder indeed has child folders
             'subscribed' => (bool)$folder->is_subscribed(),
             'removable' => !$folder->default,
             'subtype'  => $folder->subtype,
             'group' => $folder->default ? 'default' : $folder->get_namespace(),
             'class' => trim($folder->get_namespace() . ($folder->default ? ' default' : '')),
             'caldavuid' => $folder->get_uid(),
             'history' => !empty($this->bonnie_api),
         );
     }
 
     /**
      * Get a list of available task lists from this source
      */
     public function get_lists(&$tree = null)
     {
+        $this->_read_lists();
+
         // attempt to create a default list for this user
         if (empty($this->lists) && !isset($this->search_more_results)) {
             $prop = array('name' => 'Tasks', 'color' => '0000CC', 'default' => true);
             if ($this->create_list($prop))
                 $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();
         $prefs = $this->rc->config->get('kolab_tasklists', array());
 
         $lists = array();
         foreach ($folders as $folder) {
             $list_id   = $folder->id; // kolab_storage::folder_id($folder->name);
             $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'     => $folder->get_name(),
+                    '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),
+                    'name'     => $fullname,
                     'listname' => $listname,
                     'virtual'  => true,
                     'editable' => false,
                     'rights'   => 'l',
                     'group'    => $folder->get_namespace(),
                     'class'    => 'folder',
                     'parent'   => $parent_id,
                 );
             }
             else {
                 if (!$this->lists[$list_id]) {
                     $this->lists[$list_id] = $this->folder_props($folder, $prefs);
                     $this->folders[$list_id] = $folder;
                 }
                 $this->lists[$list_id]['parent'] = $parent_id;
                 $lists[$list_id] = $this->lists[$list_id];
             }
         }
 
         return $lists;
     }
 
     /**
      * 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
      */
     protected function get_folder($id)
     {
+        $this->_read_lists();
+
         // 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, $this->rc->config->get('kolab_tasklists', array()));
             }
         }
 
         return $this->folders[$id];
     }
 
 
     /**
      * Create a new list assigned to the current user
      *
      * @param array Hash array with list properties
      *        name: List name
      *       color: The color of the list
      *  showalarms: True if alarms are enabled
      * @return mixed ID of the new list on success, False on error
      */
     public function create_list(&$prop)
     {
         $prop['type'] = 'task' . ($prop['default'] ? '.default' : '');
         $prop['active'] = true; // activate folder by default
         $prop['subscribed'] = true;
         $folder = kolab_storage::folder_update($prop);
 
         if ($folder === false) {
             $this->last_error = kolab_storage::$last_error;
             return false;
         }
 
         // create ID
         $id = kolab_storage::folder_id($folder);
 
         $prefs['kolab_tasklists'] = $this->rc->config->get('kolab_tasklists', array());
 
         if (isset($prop['showalarms']))
             $prefs['kolab_tasklists'][$id]['showalarms'] = $prop['showalarms'] ? true : false;
 
         if ($prefs['kolab_tasklists'][$id])
             $this->rc->user->save_prefs($prefs);
 
         // force page reload to properly render folder hierarchy
         if (!empty($prop['parent'])) {
             $prop['_reload'] = true;
         }
         else {
             $folder = kolab_storage::get_folder($folder);
             $prop += $this->folder_props($folder, array());
         }
 
         return $id;
     }
 
     /**
      * Update properties of an existing tasklist
      *
      * @param array Hash array with list properties
      *          id: List Identifier
      *        name: List name
      *       color: The color of the list
      *  showalarms: True if alarms are enabled (if supported)
      * @return boolean True on success, Fales on failure
      */
     public function edit_list(&$prop)
     {
         if ($prop['id'] && ($folder = $this->get_folder($prop['id']))) {
             $prop['oldname'] = $folder->name;
             $prop['type'] = 'task';
             $newfolder = kolab_storage::folder_update($prop);
 
             if ($newfolder === false) {
                 $this->last_error = kolab_storage::$last_error;
                 return false;
             }
 
             // create ID
             $id = kolab_storage::folder_id($newfolder);
 
             // fallback to local prefs
             $prefs['kolab_tasklists'] = $this->rc->config->get('kolab_tasklists', array());
             unset($prefs['kolab_tasklists'][$prop['id']]);
 
             if (isset($prop['showalarms']))
                 $prefs['kolab_tasklists'][$id]['showalarms'] = $prop['showalarms'] ? true : false;
 
             if ($prefs['kolab_tasklists'][$id])
                 $this->rc->user->save_prefs($prefs);
 
             // force page reload if folder name/hierarchy changed
             if ($newfolder != $prop['oldname'])
                 $prop['_reload'] = true;
 
             return $id;
         }
 
         return false;
     }
 
     /**
      * Set active/subscribed state of a list
      *
      * @param array Hash array with list properties
      *          id: List Identifier
      *      active: True if list is active, false if not
      *   permanent: True if list is to be subscribed permanently
      * @return boolean True on success, Fales on failure
      */
     public function subscribe_list($prop)
     {
         if ($prop['id'] && ($folder = $this->get_folder($prop['id']))) {
             $ret = false;
             if (isset($prop['permanent']))
                 $ret |= $folder->subscribe(intval($prop['permanent']));
             if (isset($prop['active']))
                 $ret |= $folder->activate(intval($prop['active']));
 
             // apply to child folders, too
             if ($prop['recursive']) {
                 foreach ((array)kolab_storage::list_folders($folder->name, '*', 'task') as $subfolder) {
                     if (isset($prop['permanent']))
                         ($prop['permanent'] ? kolab_storage::folder_subscribe($subfolder) : kolab_storage::folder_unsubscribe($subfolder));
                     if (isset($prop['active']))
                         ($prop['active'] ? kolab_storage::folder_activate($subfolder) : kolab_storage::folder_deactivate($subfolder));
                 }
             }
+
             return $ret;
         }
+
         return false;
     }
 
     /**
      * Delete the given list with all its contents
      *
      * @param array Hash array with list properties
      *      id: list Identifier
      * @return boolean True on success, Fales on failure
      */
     public function delete_list($prop)
     {
         if ($prop['id'] && ($folder = $this->get_folder($prop['id']))) {
-          if (kolab_storage::folder_delete($folder->name))
-              return true;
-          else
-              $this->last_error = kolab_storage::$last_error;
+            if (kolab_storage::folder_delete($folder->name)) {
+                return true;
+            }
+
+            $this->last_error = kolab_storage::$last_error;
         }
 
         return false;
     }
 
     /**
      * Search for shared or otherwise not listed tasklists the user has access
      *
      * @param string Search string
      * @param string Section/source to search
      * @return array List of tasklists
      */
     public 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('task', $query, array('other')) as $folder) {
                 $this->folders[$folder->id] = $folder;
                 $this->lists[$folder->id] = $this->folder_props($folder, array());
             }
         }
         // 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 tasks folders shared by this user
                 foreach (kolab_storage::list_user_folders($user, 'task', false) as $foldername) {
                     $folders[] = new kolab_storage_folder($foldername, 'task');
                 }
 
                 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, array());
 
                     foreach ($folders as $folder) {
                         $this->folders[$folder->id] = $folder;
                         $this->lists[$folder->id] = $this->folder_props($folder, array());
                         $count++;
                     }
                 }
 
                 if ($count >= $limit) {
                     $this->search_more_results = true;
                     break;
                 }
             }
         }
 
         return $this->get_lists();
     }
 
     /**
      * Get a list of tags to assign tasks to
      *
      * @return array List of tags
      */
     public function get_tags()
     {
         $config = kolab_storage_config::get_instance();
         $tags   = $config->get_tags();
         $backend_tags = array_map(function($v) { return $v['name']; }, $tags);
 
         return array_values(array_unique(array_merge($this->tags, $backend_tags)));
     }
 
     /**
      * Get number of tasks matching the given filter
      *
      * @param array List of lists to count tasks of
      * @return array Hash array with counts grouped by status (all|flagged|completed|today|tomorrow|nodate)
      */
     public function count_tasks($lists = null)
     {
-        if (empty($lists))
-            $lists = array_keys($this->lists);
-        else if (is_string($lists))
+        if (empty($lists)) {
+            $lists = $this->_read_lists();
+            $lists = array_keys($lists);
+        }
+        else if (is_string($lists)) {
             $lists = explode(',', $lists);
+        }
 
-        $today_date = new DateTime('now', $this->plugin->timezone);
-        $today = $today_date->format('Y-m-d');
+        $today_date    = new DateTime('now', $this->plugin->timezone);
+        $today         = $today_date->format('Y-m-d');
         $tomorrow_date = new DateTime('now + 1 day', $this->plugin->timezone);
-        $tomorrow = $tomorrow_date->format('Y-m-d');
+        $tomorrow      = $tomorrow_date->format('Y-m-d');
 
         $counts = array('all' => 0, 'flagged' => 0, 'today' => 0, 'tomorrow' => 0, 'overdue' => 0, 'nodate' => 0, 'mytasks' => 0);
+
         foreach ($lists as $list_id) {
             if (!$folder = $this->get_folder($list_id)) {
                 continue;
             }
+
             foreach ($folder->select(array(array('tags','!~','x-complete'))) as $record) {
                 $rec = $this->_to_rcube_task($record, $list_id, false);
 
                 if ($this->is_complete($rec))  // don't count complete tasks
                     continue;
 
                 $counts['all']++;
                 if ($rec['flagged'])
                     $counts['flagged']++;
                 if (empty($rec['date']))
                     $counts['nodate']++;
                 else if ($rec['date'] == $today)
                     $counts['today']++;
                 else if ($rec['date'] == $tomorrow)
                     $counts['tomorrow']++;
                 else if ($rec['date'] < $today)
                     $counts['overdue']++;
                 if ($this->plugin->is_attendee($rec) !== false)
                     $counts['mytasks']++;
             }
         }
 
         // avoid session race conditions that will loose temporary subscriptions
         $this->plugin->rc->session->nowrite = true;
 
         return $counts;
     }
 
     /**
      * Get all task records matching the given filter
      *
      * @param array Hash array with filter criterias:
      *  - mask:  Bitmask representing the filter selection (check against tasklist::FILTER_MASK_* constants)
      *  - from:  Date range start as string (Y-m-d)
      *  - to:    Date range end as string (Y-m-d)
      *  - search: Search query string
      * @param array List of lists to get tasks from
      * @return array List of tasks records matchin the criteria
      */
     public function list_tasks($filter, $lists = null)
     {
-        if (empty($lists))
-            $lists = array_keys($this->lists);
-        else if (is_string($lists))
+        if (empty($lists)) {
+            $lists = $this->_read_lists();
+            $lists = array_keys($lists);
+        }
+        else if (is_string($lists)) {
             $lists = explode(',', $lists);
+        }
 
+        $config  = kolab_storage_config::get_instance();
         $results = array();
 
         // query Kolab storage
         $query = array();
         if ($filter['mask'] & tasklist::FILTER_MASK_COMPLETE)
             $query[] = array('tags','~','x-complete');
         else if (empty($filter['since']))
             $query[] = array('tags','!~','x-complete');
 
         // full text search (only works with cache enabled)
         if ($filter['search']) {
             $search = mb_strtolower($filter['search']);
             foreach (rcube_utils::normalize_string($search, true) as $word) {
                 $query[] = array('words', '~', $word);
             }
         }
 
         if ($filter['since']) {
             $query[] = array('changed', '>=', $filter['since']);
         }
 
-        // load all tags into memory first
-        kolab_storage_config::get_instance()->get_tags();
-
         foreach ($lists as $list_id) {
             if (!$folder = $this->get_folder($list_id)) {
                 continue;
             }
-            foreach ($folder->select($query) as $record) {
-                $this->load_tags($record);
-                $task = $this->_to_rcube_task($record, $list_id);
 
+            foreach ($folder->select($query) as $record) {
                 // TODO: post-filter tasks returned from storage
-
-                $results[] = $task;
+                $record['list_id'] = $list_id;
+                $results[] = $record;
             }
         }
 
+        $config->apply_tags($results, true);
+        $config->apply_links($results);
+
+        foreach (array_keys($results) as $idx) {
+            $results[$idx] = $this->_to_rcube_task($results[$idx], $results[$idx]['list_id']);
+        }
+
         // avoid session race conditions that will loose temporary subscriptions
         $this->plugin->rc->session->nowrite = true;
 
         return $results;
     }
 
     /**
      * Return data of a specific task
      *
      * @param mixed  Hash array with task properties or task UID
      * @return array Hash array with task properties or false if not found
      */
     public function get_task($prop)
     {
+        $this->_read_lists();
         $this->_parse_id($prop);
+
         $id      = $prop['uid'];
         $list_id = $prop['list'];
         $folders = $list_id ? array($list_id => $this->get_folder($list_id)) : $this->folders;
 
         // find task in the available folders
         foreach ($folders as $list_id => $folder) {
             if (is_numeric($list_id) || !$folder)
                 continue;
             if (!$this->tasks[$id] && ($object = $folder->get_object($id))) {
                 $this->load_tags($object);
                 $this->tasks[$id] = $this->_to_rcube_task($object, $list_id);
                 break;
             }
         }
 
         return $this->tasks[$id];
     }
 
     /**
      * Get all decendents of the given task record
      *
      * @param mixed  Hash array with task properties or task UID
      * @param boolean True if all childrens children should be fetched
      * @return array List of all child task IDs
      */
     public function get_childs($prop, $recursive = false)
     {
         if (is_string($prop)) {
             $task = $this->get_task($prop);
             $prop = array('uid' => $task['uid'], 'list' => $task['list']);
         }
         else {
             $this->_parse_id($prop);
         }
 
         $childs = array();
         $list_id = $prop['list'];
         $task_ids = array($prop['uid']);
         $folder = $this->get_folder($list_id);
 
         // query for childs (recursively)
         while ($folder && !empty($task_ids)) {
             $query_ids = array();
             foreach ($task_ids as $task_id) {
                 $query = array(array('tags','=','x-parent:' . $task_id));
                 foreach ($folder->select($query) as $record) {
                     // don't rely on kolab_storage_folder filtering
                     if ($record['parent_id'] == $task_id) {
                         $childs[] = $list_id . ':' . $record['uid'];
                         $query_ids[] = $record['uid'];
                     }
                 }
             }
 
             if (!$recursive)
                 break;
 
             $task_ids = $query_ids;
         }
 
         return $childs;
     }
 
     /**
      * Provide a list of revisions for the given task
      *
      * @param array  $task Hash array with task properties
      * @return array List of changes, each as a hash array
      * @see tasklist_driver::get_task_changelog()
      */
     public function get_task_changelog($prop)
     {
         if (empty($this->bonnie_api)) {
             return false;
         }
 
         list($uid, $mailbox, $msguid) = $this->_resolve_task_identity($prop);
 
         $result = $uid && $mailbox ? $this->bonnie_api->changelog('task', $uid, $mailbox, $msguid) : null;
         if (is_array($result) && $result['uid'] == $uid) {
             return $result['changes'];
         }
 
         return false;
     }
 
     /**
      * Return full data of a specific revision of an event
      *
      * @param mixed  $task UID string or hash array with task properties
      * @param mixed  $rev Revision number
      *
      * @return array Task object as hash array
      * @see tasklist_driver::get_task_revision()
      */
     public function get_task_revison($prop, $rev)
     {
         if (empty($this->bonnie_api)) {
             return false;
         }
 
         $this->_parse_id($prop);
         $uid     = $prop['uid'];
         $list_id = $prop['list'];
         list($uid, $mailbox, $msguid) = $this->_resolve_task_identity($prop);
 
         // call Bonnie API
         $result = $this->bonnie_api->get('task', $uid, $rev, $mailbox, $msguid);
         if (is_array($result) && $result['uid'] == $uid && !empty($result['xml'])) {
             $format = kolab_format::factory('task');
             $format->load($result['xml']);
             $rec = $format->to_array();
             $format->get_attachments($rec, true);
 
             if ($format->is_valid()) {
                 $rec = self::_to_rcube_task($rec, $list_id, false);
                 $rec['rev'] = $result['rev'];
                 return $rec;
             }
         }
 
         return false;
     }
 
     /**
      * Command the backend to restore a certain revision of a task.
      * This shall replace the current object with an older version.
      *
      * @param mixed  $task UID string or hash array with task properties
      * @param mixed  $rev Revision number
      *
      * @return boolean True on success, False on failure
      * @see tasklist_driver::restore_task_revision()
      */
     public function restore_task_revision($prop, $rev)
     {
         if (empty($this->bonnie_api)) {
             return false;
         }
 
         $this->_parse_id($prop);
         $uid     = $prop['uid'];
         $list_id = $prop['list'];
         list($uid, $mailbox, $msguid) = $this->_resolve_task_identity($prop);
 
-        $folder = $this->get_folder($list_id);
+        $folder  = $this->get_folder($list_id);
         $success = false;
 
         if ($folder && ($raw_msg = $this->bonnie_api->rawdata('task', $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);
             }
         }
 
         return $success;
     }
 
     /**
      * Get a list of property changes beteen two revisions of a task object
      *
      * @param array  $task Hash array with task properties
      * @param mixed  $rev   Revisions: "from:to"
      *
      * @return array List of property changes, each as a hash array
      * @see tasklist_driver::get_task_diff()
      */
     public function get_task_diff($prop, $rev1, $rev2)
     {
         $this->_parse_id($prop);
         $uid     = $prop['uid'];
         $list_id = $prop['list'];
         list($uid, $mailbox, $msguid) = $this->_resolve_task_identity($prop);
 
         // call Bonnie API
         $result = $this->bonnie_api->diff('task', $uid, $rev1, $rev2, $mailbox, $msguid, $instance_id);
         if (is_array($result) && $result['uid'] == $uid) {
             $result['rev1'] = $rev1;
             $result['rev2'] = $rev2;
 
             $keymap = array(
                 'start'    => 'start',
                 'due'      => 'date',
                 'dstamp'   => 'changed',
                 'summary'  => 'title',
                 'alarm'    => 'alarms',
                 'attendee' => 'attendees',
                 'attach'   => 'attachments',
                 'rrule'    => 'recurrence',
                 'related-to' => 'parent_id',
                 'percent-complete' => 'complete',
                 'lastmodified-date' => 'changed',
             );
             $prop_keymaps = array(
                 'attachments' => array('fmttype' => 'mimetype', 'label' => 'name'),
                 'attendees'   => array('partstat' => 'status'),
             );
             $special_changes = array();
 
             // map kolab event properties to keys the client expects
             array_walk($result['changes'], function(&$change, $i) use ($keymap, $prop_keymaps, $special_changes) {
                 if (array_key_exists($change['property'], $keymap)) {
                     $change['property'] = $keymap[$change['property']];
                 }
                 if ($change['property'] == 'priority') {
                     $change['property'] = 'flagged';
                     $change['old'] = $change['old'] == 1 ? $this->plugin->gettext('yes') : null;
                     $change['new'] = $change['new'] == 1 ? $this->plugin->gettext('yes') : null;
                 }
                 // map alarms trigger value
                 if ($change['property'] == 'alarms') {
                     if (is_array($change['old']) && is_array($change['old']['trigger']))
                         $change['old']['trigger'] = $change['old']['trigger']['value'];
                     if (is_array($change['new']) && is_array($change['new']['trigger']))
                         $change['new']['trigger'] = $change['new']['trigger']['value'];
                 }
                 // make all property keys uppercase
                 if ($change['property'] == 'recurrence') {
                     $special_changes['recurrence'] = $i;
                     foreach (array('old','new') as $m) {
                         if (is_array($change[$m])) {
                             $props = array();
                             foreach ($change[$m] as $k => $v) {
                                 $props[strtoupper($k)] = $v;
                             }
                             $change[$m] = $props;
                         }
                     }
                 }
                 // map property keys names
                 if (is_array($prop_keymaps[$change['property']])) {
                   foreach ($prop_keymaps[$change['property']] as $k => $dest) {
                     if (is_array($change['old']) && array_key_exists($k, $change['old'])) {
                         $change['old'][$dest] = $change['old'][$k];
                         unset($change['old'][$k]);
                     }
                     if (is_array($change['new']) && array_key_exists($k, $change['new'])) {
                         $change['new'][$dest] = $change['new'][$k];
                         unset($change['new'][$k]);
                     }
                   }
                 }
 
                 if ($change['property'] == 'exdate') {
                     $special_changes['exdate'] = $i;
                 }
                 else if ($change['property'] == 'rdate') {
                     $special_changes['rdate'] = $i;
                 }
             });
 
             // merge some recurrence changes
             foreach (array('exdate','rdate') as $prop) {
                 if (array_key_exists($prop, $special_changes)) {
                     $exdate = $result['changes'][$special_changes[$prop]];
                     if (array_key_exists('recurrence', $special_changes)) {
                         $recurrence = &$result['changes'][$special_changes['recurrence']];
                     }
                     else {
                         $i = count($result['changes']);
                         $result['changes'][$i] = array('property' => 'recurrence', 'old' => array(), 'new' => array());
                         $recurrence = &$result['changes'][$i]['recurrence'];
                     }
                     $key = strtoupper($prop);
                     $recurrence['old'][$key] = $exdate['old'];
                     $recurrence['new'][$key] = $exdate['new'];
                     unset($result['changes'][$special_changes[$prop]]);
                 }
             }
 
             return $result;
         }
 
         return false;
     }
 
     /**
      * Helper method to resolved the given task identifier into uid and folder
      *
      * @return array (uid,folder,msguid) tuple
      */
     private function _resolve_task_identity($prop)
     {
         $mailbox = $msguid = null;
 
         $this->_parse_id($prop);
         $uid     = $prop['uid'];
         $list_id = $prop['list'];
 
         if ($folder = $this->get_folder($list_id)) {
             $mailbox = $folder->get_mailbox_id();
 
             // get task 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);
     }
 
-
     /**
      * Get a list of pending alarms to be displayed to the user
      *
      * @param  integer Current time (unix timestamp)
      * @param  mixed   List of list IDs to show alarms for (either as array or comma-separated string)
      * @return array   A list of alarms, each encoded as hash array with task properties
      * @see tasklist_driver::pending_alarms()
      */
     public function pending_alarms($time, $lists = null)
     {
         $interval = 300;
         $time -= $time % 60;
 
         $slot = $time;
         $slot -= $slot % $interval;
 
         $last = $time - max(60, $this->rc->config->get('refresh_interval', 0));
         $last -= $last % $interval;
 
         // only check for alerts once in 5 minutes
         if ($last == $slot)
             return array();
 
         if ($lists && is_string($lists))
             $lists = explode(',', $lists);
 
         $time = $slot + $interval;
 
         $candidates = array();
-        $query = array(array('tags', '=', 'x-has-alarms'), array('tags', '!=', 'x-complete'));
+        $query      = array(
+            array('tags', '=', 'x-has-alarms'),
+            array('tags', '!=', 'x-complete')
+        );
+
+        $this->_read_lists();
+
         foreach ($this->lists as $lid => $list) {
             // skip lists with alarms disabled
             if (!$list['showalarms'] || ($lists && !in_array($lid, $lists)))
                 continue;
 
             $folder = $this->get_folder($lid);
             foreach ($folder->select($query) as $record) {
                 if (!($record['valarms'] || $record['alarms']) || $record['status'] == 'COMPLETED' || $record['complete'] == 100)  // don't trust query :-)
                     continue;
 
                 $task = $this->_to_rcube_task($record, $lid, false);
 
                 // add to list if alarm is set
                 $alarm = libcalendaring::get_next_alarm($task, 'task');
                 if ($alarm && $alarm['time'] && $alarm['time'] <= $time && in_array($alarm['action'], $this->alarm_types)) {
                     $id = $alarm['id'];  // use alarm-id as primary identifier
                     $candidates[$id] = array(
                         'id'       => $id,
                         'title'    => $task['title'],
                         'date'     => $task['date'],
                         'time'     => $task['time'],
                         'notifyat' => $alarm['time'],
                         'action'   => $alarm['action'],
                     );
                 }
             }
         }
 
         // get alarm information stored in local database
         if (!empty($candidates)) {
             $alarm_ids = array_map(array($this->rc->db, 'quote'), array_keys($candidates));
             $result = $this->rc->db->query("SELECT *"
                 . " FROM " . $this->rc->db->table_name('kolab_alarms', true)
                 . " WHERE `alarm_id` IN (" . join(',', $alarm_ids) . ")"
                     . " AND `user_id` = ?",
                 $this->rc->user->ID
             );
 
             while ($result && ($rec = $this->rc->db->fetch_assoc($result))) {
                 $dbdata[$rec['alarm_id']] = $rec;
             }
         }
 
         $alarms = array();
         foreach ($candidates as $id => $task) {
           // skip dismissed
           if ($dbdata[$id]['dismissed'])
               continue;
 
           // snooze function may have shifted alarm time
           $notifyat = $dbdata[$id]['notifyat'] ? strtotime($dbdata[$id]['notifyat']) : $task['notifyat'];
           if ($notifyat <= $time)
               $alarms[] = $task;
         }
 
         return $alarms;
     }
 
     /**
      * (User) feedback after showing an alarm notification
      * This should mark the alarm as 'shown' or snooze it for the given amount of time
      *
      * @param  string  Task identifier
      * @param  integer Suspend the alarm for this number of seconds
      */
     public function dismiss_alarm($id, $snooze = 0)
     {
         // delete old alarm entry
         $this->rc->db->query(
             "DELETE FROM " . $this->rc->db->table_name('kolab_alarms', true) . "
              WHERE `alarm_id` = ? AND `user_id` = ?",
             $id,
             $this->rc->user->ID
         );
 
         // set new notifyat time or unset if not snoozed
         $notifyat = $snooze > 0 ? date('Y-m-d H:i:s', time() + $snooze) : null;
 
         $query = $this->rc->db->query(
             "INSERT INTO " . $this->rc->db->table_name('kolab_alarms', true) . "
              (`alarm_id`, `user_id`, `dismissed`, `notifyat`)
              VALUES (?, ?, ?, ?)",
             $id,
             $this->rc->user->ID,
             $snooze > 0 ? 0 : 1,
             $notifyat
         );
 
         return $this->rc->db->affected_rows($query);
     }
 
     /**
      * Remove alarm dismissal or snooze state
      *
      * @param  string  Task identifier
      */
     public function clear_alarms($id)
     {
         // delete alarm entry
         $this->rc->db->query(
             "DELETE FROM " . $this->rc->db->table_name('kolab_alarms', true) . "
              WHERE `alarm_id` = ? AND `user_id` = ?",
             $id,
             $this->rc->user->ID
         );
 
         return true;
     }
 
     /**
      * Get task tags
      */
     private function load_tags(&$object)
     {
         // this task hasn't been migrated yet
         if (!empty($object['categories'])) {
             // OPTIONAL: call kolab_storage_config::apply_tags() to migrate the object
             $object['tags'] = (array)$object['categories'];
             if (!empty($object['tags'])) {
                 $this->tags = array_merge($this->tags, $object['tags']);
             }
         }
         else {
             $config = kolab_storage_config::get_instance();
             $tags   = $config->get_tags($object['uid']);
             $object['tags'] = array_map(function($v) { return $v['name']; }, $tags);
         }
     }
 
     /**
      * Update task tags
      */
     private function save_tags($uid, $tags)
     {
         $config = kolab_storage_config::get_instance();
         $config->save_tags($uid, $tags);
     }
 
     /**
      * Find messages linked with a task record
      */
     private function get_links($uid)
     {
         $config = kolab_storage_config::get_instance();
         return $config->get_object_links($uid);
     }
 
     /**
      *
      */
     private function save_links($uid, $links)
     {
-        // make sure we have a valid array
-        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);
+        return $config->save_object_links($uid, (array) $links);
     }
 
     /**
      * Extract uid + list identifiers from the given input
      *
      * @param mixed array or string with task identifier(s)
      */
     private function _parse_id(&$prop)
     {
         $id_ = null;
         if (is_array($prop)) {
             // 'uid' + 'list' available, nothing to be done
             if (!empty($prop['uid']) && !empty($prop['list'])) {
                 return;
             }
 
             // 'id' is given
             if (!empty($prop['id'])) {
                 if (!empty($prop['list'])) {
                     $list_id = $prop['_fromlist'] ?: $prop['list'];
                     if (strpos($prop['id'], $list_id.':') === 0) {
                         $prop['uid'] = substr($prop['id'], strlen($list_id)+1);
                     }
                     else {
                         $prop['uid'] = $prop['id'];
                     }
                 }
                 else {
                     $id_ = $prop['id'];
                 }
             }
         }
         else {
             $id_ = strval($prop);
             $prop = array();
         }
 
         // split 'id' into list + uid
         if (!empty($id_)) {
             list($list, $uid) = explode(':', $id_, 2);
             if (!empty($uid)) {
                 $prop['uid'] = $uid;
                 $prop['list'] = $list;
             }
             else {
                 $prop['uid'] = $id_;
             }
         }
     }
 
     /**
      * Convert from Kolab_Format to internal representation
      */
     private function _to_rcube_task($record, $list_id, $all = true)
     {
         $id_prefix = $list_id . ':';
         $task = array(
             'id' => $id_prefix . $record['uid'],
             'uid' => $record['uid'],
             'title' => $record['title'],
 //            'location' => $record['location'],
             'description' => $record['description'],
             'flagged' => $record['priority'] == 1,
             'complete' => floatval($record['complete'] / 100),
             'status' => $record['status'],
             'parent_id' => $record['parent_id'] ? $id_prefix . $record['parent_id'] : null,
             'recurrence' => $record['recurrence'],
             'attendees' => $record['attendees'],
             'organizer' => $record['organizer'],
             'sequence' => $record['sequence'],
             'tags' => $record['tags'],
             'list' => $list_id,
+            'links' => $record['links'],
         );
 
         // we can sometimes skip this expensive operation
-        if ($all) {
+        if ($all && !array_key_exists('links', $task)) {
             $task['links'] = $this->get_links($task['uid']);
         }
 
         // convert from DateTime to internal date format
         if (is_a($record['due'], 'DateTime')) {
             $due = $this->plugin->lib->adjust_timezone($record['due']);
             $task['date'] = $due->format('Y-m-d');
             if (!$record['due']->_dateonly)
                 $task['time'] = $due->format('H:i');
         }
         // convert from DateTime to internal date format
         if (is_a($record['start'], 'DateTime')) {
             $start = $this->plugin->lib->adjust_timezone($record['start']);
             $task['startdate'] = $start->format('Y-m-d');
             if (!$record['start']->_dateonly)
                 $task['starttime'] = $start->format('H:i');
         }
         if (is_a($record['changed'], 'DateTime')) {
             $task['changed'] = $record['changed'];
         }
         if (is_a($record['created'], 'DateTime')) {
             $task['created'] = $record['created'];
         }
 
         if ($record['valarms']) {
             $task['valarms'] = $record['valarms'];
         }
         else if ($record['alarms']) {
             $task['alarms'] = $record['alarms'];
         }
 
         if (!empty($task['attendees'])) {
             foreach ((array)$task['attendees'] as $i => $attendee) {
                 if (is_array($attendee['delegated-from'])) {
                     $task['attendees'][$i]['delegated-from'] = join(', ', $attendee['delegated-from']);
                 }
                 if (is_array($attendee['delegated-to'])) {
                     $task['attendees'][$i]['delegated-to'] = join(', ', $attendee['delegated-to']);
                 }
             }
         }
 
         if (!empty($record['_attachments'])) {
             foreach ($record['_attachments'] as $key => $attachment) {
                 if ($attachment !== false) {
                     if (!$attachment['name'])
                         $attachment['name'] = $key;
                     $attachments[] = $attachment;
                 }
             }
 
             $task['attachments'] = $attachments;
         }
 
         return $task;
     }
 
     /**
      * Convert the given task record into a data structure that can be passed to kolab_storage backend for saving
      * (opposite of self::_to_rcube_event())
      */
     private function _from_rcube_task($task, $old = array())
     {
-        $object = $task;
+        $object    = $task;
         $id_prefix = $task['list'] . ':';
 
         if (!empty($task['date'])) {
             $object['due'] = rcube_utils::anytodatetime($task['date'].' '.$task['time'], $this->plugin->timezone);
             if (empty($task['time']))
                 $object['due']->_dateonly = true;
             unset($object['date']);
         }
 
         if (!empty($task['startdate'])) {
             $object['start'] = rcube_utils::anytodatetime($task['startdate'].' '.$task['starttime'], $this->plugin->timezone);
             if (empty($task['starttime']))
                 $object['start']->_dateonly = true;
             unset($object['startdate']);
         }
 
         // as per RFC (and the Kolab schema validation), start and due dates need to be of the same type (#3614)
         // this should be catched in the client already but just make sure we don't write invalid objects
         if (!empty($object['start']) && !empty($object['due']) && $object['due']->_dateonly != $object['start']->_dateonly) {
             $object['start']->_dateonly = true;
             $object['due']->_dateonly = true;
         }
 
         $object['complete'] = $task['complete'] * 100;
         if ($task['complete'] == 1.0 && empty($task['complete']))
             $object['status'] = 'COMPLETED';
 
         if ($task['flagged'])
             $object['priority'] = 1;
         else
             $object['priority'] = $old['priority'] > 1 ? $old['priority'] : 0;
 
         // remove list: prefix from parent_id
         if (!empty($task['parent_id']) && strpos($task['parent_id'], $id_prefix) === 0) {
             $object['parent_id'] = substr($task['parent_id'], strlen($id_prefix));
         }
 
         // copy meta data (starting with _) from old object
         foreach ((array)$old as $key => $val) {
             if (!isset($object[$key]) && $key[0] == '_')
                 $object[$key] = $val;
         }
 
         // copy recurrence rules if the client didn't submit it (#2713)
         if (!array_key_exists('recurrence', $object) && $old['recurrence']) {
             $object['recurrence'] = $old['recurrence'];
         }
 
         // delete existing attachment(s)
         if (!empty($task['deleted_attachments'])) {
             foreach ($task['deleted_attachments'] as $attachment) {
                 if (is_array($object['_attachments'])) {
                     foreach ($object['_attachments'] as $idx => $att) {
                         if ($att['id'] == $attachment)
                             $object['_attachments'][$idx] = false;
                     }
                 }
             }
             unset($task['deleted_attachments']);
         }
 
         // in kolab_storage attachments are indexed by content-id
         if (is_array($task['attachments'])) {
             foreach ($task['attachments'] as $idx => $attachment) {
                 $key = null;
                 // Roundcube ID has nothing to do with the storage ID, remove it
                 if ($attachment['content'] || $attachment['path']) {
                     unset($attachment['id']);
                 }
                 else {
                     foreach ((array)$old['_attachments'] as $cid => $oldatt) {
                         if ($oldatt && $attachment['id'] == $oldatt['id'])
                             $key = $cid;
                     }
                 }
 
                 // replace existing entry
                 if ($key) {
                     $object['_attachments'][$key] = $attachment;
                 }
                 // append as new attachment
                 else {
                     $object['_attachments'][] = $attachment;
                 }
             }
 
             unset($object['attachments']);
         }
 
         // allow sequence increments if I'm the organizer
         if ($this->plugin->is_organizer($object) && empty($object['_method'])) {
             unset($object['sequence']);
         }
         else if (isset($old['sequence']) && empty($object['_method'])) {
             $object['sequence'] = $old['sequence'];
         }
 
         unset($object['tempid'], $object['raw'], $object['list'], $object['flagged'], $object['tags'], $object['created']);
         return $object;
     }
 
     /**
      * Add a single task to the database
      *
      * @param array Hash array with task properties (see header of tasklist_driver.php)
      * @return mixed New task ID on success, False on error
      */
     public function create_task($task)
     {
         return $this->edit_task($task);
     }
 
     /**
      * Update an task entry with the given data
      *
      * @param array Hash array with task properties (see header of tasklist_driver.php)
      * @return boolean True on success, False on error
      */
     public function edit_task($task)
     {
         $this->_parse_id($task);
         $list_id = $task['list'];
         if (!$list_id || !($folder = $this->get_folder($list_id))) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Invalid list identifer to save task: " . print_r($list_id, true)),
                 true, false);
             return false;
         }
 
         // email links and tags are stored separately
         $links = $task['links'];
-        $tags = $task['tags'];
+        $tags  = $task['tags'];
         unset($task['tags'], $task['links']);
 
         // moved from another folder
         if ($task['_fromlist'] && ($fromfolder = $this->get_folder($task['_fromlist']))) {
             if (!$fromfolder->move($task['uid'], $folder))
                 return false;
 
             unset($task['_fromlist']);
         }
 
         // load previous version of this task to merge
         if ($task['id']) {
             $old = $folder->get_object($task['uid']);
             if (!$old || PEAR::isError($old))
                 return false;
 
             // merge existing properties if the update isn't complete
             if (!isset($task['title']) || !isset($task['complete']))
                 $task += $this->_to_rcube_task($old, $list_id);
         }
 
         // generate new task object from RC input
         $object = $this->_from_rcube_task($task, $old);
         $saved  = $folder->save($object, 'task', $task['uid']);
 
         if (!$saved) {
             rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Error saving task 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);
 
             $task = $this->_to_rcube_task($object, $list_id);
             $task['tags'] = (array) $tags;
             $this->tasks[$task['uid']] = $task;
         }
 
         return $saved;
     }
 
     /**
      * Move a single task to another list
      *
      * @param array   Hash array with task properties:
      * @return boolean True on success, False on error
      * @see tasklist_driver::move_task()
      */
     public function move_task($task)
     {
         $this->_parse_id($task);
         $list_id = $task['list'];
         if (!$list_id || !($folder = $this->get_folder($list_id)))
             return false;
 
         // execute move command
         if ($task['_fromlist'] && ($fromfolder = $this->get_folder($task['_fromlist']))) {
             return $fromfolder->move($task['uid'], $folder);
         }
 
         return false;
     }
 
     /**
      * Remove a single task from the database
      *
      * @param array   Hash array with task properties:
      *      id: Task identifier
      * @param boolean Remove record irreversible (mark as deleted otherwise, if supported by the backend)
      * @return boolean True on success, False on error
      */
     public function delete_task($task, $force = true)
     {
         $this->_parse_id($task);
         $list_id = $task['list'];
         if (!$list_id || !($folder = $this->get_folder($list_id)))
             return false;
 
         $status = $folder->delete($task['uid']);
 
         if ($status) {
             // remove tag assignments
             // @TODO: don't do this when undelete feature will be implemented
             $this->save_tags($task['uid'], null);
         }
 
         return $status;
     }
 
     /**
      * Restores a single deleted task (if supported)
      *
      * @param array Hash array with task properties:
      *      id: Task identifier
      * @return boolean True on success, False on error
      */
     public function undelete_task($prop)
     {
         // TODO: implement this
         return false;
     }
 
 
     /**
      * Get attachment properties
      *
      * @param string $id    Attachment identifier
      * @param array  $task  Hash array with event properties:
      *         id: Task identifier
      *       list: List identifier
      *        rev: Revision (optional)
      *
      * @return array Hash array with attachment properties:
      *         id: Attachment identifier
      *       name: Attachment name
      *   mimetype: MIME content type of the attachment
      *       size: Attachment size
      */
     public function get_attachment($id, $task)
     {
         // get old revision of the object
         if ($task['rev']) {
             $task = $this->get_task_revison($task, $task['rev']);
         }
         else {
             $task = $this->get_task($task);
         }
 
         if ($task && !empty($task['attachments'])) {
             foreach ($task['attachments'] as $att) {
                 if ($att['id'] == $id)
                     return $att;
             }
         }
 
         return null;
     }
 
     /**
      * Get attachment body
      *
      * @param string $id    Attachment identifier
      * @param array  $task  Hash array with event properties:
      *         id: Task identifier
      *       list: List identifier
      *        rev: Revision (optional)
      *
      * @return string Attachment body
      */
     public function get_attachment_body($id, $task)
     {
         $this->_parse_id($task);
 
         // get old revision of event
         if ($task['rev']) {
             if (empty($this->bonnie_api)) {
                 return false;
             }
 
             $cid = substr($id, 4);
 
             // call Bonnie API and get the raw mime message
             list($uid, $mailbox, $msguid) = $this->_resolve_task_identity($task);
             if ($msg_raw = $this->bonnie_api->rawdata('task', $uid, $task['rev'], $mailbox, $msguid)) {
                 // parse the message and find the part with the matching content-id
                 $message = rcube_mime::parse_message($msg_raw);
                 foreach ((array)$message->parts as $part) {
                     if ($part->headers['content-id'] && trim($part->headers['content-id'], '<>') == $cid) {
                         return $part->body;
                     }
                 }
             }
 
             return false;
         }
 
 
         if ($storage = $this->get_folder($task['list'])) {
             return $storage->get_attachment($task['uid'], $id);
         }
 
         return false;
     }
 
     /**
      * Build a struct representing the given message reference
      *
      * @see tasklist_driver::get_message_reference()
      */
     public function get_message_reference($uri_or_headers, $folder = null)
     {
         if (is_object($uri_or_headers)) {
             $uri_or_headers = kolab_storage_config::get_message_uri($uri_or_headers, $folder);
         }
 
         if (is_string($uri_or_headers)) {
             return kolab_storage_config::get_message_reference($uri_or_headers, 'task');
         }
 
         return false;
     }
 
     /**
      * Find tasks assigned to a specified message
      *
      * @see tasklist_driver::get_message_related_tasks()
      */
     public function get_message_related_tasks($headers, $folder)
     {
         $config = kolab_storage_config::get_instance();
         $result = $config->get_message_relations($headers, $folder, 'task');
 
         foreach ($result as $idx => $rec) {
             $result[$idx] = $this->_to_rcube_task($rec, kolab_storage::folder_id($rec['_mailbox']));
         }
 
         return $result;
     }
 
     /**
      * 
      */
     public function tasklist_edit_form($action, $list, $fieldprop)
     {
+        $this->_read_lists();
+
         if ($list['id'] && ($list = $this->lists[$list['id']])) {
             $folder_name = $this->get_folder($list['id'])->name; // UTF7
         }
         else {
             $folder_name = '';
         }
 
         $storage = $this->rc->get_storage();
         $delim   = $storage->get_hierarchy_delimiter();
         $form    = array();
 
         if (strlen($folder_name)) {
             $path_imap = explode($delim, $folder_name);
             array_pop($path_imap);  // pop off name part
             $path_imap = implode($path_imap, $delim);
 
             $options = $storage->folder_info($folder_name);
         }
         else {
             $path_imap = '';
         }
 
         $hidden_fields[] = array('name' => 'oldname', 'value' => $folder_name);
 
         // folder name (default field)
         $input_name = new html_inputfield(array('name' => 'name', 'id' => 'taskedit-tasklistame', 'size' => 20));
         $fieldprop['name']['value'] = $input_name->show($list['editname'], array('disabled' => ($options['norename'] || $options['protected'])));
 
         // 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('task', array('name' => 'parent', 'id' => 'taskedit-parentfolder'), $folder_name);
             $fieldprop['parent'] = array(
                 'id'    => 'taskedit-parentfolder',
                 'label' => $this->plugin->gettext('parentfolder'),
                 'value' => $select->show($path_imap),
             );
         }
 
         // General tab
         $form['properties'] = array(
             'name' => $this->rc->gettext('properties'),
             'fields' => array(),
         );
 
         foreach (array('name','parent','showalarms') as $f) {
             $form['properties']['fields'][$f] = $fieldprop[$f];
         }
 
         // add folder ACL tab
         if ($action != 'form-new') {
             $form['sharing'] = array(
                 'name'    => rcube::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'], rcube::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, rcube::Q($tab['name'])) . $content) . "\n";
             }
         }
 
         return $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('tasklist.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'));
     }
 }
diff --git a/plugins/tasklist/tasklist.php b/plugins/tasklist/tasklist.php
index 6b43e167..457f66d6 100644
--- a/plugins/tasklist/tasklist.php
+++ b/plugins/tasklist/tasklist.php
@@ -1,2280 +1,2280 @@
 <?php
 
 /**
  * Tasks plugin for Roundcube webmail
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2012, 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 tasklist extends rcube_plugin
 {
     const FILTER_MASK_TODAY = 1;
     const FILTER_MASK_TOMORROW = 2;
     const FILTER_MASK_WEEK = 4;
     const FILTER_MASK_LATER = 8;
     const FILTER_MASK_NODATE = 16;
     const FILTER_MASK_OVERDUE = 32;
     const FILTER_MASK_FLAGGED = 64;
     const FILTER_MASK_COMPLETE = 128;
     const FILTER_MASK_ASSIGNED = 256;
     const FILTER_MASK_MYTASKS = 512;
 
     const SESSION_KEY = 'tasklist_temp';
 
     public static $filter_masks = array(
         'today'    => self::FILTER_MASK_TODAY,
         'tomorrow' => self::FILTER_MASK_TOMORROW,
         'week'     => self::FILTER_MASK_WEEK,
         'later'    => self::FILTER_MASK_LATER,
         'nodate'   => self::FILTER_MASK_NODATE,
         'overdue'  => self::FILTER_MASK_OVERDUE,
         'flagged'  => self::FILTER_MASK_FLAGGED,
         'complete' => self::FILTER_MASK_COMPLETE,
         'assigned' => self::FILTER_MASK_ASSIGNED,
         'mytasks'  => self::FILTER_MASK_MYTASKS,
     );
 
     public $task = '?(?!login|logout).*';
     public $allowed_prefs = array('tasklist_sort_col','tasklist_sort_order');
 
     public $rc;
     public $lib;
     public $driver;
     public $timezone;
     public $ui;
     public $home;  // declare public to be used in other classes
 
     private $collapsed_tasks = array();
     private $message_tasks = array();
     private $itip;
     private $ical;
 
 
     /**
      * Plugin initialization.
      */
     function init()
     {
         $this->require_plugin('libcalendaring');
         $this->require_plugin('jqueryui');
 
         $this->rc  = rcube::get_instance();
         $this->lib = libcalendaring::get_instance();
 
         $this->register_task('tasks', 'tasklist');
 
         // load plugin configuration
         $this->load_config();
 
         $this->timezone = $this->lib->timezone;
 
         // proceed initialization in startup hook
         $this->add_hook('startup', array($this, 'startup'));
 
         $this->add_hook('user_delete', array($this, 'user_delete'));
     }
 
     /**
      * Startup hook
      */
     public function startup($args)
     {
         // the tasks module can be enabled/disabled by the kolab_auth plugin
         if ($this->rc->config->get('tasklist_disabled', false) || !$this->rc->config->get('tasklist_enabled', true))
             return;
 
         // load localizations
         $this->add_texts('localization/', $args['task'] == 'tasks' && (!$args['action'] || $args['action'] == 'print'));
         $this->rc->load_language($_SESSION['language'], array('tasks.tasks' => $this->gettext('navtitle')));  // add label for task title
 
         if ($args['task'] == 'tasks' && $args['action'] != 'save-pref') {
             $this->load_driver();
 
             // register calendar actions
             $this->register_action('index', array($this, 'tasklist_view'));
             $this->register_action('task', array($this, 'task_action'));
             $this->register_action('tasklist', array($this, 'tasklist_action'));
             $this->register_action('counts', array($this, 'fetch_counts'));
             $this->register_action('fetch', array($this, 'fetch_tasks'));
             $this->register_action('print', array($this, 'print_tasks'));
             $this->register_action('inlineui', array($this, 'get_inline_ui'));
             $this->register_action('mail2task', array($this, 'mail_message2task'));
             $this->register_action('get-attachment', array($this, 'attachment_get'));
             $this->register_action('upload', array($this, 'attachment_upload'));
             $this->register_action('mailimportitip', array($this, 'mail_import_itip'));
             $this->register_action('mailimportattach', array($this, 'mail_import_attachment'));
             $this->register_action('itip-status', array($this, 'task_itip_status'));
             $this->register_action('itip-remove', array($this, 'task_itip_remove'));
             $this->register_action('itip-decline-reply', array($this, 'mail_itip_decline_reply'));
             $this->register_action('itip-delegate', array($this, 'mail_itip_delegate'));
             $this->add_hook('refresh', array($this, 'refresh'));
 
             $this->collapsed_tasks = array_filter(explode(',', $this->rc->config->get('tasklist_collapsed_tasks', '')));
         }
         else if ($args['task'] == 'mail') {
             if ($args['action'] == 'show' || $args['action'] == 'preview') {
                 if ($this->rc->config->get('tasklist_mail_embed', true)) {
                     $this->add_hook('message_load', array($this, 'mail_message_load'));
                 }
                 $this->add_hook('template_object_messagebody', array($this, 'mail_messagebody_html'));
             }
 
             // add 'Create event' item to message menu
             if ($this->api->output->type == 'html') {
                 $this->api->add_content(html::tag('li', null, 
                     $this->api->output->button(array(
                         'command'  => 'tasklist-create-from-mail',
                         'label'    => 'tasklist.createfrommail',
                         'type'     => 'link',
                         'classact' => 'icon taskaddlink active',
                         'class'    => 'icon taskaddlink',
                         'innerclass' => 'icon taskadd',
                     ))),
                 'messagemenu');
 
                 $this->api->output->add_label('tasklist.createfrommail');
             }
         }
 
         if (!$this->rc->output->ajax_call && !$this->rc->output->env['framed']) {
             $this->load_ui();
             $this->ui->init();
         }
 
         // add hooks for alarms handling
         $this->add_hook('pending_alarms', array($this, 'pending_alarms'));
         $this->add_hook('dismiss_alarms', array($this, 'dismiss_alarms'));
     }
 
     /**
      *
      */
     private function load_ui()
     {
         if (!$this->ui) {
             require_once($this->home . '/tasklist_ui.php');
             $this->ui = new tasklist_ui($this);
         }
     }
 
     /**
      * Helper method to load the backend driver according to local config
      */
     private function load_driver()
     {
         if (is_object($this->driver))
             return;
 
         $driver_name  = $this->rc->config->get('tasklist_driver', 'database');
         $driver_class = 'tasklist_' . $driver_name . '_driver';
 
         require_once($this->home . '/drivers/tasklist_driver.php');
         require_once($this->home . '/drivers/' . $driver_name . '/' . $driver_class . '.php');
 
         switch ($driver_name) {
         case "kolab":
             $this->require_plugin('libkolab');
         default:
             $this->driver = new $driver_class($this);
             break;
         }
 
         $this->rc->output->set_env('tasklist_driver', $driver_name);
     }
 
 
     /**
      * Dispatcher for task-related actions initiated by the client
      */
     public function task_action()
     {
         $filter = intval(rcube_utils::get_input_value('filter', rcube_utils::INPUT_GPC));
         $action = rcube_utils::get_input_value('action', rcube_utils::INPUT_GPC);
         $rec    = rcube_utils::get_input_value('t', rcube_utils::INPUT_POST, true);
         $oldrec = $rec;
         $success = $refresh = $got_msg = false;
 
         // force notify if hidden + active
         $itip_send_option = (int)$this->rc->config->get('calendar_itip_send_option', 3);
         if ($itip_send_option === 1 && empty($rec['_reportpartstat']))
             $rec['_notify'] = 1;
 
         switch ($action) {
         case 'new':
             $oldrec = null;
             $rec = $this->prepare_task($rec);
             $rec['uid'] = $this->generate_uid();
             $temp_id = $rec['tempid'];
             if ($success = $this->driver->create_task($rec)) {
                 $refresh = $this->driver->get_task($rec);
                 if ($temp_id) $refresh['tempid'] = $temp_id;
                 $this->cleanup_task($rec);
             }
             break;
 
         case 'complete':
             $complete = intval(rcube_utils::get_input_value('complete', rcube_utils::INPUT_POST));
             if (!($rec = $this->driver->get_task($rec))) {
                 break;
             }
 
             $oldrec = $rec;
             $rec['status'] = $complete ? 'COMPLETED' : ($rec['complete'] > 0 ? 'IN-PROCESS' : 'NEEDS-ACTION');
 
             // sent itip notifications if enabled (no user interaction here)
             if (($itip_send_option & 1)) {
                 if ($this->is_attendee($rec)) {
                     $rec['_reportpartstat'] = $rec['status'];
                 }
                 else if ($this->is_organizer($rec)) {
                     $rec['_notify'] = 1;
                 }
             }
 
         case 'edit':
             $oldrec = $this->driver->get_task($rec);
             $rec = $this->prepare_task($rec);
             $clone = $this->handle_recurrence($rec, $this->driver->get_task($rec));
             if ($success = $this->driver->edit_task($rec)) {
                 $refresh[] = $this->driver->get_task($rec);
                 $this->cleanup_task($rec);
 
                 // add clone from recurring task
                 if ($clone && $this->driver->create_task($clone)) {
                     $refresh[] = $this->driver->get_task($clone);
                     $this->driver->clear_alarms($rec['id']);
                 }
 
                 // move all childs if list assignment was changed
                 if (!empty($rec['_fromlist']) && !empty($rec['list']) && $rec['_fromlist'] != $rec['list']) {
                     foreach ($this->driver->get_childs(array('id' => $rec['id'], 'list' => $rec['_fromlist']), true) as $cid) {
                         $child = array('id' => $cid, 'list' => $rec['list'], '_fromlist' => $rec['_fromlist']);
                         if ($this->driver->move_task($child)) {
                             $r = $this->driver->get_task($child);
                             if ((bool)($filter & self::FILTER_MASK_COMPLETE) == $this->driver->is_complete($r)) {
                                 $refresh[] = $r;
                             }
                         }
                     }
                 }
             }
             break;
 
           case 'move':
               foreach ((array)$rec['id'] as $id) {
                   $r = $rec;
                   $r['id'] = $id;
                   if ($this->driver->move_task($r)) {
                       $new_task = $this->driver->get_task($r);
                       $new_task['tempid'] = $id;
                       $refresh[] = $new_task;
                       $success = true;
 
                       // move all childs, too
                       foreach ($this->driver->get_childs(array('id' => $id, 'list' => $rec['_fromlist']), true) as $cid) {
                           $child = $rec;
                           $child['id'] = $cid;
                           if ($this->driver->move_task($child)) {
                               $r = $this->driver->get_task($child);
                               if ((bool)($filter & self::FILTER_MASK_COMPLETE) == $this->driver->is_complete($r)) {
                                   $r['tempid'] = $cid;
                                   $refresh[] = $r;
                               }
                           }
                       }
                   }
               }
               break;
 
         case 'delete':
             $mode  = intval(rcube_utils::get_input_value('mode', rcube_utils::INPUT_POST));
             $oldrec = $this->driver->get_task($rec);
             if ($success = $this->driver->delete_task($rec, false)) {
                 // delete/modify all childs
                 foreach ($this->driver->get_childs($rec, $mode) as $cid) {
                     $child = array('id' => $cid, 'list' => $rec['list']);
 
                     if ($mode == 1) {  // delete all childs
                         if ($this->driver->delete_task($child, false)) {
                             if ($this->driver->undelete)
                                 $_SESSION['tasklist_undelete'][$rec['id']][] = $cid;
                         }
                         else
                             $success = false;
                     }
                     else {
                         $child['parent_id'] = strval($oldrec['parent_id']);
                         $this->driver->edit_task($child);
                     }
                 }
                 // update parent task to adjust list of children
                 if (!empty($oldrec['parent_id'])) {
                     $refresh[] = $this->driver->get_task(array('id' => $oldrec['parent_id'], 'list' => $rec['list']));
                 }
             }
 
             if (!$success)
                 $this->rc->output->command('plugin.reload_data');
             break;
 
         case 'undelete':
             if ($success = $this->driver->undelete_task($rec)) {
                 $refresh[] = $this->driver->get_task($rec);
                 foreach ((array)$_SESSION['tasklist_undelete'][$rec['id']] as $cid) {
                     if ($this->driver->undelete_task($rec)) {
                         $refresh[] = $this->driver->get_task($rec);
                     }
                 }
             }
             break;
 
         case 'collapse':
             foreach (explode(',', $rec['id']) as $rec_id) {
                 if (intval(rcube_utils::get_input_value('collapsed', rcube_utils::INPUT_GPC))) {
                     $this->collapsed_tasks[] = $rec_id;
                 }
                 else {
                     $i = array_search($rec_id, $this->collapsed_tasks);
                     if ($i !== false)
                         unset($this->collapsed_tasks[$i]);
                 }
             }
 
             $this->rc->user->save_prefs(array('tasklist_collapsed_tasks' => join(',', array_unique($this->collapsed_tasks))));
             return;  // avoid further actions
 
         case 'rsvp':
             $status = rcube_utils::get_input_value('status', rcube_utils::INPUT_GPC);
             $noreply = intval(rcube_utils::get_input_value('noreply', rcube_utils::INPUT_GPC)) || $status == 'needs-action';
             $task = $this->driver->get_task($rec);
             $task['attendees'] = $rec['attendees'];
             $task['_type'] = 'task';
 
             // send invitation to delegatee + add it as attendee
             if ($status == 'delegated' && $rec['to']) {
                 $itip = $this->load_itip();
                 if ($itip->delegate_to($task, $rec['to'], (bool)$rec['rsvp'])) {
                     $this->rc->output->show_message('tasklist.itipsendsuccess', 'confirmation');
                     $refresh[] = $task;
                     $noreply = false;
                 }
             }
 
             $rec = $task;
 
             if ($success = $this->driver->edit_task($rec)) {
                 if (!$noreply) {
                     // let the reply clause further down send the iTip message
                     $rec['_reportpartstat'] = $status;
                 }
             }
             break;
 
         case 'changelog':
             $data = $this->driver->get_task_changelog($rec);
             if (is_array($data) && !empty($data)) {
                 $lib = $this->lib;
                 $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 = $lib->adjust_timezone($change['date']);
                       if ($dt instanceof DateTime) {
                           $change['date'] = $this->rc->format_date($dt, $dtformat, false);
                       }
                   }
                 });
                 $this->rc->output->command('plugin.task_render_changelog', $data);
             }
             else {
                 $this->rc->output->command('plugin.task_render_changelog', false);
             }
             $got_msg = true;
             break;
 
         case 'diff':
             $data = $this->driver->get_task_diff($rec, $rec['rev1'], $rec['rev2']);
             if (is_array($data)) {
                 // convert some properties, similar to self::_client_event()
                 $lib = $this->lib;
                 $date_format = $this->rc->config->get('date_format', 'Y-m-d');
                 $time_format = $this->rc->config->get('time_format', 'H:i');
                 array_walk($data['changes'], function(&$change, $i) use ($lib, $date_format, $time_format) {
                     // convert date cols
                     if (in_array($change['property'], array('date','start','created','changed'))) {
                         if (!empty($change['old'])) {
                             $dtformat = strlen($change['old']) == 10 ? $date_format : $date_format . ' ' . $time_format;
                             $change['old_'] = $lib->adjust_timezone($change['old'], strlen($change['old']) == 10)->format($dtformat);
                         }
                         if (!empty($change['new'])) {
                             $dtformat = strlen($change['new']) == 10 ? $date_format : $date_format . ' ' . $time_format;
                             $change['new_'] = $lib->adjust_timezone($change['new'], strlen($change['new']) == 10)->format($dtformat);
                         }
                     }
                     // create textual representation for alarms and recurrence
                     if ($change['property'] == 'alarms') {
                         if (is_array($change['old']))
                             $change['old_'] = libcalendaring::alarm_text($change['old']);
                         if (is_array($change['new']))
                             $change['new_'] = libcalendaring::alarm_text(array_merge((array)$change['old'], $change['new']));
                     }
                     if ($change['property'] == 'recurrence') {
                         if (is_array($change['old']))
                             $change['old_'] = $lib->recurrence_text($change['old']);
                         if (is_array($change['new']))
                             $change['new_'] = $lib->recurrence_text(array_merge((array)$change['old'], $change['new']));
                     }
                     if ($change['property'] == 'complete') {
                         $change['old_'] = intval($change['old']) . '%';
                         $change['new_'] = intval($change['new']) . '%';
                     }
                     if ($change['property'] == 'attachments') {
                         if (is_array($change['old']))
                             $change['old']['classname'] = rcube_utils::file2class($change['old']['mimetype'], $change['old']['name']);
                         if (is_array($change['new'])) {
                             $change['new'] = array_merge((array)$change['old'], $change['new']);
                             $change['new']['classname'] = rcube_utils::file2class($change['new']['mimetype'], $change['new']['name']);
                         }
                     }
                     // resolve parent_id to the refered task title for display
                     if ($change['property'] == 'parent_id') {
                         $change['property'] = 'parent-title';
                         if (!empty($change['old']) && ($old_parent = $this->driver->get_task(array('id' => $change['old'], 'list' => $rec['list'])))) {
                             $change['old_'] = $old_parent['title'];
                         }
                         if (!empty($change['new']) && ($new_parent = $this->driver->get_task(array('id' => $change['new'], 'list' => $rec['list'])))) {
                             $change['new_'] = $new_parent['title'];
                         }
                     }
                     // compute a nice diff of description texts
                     if ($change['property'] == 'description') {
                         $change['diff_'] = libkolab::html_diff($change['old'], $change['new']);
                     }
                 });
                 $this->rc->output->command('plugin.task_show_diff', $data);
             }
             else {
                 $this->rc->output->command('display_message', $this->gettext('objectdiffnotavailable'), 'error');
             }
             $got_msg = true;
             break;
 
         case 'show':
             if ($rec = $this->driver->get_task_revison($rec, $rec['rev'])) {
                 $this->encode_task($rec);
                 $rec['readonly'] = 1;
                 $this->rc->output->command('plugin.task_show_revision', $rec);
             }
             else {
                 $this->rc->output->command('display_message', $this->gettext('objectnotfound'), 'error');
             }
             $got_msg = true;
             break;
 
         case 'restore':
             if ($success = $this->driver->restore_task_revision($rec, $rec['rev'])) {
                 $refresh = $this->driver->get_task($rec);
                 $this->rc->output->command('display_message', $this->gettext(array('name' => 'objectrestoresuccess', 'vars' => array('rev' => $rec['rev']))), 'confirmation');
                 $this->rc->output->command('plugin.close_history_dialog');
             }
             else {
                 $this->rc->output->command('display_message', $this->gettext('objectrestoreerror'), 'error');
             }
             $got_msg = true;
             break;
 
         }
 
         if ($success) {
             $this->rc->output->show_message('successfullysaved', 'confirmation');
             $this->update_counts($oldrec, $refresh);
         }
         else if (!$got_msg) {
             $this->rc->output->show_message('tasklist.errorsaving', 'error');
         }
 
         // send out notifications
         if ($success && $rec['_notify'] && ($rec['attendees'] || $oldrec['attendees'])) {
             // make sure we have the complete record
             $task = $action == 'delete' ? $oldrec : $this->driver->get_task($rec);
 
             // only notify if data really changed (TODO: do diff check on client already)
             if (!$oldrec || $action == 'delete' || self::task_diff($task, $oldrec)) {
                 $sent = $this->notify_attendees($task, $oldrec, $action, $rec['_comment']);
                 if ($sent > 0)
                     $this->rc->output->show_message('tasklist.itipsendsuccess', 'confirmation');
                 else if ($sent < 0)
                     $this->rc->output->show_message('tasklist.errornotifying', 'error');
             }
         }
         else if ($success && $rec['_reportpartstat'] && $rec['_reportpartstat'] != 'NEEDS-ACTION') {
             // get the full record after update
             $task = $this->driver->get_task($rec);
 
             // send iTip REPLY with the updated partstat
             if ($task['organizer'] && ($idx = $this->is_attendee($task)) !== false) {
                 $sender = $task['attendees'][$idx];
                 $status = strtolower($sender['status']);
 
                 if (!empty($_POST['comment']))
                     $task['comment'] = rcube_utils::get_input_value('comment', rcube_utils::INPUT_POST);
 
                 $itip = $this->load_itip();
                 $itip->set_sender_email($sender['email']);
 
                 if ($itip->send_itip_message($this->to_libcal($task), 'REPLY', $task['organizer'], 'itipsubject' . $status, 'itipmailbody' . $status))
                     $this->rc->output->command('display_message', $this->gettext(array('name' => 'sentresponseto', 'vars' => array('mailto' => $task['organizer']['name'] ?: $task['organizer']['email']))), 'confirmation');
                 else
                     $this->rc->output->command('display_message', $this->gettext('itipresponseerror'), 'error');
             }
         }
 
         // unlock client
         $this->rc->output->command('plugin.unlock_saving');
 
         if ($refresh) {
             if ($refresh['id']) {
                 $this->encode_task($refresh);
             }
             else if (is_array($refresh)) {
                 foreach ($refresh as $i => $r)
                     $this->encode_task($refresh[$i]);
             }
             $this->rc->output->command('plugin.update_task', $refresh);
         }
     }
 
     /**
      * Load iTIP functions
      */
     private function load_itip()
     {
         if (!$this->itip) {
             require_once realpath(__DIR__ . '/../libcalendaring/lib/libcalendaring_itip.php');
             $this->itip = new libcalendaring_itip($this, 'tasklist');
             $this->itip->set_rsvp_actions(array('accepted','declined','delegated'));
             $this->itip->set_rsvp_status(array('accepted','tentative','declined','delegated','in-process','completed'));
         }
 
         return $this->itip;
     }
 
     /**
      * repares new/edited task properties before save
      */
     private function prepare_task($rec)
     {
         // try to be smart and extract date from raw input
         if ($rec['raw']) {
             foreach (array('today','tomorrow','sunday','monday','tuesday','wednesday','thursday','friday','saturday','sun','mon','tue','wed','thu','fri','sat') as $word) {
                 $locwords[] = '/^' . preg_quote(mb_strtolower($this->gettext($word))) . '\b/i';
                 $normwords[] = $word;
                 $datewords[] = $word;
             }
             foreach (array('jan','feb','mar','apr','may','jun','jul','aug','sep','oct','now','dec') as $month) {
                 $locwords[] = '/(' . preg_quote(mb_strtolower($this->gettext('long'.$month))) . '|' . preg_quote(mb_strtolower($this->gettext($month))) . ')\b/i';
                 $normwords[] = $month;
                 $datewords[] = $month;
             }
             foreach (array('on','this','next','at') as $word) {
                 $fillwords[] = preg_quote(mb_strtolower($this->gettext($word)));
                 $fillwords[] = $word;
             }
 
             $raw = trim($rec['raw']);
             $date_str = '';
 
             // translate localized keywords
             $raw = preg_replace('/^(' . join('|', $fillwords) . ')\s*/i', '', $raw);
             $raw = preg_replace($locwords, $normwords, $raw);
 
             // find date pattern
             $date_pattern = '!^(\d+[./-]\s*)?((?:\d+[./-])|' . join('|', $datewords) . ')\.?(\s+\d{4})?[:;,]?\s+!i';
             if (preg_match($date_pattern, $raw, $m)) {
                 $date_str .= $m[1] . $m[2] . $m[3];
                 $raw = preg_replace(array($date_pattern, '/^(' . join('|', $fillwords) . ')\s*/i'), '', $raw);
                 // add year to date string
                 if ($m[1] && !$m[3])
                     $date_str .= date('Y');
             }
 
             // find time pattern
             $time_pattern = '/^(\d+([:.]\d+)?(\s*[hapm.]+)?),?\s+/i';
             if (preg_match($time_pattern, $raw, $m)) {
                 $has_time = true;
                 $date_str .= ($date_str ? ' ' : 'today ') . $m[1];
                 $raw = preg_replace($time_pattern, '', $raw);
             }
 
             // yes, raw input matched a (valid) date
             if (strlen($date_str) && strtotime($date_str) && ($date = new DateTime($date_str, $this->timezone))) {
                 $rec['date'] = $date->format('Y-m-d');
                 if ($has_time)
                     $rec['time'] = $date->format('H:i');
                 $rec['title'] = $raw;
             }
             else
                 $rec['title'] = $rec['raw'];
         }
 
         // normalize input from client
         if (isset($rec['complete'])) {
             $rec['complete'] = floatval($rec['complete']);
             if ($rec['complete'] > 1)
                 $rec['complete'] /= 100;
         }
         if (isset($rec['flagged']))
             $rec['flagged'] = intval($rec['flagged']);
 
         // fix for garbage input
         if ($rec['description'] == 'null')
             $rec['description'] = '';
 
         foreach ($rec as $key => $val) {
             if ($val === 'null')
                 $rec[$key] = null;
         }
 
         if (!empty($rec['date'])) {
             $this->normalize_dates($rec, 'date', 'time');
         }
 
         if (!empty($rec['startdate'])) {
             $this->normalize_dates($rec, 'startdate', 'starttime');
         }
 
         // convert tags to array, filter out empty entries
         if (isset($rec['tags']) && !is_array($rec['tags'])) {
             $rec['tags'] = array_filter((array)$rec['tags']);
         }
 
         // convert the submitted alarm values
         if ($rec['valarms']) {
             $valarms = array();
             foreach (libcalendaring::from_client_alarms($rec['valarms']) as $alarm) {
                 // alarms can only work with a date (either task start, due or absolute alarm date)
                 if (is_a($alarm['trigger'], 'DateTime') || $rec['date'] || $rec['startdate'])
                     $valarms[] = $alarm;
             }
             $rec['valarms'] = $valarms;
         }
 
         // convert the submitted recurrence settings
         if (is_array($rec['recurrence'])) {
             $refdate = null;
             if (!empty($rec['date'])) {
                 $refdate = new DateTime($rec['date'] . ' ' . $rec['time'], $this->timezone);
             }
             else if (!empty($rec['startdate'])) {
                 $refdate = new DateTime($rec['startdate'] . ' ' . $rec['starttime'], $this->timezone);
             }
 
             if ($refdate) {
                 $rec['recurrence'] = $this->lib->from_client_recurrence($rec['recurrence'], $refdate);
 
                 // translate count into an absolute end date.
                 // why? because when shifting completed tasks to the next recurrence,
                 // the initial start date to count from gets lost.
                 if ($rec['recurrence']['COUNT']) {
                     $engine = libcalendaring::get_recurrence();
                     $engine->init($rec['recurrence'], $refdate);
                     if ($until = $engine->end()) {
                         $rec['recurrence']['UNTIL'] = $until;
                         unset($rec['recurrence']['COUNT']);
                     }
                 }
             }
             else {  // recurrence requires a reference date
                 $rec['recurrence'] = '';
             }
         }
 
         $attachments = array();
         $taskid = $rec['id'];
         if (is_array($_SESSION[self::SESSION_KEY]) && $_SESSION[self::SESSION_KEY]['id'] == $taskid) {
             if (!empty($_SESSION[self::SESSION_KEY]['attachments'])) {
                 foreach ($_SESSION[self::SESSION_KEY]['attachments'] as $id => $attachment) {
                     if (is_array($rec['attachments']) && in_array($id, $rec['attachments'])) {
                         $attachments[$id] = $this->rc->plugins->exec_hook('attachment_get', $attachment);
                         unset($attachments[$id]['abort'], $attachments[$id]['group']);
                     }
                 }
             }
         }
 
         $rec['attachments'] = $attachments;
 
         // convert link references into simple URIs
         if (array_key_exists('links', $rec)) {
             $rec['links'] = array_map(function($link) { return is_array($link) ? $link['uri'] : strval($link); }, (array)$rec['links']);
         }
 
         // convert invalid data
         if (isset($rec['attendees']) && !is_array($rec['attendees']))
             $rec['attendees'] = array();
 
         foreach ((array)$rec['attendees'] as $i => $attendee) {
             if (is_string($attendee['rsvp'])) {
                 $rec['attendees'][$i]['rsvp'] = $attendee['rsvp'] == 'true' || $attendee['rsvp'] == '1';
             }
         }
 
         // copy the task status to my attendee partstat
         if (!empty($rec['_reportpartstat'])) {
             if (($idx = $this->is_attendee($rec)) !== false) {
                 if (!($rec['_reportpartstat'] == 'NEEDS-ACTION' && $rec['attendees'][$idx]['status'] == 'ACCEPTED'))
                     $rec['attendees'][$idx]['status'] = $rec['_reportpartstat'];
                 else
                     unset($rec['_reportpartstat']);
             }
         }
 
         // set organizer from identity selector
         if ((isset($rec['_identity']) || (!empty($rec['attendees']) && empty($rec['organizer']))) &&
                 ($identity = $this->rc->user->get_identity($rec['_identity']))) {
             $rec['organizer'] = array('name' => $identity['name'], 'email' => $identity['email']);
         }
 
         if (is_numeric($rec['id']) && $rec['id'] < 0)
             unset($rec['id']);
 
         return $rec;
     }
 
     /**
      * Utility method to convert a tasks date/time values into a normalized format
      */
     private function normalize_dates(&$rec, $date_key, $time_key)
     {
         try {
             // parse date from user format (#2801)
             $date_format = $this->rc->config->get(empty($rec[$time_key]) ? 'date_format' : 'date_long', 'Y-m-d');
             $date = DateTime::createFromFormat($date_format, trim($rec[$date_key] . ' ' . $rec[$time_key]), $this->timezone);
 
             // fall back to default strtotime logic
             if (empty($date)) {
                 $date = new DateTime($rec[$date_key] . ' ' . $rec[$time_key], $this->timezone);
             }
 
             $rec[$date_key] = $date->format('Y-m-d');
             if (!empty($rec[$time_key]))
                 $rec[$time_key] = $date->format('H:i');
 
             return true;
         }
         catch (Exception $e) {
             $rec[$date_key] = $rec[$time_key] = null;
         }
 
         return false;
     }
 
     /**
      * Releases some resources after successful save
      */
     private function cleanup_task(&$rec)
     {
         // remove temp. attachment files
         if (!empty($_SESSION[self::SESSION_KEY]) && ($taskid = $_SESSION[self::SESSION_KEY]['id'])) {
             $this->rc->plugins->exec_hook('attachments_cleanup', array('group' => $taskid));
             $this->rc->session->remove(self::SESSION_KEY);
         }
     }
 
     /**
      * When flagging a recurring task as complete,
      * clone it and shift dates to the next occurrence
      */
     private function handle_recurrence(&$rec, $old)
     {
         $clone = null;
         if ($this->driver->is_complete($rec) && $old && !$this->driver->is_complete($old) && is_array($rec['recurrence'])) {
             $engine = libcalendaring::get_recurrence();
             $rrule = $rec['recurrence'];
             $updates = array();
 
             // compute the next occurrence of date attributes
             foreach (array('date'=>'time', 'startdate'=>'starttime') as $date_key => $time_key) {
                 if (empty($rec[$date_key]))
                     continue;
 
                 $date = new DateTime($rec[$date_key] . ' ' . $rec[$time_key], $this->timezone);
                 $engine->init($rrule, $date);
                 if ($next = $engine->next()) {
                     $updates[$date_key] = $next->format('Y-m-d');
                     if (!empty($rec[$time_key]))
                         $updates[$time_key] = $next->format('H:i');
                 }
             }
 
             // shift absolute alarm dates
             if (!empty($updates) && is_array($rec['valarms'])) {
                 $updates['valarms'] = array();
                 unset($rrule['UNTIL'], $rrule['COUNT']);  // make recurrence rule unlimited
 
                 foreach ($rec['valarms'] as $i => $alarm) {
                     if ($alarm['trigger'] instanceof DateTime) {
                         $engine->init($rrule, $alarm['trigger']);
                         if ($next = $engine->next()) {
                             $alarm['trigger'] = $next;
                         }
                     }
                     $updates['valarms'][$i] = $alarm;
                 }
             }
 
             if (!empty($updates)) {
                 // clone task to save a completed copy
                 $clone = $rec;
                 $clone['uid'] = $this->generate_uid();
                 $clone['parent_id'] = $rec['id'];
                 unset($clone['id'], $clone['recurrence'], $clone['attachments']);
 
                 // update the task but unset completed flag
                 $rec = array_merge($rec, $updates);
                 $rec['complete'] = $old['complete'];
                 $rec['status'] = $old['status'];
             }
         }
 
         return $clone;
     }
 
     /**
      * Send out an invitation/notification to all task attendees
      */
     private function notify_attendees($task, $old, $action = 'edit', $comment = null)
     {
         if ($action == 'delete' || ($task['status'] == 'CANCELLED' && $old['status'] != $task['status'])) {
             $task['cancelled'] = true;
             $is_cancelled      = true;
         }
 
         $itip   = $this->load_itip();
         $emails = $this->lib->get_user_emails();
         $itip_notify = (int)$this->rc->config->get('calendar_itip_send_option', 3);
 
         // add comment to the iTip attachment
         $task['comment'] = $comment;
 
         // needed to generate VTODO instead of VEVENT entry
         $task['_type'] = 'task';
 
         // compose multipart message using PEAR:Mail_Mime
         $method  = $action == 'delete' ? 'CANCEL' : 'REQUEST';
         $object = $this->to_libcal($task);
         $message = $itip->compose_itip_message($object, $method, $task['sequence'] > $old['sequence']);
 
         // list existing attendees from the $old task
         $old_attendees = array();
         foreach ((array)$old['attendees'] as $attendee) {
             $old_attendees[] = $attendee['email'];
         }
 
         // send to every attendee
         $sent = 0; $current = array();
         foreach ((array)$task['attendees'] as $attendee) {
             $current[] = strtolower($attendee['email']);
 
             // skip myself for obvious reasons
             if (!$attendee['email'] || in_array(strtolower($attendee['email']), $emails)) {
                 continue;
             }
 
             // skip if notification is disabled for this attendee
             if ($attendee['noreply'] && $itip_notify & 2) {
                 continue;
             }
 
             // skip if this attendee has delegated and set RSVP=FALSE
             if ($attendee['status'] == 'DELEGATED' && $attendee['rsvp'] === false) {
                 continue;
             }
 
             // which template to use for mail text
             $is_new   = !in_array($attendee['email'], $old_attendees);
             $is_rsvp  = $is_new || $task['sequence'] > $old['sequence'];
             $bodytext = $is_cancelled ? 'itipcancelmailbody' : ($is_new ? 'invitationmailbody' : 'itipupdatemailbody');
             $subject  = $is_cancelled ? 'itipcancelsubject'  : ($is_new ? 'invitationsubject' : ($task['title'] ? 'itipupdatesubject' : 'itipupdatesubjectempty'));
 
             // finally send the message
             if ($itip->send_itip_message($object, $method, $attendee, $subject, $bodytext, $message, $is_rsvp))
                 $sent++;
             else
                 $sent = -100;
         }
 
         // send CANCEL message to removed attendees
         foreach ((array)$old['attendees'] as $attendee) {
             if (!$attendee['email'] || in_array(strtolower($attendee['email']), $current)) {
                 continue;
             }
 
             $vtodo = $this->to_libcal($old);
             $vtodo['cancelled'] = $is_cancelled;
             $vtodo['attendees'] = array($attendee);
             $vtodo['comment']   = $comment;
 
             if ($itip->send_itip_message($vtodo, 'CANCEL', $attendee, 'itipcancelsubject', 'itipcancelmailbody'))
                 $sent++;
             else
                 $sent = -100;
         }
 
         return $sent;
     }
 
     /**
      * Compare two task objects and return differing properties
      *
      * @param array Event A
      * @param array Event B
      * @return array List of differing task properties
      */
     public static function task_diff($a, $b)
     {
         $diff   = array();
         $ignore = array('changed' => 1, 'attachments' => 1);
 
         foreach (array_unique(array_merge(array_keys($a), array_keys($b))) as $key) {
             if (!$ignore[$key] && $a[$key] != $b[$key])
                 $diff[] = $key;
         }
 
         // only compare number of attachments
         if (count($a['attachments']) != count($b['attachments']))
             $diff[] = 'attachments';
 
         return $diff;
     }
 
     /**
      * Dispatcher for tasklist actions initiated by the client
      */
     public function tasklist_action()
     {
         $action  = rcube_utils::get_input_value('action', rcube_utils::INPUT_GPC);
         $list    = rcube_utils::get_input_value('l', rcube_utils::INPUT_GPC, true);
         $success = false;
 
         if (isset($list['showalarms']))
           $list['showalarms'] = intval($list['showalarms']);
 
         switch ($action) {
         case 'form-new':
         case 'form-edit':
             echo $this->ui->tasklist_editform($action, $list);
             exit;
 
         case 'new':
             $list += array('showalarms' => true, 'active' => true, 'editable' => true);
             if ($insert_id = $this->driver->create_list($list)) {
                 $list['id'] = $insert_id;
                 if (!$list['_reload']) {
                     $this->load_ui();
                     $list['html'] = $this->ui->tasklist_list_item($insert_id, $list, $jsenv);
                     $list += (array)$jsenv[$insert_id];
                 }
                 $this->rc->output->command('plugin.insert_tasklist', $list);
                 $success = true;
             }
             break;
 
         case 'edit':
             if ($newid = $this->driver->edit_list($list)) {
                 $list['oldid'] = $list['id'];
                 $list['id'] = $newid;
                 $this->rc->output->command('plugin.update_tasklist', $list);
                 $success = true;
             }
             break;
 
         case 'subscribe':
             $success = $this->driver->subscribe_list($list);
             break;
 
         case 'delete':
             if (($success = $this->driver->delete_list($list)))
                 $this->rc->output->command('plugin.destroy_tasklist', $list);
             break;
 
         case 'search':
             $this->load_ui();
             $results = array();
             $query   = rcube_utils::get_input_value('q', rcube_utils::INPUT_GPC);
             $source  = rcube_utils::get_input_value('source', rcube_utils::INPUT_GPC);
 
             foreach ((array)$this->driver->search_lists($query, $source) as $id => $prop) {
                 $editname = $prop['editname'];
                 unset($prop['editname']);  // force full name to be displayed
                 $prop['active'] = false;
 
                 // let the UI generate HTML and CSS representation for this calendar
                 $html = $this->ui->tasklist_list_item($id, $prop, $jsenv);
                 $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;
         }
 
         if ($success)
             $this->rc->output->show_message('successfullysaved', 'confirmation');
         else
             $this->rc->output->show_message('tasklist.errorsaving', 'error');
 
         $this->rc->output->command('plugin.unlock_saving');
     }
 
     /**
      * Get counts for active tasks divided into different selectors
      */
     public function fetch_counts()
     {
         if (isset($_REQUEST['lists'])) {
             $lists = rcube_utils::get_input_value('lists', rcube_utils::INPUT_GPC);
         }
         else {
             foreach ($this->driver->get_lists() as $list) {
                 if ($list['active'])
                     $lists[] = $list['id'];
             }
         }
         $counts = $this->driver->count_tasks($lists);
         $this->rc->output->command('plugin.update_counts', $counts);
     }
 
     /**
      * Adjust the cached counts after changing a task
      */
     public function update_counts($oldrec, $newrec)
     {
         // rebuild counts until this function is finally implemented
         $this->fetch_counts();
 
         // $this->rc->output->command('plugin.update_counts', $counts);
     }
 
     /**
      *
      */
     public function fetch_tasks()
     {
         $f = intval(rcube_utils::get_input_value('filter', rcube_utils::INPUT_GPC));
         $search = rcube_utils::get_input_value('q', rcube_utils::INPUT_GPC);
         $lists  = rcube_utils::get_input_value('lists', rcube_utils::INPUT_GPC);
         $filter = array('mask' => $f, 'search' => $search);
 /*
         // convert magic date filters into a real date range
         switch ($f) {
         case self::FILTER_MASK_TODAY:
             $today = new DateTime('now', $this->timezone);
             $filter['from'] = $filter['to'] = $today->format('Y-m-d');
             break;
 
         case self::FILTER_MASK_TOMORROW:
             $tomorrow = new DateTime('now + 1 day', $this->timezone);
             $filter['from'] = $filter['to'] = $tomorrow->format('Y-m-d');
             break;
 
         case self::FILTER_MASK_OVERDUE:
             $yesterday = new DateTime('yesterday', $this->timezone);
             $filter['to'] = $yesterday->format('Y-m-d');
             break;
 
         case self::FILTER_MASK_WEEK:
             $today = new DateTime('now', $this->timezone);
             $filter['from'] = $today->format('Y-m-d');
             $weekend = new DateTime('now + 7 days', $this->timezone);
             $filter['to'] = $weekend->format('Y-m-d');
             break;
 
         case self::FILTER_MASK_LATER:
             $date = new DateTime('now + 8 days', $this->timezone);
             $filter['from'] = $date->format('Y-m-d');
             break;
 
         }
 */
         $data = $this->tasks_data($this->driver->list_tasks($filter, $lists), $f);
         $this->rc->output->command('plugin.data_ready', array(
             'filter' => $f,
             'lists' => $lists,
             'search' => $search,
             'data' => $data,
             'tags' => $this->driver->get_tags(),
         ));
     }
 
     /**
      * Handler for printing calendars
      */
     public function print_tasks()
     {
         // Add CSS stylesheets to the page header
         $skin_path = $this->local_skin_path();
 
         $this->include_stylesheet($skin_path . '/print.css');
         $this->include_script('tasklist.js');
 
         $this->rc->output->add_handlers(array(
             'plugin.tasklist_print' => array($this, 'print_tasks_list'),
         ));
 
         $this->rc->output->set_pagetitle($this->gettext('print'));
         $this->rc->output->send('tasklist.print');
     }
 
     /**
      * Handler for printing calendars
      */
     public function print_tasks_list($attrib)
     {
         $f      = intval(rcube_utils::get_input_value('filter', rcube_utils::INPUT_GPC));
         $search = rcube_utils::get_input_value('q', rcube_utils::INPUT_GPC);
         $lists  = rcube_utils::get_input_value('lists', rcube_utils::INPUT_GPC);
         $filter = array('mask' => $f, 'search' => $search);
 
         $data = $this->tasks_data($this->driver->list_tasks($filter, $lists), $f);
 
         // we'll build the tasks table in javascript on page load
         // where we have sorting methods, etc.
         $this->rc->output->set_env('tasks', $data);
 
         return $this->ui->tasks_resultview($attrib);
     }
 
     /**
      * Prepare and sort the given task records to be sent to the client
      */
     private function tasks_data($records, $f)
     {
         $data = $this->task_tree = $this->task_titles = array();
 
         foreach ($records as $rec) {
             if ($rec['parent_id']) {
                 $this->task_tree[$rec['id']] = $rec['parent_id'];
             }
 
             $this->encode_task($rec);
 
             // apply filter; don't trust the driver on this :-)
             if ((!$f && !$this->driver->is_complete($rec)) || ($rec['mask'] & $f))
                 $data[] = $rec;
         }
 
         // assign hierarchy level indicators for later sorting
         array_walk($data, array($this, 'task_walk_tree'));
 
         return $data;
     }
 
     /**
      * Prepare the given task record before sending it to the client
      */
     private function encode_task(&$rec)
     {
         $rec['mask'] = $this->filter_mask($rec);
         $rec['flagged'] = intval($rec['flagged']);
         $rec['complete'] = floatval($rec['complete']);
 
         if (is_object($rec['created'])) {
             $rec['created_'] = $this->rc->format_date($rec['created']);
             $rec['created'] = $rec['created']->format('U');
         }
         if (is_object($rec['changed'])) {
             $rec['changed_'] = $this->rc->format_date($rec['changed']);
             $rec['changed'] = $rec['changed']->format('U');
         }
         else {
             $rec['changed'] = null;
         }
 
         if ($rec['date']) {
             try {
                 $date = new DateTime($rec['date'] . ' ' . $rec['time'], $this->timezone);
                 $rec['datetime'] = intval($date->format('U'));
                 $rec['date'] = $date->format($this->rc->config->get('date_format', 'Y-m-d'));
                 $rec['_hasdate'] = 1;
             }
             catch (Exception $e) {
                 $rec['date'] = $rec['datetime'] = null;
             }
         }
         else {
             $rec['date'] = $rec['datetime'] = null;
             $rec['_hasdate'] = 0;
         }
 
         if ($rec['startdate']) {
             try {
                 $date = new DateTime($rec['startdate'] . ' ' . $rec['starttime'], $this->timezone);
                 $rec['startdatetime'] = intval($date->format('U'));
                 $rec['startdate'] = $date->format($this->rc->config->get('date_format', 'Y-m-d'));
             }
             catch (Exception $e) {
                 $rec['startdate'] = $rec['startdatetime'] = null;
             }
         }
 
         if ($rec['valarms']) {
             $rec['alarms_text'] = libcalendaring::alarms_text($rec['valarms']);
             $rec['valarms'] = libcalendaring::to_client_alarms($rec['valarms']);
         }
 
         if ($rec['recurrence']) {
             $rec['recurrence_text'] = $this->lib->recurrence_text($rec['recurrence']);
             $rec['recurrence'] = $this->lib->to_client_recurrence($rec['recurrence'], $rec['time'] || $rec['starttime']);
         }
 
         foreach ((array)$rec['attachments'] as $k => $attachment) {
             $rec['attachments'][$k]['classname'] = rcube_utils::file2class($attachment['mimetype'], $attachment['name']);
         }
 
         // convert link URIs references into structs
         if (array_key_exists('links', $rec)) {
-            foreach ((array)$rec['links'] as $i => $link) {
-                if (strpos($link, 'imap://') === 0 && ($msgref = $this->driver->get_message_reference($link))) {
+            foreach ((array) $rec['links'] as $i => $link) {
+                if (strpos($link, 'imap://') === 0 && ($msgref = $this->driver->get_message_reference($link, 'task'))) {
                     $rec['links'][$i] = $msgref;
                 }
             }
         }
 
         // Convert HTML description into plain text
         if ($this->is_html($rec)) {
             $h2t = new rcube_html2text($rec['description'], false, true, 0);
             $rec['description'] = $h2t->get_text();
         }
 
         if (!is_array($rec['tags']))
             $rec['tags'] = (array)$rec['tags'];
         sort($rec['tags'], SORT_LOCALE_STRING);
 
         if (in_array($rec['id'], $this->collapsed_tasks))
           $rec['collapsed'] = true;
 
         if (empty($rec['parent_id']))
             $rec['parent_id'] = null;
 
         $this->task_titles[$rec['id']] = $rec['title'];
     }
 
     /**
      * Determine whether the given task description is HTML formatted
      */
     private function is_html($task)
     {
         // check for opening and closing <html> or <body> tags
         return (preg_match('/<(html|body)(\s+[a-z]|>)/', $task['description'], $m) && strpos($task['description'], '</'.$m[1].'>') > 0);
     }
 
     /**
      * Callback function for array_walk over all tasks.
      * Sets tree depth and parent titles
      */
     private function task_walk_tree(&$rec)
     {
         $rec['_depth'] = 0;
         $parent_titles = array();
         $parent_id = $this->task_tree[$rec['id']];
         while ($parent_id) {
             $rec['_depth']++;
             array_unshift($parent_titles, $this->task_titles[$parent_id]);
             $parent_id = $this->task_tree[$parent_id];
         }
 
         if (count($parent_titles)) {
             $rec['parent_title'] = join(' » ', array_filter($parent_titles));
         }
     }
 
     /**
      * Compute the filter mask of the given task
      *
      * @param array Hash array with Task record properties
      * @return int Filter mask
      */
     public function filter_mask($rec)
     {
         static $today, $tomorrow, $weeklimit;
 
         if (!$today) {
             $today_date = new DateTime('now', $this->timezone);
             $today = $today_date->format('Y-m-d');
             $tomorrow_date = new DateTime('now + 1 day', $this->timezone);
             $tomorrow = $tomorrow_date->format('Y-m-d');
             $week_date = new DateTime('now + 7 days', $this->timezone);
             $weeklimit = $week_date->format('Y-m-d');
         }
 
         $mask = 0;
         $start = $rec['startdate'] ?: '1900-00-00';
         $duedate = $rec['date'] ?: '3000-00-00';
 
         if ($rec['flagged'])
             $mask |= self::FILTER_MASK_FLAGGED;
         if ($this->driver->is_complete($rec))
             $mask |= self::FILTER_MASK_COMPLETE;
 
         if (empty($rec['date']))
             $mask |= self::FILTER_MASK_NODATE;
         else if ($rec['date'] < $today)
             $mask |= self::FILTER_MASK_OVERDUE;
 
         if ($duedate <= $today || ($rec['startdate'] && $start <= $today))
             $mask |= self::FILTER_MASK_TODAY;
         if ($duedate <= $tomorrow || ($rec['startdate'] && $start <= $tomorrow))
             $mask |= self::FILTER_MASK_TOMORROW;
         if (($start > $tomorrow && $start <= $weeklimit) || ($duedate > $tomorrow && $duedate <= $weeklimit))
             $mask |= self::FILTER_MASK_WEEK;
         else if ($start > $weeklimit || ($rec['date'] && $duedate > $weeklimit))
             $mask |= self::FILTER_MASK_LATER;
 
         // add masks for assigned tasks
         if ($this->is_organizer($rec) && !empty($rec['attendees']) && $this->is_attendee($rec) === false)
             $mask |= self::FILTER_MASK_ASSIGNED;
         else if (/*empty($rec['attendees']) ||*/ $this->is_attendee($rec) !== false)
             $mask |= self::FILTER_MASK_MYTASKS;
 
         return $mask;
     }
 
     /**
      * Determine whether the current user is an attendee of the given task
      */
     public function is_attendee($task)
     {
         $emails = $this->lib->get_user_emails();
         foreach ((array)$task['attendees'] as $i => $attendee) {
             if ($attendee['email'] && in_array(strtolower($attendee['email']), $emails)) {
                 return $i;
             }
         }
 
         return false;
     }
 
     /**
      * Determine whether the current user is the organizer of the given task
      */
     public function is_organizer($task)
     {
         $emails = $this->lib->get_user_emails();
         return (empty($task['organizer']) || in_array(strtolower($task['organizer']['email']), $emails));
     }
 
 
     /*******  UI functions  ********/
 
     /**
      * Render main view of the tasklist task
      */
     public function tasklist_view()
     {
         $this->ui->init();
         $this->ui->init_templates();
 
         // set autocompletion env
         $this->rc->output->set_env('autocomplete_threads', (int)$this->rc->config->get('autocomplete_threads', 0));
         $this->rc->output->set_env('autocomplete_max', (int)$this->rc->config->get('autocomplete_max', 15));
         $this->rc->output->set_env('autocomplete_min_length', $this->rc->config->get('autocomplete_min_length'));
         $this->rc->output->add_label('autocompletechars', 'autocompletemore', 'delete', 'close', 'libcalendaring.expandattendeegroup', 'libcalendaring.expandattendeegroupnodata');
 
         $this->rc->output->set_pagetitle($this->gettext('navtitle'));
         $this->rc->output->send('tasklist.mainview');
     }
 
 
     /**
      *
      */
     public function get_inline_ui()
     {
         foreach (array('save','cancel','savingdata') as $label)
             $texts['tasklist.'.$label] = $this->gettext($label);
 
         $texts['tasklist.newtask'] = $this->gettext('createfrommail');
 
 
         $this->ui->init_templates();
         $this->ui->tasklists();
 
         // collect env variables
         $env = array(
             'tasklists' => $this->rc->output->get_env('tasklists'),
             'tasklist_settings' => $this->ui->load_settings(),
         );
 
         echo $this->api->output->parse('tasklist.taskedit', false, false);
 
         $script_add = '';
         foreach ($this->ui->get_gui_objects() as $obj => $id) {
             $script_add .= rcmail_output::JS_OBJECT_NAME . ".gui_object('$obj', '$id');\n";
         }
 
         echo html::tag('script', array('type' => 'text/javascript'),
             rcmail_output::JS_OBJECT_NAME . ".set_env(" . json_encode($env) . ");\n".
             rcmail_output::JS_OBJECT_NAME . ".add_label(" . json_encode($texts) . ");\n".
             $script_add
         );
         exit;
     }
 
     /**
      * Handler for keep-alive requests
      * This will check for updated data in active lists and sync them to the client
      */
     public function refresh($attr)
     {
         // refresh the entire list every 10th time to also sync deleted items
         if (rand(0,10) == 10) {
             $this->rc->output->command('plugin.reload_data');
             return;
         }
 
         $filter = array(
             'since'  => $attr['last'],
             'search' => rcube_utils::get_input_value('q', rcube_utils::INPUT_GPC),
             'mask'   => intval(rcube_utils::get_input_value('filter', rcube_utils::INPUT_GPC)) & self::FILTER_MASK_COMPLETE,
         );
         $lists = rcube_utils::get_input_value('lists', rcube_utils::INPUT_GPC);;
 
         $updates = $this->driver->list_tasks($filter, $lists);
         if (!empty($updates)) {
             $this->rc->output->command('plugin.refresh_tasks', $this->tasks_data($updates, 255), true);
 
             // update counts
             $counts = $this->driver->count_tasks($lists);
             $this->rc->output->command('plugin.update_counts', $counts);
         }
     }
 
     /**
      * Handler for pending_alarms plugin hook triggered by the calendar module on keep-alive requests.
      * This will check for pending notifications and pass them to the client
      */
     public function pending_alarms($p)
     {
         $this->load_driver();
         if ($alarms = $this->driver->pending_alarms($p['time'] ?: time())) {
             foreach ($alarms as $alarm) {
                 // encode alarm object to suit the expectations of the calendaring code
                 if ($alarm['date'])
                     $alarm['start'] = new DateTime($alarm['date'].' '.$alarm['time'], $this->timezone);
 
                 $alarm['id'] = 'task:' . $alarm['id'];  // prefix ID with task:
                 $alarm['allday'] = empty($alarm['time']) ? 1 : 0;
                 $p['alarms'][] = $alarm;
             }
         }
 
         return $p;
     }
 
     /**
      * Handler for alarm dismiss hook triggered by the calendar module
      */
     public function dismiss_alarms($p)
     {
         $this->load_driver();
         foreach ((array)$p['ids'] as $id) {
             if (strpos($id, 'task:') === 0)
                 $p['success'] |= $this->driver->dismiss_alarm(substr($id, 5), $p['snooze']);
         }
 
         return $p;
     }
 
 
     /******* Attachment handling  *******/
 
     /**
      * Handler for attachments upload
     */
     public function attachment_upload()
     {
         $this->lib->attachment_upload(self::SESSION_KEY);
     }
 
     /**
      * Handler for attachments download/displaying
      */
     public function attachment_get()
     {
         // show loading page
         if (!empty($_GET['_preload'])) {
             return $this->lib->attachment_loading_page();
         }
 
         $task = rcube_utils::get_input_value('_t', rcube_utils::INPUT_GPC);
         $list = rcube_utils::get_input_value('_list', rcube_utils::INPUT_GPC);
         $id   = rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC);
         $rev  = rcube_utils::get_input_value('_rev', rcube_utils::INPUT_GPC);
 
         $task = array('id' => $task, 'list' => $list, 'rev' => $rev);
         $attachment = $this->driver->get_attachment($id, $task);
 
         // show part page
         if (!empty($_GET['_frame'])) {
             $this->lib->attachment = $attachment;
             $this->register_handler('plugin.attachmentframe', array($this->lib, 'attachment_frame'));
             $this->register_handler('plugin.attachmentcontrols', array($this->lib, 'attachment_header'));
             $this->rc->output->send('tasklist.attachment');
         }
         // deliver attachment content
         else if ($attachment) {
             $attachment['body'] = $this->driver->get_attachment_body($id, $task);
             $this->lib->attachment_get($attachment);
         }
 
         // if we arrive here, the requested part was not found
         header('HTTP/1.1 404 Not Found');
         exit;
     }
 
 
     /*******  Email related function *******/
 
     public function mail_message2task()
     {
         $uid  = rcube_utils::get_input_value('_uid', rcube_utils::INPUT_POST);
         $mbox = rcube_utils::get_input_value('_mbox', rcube_utils::INPUT_POST);
         $task = array();
 
         // establish imap connection
         $imap = $this->rc->get_storage();
         $imap->set_folder($mbox);
         $message = new rcube_message($uid);
 
         if ($message->headers) {
             $task['title'] = trim($message->subject);
             $task['description'] = trim($message->first_text_part());
             $task['id'] = -$uid;
 
             $this->load_driver();
 
             // add a reference to the email message
             if ($msgref = $this->driver->get_message_reference($message->headers, $mbox)) {
                 $task['links'] = array($msgref);
             }
             // copy mail attachments to task
             else if ($message->attachments && $this->driver->attachments) {
                 if (!is_array($_SESSION[self::SESSION_KEY]) || $_SESSION[self::SESSION_KEY]['id'] != $task['id']) {
                     $_SESSION[self::SESSION_KEY] = array();
                     $_SESSION[self::SESSION_KEY]['id'] = $task['id'];
                     $_SESSION[self::SESSION_KEY]['attachments'] = array();
                 }
 
                 foreach ((array)$message->attachments as $part) {
                     $attachment = array(
                         'data' => $imap->get_message_part($uid, $part->mime_id, $part),
                         'size' => $part->size,
                         'name' => $part->filename,
                         'mimetype' => $part->mimetype,
                         'group' => $task['id'],
                     );
 
                     $attachment = $this->rc->plugins->exec_hook('attachment_save', $attachment);
 
                     if ($attachment['status'] && !$attachment['abort']) {
                         $id = $attachment['id'];
                         $attachment['classname'] = rcube_utils::file2class($attachment['mimetype'], $attachment['name']);
 
                         // store new attachment in session
                         unset($attachment['status'], $attachment['abort'], $attachment['data']);
                         $_SESSION[self::SESSION_KEY]['attachments'][$id] = $attachment;
 
                         $attachment['id'] = 'rcmfile' . $attachment['id'];  // add prefix to consider it 'new'
                         $task['attachments'][] = $attachment;
                     }
                 }
             }
 
             $this->rc->output->command('plugin.mail2taskdialog', $task);
         }
         else {
             $this->rc->output->command('display_message', $this->gettext('messageopenerror'), 'error');
         }
 
         $this->rc->output->send();
     }
 
     /**
      * Add UI element to copy task invitations or updates to the tasklist
      */
     public function mail_messagebody_html($p)
     {
         // load iCalendar functions (if necessary)
         if (!empty($this->lib->ical_parts)) {
             $this->get_ical();
             $this->load_itip();
         }
 
         $html = '';
         $has_tasks = false;
         $ical_objects = $this->lib->get_mail_ical_objects();
 
         // show a box for every task in the file
         foreach ($ical_objects as $idx => $task) {
             if ($task['_type'] != 'task') {
                 continue;
             }
 
             $has_tasks = true;
 
             // get prepared inline UI for this event object
             if ($ical_objects->method) {
                 $html .= html::div('tasklist-invitebox',
                     $this->itip->mail_itip_inline_ui(
                         $task,
                         $ical_objects->method,
                         $ical_objects->mime_id . ':' . $idx,
                         'tasks',
                         rcube_utils::anytodatetime($ical_objects->message_date)
                     )
                 );
             }
 
             // limit listing
             if ($idx >= 3) {
                 break;
             }
         }
 
         // list linked tasks
         $links = array();
         foreach ($this->message_tasks as $task) {
             $checkbox = new html_checkbox(array(
                 'name' => 'completed',
                 'class' => 'complete',
                 'title' => $this->gettext('complete'),
                 'data-list' => $task['list'],
             ));
             $complete = $this->driver->is_complete($task);
             $links[] = html::tag('li', 'messagetaskref' . ($complete ? ' complete' : ''),
                 $checkbox->show($complete ? $task['id'] : null, array('value' => $task['id'])) . ' ' .
                 html::a(array(
                     'href' => $this->rc->url(array(
                         'task' => 'tasks',
                         'list' => $task['list'],
                         'id' => $task['id'],
                     )),
                     'class' => 'messagetasklink',
                     'rel' => $task['id'] . '@' . $task['list'],
                     'target' => '_blank',
                 ), rcube::Q($task['title']))
             );
         }
         if (count($links)) {
             $html .= html::div('messagetasklinks', html::tag('ul', 'tasklist', join("\n", $links)));
         }
 
         // prepend iTip/relation boxes to message body
         if ($html) {
             $this->load_ui();
             $this->ui->init();
 
             $p['content'] = $html . $p['content'];
 
             $this->rc->output->add_label('tasklist.savingdata','tasklist.deletetaskconfirm','tasklist.declinedeleteconfirm');
         }
 
         // add "Save to tasks" button into attachment menu
         if ($has_tasks) {
             $this->add_button(array(
                 'id'         => 'attachmentsavetask',
                 'name'       => 'attachmentsavetask',
                 'type'       => 'link',
                 'wrapper'    => 'li',
                 'command'    => 'attachment-save-task',
                 'class'      => 'icon tasklistlink',
                 'classact'   => 'icon tasklistlink active',
                 'innerclass' => 'icon taskadd',
                 'label'      => 'tasklist.savetotasklist',
             ), 'attachmentmenu');
         }
 
         return $p;
     }
 
     /**
      * 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->load_driver();
             $this->message_tasks = $this->driver->get_message_related_tasks($p['object']->headers, $p['object']->folder);
 
             // sort message tasks by completeness and due date
             $driver = $this->driver;
             array_walk($this->message_tasks, array($this, 'encode_task'));
             usort($this->message_tasks, function($a, $b) use ($driver) {
                 $a_complete = intval($driver->is_complete($a));
                 $b_complete = intval($driver->is_complete($b));
                 $d = $a_complete - $b_complete;
                 if (!$d) $d = $b['_hasdate'] - $a['_hasdate'];
                 if (!$d) $d = $a['datetime'] - $b['datetime'];
                 return $d;
             });
         }
     }
 
     /**
      * Load iCalendar functions
      */
     public function get_ical()
     {
         if (!$this->ical) {
             $this->ical = libcalendaring::get_ical();
         }
 
         return $this->ical;
     }
 
     /**
      * Get properties of the tasklist this user has specified as default
      */
     public function get_default_tasklist($sensitivity = null)
     {
         $lists = $this->driver->get_lists();
         $list = null;
 
         foreach ($lists as $l) {
             if ($sensitivity && $l['subtype'] == $sensitivity) {
                 $list = $l;
                 break;
             }
             if ($l['default']) {
                 $list = $l;
             }
 
             if ($l['editable']) {
                 $first = $l;
             }
         }
 
         return $list ?: $first;
     }
 
     /**
      * Import the full payload from a mail message attachment
      */
     public function mail_import_attachment()
     {
         $uid     = rcube_utils::get_input_value('_uid', rcube_utils::INPUT_POST);
         $mbox    = rcube_utils::get_input_value('_mbox', rcube_utils::INPUT_POST);
         $mime_id = rcube_utils::get_input_value('_part', rcube_utils::INPUT_POST);
         $charset = RCUBE_CHARSET;
 
         // establish imap connection
         $imap = $this->rc->get_storage();
         $imap->set_folder($mbox);
 
         if ($uid && $mime_id) {
             $part    = $imap->get_message_part($uid, $mime_id);
 //            $headers = $imap->get_message_headers($uid);
 
             if ($part->ctype_parameters['charset']) {
                 $charset = $part->ctype_parameters['charset'];
             }
 
             if ($part) {
                 $tasks = $this->get_ical()->import($part, $charset);
             }
         }
 
         $success = $existing = 0;
 
         if (!empty($tasks)) {
             // find writeable tasklist to store task
             $cal_id = !empty($_REQUEST['_list']) ? rcube_utils::get_input_value('_list', rcube_utils::INPUT_POST) : null;
             $lists  = $this->driver->get_lists();
 
             foreach ($tasks as $task) {
                 // save to tasklist
                 $list   = $lists[$cal_id] ?: $this->get_default_tasklist($task['sensitivity']);
                 if ($list && $list['editable'] && $task['_type'] == 'task') {
                     $task = $this->from_ical($task);
                     $task['list'] = $list['id'];
 
                     if (!$this->driver->get_task($task['uid'])) {
                         $success += (bool) $this->driver->create_task($task);
                     }
                     else {
                         $existing++;
                     }
                 }
             }
         }
 
         if ($success) {
             $this->rc->output->command('display_message', $this->gettext(array(
                 'name' => 'importsuccess',
                 'vars' => array('nr' => $success),
             )), 'confirmation');
         }
         else if ($existing) {
             $this->rc->output->command('display_message', $this->gettext('importwarningexists'), 'warning');
         }
         else {
             $this->rc->output->command('display_message', $this->gettext('errorimportingtask'), 'error');
         }
     }
 
     /**
      * Handler for POST request to import an event attached to a mail message
      */
     public function mail_import_itip()
     {
         $uid     = rcube_utils::get_input_value('_uid', rcube_utils::INPUT_POST);
         $mbox    = rcube_utils::get_input_value('_mbox', rcube_utils::INPUT_POST);
         $mime_id = rcube_utils::get_input_value('_part', rcube_utils::INPUT_POST);
         $status  = rcube_utils::get_input_value('_status', rcube_utils::INPUT_POST);
         $delete  = intval(rcube_utils::get_input_value('_del', rcube_utils::INPUT_POST));
         $noreply = intval(rcube_utils::get_input_value('_noreply', rcube_utils::INPUT_POST)) || $status == 'needs-action';
 
         $error_msg = $this->gettext('errorimportingtask');
         $success   = false;
         $delegate = null;
 
         if ($status == 'delegated') {
             $delegates = rcube_mime::decode_address_list(rcube_utils::get_input_value('_to', rcube_utils::INPUT_POST, true), 1, false);
             $delegate  = reset($delegates);
 
             if (empty($delegate) || empty($delegate['mailto'])) {
                 $this->rc->output->command('display_message', $this->gettext('libcalendaring.delegateinvalidaddress'), 'error');
                 return;
             }
         }
 
         // successfully parsed tasks?
         if ($task = $this->lib->mail_get_itip_object($mbox, $uid, $mime_id, 'task')) {
             $task = $this->from_ical($task);
 
             // forward iTip request to delegatee
             if ($delegate) {
                 $rsvpme = intval(rcube_utils::get_input_value('_rsvp', rcube_utils::INPUT_POST));
 
                 $itip = $this->load_itip();
                 if ($itip->delegate_to($task, $delegate, $rsvpme ? true : false)) {
                     $this->rc->output->show_message('tasklist.itipsendsuccess', 'confirmation');
                 }
                 else {
                     $this->rc->output->command('display_message', $this->gettext('itipresponseerror'), 'error');
                 }
             }
 
             // find writeable list to store the task
             $list_id = !empty($_REQUEST['_folder']) ? rcube_utils::get_input_value('_folder', rcube_utils::INPUT_POST) : null;
             $lists   = $this->driver->get_lists();
             $list    = $lists[$list_id];
             $dontsave = ($_REQUEST['_folder'] === '' && $task['_method'] == 'REQUEST');
 
             // select default list except user explicitly selected 'none'
             if (!$list && !$dontsave) {
                 $list = $this->get_default_tasklist($task['sensitivity']);
             }
 
             $metadata = array(
                 'uid'      => $task['uid'],
                 'changed'  => is_object($task['changed']) ? $task['changed']->format('U') : 0,
                 'sequence' => intval($task['sequence']),
                 'fallback' => strtoupper($status),
                 'method'   => $task['_method'],
                 'task'     => 'tasks',
             );
 
             // update my attendee status according to submitted method
             if (!empty($status)) {
                 $organizer = $task['organizer'];
                 $emails    = $this->lib->get_user_emails();
 
                 foreach ($task['attendees'] as $i => $attendee) {
                     if ($attendee['email'] && in_array(strtolower($attendee['email']), $emails)) {
                         $metadata['attendee'] = $attendee['email'];
                         $metadata['rsvp']     = $attendee['role'] != 'NON-PARTICIPANT';
                         $reply_sender         = $attendee['email'];
 
                         $task['attendees'][$i]['status'] = strtoupper($status);
                         if (!in_array($task['attendees'][$i]['status'], array('NEEDS-ACTION','DELEGATED'))) {
                             $task['attendees'][$i]['rsvp'] = false;  // unset RSVP attribute
                         }
                     }
                 }
 
                 // add attendee with this user's default identity if not listed
                 if (!$reply_sender) {
                     $sender_identity = $this->rc->user->list_emails(true);
                     $task['attendees'][] = array(
                         'name'   => $sender_identity['name'],
                         'email'  => $sender_identity['email'],
                         'role'   => 'OPT-PARTICIPANT',
                         'status' => strtoupper($status),
                     );
                     $metadata['attendee'] = $sender_identity['email'];
                 }
             }
 
             // save to tasklist
             if ($list && $list['editable']) {
                 $task['list'] = $list['id'];
 
                 // check for existing task with the same UID
                 $existing = $this->driver->get_task($task['uid']);
 
                 if ($existing) {
                     // only update attendee status
                     if ($task['_method'] == 'REPLY') {
                         // try to identify the attendee using the email sender address
                         $existing_attendee = -1;
                         $existing_attendee_emails = array();
                         foreach ($existing['attendees'] as $i => $attendee) {
                             $existing_attendee_emails[] = $attendee['email'];
                             if ($task['_sender'] && ($attendee['email'] == $task['_sender'] || $attendee['email'] == $task['_sender_utf'])) {
                                 $existing_attendee = $i;
                             }
                         }
 
                         $task_attendee = null;
                         foreach ($task['attendees'] as $attendee) {
                             if ($task['_sender'] && ($attendee['email'] == $task['_sender'] || $attendee['email'] == $task['_sender_utf'])) {
                                 $task_attendee        = $attendee;
                                 $metadata['fallback'] = $attendee['status'];
                                 $metadata['attendee'] = $attendee['email'];
                                 $metadata['rsvp']     = $attendee['rsvp'] || $attendee['role'] != 'NON-PARTICIPANT';
                                 if ($attendee['status'] != 'DELEGATED') {
                                     break;
                                 }
                             }
                             // also copy delegate attendee
                             else if (!empty($attendee['delegated-from']) &&
                                      (stripos($attendee['delegated-from'], $task['_sender']) !== false || stripos($attendee['delegated-from'], $task['_sender_utf']) !== false) &&
                                      (!in_array($attendee['email'], $existing_attendee_emails))) {
                                 $existing['attendees'][] = $attendee;
                             }
                         }
 
                         // if delegatee has declined, set delegator's RSVP=True
                         if ($task_attendee && $task_attendee['status'] == 'DECLINED' && $task_attendee['delegated-from']) {
                             foreach ($existing['attendees'] as $i => $attendee) {
                                 if ($attendee['email'] == $task_attendee['delegated-from']) {
                                     $existing['attendees'][$i]['rsvp'] = true;
                                     break;
                                 }
                             }
                         }
 
                         // found matching attendee entry in both existing and new events
                         if ($existing_attendee >= 0 && $task_attendee) {
                             $existing['attendees'][$existing_attendee] = $task_attendee;
                             $success = $this->driver->edit_task($existing);
                         }
                         // update the entire attendees block
                         else if (($task['sequence'] >= $existing['sequence'] || $task['changed'] >= $existing['changed']) && $task_attendee) {
                             $existing['attendees'][] = $task_attendee;
                             $success = $this->driver->edit_task($existing);
                         }
                         else {
                             $error_msg = $this->gettext('newerversionexists');
                         }
                     }
                     // delete the task when declined
                     else if ($status == 'declined' && $delete) {
                         $deleted = $this->driver->delete_task($existing, true);
                         $success = true;
                     }
                     // import the (newer) task
                     else if ($task['sequence'] >= $existing['sequence'] || $task['changed'] >= $existing['changed']) {
                         $task['id']   = $existing['id'];
                         $task['list'] = $existing['list'];
 
                         // preserve my participant status for regular updates
                         if (empty($status)) {
                             $emails = $this->lib->get_user_emails();
                             foreach ($task['attendees'] as $i => $attendee) {
                                 if ($attendee['email'] && in_array(strtolower($attendee['email']), $emails)) {
                                     foreach ($existing['attendees'] as $j => $_attendee) {
                                         if ($attendee['email'] == $_attendee['email']) {
                                             $task['attendees'][$i] = $existing['attendees'][$j];
                                             break;
                                         }
                                     }
                                 }
                             }
                         }
 
                         // set status=CANCELLED on CANCEL messages
                         if ($task['_method'] == 'CANCEL') {
                             $task['status'] = 'CANCELLED';
                         }
                         // show me as free when declined (#1670)
                         if ($status == 'declined' || $task['status'] == 'CANCELLED') {
                             $task['free_busy'] = 'free';
                         }
 
                         $success = $this->driver->edit_task($task);
                     }
                     else if (!empty($status)) {
                         $existing['attendees'] = $task['attendees'];
                         if ($status == 'declined') { // show me as free when declined (#1670)
                             $existing['free_busy'] = 'free';
                         }
 
                         $success = $this->driver->edit_event($existing);
                     }
                     else {
                         $error_msg = $this->gettext('newerversionexists');
                     }
                 }
                 else if (!$existing && ($status != 'declined' || $this->rc->config->get('kolab_invitation_tasklists'))) {
                     $success = $this->driver->create_task($task);
                 }
                 else if ($status == 'declined') {
                     $error_msg = null;
                 }
             }
             else if ($status == 'declined' || $dontsave) {
                 $error_msg = null;
             }
             else {
                 $error_msg = $this->gettext('nowritetasklistfound');
             }
         }
 
         if ($success || $dontsave) {
             if ($success) {
                 $message = $task['_method'] == 'REPLY' ? 'attendeupdateesuccess' : ($deleted ? 'successremoval' : ($existing ? 'updatedsuccessfully' : 'importedsuccessfully'));
                 $this->rc->output->command('display_message', $this->gettext(array('name' => $message, 'vars' => array('list' => $list['name']))), 'confirmation');
             }
 
             $metadata['rsvp']         = intval($metadata['rsvp']);
             $metadata['after_action'] = $this->rc->config->get('calendar_itip_after_action', 0);
 
             $this->rc->output->command('plugin.itip_message_processed', $metadata);
             $error_msg = null;
         }
         else if ($error_msg) {
             $this->rc->output->command('display_message', $error_msg, 'error');
         }
 
         // send iTip reply
         if ($task['_method'] == 'REQUEST' && $organizer && !$noreply && !in_array(strtolower($organizer['email']), $emails) && !$error_msg) {
             $task['comment'] = rcube_utils::get_input_value('_comment', rcube_utils::INPUT_POST);
             $itip = $this->load_itip();
             $itip->set_sender_email($reply_sender);
 
             if ($itip->send_itip_message($this->to_libcal($task), 'REPLY', $organizer, 'itipsubject' . $status, 'itipmailbody' . $status))
                 $this->rc->output->command('display_message', $this->gettext(array('name' => 'sentresponseto', 'vars' => array('mailto' => $organizer['name'] ?: $organizer['email']))), 'confirmation');
             else
                 $this->rc->output->command('display_message', $this->gettext('itipresponseerror'), 'error');
         }
 
         $this->rc->output->send();
     }
 
 
     /****  Task invitation plugin hooks ****/
 
     /**
      * Handler for task/itip-delegate requests
      */
     function mail_itip_delegate()
     {
         // forward request to mail_import_itip() with the right status
         $_POST['_status'] = $_REQUEST['_status'] = 'delegated';
         $this->mail_import_itip();
     }
 
     /**
      * Handler for task/itip-status requests
      */
     public function task_itip_status()
     {
         $data = rcube_utils::get_input_value('data', rcube_utils::INPUT_POST, true);
 
         // find local copy of the referenced task
         $existing = $this->driver->get_task($data);
         $itip     = $this->load_itip();
         $response = $itip->get_itip_status($data, $existing);
 
         // get a list of writeable lists to save new tasks to
         if (!$existing && $response['action'] == 'rsvp' || $response['action'] == 'import') {
             $lists  = $this->driver->get_lists();
             $select = new html_select(array('name' => 'tasklist', 'id' => 'itip-saveto', 'is_escaped' => true));
             $select->add('--', '');
 
             foreach ($lists as $list) {
                 if ($list['editable']) {
                     $select->add($list['name'], $list['id']);
                 }
             }
         }
 
         if ($select) {
             $default_list = $this->get_default_tasklist($data['sensitivity']);
             $response['select'] = html::span('folder-select', $this->gettext('saveintasklist') . '&nbsp;' .
                 $select->show($default_list['id']));
         }
 
         $this->rc->output->command('plugin.update_itip_object_status', $response);
     }
 
     /**
      * Handler for task/itip-remove requests
      */
     public function task_itip_remove()
     {
         $success = false;
         $uid     = rcube_utils::get_input_value('uid', rcube_utils::INPUT_POST);
 
         // search for event if only UID is given
         if ($task = $this->driver->get_task($uid)) {
             $success = $this->driver->delete_task($task, true);
         }
 
         if ($success) {
             $this->rc->output->show_message('tasklist.successremoval', 'confirmation');
         }
         else {
             $this->rc->output->show_message('tasklist.errorsaving', 'error');
         }
     }
 
 
     /*******  Utility functions  *******/
 
     /**
      * Generate a unique identifier for an event
      */
     public function generate_uid()
     {
       return strtoupper(md5(time() . uniqid(rand())) . '-' . substr(md5($this->rc->user->get_username()), 0, 16));
     }
 
     /**
      * Map task properties for ical exprort using libcalendaring
      */
     public function to_libcal($task)
     {
         $object = $task;
         $object['_type'] = 'task';
         $object['categories'] = (array)$task['tags'];
 
         // convert to datetime objects
         if (!empty($task['date'])) {
             $object['due'] = rcube_utils::anytodatetime($task['date'].' '.$task['time'], $this->timezone);
             if (empty($task['time']))
                 $object['due']->_dateonly = true;
             unset($object['date']);
         }
 
         if (!empty($task['startdate'])) {
             $object['start'] = rcube_utils::anytodatetime($task['startdate'].' '.$task['starttime'], $this->timezone);
             if (empty($task['starttime']))
                 $object['start']->_dateonly = true;
             unset($object['startdate']);
         }
 
         $object['complete'] = $task['complete'] * 100;
         if ($task['complete'] == 1.0 && empty($task['complete'])) {
             $object['status'] = 'COMPLETED';
         }
 
         if ($task['flagged']) {
             $object['priority'] = 1;
         }
         else if (!$task['priority']) {
             $object['priority'] = 0;
         }
 
         return $object;
     }
 
     /**
      * Convert task properties from ical parser to the internal format
      */
     public function from_ical($vtodo)
     {
         $task = $vtodo;
 
         $task['tags'] = array_filter((array)$vtodo['categories']);
         $task['flagged'] = $vtodo['priority'] == 1;
         $task['complete'] = floatval($vtodo['complete'] / 100);
 
         // convert from DateTime to internal date format
         if (is_a($vtodo['due'], 'DateTime')) {
             $due = $this->lib->adjust_timezone($vtodo['due']);
             $task['date'] = $due->format('Y-m-d');
             if (!$vtodo['due']->_dateonly)
                 $task['time'] = $due->format('H:i');
         }
         // convert from DateTime to internal date format
         if (is_a($vtodo['start'], 'DateTime')) {
             $start = $this->lib->adjust_timezone($vtodo['start']);
             $task['startdate'] = $start->format('Y-m-d');
             if (!$vtodo['start']->_dateonly)
                 $task['starttime'] = $start->format('H:i');
         }
         if (is_a($vtodo['dtstamp'], 'DateTime')) {
             $task['changed'] = $vtodo['dtstamp'];
         }
 
         unset($task['categories'], $task['due'], $task['start'], $task['dtstamp']);
 
         return $task;
     }
 
     /**
      * Handler for user_delete plugin hook
      */
     public function user_delete($args)
     {
        $this->load_driver();
        return $this->driver->user_delete($args);
     }
 
 
     /**
      * Magic getter for public access to protected members
      */
     public function __get($name)
     {
         switch ($name) {
             case 'ical':
                 return $this->get_ical();
 
             case 'itip':
                 return $this->load_itip();
 
             case 'driver':
                 $this->load_driver();
                 return $this->driver;
         }
 
         return null;
     }
 }