diff --git a/plugins/calendar/calendar.php b/plugins/calendar/calendar.php
index d674522b..f8c5036c 100644
--- a/plugins/calendar/calendar.php
+++ b/plugins/calendar/calendar.php
@@ -1,3311 +1,3311 @@
 <?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
     rcube_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, Q($this->gettext('default_view'))),
+        '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, Q($this->gettext('timeslots'))),
+        '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(rcube_label('sunday'), '0');
       $select->add(rcube_label('monday'), '1');
       $select->add(rcube_label('tuesday'), '2');
       $select->add(rcube_label('wednesday'), '3');
       $select->add(rcube_label('thursday'), '4');
       $select->add(rcube_label('friday'), '5');
       $select->add(rcube_label('saturday'), '6');
       $p['blocks']['view']['options']['first_day'] = array(
-        'title' => html::label($field_id, Q($this->gettext('first_day'))),
+        '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, Q($this->gettext('first_hour'))),
+        '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, Q($this->gettext('workinghours'))),
+        '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', Q($this->gettext('eventcoloring'))),
+        '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'])) {
       if (!$p['current']) {
         $p['blocks']['view']['content'] = true;
         return $p;
       }
 
       $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(rcube_label(strtolower("alarm{$type}option"), 'libcalendaring'), $type);
 
       $p['blocks']['view']['options']['alarmtype'] = array(
-        'title' => html::label($field_id, Q($this->gettext('defaultalarmtype'))),
+        'title' => html::label($field_id, rcube::Q($this->gettext('defaultalarmtype'))),
         'content' => $select_type->show($this->rc->config->get('calendar_default_alarm_type', '')),
       );
     }
 
     if (!isset($no_override['calendar_default_alarm_offset'])) {
       if (!$p['current']) {
         $p['blocks']['view']['content'] = true;
         return $p;
       }
 
       $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(rcube_label('trigger' . $trigger, 'libcalendaring'), $trigger);
 
       $preset = libcalendaring::parse_alarm_value($this->rc->config->get('calendar_default_alarm_offset', '-15M'));
       $p['blocks']['view']['options']['alarmoffset'] = array(
-        'title' => html::label($field_id . 'value', Q($this->gettext('defaultalarmoffset'))),
+        'title' => html::label($field_id . 'value', rcube::Q($this->gettext('defaultalarmoffset'))),
         'content' => $input_value->show($preset[0]) . ' ' . $select_offset->show($preset[1]),
       );
     }
 
     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', Q($this->gettext('defaultcalendar'))),
+        '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, Q($this->gettext('afteraction'))),
+        '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(rcube_label(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(rcube_label('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 taks
    */
   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'])) {
       rcube_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 = rcube_label(array('name' => 'filesizeerror', 'vars' => array(
             'size' => show_bytes(parse_bytes(ini_get('upload_max_filesize'))))));
       }
       else {
         $msg = rcube_label('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;
         }
       }
     }
 
     // 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
     send_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
     send_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', Q($event['title']))
+      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 = intval(rcube_utils::get_input_value('_rsvp', rcube_utils::INPUT_POST));
 
         $itip = $this->load_itip();
         if ($itip->delegate_to($event, $delegate, $rsvpme ? true : false)) {
           $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_mailbox($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_mailbox($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_driver.php b/plugins/calendar/drivers/kolab/kolab_driver.php
index 0cd273a4..1c52fbab 100644
--- a/plugins/calendar/drivers/kolab/kolab_driver.php
+++ b/plugins/calendar/drivers/kolab/kolab_driver.php
@@ -1,2525 +1,2525 @@
 <?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->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();
 
     foreach ($folders as $folder) {
       if ($folder instanceof kolab_storage_folder_user) {
         $calendar = new kolab_user_calendar($folder->name, $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)
   {
     // 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);
         $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),
           '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)
   {
     $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)
   {
     // 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;
     }
 
     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 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)
       $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)
         $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'));
     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);
     }
 
     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'    => Q($this->cal->gettext('tabsharing')),
+          '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, Q($fieldset['name'])) . $subcontent) ."\n";
+            $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, Q($tab['name'])) . $content) ."\n";
+        $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'] : rcube_label($col);
 
-        $table->add('title', html::label($colprop['id'], Q($label)));
+        $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/lib/calendar_ui.php b/plugins/calendar/lib/calendar_ui.php
index 5478f355..6ca19c97 100644
--- a/plugins/calendar/lib/calendar_ui.php
+++ b/plugins/calendar/lib/calendar_ui.php
@@ -1,881 +1,881 @@
 <?php
 /**
  * User Interface class for the Calendar plugin
  *
  * @author Lazlo Westerhof <hello@lazlo.me>
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2010, Lazlo Westerhof <hello@lazlo.me>
  * 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 calendar_ui
 {
   private $rc;
   private $cal;
   private $ready = false;
   public $screen;
 
   function __construct($cal)
   {
     $this->cal = $cal;
     $this->rc = $cal->rc;
     $this->screen = $this->rc->task == 'calendar' ? ($this->rc->action ? $this->rc->action: 'calendar') : 'other';
   }
     
   /**
    * Calendar UI initialization and requests handlers
    */
   public function init()
   {
     if ($this->ready)  // already done
       return;
       
     // add taskbar button
     $this->cal->add_button(array(
       'command' => 'calendar',
       'class'   => 'button-calendar',
       'classsel' => 'button-calendar button-selected',
       'innerclass' => 'button-inner',
       'label'   => 'calendar.calendar',
       ), 'taskbar');
     
     // load basic client script
     $this->cal->include_script('calendar_base.js');
     
     $skin_path = $this->cal->local_skin_path();
     $this->cal->include_stylesheet($skin_path . '/calendar.css');
     
     $this->ready = true;
   }
 
   /**
    * Register handler methods for the template engine
    */
   public function init_templates()
   {
     $this->cal->register_handler('plugin.calendar_css', array($this, 'calendar_css'));
     $this->cal->register_handler('plugin.calendar_list', array($this, 'calendar_list'));
     $this->cal->register_handler('plugin.calendar_select', array($this, 'calendar_select'));
     $this->cal->register_handler('plugin.identity_select', array($this, 'identity_select'));
     $this->cal->register_handler('plugin.category_select', array($this, 'category_select'));
     $this->cal->register_handler('plugin.status_select', array($this, 'status_select'));
     $this->cal->register_handler('plugin.freebusy_select', array($this, 'freebusy_select'));
     $this->cal->register_handler('plugin.priority_select', array($this, 'priority_select'));
     $this->cal->register_handler('plugin.sensitivity_select', array($this, 'sensitivity_select'));
     $this->cal->register_handler('plugin.alarm_select', array($this, 'alarm_select'));
     $this->cal->register_handler('plugin.recurrence_form', array($this->cal->lib, 'recurrence_form'));
     $this->cal->register_handler('plugin.attachments_form', array($this, 'attachments_form'));
     $this->cal->register_handler('plugin.attachments_list', array($this, 'attachments_list'));
     $this->cal->register_handler('plugin.filedroparea', array($this, 'file_drop_area'));
     $this->cal->register_handler('plugin.attendees_list', array($this, 'attendees_list'));
     $this->cal->register_handler('plugin.attendees_form', array($this, 'attendees_form'));
     $this->cal->register_handler('plugin.resources_form', array($this, 'resources_form'));
     $this->cal->register_handler('plugin.resources_list', array($this, 'resources_list'));
     $this->cal->register_handler('plugin.resources_searchform', array($this, 'resources_search_form'));
     $this->cal->register_handler('plugin.resource_info', array($this, 'resource_info'));
     $this->cal->register_handler('plugin.resource_calendar', array($this, 'resource_calendar'));
     $this->cal->register_handler('plugin.attendees_freebusy_table', array($this, 'attendees_freebusy_table'));
     $this->cal->register_handler('plugin.edit_attendees_notify', array($this, 'edit_attendees_notify'));
     $this->cal->register_handler('plugin.edit_recurring_warning', array($this, 'recurring_event_warning'));
     $this->cal->register_handler('plugin.event_rsvp_buttons', array($this, 'event_rsvp_buttons'));
     $this->cal->register_handler('plugin.angenda_options', array($this, 'angenda_options'));
     $this->cal->register_handler('plugin.events_import_form', array($this, 'events_import_form'));
     $this->cal->register_handler('plugin.events_export_form', array($this, 'events_export_form'));
     $this->cal->register_handler('plugin.object_changelog_table', array('libkolab', 'object_changelog_table'));
     $this->cal->register_handler('plugin.searchform', array($this->rc->output, 'search_form'));  // use generic method from rcube_template
   }
 
   /**
    * Adds CSS stylesheets to the page header
    */
   public function addCSS()
   {
     $skin_path = $this->cal->local_skin_path();
     $this->cal->include_stylesheet($skin_path . '/fullcalendar.css');
   }
 
   /**
    * Adds JS files to the page header
    */
   public function addJS()
   {
     $this->cal->include_script('calendar_ui.js');
     $this->cal->include_script('lib/js/fullcalendar.js');
     $this->rc->output->include_script('treelist.js');
 
     // include kolab folderlist widget if available
     if (in_array('libkolab', $this->cal->api->loaded_plugins())) {
         $this->cal->api->include_script('libkolab/js/folderlist.js');
         $this->cal->api->include_script('libkolab/js/audittrail.js');
     }
 
     jqueryui::miniColors();
   }
 
   /**
    *
    */
   function calendar_css($attrib = array())
   {
     $mode = $this->rc->config->get('calendar_event_coloring', $this->cal->defaults['calendar_event_coloring']);
     $categories = $this->cal->driver->list_categories();
     $css = "\n";
     
     foreach ((array)$categories as $class => $color) {
       if (empty($color))
         continue;
       
       $class = 'cat-' . asciiwords(strtolower($class), true);
       $css  .= ".$class { color: #$color }\n";
       if ($mode > 0) {
         if ($mode == 2) {
           $css .= ".fc-event-$class .fc-event-bg {";
           $css .= " opacity: 0.9;";
           $css .= " filter: alpha(opacity=90);";
         }
         else {
           $css .= ".fc-event-$class.fc-event-skin, ";
           $css .= ".fc-event-$class .fc-event-skin, ";
           $css .= ".fc-event-$class .fc-event-inner {";
         }
         $css .= " background-color: #" . $color . ";";
         if ($mode % 2)
           $css .= " border-color: #$color;";
         $css .= "}\n";
       }
     }
     
     $calendars = $this->cal->driver->list_calendars();
     foreach ((array)$calendars as $id => $prop) {
       if (!$prop['color'])
         continue;
       $css .= $this->calendar_css_classes($id, $prop, $mode);
     }
     
     return html::tag('style', array('type' => 'text/css'), $css);
   }
 
   /**
    *
    */
   public function calendar_css_classes($id, $prop, $mode)
   {
     $color = $prop['color'];
     $class = 'cal-' . asciiwords($id, true);
     $css .= "li .$class, #eventshow .$class { color: #$color }\n";
 
     if ($mode != 1) {
       if ($mode == 3) {
         $css .= ".fc-event-$class .fc-event-bg {";
         $css .= " opacity: 0.9;";
         $css .= " filter: alpha(opacity=90);";
       }
       else {
         $css .= ".fc-event-$class, ";
         $css .= ".fc-event-$class .fc-event-inner {";
       }
       if (!$attrib['printmode'])
         $css .= " background-color: #$color;";
       if ($mode % 2 == 0)
       $css .= " border-color: #$color;";
       $css .= "}\n";
     }
 
     return $css . ".$class .handle { background-color: #$color; }\n";
   }
 
   /**
    *
    */
   function calendar_list($attrib = array())
   {
     $html = '';
     $jsenv = array();
     $tree = true;
     $calendars = $this->cal->driver->list_calendars(0, $tree);
 
     // walk folder tree
     if (is_object($tree)) {
       $html = $this->list_tree_html($tree, $calendars, $jsenv, $attrib);
 
       // append birthdays calendar which isn't part of $tree
       if ($bdaycal = $calendars[calendar_driver::BIRTHDAY_CALENDAR_ID]) {
         $calendars = array(calendar_driver::BIRTHDAY_CALENDAR_ID => $bdaycal);
       }
       else {
         $calendars = array();  // clear array for flat listing
       }
     }
     else {
       // fall-back to flat folder listing
       $attrib['class'] .= ' flat';
     }
 
     foreach ((array)$calendars as $id => $prop) {
       if ($attrib['activeonly'] && !$prop['active'])
         continue;
 
       $html .= html::tag('li', array('id' => 'rcmlical' . $id, 'class' => $prop['group']),
         $content = $this->calendar_list_item($id, $prop, $jsenv, $attrib['activeonly'])
       );
     }
 
     $this->rc->output->set_env('calendars', $jsenv);
     $this->rc->output->add_gui_object('calendarslist', $attrib['id']);
 
     return html::tag('ul', $attrib, $html, html::$common_attrib);
   }
 
   /**
    * Return html for a structured list <ul> for the folder tree
    */
   public function list_tree_html($node, $data, &$jsenv, $attrib)
   {
     $out = '';
     foreach ($node->children as $folder) {
       $id = $folder->id;
       $prop = $data[$id];
       $is_collapsed = false; // TODO: determine this somehow?
 
       $content = $this->calendar_list_item($id, $prop, $jsenv, $attrib['activeonly']);
 
       if (!empty($folder->children)) {
         $content .= html::tag('ul', array('style' => ($is_collapsed ? "display:none;" : null)),
           $this->list_tree_html($folder, $data, $jsenv, $attrib));
       }
 
       if (strlen($content)) {
         $out .= html::tag('li', array(
             'id' => 'rcmlical' . rcube_utils::html_identifier($id),
             'class' => $prop['group'] . ($prop['virtual'] ? ' virtual' : ''),
           ),
           $content);
       }
     }
 
     return $out;
   }
 
   /**
    * Helper method to build a calendar list item (HTML content and js data)
    */
   public function calendar_list_item($id, $prop, &$jsenv, $activeonly = false)
   {
     // enrich calendar properties with settings from the driver
     if (!$prop['virtual']) {
       unset($prop['user_id']);
       $prop['alarms']      = $this->cal->driver->alarms;
       $prop['attendees']   = $this->cal->driver->attendees;
       $prop['freebusy']    = $this->cal->driver->freebusy;
       $prop['attachments'] = $this->cal->driver->attachments;
       $prop['undelete']    = $this->cal->driver->undelete;
       $prop['feedurl']     = $this->cal->get_url(array('_cal' => $this->cal->ical_feed_hash($id) . '.ics', 'action' => 'feed'));
 
       $jsenv[$id] = $prop;
     }
 
     $classes = array('calendar', 'cal-'  . asciiwords($id, true));
     $title = $prop['title'] ?: ($prop['name'] != $prop['listname'] || strlen($prop['name']) > 25 ?
       html_entity_decode($prop['name'], ENT_COMPAT, RCUBE_CHARSET) : '');
 
     if ($prop['virtual'])
       $classes[] = 'virtual';
     else if (!$prop['editable'])
       $classes[] = 'readonly';
     if ($prop['subscribed'])
       $classes[] = 'subscribed';
     if ($prop['subscribed'] === 2)
       $classes[] = 'partial';
     if ($prop['class'])
       $classes[] = $prop['class'];
 
     $content = '';
     if (!$activeonly || $prop['active']) {
       $label_id = 'cl:' . $id;
       $content = html::div(join(' ', $classes),
-        html::span(array('class' => 'calname', 'id' => $label_id, 'title' => $title), $prop['editname'] ? Q($prop['editname']) : $prop['listname']) .
+        html::span(array('class' => 'calname', 'id' => $label_id, 'title' => $title), $prop['editname'] ? rcube::Q($prop['editname']) : $prop['listname']) .
         ($prop['virtual'] ? '' :
           html::tag('input', array('type' => 'checkbox', 'name' => '_cal[]', 'value' => $id, 'checked' => $prop['active'], 'aria-labelledby' => $label_id), '') .
           html::span('actions', 
             ($prop['removable'] ? html::a(array('href' => '#', 'class' => 'remove', 'title' => $this->cal->gettext('removelist')), ' ') : '') .
             html::a(array('href' => '#', 'class' => 'quickview', 'title' => $this->cal->gettext('quickview'), 'role' => 'checkbox', 'aria-checked' => 'false'), '') .
             (isset($prop['subscribed']) ? html::a(array('href' => '#', 'class' => 'subscribed', 'title' => $this->cal->gettext('calendarsubscribe'), 'role' => 'checkbox', 'aria-checked' => $prop['subscribed'] ? 'true' : 'false'), ' ') : '')
           ) .
           html::span(array('class' => 'handle', 'style' => "background-color: #" . ($prop['color'] ?: 'f00')), '&nbsp;')
         )
       );
     }
 
     return $content;
   }
 
   /**
    *
    */
   function angenda_options($attrib = array())
   {
     $attrib += array('id' => 'agendaoptions');
     $attrib['style'] .= 'display:none';
     
     $select_range = new html_select(array('name' => 'listrange', 'id' => 'agenda-listrange'));
     $select_range->add(1 . ' ' . preg_replace('/\(.+\)/', '', $this->cal->lib->gettext('days')), $days);
     foreach (array(2,5,7,14,30,60,90,180,365) as $days)
       $select_range->add($days . ' ' . preg_replace('/\(|\)/', '', $this->cal->lib->gettext('days')), $days);
     
     $html .= html::label('agenda-listrange', $this->cal->gettext('listrange'));
     $html .= $select_range->show($this->rc->config->get('calendar_agenda_range', $this->cal->defaults['calendar_agenda_range']));
     
     $select_sections = new html_select(array('name' => 'listsections', 'id' => 'agenda-listsections'));
     $select_sections->add('---', '');
     foreach (array('day' => 'libcalendaring.days', 'week' => 'libcalendaring.weeks', 'month' => 'libcalendaring.months', 'smart' => 'calendar.smartsections') as $val => $label)
       $select_sections->add(preg_replace('/\(|\)/', '', ucfirst($this->rc->gettext($label))), $val);
     
     $html .= html::span('spacer', '&nbsp;');
     $html .= html::label('agenda-listsections', $this->cal->gettext('listsections'));
     $html .= $select_sections->show($this->rc->config->get('calendar_agenda_sections', $this->cal->defaults['calendar_agenda_sections']));
     
     return html::div($attrib, $html);
   }
 
   /**
    * Render a HTML select box for calendar selection
    */
   function calendar_select($attrib = array())
   {
     $attrib['name']       = 'calendar';
     $attrib['is_escaped'] = true;
     $select = new html_select($attrib);
 
     foreach ((array)$this->cal->driver->list_calendars() as $id => $prop) {
       if ($prop['editable'] || strpos($prop['rights'], 'i') !== false)
         $select->add($prop['name'], $id);
     }
 
     return $select->show(null);
   }
 
   /**
    * Render a HTML select box for user identity selection
    */
   function identity_select($attrib = array())
   {
     $attrib['name'] = 'identity';
     $select         = new html_select($attrib);
     $identities     = $this->rc->user->list_emails();
 
     foreach ($identities as $ident) {
         $select->add(format_email_recipient($ident['email'], $ident['name']), $ident['identity_id']);
     }
 
     return $select->show(null);
   }
 
   /**
    * Render a HTML select box to select an event category
    */
   function category_select($attrib = array())
   {
     $attrib['name'] = 'categories';
     $select = new html_select($attrib);
     $select->add('---', '');
     foreach (array_keys((array)$this->cal->driver->list_categories()) as $cat) {
       $select->add($cat, $cat);
     }
 
     return $select->show(null);
   }
 
   /**
    * Render a HTML select box for status property
    */
   function status_select($attrib = array())
   {
     $attrib['name'] = 'status';
     $select = new html_select($attrib);
     $select->add('---', '');
     $select->add($this->cal->gettext('status-confirmed'), 'CONFIRMED');
     $select->add($this->cal->gettext('status-cancelled'), 'CANCELLED');
     //$select->add($this->cal->gettext('tentative'), 'TENTATIVE');
     return $select->show(null);
   }
 
   /**
    * Render a HTML select box for free/busy/out-of-office property
    */
   function freebusy_select($attrib = array())
   {
     $attrib['name'] = 'freebusy';
     $select = new html_select($attrib);
     $select->add($this->cal->gettext('free'), 'free');
     $select->add($this->cal->gettext('busy'), 'busy');
     // out-of-office is not supported by libkolabxml (#3220)
     // $select->add($this->cal->gettext('outofoffice'), 'outofoffice');
     $select->add($this->cal->gettext('tentative'), 'tentative');
     return $select->show(null);
   }
 
   /**
    * Render a HTML select for event priorities
    */
   function priority_select($attrib = array())
   {
     $attrib['name'] = 'priority';
     $select = new html_select($attrib);
     $select->add('---', '0');
     $select->add('1 '.$this->cal->gettext('highest'), '1');
     $select->add('2 '.$this->cal->gettext('high'),    '2');
     $select->add('3 ',                                '3');
     $select->add('4 ',                                '4');
     $select->add('5 '.$this->cal->gettext('normal'),  '5');
     $select->add('6 ',                                '6');
     $select->add('7 ',                                '7');
     $select->add('8 '.$this->cal->gettext('low'),     '8');
     $select->add('9 '.$this->cal->gettext('lowest'),  '9');
     return $select->show(null);
   }
   
   /**
    * Render HTML input for sensitivity selection
    */
   function sensitivity_select($attrib = array())
   {
     $attrib['name'] = 'sensitivity';
     $select = new html_select($attrib);
     $select->add($this->cal->gettext('public'), 'public');
     $select->add($this->cal->gettext('private'), 'private');
     $select->add($this->cal->gettext('confidential'), 'confidential');
     return $select->show(null);
   }
   
   /**
    * Render HTML form for alarm configuration
    */
   function alarm_select($attrib = array())
   {
     return $this->cal->lib->alarm_select($attrib, $this->cal->driver->alarm_types, $this->cal->driver->alarm_absolute);
   }
 
   /**
    *
    */
   function edit_attendees_notify($attrib = array())
   {
     $checkbox = new html_checkbox(array('name' => '_notify', 'id' => 'edit-attendees-donotify', 'value' => 1));
     return html::div($attrib, html::label(null, $checkbox->show(1) . ' ' . $this->cal->gettext('sendnotifications')));
   }
 
   /**
    * Generate the form for recurrence settings
    */
   function recurring_event_warning($attrib = array())
   {
     $attrib['id'] = 'edit-recurring-warning';
     
     $radio = new html_radiobutton(array('name' => '_savemode', 'class' => 'edit-recurring-savemode'));
     $form = html::label(null, $radio->show('', array('value' => 'current')) . $this->cal->gettext('currentevent')) . ' ' .
        html::label(null, $radio->show('', array('value' => 'future')) . $this->cal->gettext('futurevents')) . ' ' .
        html::label(null, $radio->show('all', array('value' => 'all')) . $this->cal->gettext('allevents')) . ' ' .
        html::label(null, $radio->show('', array('value' => 'new')) . $this->cal->gettext('saveasnew'));
        
     return html::div($attrib, html::div('message', html::span('ui-icon ui-icon-alert', '') . $this->cal->gettext('changerecurringeventwarning')) . html::div('savemode', $form));
   }
 
   /**
    * Form for uploading and importing events
    */
   function events_import_form($attrib = array())
   {
     if (!$attrib['id'])
       $attrib['id'] = 'rcmImportForm';
 
     // Get max filesize, enable upload progress bar
     $max_filesize = rcube_upload_init();
 
     $accept = '.ics, text/calendar, text/x-vcalendar, application/ics';
     if (class_exists('ZipArchive', false)) {
       $accept .= ', .zip, application/zip';
     }
 
     $input = new html_inputfield(array(
       'type' => 'file', 'name' => '_data', 'size' => $attrib['uploadfieldsize'],
       'accept' => $accept));
 
     $select = new html_select(array('name' => '_range', 'id' => 'event-import-range'));
     $select->add(array(
         $this->cal->gettext('onemonthback'),
         $this->cal->gettext(array('name' => 'nmonthsback', 'vars' => array('nr'=>2))),
         $this->cal->gettext(array('name' => 'nmonthsback', 'vars' => array('nr'=>3))),
         $this->cal->gettext(array('name' => 'nmonthsback', 'vars' => array('nr'=>6))),
         $this->cal->gettext(array('name' => 'nmonthsback', 'vars' => array('nr'=>12))),
         $this->cal->gettext('all'),
       ),
       array('1','2','3','6','12',0));
 
     $html .= html::div('form-section',
       html::div(null, $input->show()) .
       html::div('hint', rcube_label(array('name' => 'maxuploadsize', 'vars' => array('size' => $max_filesize))))
     );
 
     $html .= html::div('form-section',
       html::label('event-import-calendar', $this->cal->gettext('calendar')) .
       $this->calendar_select(array('name' => 'calendar', 'id' => 'event-import-calendar'))
     );
 
     $html .= html::div('form-section',
       html::label('event-import-range', $this->cal->gettext('importrange')) .
       $select->show(1)
     );
 
     $this->rc->output->add_gui_object('importform', $attrib['id']);
     $this->rc->output->add_label('import');
 
     return html::tag('form', array('action' => $this->rc->url(array('task' => 'calendar', 'action' => 'import_events')),
       'method' => "post", 'enctype' => 'multipart/form-data', 'id' => $attrib['id']),
       $html
     );
   }
 
   /**
    * Form to select options for exporting events
    */
   function events_export_form($attrib = array())
   {
     if (!$attrib['id'])
       $attrib['id'] = 'rcmExportForm';
 
     $html .= html::div('form-section',
       html::label('event-export-calendar', $this->cal->gettext('calendar')) .
       $this->calendar_select(array('name' => 'calendar', 'id' => 'event-export-calendar'))
     );
 
     $select = new html_select(array('name' => 'range', 'id' => 'event-export-range'));
     $select->add(array(
         $this->cal->gettext('all'),
         $this->cal->gettext('onemonthback'),
         $this->cal->gettext(array('name' => 'nmonthsback', 'vars' => array('nr'=>2))),
         $this->cal->gettext(array('name' => 'nmonthsback', 'vars' => array('nr'=>3))),
         $this->cal->gettext(array('name' => 'nmonthsback', 'vars' => array('nr'=>6))),
         $this->cal->gettext(array('name' => 'nmonthsback', 'vars' => array('nr'=>12))),
         $this->cal->gettext('customdate'),
       ),
       array(0,'1','2','3','6','12','custom'));
 
     $startdate = new html_inputfield(array('name' => 'start', 'size' => 11, 'id' => 'event-export-startdate'));
 
     $html .= html::div('form-section',
       html::label('event-export-range', $this->cal->gettext('exportrange')) .
       $select->show(0) .
       html::span(array('style'=>'display:none'), $startdate->show())
     );
 
     $checkbox = new html_checkbox(array('name' => 'attachments', 'id' => 'event-export-attachments', 'value' => 1));
     $html .= html::div('form-section',
       html::label('event-export-range', $this->cal->gettext('exportattachments')) .
       $checkbox->show(1)
     );
 
     $this->rc->output->add_gui_object('exportform', $attrib['id']);
 
     return html::tag('form', array('action' => $this->rc->url(array('task' => 'calendar', 'action' => 'export_events')),
       'method' => "post", 'id' => $attrib['id']),
       $html
     );
   }
 
   /**
    * Generate the form for event attachments upload
    */
   function attachments_form($attrib = array())
   {
     // add ID if not given
     if (!$attrib['id'])
       $attrib['id'] = 'rcmUploadForm';
 
     // Get max filesize, enable upload progress bar
     $max_filesize = rcube_upload_init();
 
     $button = new html_inputfield(array('type' => 'button'));
     $input = new html_inputfield(array(
       'type' => 'file', 'name' => '_attachments[]',
       'multiple' => 'multiple', 'size' => $attrib['attachmentfieldsize']));
 
     return html::div($attrib,
       html::div(null, $input->show()) .
       html::div('formbuttons', $button->show($this->rc->gettext('upload'), array('class' => 'button mainaction',
         'onclick' => rcmail_output::JS_OBJECT_NAME . ".upload_file(this.form)"))) .
       html::div('hint', $this->rc->gettext(array('name' => 'maxuploadsize', 'vars' => array('size' => $max_filesize))))
     );
   }
 
   /**
    * Register UI object for HTML5 drag & drop file upload
    */
   function file_drop_area($attrib = array())
   {
       if ($attrib['id']) {
           $this->rc->output->add_gui_object('filedrop', $attrib['id']);
           $this->rc->output->set_env('filedrop', array('action' => 'upload', 'fieldname' => '_attachments'));
       }
   }
 
   /**
    * Generate HTML element for attachments list
    */
   function attachments_list($attrib = array())
   {
     if (!$attrib['id'])
       $attrib['id'] = 'rcmAttachmentList';
 
     $skin_path = $this->cal->local_skin_path();
     if ($attrib['deleteicon']) {
       $_SESSION[calendar::SESSION_KEY . '_deleteicon'] = $skin_path . $attrib['deleteicon'];
       $this->rc->output->set_env('deleteicon', $skin_path . $attrib['deleteicon']);
     }
     if ($attrib['cancelicon'])
       $this->rc->output->set_env('cancelicon', $skin_path . $attrib['cancelicon']);
     if ($attrib['loadingicon'])
       $this->rc->output->set_env('loadingicon', $skin_path . $attrib['loadingicon']);
 
     $this->rc->output->add_gui_object('attachmentlist', $attrib['id']);
     $this->attachmentlist_id = $attrib['id'];
 
     return html::tag('ul', $attrib, '', html::$common_attrib);
   }
 
   /**
    * Handler for calendar form template.
    * The form content could be overriden by the driver
    */
   function calendar_editform($action, $calendar = array())
   {
     // compose default calendar form fields
     $input_name = new html_inputfield(array('name' => 'name', 'id' => 'calendar-name', 'size' => 20));
     $input_color = new html_inputfield(array('name' => 'color', 'id' => 'calendar-color', 'size' => 6));
 
     $formfields = array(
       'name' => array(
         'label' => $this->cal->gettext('name'),
         'value' => $input_name->show($calendar['name']),
         'id' => 'calendar-name',
       ),
       'color' => array(
         'label' => $this->cal->gettext('color'),
         'value' => $input_color->show($calendar['color']),
         'id' => 'calendar-color',
       ),
     );
 
     if ($this->cal->driver->alarms) {
       $checkbox = new html_checkbox(array('name' => 'showalarms', 'id' => 'calendar-showalarms', 'value' => 1));
       $formfields['showalarms'] = array(
         'label' => $this->cal->gettext('showalarms'),
         'value' => $checkbox->show($calendar['showalarms']?1:0),
         'id' => 'calendar-showalarms',
       );
     }
 
     // allow driver to extend or replace the form content
     return html::tag('form', array('action' => "#", 'method' => "get", 'id' => 'calendarpropform'),
       $this->cal->driver->calendar_form($action, $calendar, $formfields)
     );
   }
 
   /**
    *
    */
   function attendees_list($attrib = array())
   {
     // add "noreply" checkbox to attendees table only
     $invitations = strpos($attrib['id'], 'attend') !== false;
 
     $invite = new html_checkbox(array('value' => 1, 'id' => 'edit-attendees-invite'));
     $table  = new html_table(array('cols' => 5 + intval($invitations), 'border' => 0, 'cellpadding' => 0, 'class' => 'rectable'));
 
     $table->add_header('role', $this->cal->gettext('role'));
     $table->add_header('name', $this->cal->gettext($attrib['coltitle'] ?: 'attendee'));
     $table->add_header('availability', $this->cal->gettext('availability'));
     $table->add_header('confirmstate', $this->cal->gettext('confirmstate'));
     if ($invitations) {
       $table->add_header(array('class' => 'invite', 'title' => $this->cal->gettext('sendinvitations')),
         $invite->show(1) . html::label('edit-attendees-invite', $this->cal->gettext('sendinvitations')));
     }
     $table->add_header('options', '');
 
     // hide invite column if disabled by config
     $itip_notify = (int)$this->rc->config->get('calendar_itip_send_option', $this->cal->defaults['calendar_itip_send_option']);
     if ($invitations && !($itip_notify & 2)) {
         $css = sprintf('#%s td.invite, #%s th.invite { display:none !important }', $attrib['id'], $attrib['id']);
         $this->rc->output->add_footer(html::tag('style', array('type' => 'text/css'), $css));
     }
 
     return $table->show($attrib);
   }
 
   /**
    *
    */
   function attendees_form($attrib = array())
   {
     $input    = new html_inputfield(array('name' => 'participant', 'id' => 'edit-attendee-name', 'size' => 30));
     $textarea = new html_textarea(array('name' => 'comment', 'id' => 'edit-attendees-comment',
         'rows' => 4, 'cols' => 55, 'title' => $this->cal->gettext('itipcommenttitle')));
 
     return html::div($attrib,
       html::div(null, $input->show() . " " .
         html::tag('input', array('type' => 'button', 'class' => 'button', 'id' => 'edit-attendee-add', 'value' => $this->cal->gettext('addattendee'))) . " " .
         html::tag('input', array('type' => 'button', 'class' => 'button', 'id' => 'edit-attendee-schedule', 'value' => $this->cal->gettext('scheduletime').'...'))) .
       html::p('attendees-commentbox', html::label(null, $this->cal->gettext('itipcomment') . $textarea->show()))
     );
   }
 
   /**
    *
    */
   function resources_form($attrib = array())
   {
     $input = new html_inputfield(array('name' => 'resource', 'id' => 'edit-resource-name', 'size' => 30));
 
     return html::div($attrib,
       html::div(null, $input->show() . " " .
         html::tag('input', array('type' => 'button', 'class' => 'button', 'id' => 'edit-resource-add', 'value' => $this->cal->gettext('addresource'))) . " " .
         html::tag('input', array('type' => 'button', 'class' => 'button', 'id' => 'edit-resource-find', 'value' => $this->cal->gettext('findresources').'...')))
       );
   }
 
   /**
    *
    */
   function resources_list($attrib = array())
   {
     $attrib += array('id' => 'calendar-resources-list');
 
     $this->rc->output->add_gui_object('resourceslist', $attrib['id']);
 
     return html::tag('ul', $attrib, '', html::$common_attrib);
   }
 
   /**
    *
    */
   public function resource_info($attrib = array())
   {
     $attrib += array('id' => 'calendar-resources-info');
 
     $this->rc->output->add_gui_object('resourceinfo', $attrib['id']);
     $this->rc->output->add_gui_object('resourceownerinfo', $attrib['id'] . '-owner');
 
     // copy address book labels for owner details to client
     $this->rc->output->add_label('name','firstname','surname','department','jobtitle','email','phone','address');
 
     $table_attrib = array('id','class','style','width','summary','cellpadding','cellspacing','border');
 
     return html::tag('table', $attrib,
         html::tag('tbody', null, ''), $table_attrib) .
 
       html::tag('table', array('id' => $attrib['id'] . '-owner', 'style' => 'display:none') + $attrib,
         html::tag('thead', null,
           html::tag('tr', null,
-            html::tag('td', array('colspan' => 2), Q($this->cal->gettext('resourceowner')))
+            html::tag('td', array('colspan' => 2), rcube::Q($this->cal->gettext('resourceowner')))
           )
         ) .
         html::tag('tbody', null, ''),
         $table_attrib);
   }
 
   /**
    *
    */
   public function resource_calendar($attrib = array())
   {
     $attrib += array('id' => 'calendar-resources-calendar');
 
     $this->rc->output->add_gui_object('resourceinfocalendar', $attrib['id']);
 
     return html::div($attrib, '');
   }
 
   /**
    * GUI object 'searchform' for the resource finder dialog
    *
    * @param array Named parameters
    * @return string HTML code for the gui object
    */
   function resources_search_form($attrib)
   {
     $attrib += array('command' => 'search-resource', 'id' => 'rcmcalresqsearchbox', 'autocomplete' => 'off');
     $attrib['name'] = '_q';
 
     $input_q = new html_inputfield($attrib);
     $out = $input_q->show();
 
     // add form tag around text field
     $out = $this->rc->output->form_tag(array(
       'name' => "rcmcalresoursqsearchform",
       'onsubmit' => rcmail_output::JS_OBJECT_NAME . ".command('" . $attrib['command'] . "'); return false",
       'style' => "display:inline"),
       $out);
 
     return $out;
   }
 
   /**
    *
    */
   function attendees_freebusy_table($attrib = array())
   {
     $table = new html_table(array('cols' => 2, 'border' => 0, 'cellspacing' => 0));
     $table->add('attendees',
       html::tag('h3', 'boxtitle', $this->cal->gettext('tabattendees')) .
       html::div('timesheader', '&nbsp;') .
       html::div(array('id' => 'schedule-attendees-list', 'class' => 'attendees-list'), '')
     );
     $table->add('times',
       html::div('scroll',
         html::tag('table', array('id' => 'schedule-freebusy-times', 'border' => 0, 'cellspacing' => 0), html::tag('thead') . html::tag('tbody')) .
         html::div(array('id' => 'schedule-event-time', 'style' => 'display:none'), '&nbsp;')
       )
     );
     
     return $table->show($attrib);
   }
 
   /**
    *
    */
   function event_invitebox($attrib = array())
   {
     if ($this->cal->event) {
       return html::div($attrib,
         $this->cal->itip->itip_object_details_table($this->cal->event, $this->cal->itip->gettext('itipinvitation')) .
         $this->cal->invitestatus
       );
     }
     
     return '';
   }
 
   function event_rsvp_buttons($attrib = array())
   {
     $actions = array('accepted','tentative','declined');
     if ($attrib['delegate'] !== 'false')
       $actions[] = 'delegated';
 
     return $this->cal->itip->itip_rsvp_buttons($attrib, $actions);
   }
 
 }
diff --git a/plugins/kolab_activesync/kolab_activesync.php b/plugins/kolab_activesync/kolab_activesync.php
index f886c8d5..80c1052e 100644
--- a/plugins/kolab_activesync/kolab_activesync.php
+++ b/plugins/kolab_activesync/kolab_activesync.php
@@ -1,572 +1,572 @@
 <?php
 
 /**
  * ActiveSync configuration utility for Kolab accounts
  *
  * @version @package_version@
  * @author Aleksander Machniak <machniak@kolabsys.com>
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2011-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_activesync extends rcube_plugin
 {
     public $task = 'settings';
     public $urlbase;
     public $backend;
 
     private $rc;
     private $ui;
     private $folder_meta;
     private $root_meta;
 
     const ROOT_MAILBOX = 'INBOX';
     const ASYNC_KEY    = '/private/vendor/kolab/activesync';
 
 
     /**
      * Plugin initialization.
      */
     public function init()
     {
         $this->rc = rcube::get_instance();
 
         $this->require_plugin('jqueryui');
         $this->require_plugin('libkolab');
 
         $this->register_action('plugin.activesync', array($this, 'config_view'));
         $this->register_action('plugin.activesync-config', array($this, 'config_frame'));
         $this->register_action('plugin.activesync-json', array($this, 'json_command'));
 
         $this->add_hook('settings_actions', array($this, 'settings_actions'));
         $this->add_hook('folder_form', array($this, 'folder_form'));
 
         $this->add_texts('localization/');
 
         if (preg_match('/^(plugin.activesync|edit-folder|save-folder)/', $this->rc->action)) {
             $this->add_label('devicedeleteconfirm', 'savingdata');
             $this->include_script('kolab_activesync.js');
         }
     }
 
     /**
      * Adds Activesync section in Settings
      */
     function settings_actions($args)
     {
         $args['actions'][] = array(
             'action' => 'plugin.activesync',
             'class'  => 'activesync',
             'label'  => 'tabtitle',
             'domain' => 'kolab_activesync',
             'title'  => 'activesynctitle',
         );
 
         return $args;
     }
 
     /**
      * Handler for folder info/edit form (folder_form hook).
      * Adds ActiveSync section.
      */
     function folder_form($args)
     {
         $mbox_imap = $args['options']['name'];
 
         // Edited folder name (empty in create-folder mode)
         if (!strlen($mbox_imap)) {
             return $args;
         }
 
         $devices = $this->list_devices();
 
         // no registered devices
         if (empty($devices)) {
             return $args;
         }
 
         list($type, ) = explode('.', (string) kolab_storage::folder_type($mbox_imap));
         if ($type && !in_array($type, array('mail', 'event', 'contact', 'task', 'note'))) {
             return $args;
         }
 
         require_once $this->home . '/kolab_activesync_ui.php';
         $this->ui = new kolab_activesync_ui($this);
 
         if ($content = $this->ui->folder_options_table($mbox_imap, $devices, $type)) {
             $args['form']['activesync'] = array(
                 'name'    => rcube::Q($this->gettext('tabtitle')),
                 'content' => $content,
             );
         }
 
         return $args;
     }
 
     /**
      * Handle JSON requests
      */
     public function json_command()
     {
         $cmd  = rcube_utils::get_input_value('cmd', rcube_utils::INPUT_POST);
         $imei = rcube_utils::get_input_value('id', rcube_utils::INPUT_POST);
 
         switch ($cmd) {
         case 'save':
             $devices       = $this->list_devices();
             $device        = $devices[$imei];
             $subscriptions = (array) rcube_utils::get_input_value('subscribed', rcube_utils::INPUT_POST);
             $devicealias   = rcube_utils::get_input_value('devicealias', rcube_utils::INPUT_POST, true);
             $device['ALIAS'] = $devicealias;
 
             $err = !$this->device_update($device, $imei);
 
             if (!$err) {
                 // iterate over folders list and update metadata if necessary
                 // old subscriptions
                 foreach (array_keys($this->folder_meta()) as $folder) {
                     $err |= !$this->folder_set($folder, $imei, intval($subscriptions[$folder]));
                     unset($subscriptions[$folder]);
                 }
                 // new subscription
                 foreach ($subscriptions as $folder => $flag) {
                     $err |= !$this->folder_set($folder, $imei, intval($flag));
                 }
 
                 $this->rc->output->command('plugin.activesync_save_complete', array(
-                    'success' => !$err, 'id' => $imei, 'alias' => Q($devicealias)));
+                    'success' => !$err, 'id' => $imei, 'alias' => rcube::Q($devicealias)));
             }
 
             if ($err)
                 $this->rc->output->show_message($this->gettext('savingerror'), 'error');
             else
                 $this->rc->output->show_message($this->gettext('successfullysaved'), 'confirmation');
 
             break;
 
         case 'delete':
             $success = $this->device_delete($imei);
 
             if ($success) {
                 $this->rc->output->show_message($this->gettext('successfullydeleted'), 'confirmation');
                 $this->rc->output->command('plugin.activesync_save_complete', array(
                     'success' => true, 'id' => $imei, 'delete' => true));
             }
             else
                 $this->rc->output->show_message($this->gettext('savingerror'), 'error');
 
             break;
 
         case 'update':
             $subscription = (int) rcube_utils::get_input_value('flag', rcube_utils::INPUT_POST);
             $folder       = rcube_utils::get_input_value('folder', rcube_utils::INPUT_POST);
 
             $err = !$this->folder_set($folder, $imei, $subscription);
 
             if ($err)
                 $this->rc->output->show_message($this->gettext('savingerror'), 'error');
             else
                 $this->rc->output->show_message($this->gettext('successfullysaved'), 'confirmation');
 
             break;
         }
 
         $this->rc->output->send();
     }
 
     /**
      * Render main UI for devices configuration
      */
     public function config_view()
     {
         $storage = $this->rc->get_storage();
 
         // checks if IMAP server supports any of METADATA, ANNOTATEMORE, ANNOTATEMORE2
         if (!($storage->get_capability('METADATA') || $storage->get_capability('ANNOTATEMORE') || $storage->get_capability('ANNOTATEMORE2'))) {
             $this->rc->output->show_message($this->gettext('notsupported'), 'error');
         }
 
         require_once $this->home . '/kolab_activesync_ui.php';
 
         $this->ui = new kolab_activesync_ui($this);
 
         $this->register_handler('plugin.devicelist', array($this->ui, 'device_list'));
 
         $this->rc->output->send('kolab_activesync.config');
     }
 
     /**
      * Render device configuration form
      */
     public function config_frame()
     {
         $storage = $this->rc->get_storage();
 
         // checks if IMAP server supports any of METADATA, ANNOTATEMORE, ANNOTATEMORE2
         if (!($storage->get_capability('METADATA') || $storage->get_capability('ANNOTATEMORE') || $storage->get_capability('ANNOTATEMORE2'))) {
             $this->rc->output->show_message($this->gettext('notsupported'), 'error');
         }
 
         require_once $this->home . '/kolab_activesync_ui.php';
 
         $this->ui = new kolab_activesync_ui($this);
 
         if (!empty($_GET['_init'])) {
             return $this->ui->init_message();
         }
 
         $this->register_handler('plugin.deviceconfigform', array($this->ui, 'device_config_form'));
         $this->register_handler('plugin.foldersubscriptions', array($this->ui, 'folder_subscriptions'));
 
         $imei    = rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC);
         $devices = $this->list_devices();
 
         if ($device = $devices[$imei]) {
             $this->ui->device        = $device;
             $this->ui->device['_id'] = $imei;
             $this->rc->output->set_env('active_device', $imei);
             $this->rc->output->command('parent.enable_command','plugin.delete-device', true);
         }
         else {
             $this->rc->output->show_message($this->gettext('devicenotfound'), 'error');
         }
 
         $this->rc->output->send('kolab_activesync.configedit');
     }
 
     /**
      * Get list of all folders available for sync
      *
      * @return array List of mailbox folders
      */
     public function list_folders()
     {
         $storage = $this->rc->get_storage();
 
         return $storage->list_folders();
     }
 
     /**
      * List known devices
      *
      * @return array Device list as hash array
      */
     public function list_devices()
     {
         if ($this->root_meta === null) {
             $storage = $this->rc->get_storage();
             // @TODO: consider server annotation instead of INBOX
             if ($meta = $storage->get_metadata(self::ROOT_MAILBOX, self::ASYNC_KEY)) {
                 $this->root_meta = $this->unserialize_metadata($meta[self::ROOT_MAILBOX][self::ASYNC_KEY]);
             }
             else {
                 $this->root_meta = array();
             }
         }
 
         if (!empty($this->root_meta['DEVICE']) && is_array($this->root_meta['DEVICE'])) {
             return $this->root_meta['DEVICE'];
         }
 
         return array();
     }
 
     /**
      * Getter for folder metadata
      *
      * @return array Hash array with meta data for each folder
      */
     public function folder_meta()
     {
         if (!isset($this->folder_meta)) {
             $this->folder_meta = array();
             $storage = $this->rc->get_storage();
 
             // get folders activesync config
             $folderdata = $storage->get_metadata("*", self::ASYNC_KEY);
 
             foreach ($folderdata as $folder => $meta) {
                 if ($asyncdata = $meta[self::ASYNC_KEY]) {
                     if ($metadata = $this->unserialize_metadata($asyncdata)) {
                         $this->folder_meta[$folder] = $metadata;
                     }
                 }
             }
         }
 
         return $this->folder_meta;
     }
 
     /**
      * Sets ActiveSync subscription flag on a folder
      *
      * @param string $name      Folder name (UTF7-IMAP)
      * @param string $deviceid  Device identifier
      * @param int    $flag      Flag value (0|1|2)
      */
     public function folder_set($name, $deviceid, $flag)
     {
         if (empty($deviceid)) {
             return false;
         }
 
         // get folders activesync config
         $metadata = $this->folder_meta();
         $metadata = $metadata[$name];
 
         if ($flag)  {
             if (empty($metadata)) {
                 $metadata = array();
             }
 
             if (empty($metadata['FOLDER'])) {
                 $metadata['FOLDER'] = array();
             }
 
             if (empty($metadata['FOLDER'][$deviceid])) {
                 $metadata['FOLDER'][$deviceid] = array();
             }
 
             // Z-Push uses:
             //  1 - synchronize, no alarms
             //  2 - synchronize with alarms
             $metadata['FOLDER'][$deviceid]['S'] = $flag;
         }
 
         if (!$flag) {
             unset($metadata['FOLDER'][$deviceid]['S']);
 
             if (empty($metadata['FOLDER'][$deviceid])) {
                 unset($metadata['FOLDER'][$deviceid]);
             }
 
             if (empty($metadata['FOLDER'])) {
                 unset($metadata['FOLDER']);
             }
 
             if (empty($metadata)) {
                 $metadata = null;
             }
         }
 
         // Return if nothing's been changed
         if (!self::data_array_diff($this->folder_meta[$name], $metadata)) {
             return true;
         }
 
         $this->folder_meta[$name] = $metadata;
 
         $storage = $this->rc->get_storage();
 
         return $storage->set_metadata($name, array(
             self::ASYNC_KEY => $this->serialize_metadata($metadata)));
     }
 
     /**
      * Device update
      *
      * @param array  $device Device data
      * @param string $id     Device ID
      *
      * @return bool True on success, False on failure
      */
     public function device_update($device, $id)
     {
         $devices_list = $this->list_devices();
         $old_device   = $devices_list[$id];
 
         if (!$old_device) {
             return false;
         }
 
         // Do nothing if nothing is changed
         if (!self::data_array_diff($old_device, $device)) {
             return true;
         }
 
         $device = array_merge($old_device, $device);
 
         $metadata = $this->root_meta;
         $metadata['DEVICE'][$id] = $device;
         $metadata = array(self::ASYNC_KEY => $this->serialize_metadata($metadata));
         $storage  = $this->rc->get_storage();
 
         $result = $storage->set_metadata(self::ROOT_MAILBOX, $metadata);
 
         if ($result) {
             // Update local cache
             $this->root_meta['DEVICE'][$id] = $device;
         }
 
         return $result;
     }
 
     /**
      * Device delete.
      *
      * @param string $id  Device ID
      *
      * @return bool True on success, False on failure
      */
     public function device_delete($id)
     {
         $devices_list = $this->list_devices();
         $old_device   = $devices_list[$id];
 
         if (!$old_device) {
             return false;
         }
 
         unset($this->root_meta['DEVICE'][$id], $this->root_meta['FOLDER'][$id]);
 
         if (empty($this->root_meta['DEVICE'])) {
             unset($this->root_meta['DEVICE']);
         }
         if (empty($this->root_meta['FOLDER'])) {
             unset($this->root_meta['FOLDER']);
         }
 
         $metadata = $this->serialize_metadata($this->root_meta);
         $metadata = array(self::ASYNC_KEY => $metadata);
         $storage  = $this->rc->get_storage();
 
         // update meta data
         $result = $storage->set_metadata(self::ROOT_MAILBOX, $metadata);
 
         if ($result) {
             // remove device annotation for every folder
             foreach ($this->folder_meta() as $folder => $meta) {
                 // skip root folder (already handled above)
                 if ($folder == self::ROOT_MAILBOX)
                     continue;
 
                 if (!empty($meta['FOLDER']) && isset($meta['FOLDER'][$id])) {
                     unset($meta['FOLDER'][$id]);
 
                     if (empty($meta['FOLDER'])) {
                         unset($this->folder_meta[$folder]['FOLDER']);
                         unset($meta['FOLDER']);
                     }
                     if (empty($meta)) {
                         unset($this->folder_meta[$folder]);
                         $meta = null;
                     }
 
                     $metadata = array(self::ASYNC_KEY => $this->serialize_metadata($meta));
                     $res = $storage->set_metadata($folder, $metadata);
 
                     if ($res && $meta) {
                         $this->folder_meta[$folder] = $meta;
                     }
                 }
             }
 
             // remove device data from syncroton database
             $db    = $this->rc->get_dbh();
             $table = $db->table_name('syncroton_device');
 
             if (in_array($table, $db->list_tables())) {
                 $db->query("DELETE FROM $table WHERE owner_id = ? AND deviceid = ?",
                     $this->rc->user->ID, $id);
             }
         }
 
         return $result;
     }
 
     /**
      * Device information (from syncroton database)
      *
      * @param string $id  Device ID
      *
      * @return array Device data
      */
     public function device_info($id)
     {
         $db    = $this->rc->get_dbh();
         $table = $db->table_name('syncroton_device');
 
         if (in_array($table, $db->list_tables())) {
             $fields = array('devicetype', 'acsversion', 'useragent', 'friendlyname', 'os',
                 'oslanguage', 'phonenumber');
 
             $result = $db->query("SELECT " . $db->array2list($fields, 'ident')
                 . " FROM $table WHERE owner_id = ? AND id = ?",
                 $this->rc->user->ID, $id);
 
             if ($result && ($sql_arr = $db->fetch_assoc($result))) {
                 return $sql_arr;
             }
         }
     }
 
     /**
      * Helper method to decode saved IMAP metadata
      */
     private function unserialize_metadata($str)
     {
         if (!empty($str)) {
             $data = @json_decode($str, true);
             return $data;
         }
 
         return null;
     }
 
     /**
      * Helper method to encode IMAP metadata for saving
      */
     private function serialize_metadata($data)
     {
         if (!empty($data) && is_array($data)) {
             $data = json_encode($data);
             return $data;
         }
 
         return null;
     }
 
     /**
      * Compares two arrays
      *
      * @param array $array1
      * @param array $array2
      *
      * @return bool True if arrays differs, False otherwise
      */
     private static function data_array_diff($array1, $array2)
     {
         if (!is_array($array1) || !is_array($array2)) {
             return $array1 != $array2;
         }
 
         if (count($array1) != count($array2)) {
             return true;
         }
 
         foreach ($array1 as $key => $val) {
             if (!array_key_exists($key, $array2)) {
                 return true;
             }
             if ($val !== $array2[$key]) {
                 return true;
             }
         }
 
         return false;
     }
 }
diff --git a/plugins/kolab_activesync/kolab_activesync_ui.php b/plugins/kolab_activesync/kolab_activesync_ui.php
index edf64114..5200e4af 100644
--- a/plugins/kolab_activesync/kolab_activesync_ui.php
+++ b/plugins/kolab_activesync/kolab_activesync_ui.php
@@ -1,277 +1,277 @@
 <?php
 
 /**
  * ActiveSync configuration user interface builder
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  * @author Aleksander Machniak <machniak@kolabsys.com>
  *
  * Copyright (C) 2011-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_activesync_ui
 {
     private $rc;
     private $plugin;
     public  $device = array();
 
     const SETUP_URL = 'http://docs.kolab.org/client-configuration';
 
 
     public function __construct($plugin)
     {
         $this->plugin    = $plugin;
         $this->rc        = rcube::get_instance();
         $skin_path       = $this->plugin->local_skin_path() . '/';
         $this->skin_path = 'plugins/kolab_activesync/' . $skin_path;
 
         $this->plugin->include_stylesheet($skin_path . 'config.css');
     }
 
     public function device_list($attrib = array())
     {
         $attrib += array('id' => 'devices-list');
 
         $devices = $this->plugin->list_devices();
         $table   = new html_table();
 
         foreach ($devices as $id => $device) {
             $name = $device['ALIAS'] ? $device['ALIAS'] : $id;
             $table->add_row(array('id' => 'rcmrow' . $id));
-            $table->add(null, html::span('devicealias', Q($name)) . html::span('devicetype', Q($device['TYPE'])));
+            $table->add(null, html::span('devicealias', rcube::Q($name)) . html::span('devicetype', rcube::Q($device['TYPE'])));
         }
 
         $this->rc->output->add_gui_object('devicelist', $attrib['id']);
         $this->rc->output->set_env('devicecount', count($devices));
 
         $this->rc->output->include_script('list.js');
 
         return $table->show($attrib);
     }
 
 
     public function device_config_form($attrib = array())
     {
         $table = new html_table(array('cols' => 2));
 
         $field_id = 'config-device-alias';
         $input = new html_inputfield(array('name' => 'devicealias', 'id' => $field_id, 'size' => 40));
         $table->add('title', html::label($field_id, $this->plugin->gettext('devicealias')));
         $table->add(null, $input->show($this->device['ALIAS'] ? $this->device['ALIAS'] : $this->device['_id']));
 
         // read-only device information
         $info = $this->plugin->device_info($this->device['ID']);
 
         if (!empty($info)) {
             foreach ($info as $key => $value) {
                 if ($value) {
-                    $table->add('title', Q($this->plugin->gettext($key)));
-                    $table->add(null, Q($value));
+                    $table->add('title', rcube::Q($this->plugin->gettext($key)));
+                    $table->add(null, rcube::Q($value));
                 }
             }
         }
 
         if ($attrib['form']) {
             $this->rc->output->add_gui_object('editform', $attrib['form']);
         }
 
         return $table->show($attrib);
     }
 
 
     public function folder_subscriptions($attrib = array())
     {
         if (!$attrib['id'])
             $attrib['id'] = 'foldersubscriptions';
 
         // group folders by type (show only known types)
         $folder_groups = array('mail' => array(), 'contact' => array(), 'event' => array(), 'task' => array(), 'note' => array());
         $folder_types  = kolab_storage::folders_typedata();
         $imei          = $this->device['_id'];
         $subscribed    = array();
 
         if ($imei) {
             $folder_meta = $this->plugin->folder_meta();
         }
 
         foreach ($this->plugin->list_folders() as $folder) {
             if ($folder_types[$folder]) {
                 list($type, ) = explode('.', $folder_types[$folder]);
             }
             else {
                 $type = 'mail';
             }
 
             if (is_array($folder_groups[$type])) {
                 $folder_groups[$type][] = $folder;
 
                 if (!empty($folder_meta) && ($meta = $folder_meta[$folder])
                     && $meta['FOLDER'] && $meta['FOLDER'][$imei]['S']
                 ) {
                     $subscribed[$folder] = intval($meta['FOLDER'][$imei]['S']);
                 }
             }
         }
 
         // build block for every folder type
         foreach ($folder_groups as $type => $group) {
             if (empty($group)) {
                 continue;
             }
             $attrib['type'] = $type;
             $html .= html::div('subscriptionblock',
                 html::tag('h3', $type, $this->plugin->gettext($type)) .
                 $this->folder_subscriptions_block($group, $attrib, $subscribed));
         }
 
         $this->rc->output->add_gui_object('subscriptionslist', $attrib['id']);
 
         return html::div($attrib, $html);
     }
 
     public function folder_subscriptions_block($a_folders, $attrib, $subscribed)
     {
         $alarms = ($attrib['type'] == 'event' || $attrib['type'] == 'task');
 
         $table = new html_table(array('cellspacing' => 0));
         $table->add_header(array('class' => 'subscription', 'title' => $this->plugin->gettext('synchronize'), 'tabindex' => 0),
             $attrib['syncicon'] ? html::img(array('src' => $this->skin_path . $attrib['syncicon'])) :
                 $this->plugin->gettext('synchronize'));
         if ($alarms) {
             $table->add_header(array('class' => 'alarm', 'title' => $this->plugin->gettext('withalarms'), 'tabindex' => 0),
                 $attrib['alarmicon'] ? html::img(array('src' => $this->skin_path . $attrib['alarmicon'])) :
                     $this->plugin->gettext('withalarms'));
         }
         $table->add_header('foldername', $this->plugin->gettext('folder'));
 
         $checkbox_sync  = new html_checkbox(array('name' => 'subscribed[]', 'class' => 'subscription'));
         $checkbox_alarm = new html_checkbox(array('name' => 'alarm[]', 'class' => 'alarm'));
 
         $names = array();
         foreach ($a_folders as $folder) {
             $foldername = $origname = preg_replace('/^INBOX &raquo;\s+/', '', kolab_storage::object_name($folder));
 
             // find folder prefix to truncate (the same code as in kolab_addressbook plugin)
             for ($i = count($names)-1; $i >= 0; $i--) {
                 if (strpos($foldername, $names[$i].' &raquo; ') === 0) {
                     $length = strlen($names[$i].' &raquo; ');
                     $prefix = substr($foldername, 0, $length);
                     $count  = count(explode(' &raquo; ', $prefix));
                     $foldername = str_repeat('&nbsp;&nbsp;', $count-1) . '&raquo; ' . substr($foldername, $length);
                     break;
                 }
             }
 
-            $folder_id = 'rcmf' . html_identifier($folder);
+            $folder_id = 'rcmf' . rcube_utils::html_identifier($folder);
             $names[] = $origname;
             $classes = array('mailbox');
 
             if ($folder_class = $this->rc->folder_classname($folder)) {
                 $foldername = html::quote($this->rc->gettext($folder_class));
                 $classes[] = $folder_class;
             }
 
             $table->add_row();
             $table->add('subscription', $checkbox_sync->show(
                 !empty($subscribed[$folder]) ? $folder : null,
                 array('value' => $folder, 'id' => $folder_id)));
 
             if ($alarms) {
                 $table->add('alarm', $checkbox_alarm->show(
                     intval($subscribed[$folder]) > 1 ? $folder : null,
                     array('value' => $folder, 'id' => $folder_id.'_alarm')));
             }
 
             $table->add(join(' ', $classes), html::label($folder_id, $foldername));
         }
 
         return $table->show();
     }
 
     public function folder_options_table($folder_name, $devices, $type)
     {
         $alarms      = $type == 'event' || $type == 'task';
         $meta        = $this->plugin->folder_meta();
         $folder_data = (array) ($meta[$folder_name] ? $meta[$folder_name]['FOLDER'] : null);
 
         $table = new html_table(array('cellspacing' => 0, 'id' => 'folder-sync-options', 'class' => 'records-table'));
 
         // table header
         $table->add_header(array('class' => 'device'), $this->plugin->gettext('devicealias'));
         $table->add_header(array('class' => 'subscription'), $this->plugin->gettext('synchronize'));
         if ($alarms) {
             $table->add_header(array('class' => 'alarm'), $this->plugin->gettext('withalarms'));
         }
 
         // table records
         foreach ($devices as $id => $device) {
             $info     = $this->plugin->device_info($device['ID']);
             $name     = $id;
             $title    = '';
             $checkbox = new html_checkbox(array('name' => "_subscriptions[$id]", 'value' => 1,
                 'onchange' => 'return activesync_object.update_sync_data(this)'));
 
             if (!empty($info)) {
                 $_name = trim($info['friendlyname'] . ' ' . $info['os']);
                 $title = $info['useragent'];
 
                 if ($_name) {
                     $name .= " ($_name)";
                 }
             }
 
             $table->add_row();
             $table->add(array('class' => 'device', 'title' => $title), $name);
             $table->add('subscription', $checkbox->show(!empty($folder_data[$id]['S']) ? 1 : 0));
 
             if ($alarms) {
                 $checkbox_alarm = new html_checkbox(array('name' => "_alarms[$id]", 'value' => 1,
                     'onchange' => 'return activesync_object.update_sync_data(this)'));
 
                 $table->add('alarm', $checkbox_alarm->show($folder_data[$id]['S'] > 1 ? 1 : 0));
             }
         }
 
         return $table->show();
     }
 
     /**
      * Displays initial page (when no devices are registered)
      */
     function init_message()
     {
         $this->plugin->load_config();
 
         $this->rc->output->add_handlers(array(
                 'initmessage' => array($this, 'init_message_content')
         ));
 
         $this->rc->output->send('kolab_activesync.configempty');
     }
 
     /**
      * Handler for initmessage template object
      */
     function init_message_content()
     {
         $url  = $this->rc->config->get('activesync_setup_url', self::SETUP_URL);
         $vars = array('url' => $url);
         $msg  = $this->plugin->gettext(array('name' => 'nodevices', 'vars' => $vars));
 
         return $msg;
     }
 }
diff --git a/plugins/kolab_addressbook/kolab_addressbook.php b/plugins/kolab_addressbook/kolab_addressbook.php
index 7dd23e2c..3b1451d3 100644
--- a/plugins/kolab_addressbook/kolab_addressbook.php
+++ b/plugins/kolab_addressbook/kolab_addressbook.php
@@ -1,1191 +1,1191 @@
 <?php
 
 /**
  * Kolab address book
  *
  * Sample plugin to add a new address book source with data from Kolab storage
  * It provides also a possibilities to manage contact folders
  * (create/rename/delete/acl) directly in Addressbook UI.
  *
  * @version @package_version@
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  * @author Aleksander Machniak <machniak@kolabsys.com>
  *
  * Copyright (C) 2011-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_addressbook extends rcube_plugin
 {
     public $task = '?(?!login|logout).*';
 
     private $sources;
     private $folders;
     private $rc;
     private $ui;
 
     public $bonnie_api = false;
 
     const GLOBAL_FIRST = 0;
     const PERSONAL_FIRST = 1;
     const GLOBAL_ONLY = 2;
     const PERSONAL_ONLY = 3;
 
     /**
      * Startup method of a Roundcube plugin
      */
     public function init()
     {
         require_once(dirname(__FILE__) . '/lib/rcube_kolab_contacts.php');
 
         $this->rc = rcube::get_instance();
 
         // load required plugin
         $this->require_plugin('libkolab');
 
         // register hooks
         $this->add_hook('addressbooks_list', array($this, 'address_sources'));
         $this->add_hook('addressbook_get', array($this, 'get_address_book'));
         $this->add_hook('config_get', array($this, 'config_get'));
 
         if ($this->rc->task == 'addressbook') {
             $this->add_texts('localization');
             $this->add_hook('contact_form', array($this, 'contact_form'));
             $this->add_hook('contact_photo', array($this, 'contact_photo'));
             $this->add_hook('template_object_directorylist', array($this, 'directorylist_html'));
 
             // Plugin actions
             $this->register_action('plugin.book', array($this, 'book_actions'));
             $this->register_action('plugin.book-save', array($this, 'book_save'));
             $this->register_action('plugin.book-search', array($this, 'book_search'));
             $this->register_action('plugin.book-subscribe', array($this, 'book_subscribe'));
 
             $this->register_action('plugin.contact-changelog', array($this, 'contact_changelog'));
             $this->register_action('plugin.contact-diff', array($this, 'contact_diff'));
             $this->register_action('plugin.contact-restore', array($this, 'contact_restore'));
 
             // get configuration for the Bonnie API
             $this->bonnie_api = libkolab::get_bonnie_api();
 
             // Load UI elements
             if ($this->api->output->type == 'html') {
                 $this->load_config();
                 require_once($this->home . '/lib/kolab_addressbook_ui.php');
                 $this->ui = new kolab_addressbook_ui($this);
             }
         }
         else if ($this->rc->task == 'settings') {
             $this->add_texts('localization');
             $this->add_hook('preferences_list', array($this, 'prefs_list'));
             $this->add_hook('preferences_save', array($this, 'prefs_save'));
         }
 
         $this->add_hook('folder_delete', array($this, 'prefs_folder_delete'));
         $this->add_hook('folder_rename', array($this, 'prefs_folder_rename'));
         $this->add_hook('folder_update', array($this, 'prefs_folder_update'));
     }
 
 
     /**
      * Handler for the addressbooks_list hook.
      *
      * This will add all instances of available Kolab-based address books
      * to the list of address sources of Roundcube.
      * This will also hide some addressbooks according to kolab_addressbook_prio setting.
      *
      * @param array $p Hash array with hook parameters
      *
      * @return array Hash array with modified hook parameters
      */
     public function address_sources($p)
     {
         $abook_prio = $this->addressbook_prio();
 
         // Disable all global address books
         // Assumes that all non-kolab_addressbook sources are global
         if ($abook_prio == self::PERSONAL_ONLY) {
             $p['sources'] = array();
         }
 
         $sources = array();
         foreach ($this->_list_sources() as $abook_id => $abook) {
             // register this address source
             $sources[$abook_id] = $this->abook_prop($abook_id, $abook);
 
             // flag folders with 'i' right as writeable
             if ($this->rc->action == 'add' && strpos($abook->rights, 'i') !== false) {
                 $sources[$abook_id]['readonly'] = false;
             }
         }
 
         // Add personal address sources to the list
         if ($abook_prio == self::PERSONAL_FIRST) {
             // $p['sources'] = array_merge($sources, $p['sources']);
             // Don't use array_merge(), because if you have folders name
             // that resolve to numeric identifier it will break output array keys
             foreach ($p['sources'] as $idx => $value)
                 $sources[$idx] = $value;
             $p['sources'] = $sources;
         }
         else {
             // $p['sources'] = array_merge($p['sources'], $sources);
             foreach ($sources as $idx => $value)
                 $p['sources'][$idx] = $value;
         }
 
         return $p;
     }
 
     /**
      * Helper method to build a hash array of address book properties
      */
     protected function abook_prop($id, $abook)
     {
         if ($abook->virtual) {
             return array(
                 'id'       => $id,
                 'name'     => $abook->get_name(),
                 'listname' => $abook->get_foldername(),
                 'group'    => $abook instanceof kolab_storage_folder_user ? 'user' : $abook->get_namespace(),
                 'readonly' => true,
                 'rights'   => 'l',
                 'kolab'    => true,
                 'virtual'  => true,
             );
         }
         else {
             return array(
                 'id'       => $id,
                 'name'     => $abook->get_name(),
                 'listname' => $abook->get_foldername(),
                 'readonly' => $abook->readonly,
                 'rights'   => $abook->rights,
                 'groups'   => $abook->groups,
                 'undelete' => $abook->undelete && $this->rc->config->get('undo_timeout'),
                 'realname' => rcube_charset::convert($abook->get_realname(), 'UTF7-IMAP'), // IMAP folder name
                 'group'    => $abook->get_namespace(),
                 'subscribed' => $abook->is_subscribed(),
                 'carddavurl' => $abook->get_carddav_url(),
                 'removable'  => true,
                 'kolab'      => true,
                 'audittrail' => !empty($this->bonnie_api),
             );
         }
     }
 
     /**
      *
      */
     public function directorylist_html($args)
     {
         $out = '';
         $jsdata = array();
         $sources = (array)$this->rc->get_address_sources();
 
         // list all non-kolab sources first
         foreach (array_filter($sources, function($source){ return empty($source['kolab']); }) as $j => $source) {
             $id = strval(strlen($source['id']) ? $source['id'] : $j);
             $out .= $this->addressbook_list_item($id, $source, $jsdata) . '</li>';
         }
 
         // render a hierarchical list of kolab contact folders
         kolab_storage::folder_hierarchy($this->folders, $tree);
         $out .= $this->folder_tree_html($tree, $sources, $jsdata);
 
         $this->rc->output->set_env('contactgroups', array_filter($jsdata, function($src){ return $src['type'] == 'group'; }));
         $this->rc->output->set_env('address_sources', array_filter($jsdata, function($src){ return $src['type'] != 'group'; }));
 
         $args['content'] = html::tag('ul', $args, $out, html::$common_attrib);
         return $args;
     }
 
     /**
      * Return html for a structured list <ul> for the folder tree
      */
     public function folder_tree_html($node, $data, &$jsdata)
     {
         $out = '';
         foreach ($node->children as $folder) {
             $id = $folder->id;
             $source = $data[$id];
             $is_collapsed = strpos($this->rc->config->get('collapsed_abooks',''), '&'.rawurlencode($id).'&') !== false;
 
             if ($folder->virtual) {
                 $source = $this->abook_prop($folder->id, $folder);
             }
             else if (empty($source)) {
                 $this->sources[$id] = new rcube_kolab_contacts($folder->name);
                 $source = $this->abook_prop($id, $this->sources[$id]);
             }
 
             $content = $this->addressbook_list_item($id, $source, $jsdata);
 
             if (!empty($folder->children)) {
                 $child_html = $this->folder_tree_html($folder, $data, $jsdata);
 
                 // copy group items...
                 if (preg_match('!<ul[^>]*>(.*)</ul>\n*$!Ums', $content, $m)) {
                     $child_html = $m[1] . $child_html;
                     $content = substr($content, 0, -strlen($m[0]) - 1);
                 }
                 // ... and re-create the subtree
                 if (!empty($child_html)) {
                     $content .= html::tag('ul', array('class' => 'groups', 'style' => ($is_collapsed ? "display:none;" : null)), $child_html);
                 }
             }
 
             $out .= $content . '</li>';
         }
 
         return $out;
     }
 
     /**
      *
      */
     protected function addressbook_list_item($id, $source, &$jsdata, $search_mode = false)
     {
         $current = rcube_utils::get_input_value('_source', rcube_utils::INPUT_GPC);
 
         if (!$source['virtual']) {
             $jsdata[$id] = $source;
             $jsdata[$id]['name'] = html_entity_decode($source['name'], ENT_NOQUOTES, RCUBE_CHARSET);
         }
 
         // set class name(s)
         $classes = array('addressbook');
         if ($source['group'])
             $classes[] = $source['group'];
         if ($current === $id)
             $classes[] = 'selected';
         if ($source['readonly'])
             $classes[] = 'readonly';
         if ($source['virtual'])
             $classes[] = 'virtual';
         if ($source['class_name'])
             $classes[] = $source['class_name'];
 
         $name = !empty($source['listname']) ? $source['listname'] : (!empty($source['name']) ? $source['name'] : $id);
         $label_id = 'kabt:' . $id;
         $inner = ($source['virtual'] ?
             html::a(array('tabindex' => '0'), $name) :
             html::a(array(
                     'href' => $this->rc->url(array('_source' => $id)),
                     'rel' => $source['id'],
                     'id' => $label_id,
                     'onclick' => "return " . rcmail_output::JS_OBJECT_NAME.".command('list','" . rcube::JQ($id) . "',this)",
                 ), $name)
         );
 
         if (isset($source['subscribed'])) {
             $inner .= html::span(array(
                 'class' => 'subscribed',
                 'title' => $this->gettext('foldersubscribe'),
                 'role' => 'checkbox',
                 'aria-checked' => $source['subscribed'] ? 'true' : 'false',
             ), '');
         }
 
         // don't wrap in <li> but add a checkbox for search results listing
         if ($search_mode) {
             $jsdata[$id]['group'] = join(' ', $classes);
 
             if (!$source['virtual']) {
                 $inner .= html::tag('input', array(
                     'type' => 'checkbox',
                     'name' => '_source[]',
                     'value' => $id,
                     'checked' => false,
                     'aria-labelledby' => $label_id,
                 ));
             }
             return html::div(null, $inner);
         }
 
         $out .= html::tag('li', array(
                 'id' => 'rcmli' . rcube_utils::html_identifier($id, true),
                 'class' => join(' ', $classes), 
                 'noclose' => true,
             ),
             html::div($source['subscribed'] ? 'subscribed' : null, $inner)
         );
 
         $groupdata = array('out' => '', 'jsdata' => $jsdata, 'source' => $id);
         if ($source['groups'] && function_exists('rcmail_contact_groups')) {
             $groupdata = rcmail_contact_groups($groupdata);
         }
 
         $jsdata = $groupdata['jsdata'];
         $out .= $groupdata['out'];
 
         return $out;
     }
 
     /**
      * Sets autocomplete_addressbooks option according to
      * kolab_addressbook_prio setting extending list of address sources
      * to be used for autocompletion.
      */
     public function config_get($args)
     {
         if ($args['name'] != 'autocomplete_addressbooks') {
             return $args;
         }
 
         $abook_prio = $this->addressbook_prio();
         // here we cannot use rc->config->get()
         $sources    = $GLOBALS['CONFIG']['autocomplete_addressbooks'];
 
         // Disable all global address books
         // Assumes that all non-kolab_addressbook sources are global
         if ($abook_prio == self::PERSONAL_ONLY) {
             $sources = array();
         }
 
         if (!is_array($sources)) {
             $sources = array();
         }
 
         $kolab_sources = array();
         foreach (array_keys($this->_list_sources()) as $abook_id) {
             if (!in_array($abook_id, $sources))
                 $kolab_sources[] = $abook_id;
         }
 
         // Add personal address sources to the list
         if (!empty($kolab_sources)) {
             if ($abook_prio == self::PERSONAL_FIRST) {
                 $sources = array_merge($kolab_sources, $sources);
             }
             else {
                 $sources = array_merge($sources, $kolab_sources);
             }
         }
 
         $args['result'] = $sources;
 
         return $args;
     }
 
 
     /**
      * Getter for the rcube_addressbook instance
      *
      * @param array $p Hash array with hook parameters
      *
      * @return array Hash array with modified hook parameters
      */
     public function get_address_book($p)
     {
         if ($p['id']) {
             $id = kolab_storage::id_decode($p['id']);
 
             // check for falsely base64 decoded identifier
             if (preg_match('![^A-Za-z0-9=/+&._ -]!', $id)) {
                 $id = $p['id'];
             }
 
             $folder = kolab_storage::get_folder($id);
 
             // try with unencoded (old-style) identifier
             if ((!$folder || $folder->type != 'contact') && $id != $p['id']) {
                 $folder = kolab_storage::get_folder($p['id']);
             }
 
             if ($folder && $folder->type == 'contact') {
                 $p['instance'] = new rcube_kolab_contacts($folder->name);
 
                 // flag source as writeable if 'i' right is given
                 if ($p['writeable'] && $this->rc->action == 'save' && strpos($p['instance']->rights, 'i') !== false) {
                     $p['instance']->readonly = false;
                 }
                 else if ($this->rc->action == 'delete' && strpos($p['instance']->rights, 't') !== false) {
                     $p['instance']->readonly = false;
                 }
             }
         }
 
         return $p;
     }
 
 
     private function _list_sources()
     {
         // already read sources
         if (isset($this->sources))
             return $this->sources;
 
         kolab_storage::$encode_ids = true;
         $this->sources = array();
         $this->folders = array();
 
         $abook_prio = $this->addressbook_prio();
 
         // Personal address source(s) disabled?
         if ($abook_prio == self::GLOBAL_ONLY) {
             return $this->sources;
         }
 
         // get all folders that have "contact" type
         $folders = kolab_storage::sort_folders(kolab_storage::get_folders('contact'));
 
         if (PEAR::isError($folders)) {
             rcube::raise_error(array(
               'code' => 600, 'type' => 'php',
               'file' => __FILE__, 'line' => __LINE__,
               'message' => "Failed to list contact folders from Kolab server:" . $folders->getMessage()),
             true, false);
         }
         else {
             // we need at least one folder to prevent from errors in Roundcube core
             // when there's also no sql nor ldap addressbook (Bug #2086)
             if (empty($folders)) {
                 if ($folder = kolab_storage::create_default_folder('contact')) {
                     $folders = array(new kolab_storage_folder($folder, 'contact'));
                 }
             }
 
             // convert to UTF8 and sort
             foreach ($folders as $folder) {
                 // create instance of rcube_contacts
                 $abook_id = $folder->id;
                 $abook = new rcube_kolab_contacts($folder->name);
                 $this->sources[$abook_id] = $abook;
                 $this->folders[$abook_id] = $folder;
             }
         }
 
         return $this->sources;
     }
 
 
     /**
      * Plugin hook called before rendering the contact form or detail view
      *
      * @param array $p Hash array with hook parameters
      *
      * @return array Hash array with modified hook parameters
      */
     public function contact_form($p)
     {
         // none of our business
         if (!is_object($GLOBALS['CONTACTS']) || !is_a($GLOBALS['CONTACTS'], 'rcube_kolab_contacts'))
             return $p;
 
         // extend the list of contact fields to be displayed in the 'personal' section
         if (is_array($p['form']['personal'])) {
             $p['form']['personal']['content']['profession']    = array('size' => 40);
             $p['form']['personal']['content']['children']      = array('size' => 40);
             $p['form']['personal']['content']['freebusyurl']   = array('size' => 40);
             $p['form']['personal']['content']['pgppublickey']  = array('size' => 70);
             $p['form']['personal']['content']['pkcs7publickey'] = array('size' => 70);
 
             // re-order fields according to the coltypes list
             $p['form']['contact']['content']  = $this->_sort_form_fields($p['form']['contact']['content'], $GLOBALS['CONTACTS']);
             $p['form']['personal']['content'] = $this->_sort_form_fields($p['form']['personal']['content'], $GLOBALS['CONTACTS']);
 
             /* define a separate section 'settings'
             $p['form']['settings'] = array(
                 'name'    => $this->gettext('settings'),
                 'content' => array(
                     'freebusyurl'  => array('size' => 40, 'visible' => true),
                     'pgppublickey' => array('size' => 70, 'visible' => true),
                     'pkcs7publickey' => array('size' => 70, 'visible' => false),
                 )
             );
             */
         }
 
         if ($this->bonnie_api && $this->rc->action == 'show' && empty($p['record']['rev'])) {
             $this->rc->output->set_env('kolab_audit_trail', true);
         }
 
         return $p;
     }
 
     /**
      * Plugin hook for the contact photo image
      */
     public function contact_photo($p)
     {
         // add photo data from old revision inline as data url
         if (!empty($p['record']['rev']) && !empty($p['data'])) {
             $p['url'] = 'data:image/gif;base64,' . base64_encode($p['data']);
         }
 
         return $p;
     }
 
     /**
      * Handler for contact audit trail changelog requests
      */
     public function contact_changelog()
     {
         if (empty($this->bonnie_api)) {
             return false;
         }
 
         $contact = rcube_utils::get_input_value('cid', rcube_utils::INPUT_POST, true);
         $source = rcube_utils::get_input_value('source', rcube_utils::INPUT_POST);
 
         list($uid, $mailbox, $msguid) = $this->_resolve_contact_identity($contact, $source);
 
         $result = $uid && $mailbox ? $this->bonnie_api->changelog('contact', $uid, $mailbox, $msguid) : null;
         if (is_array($result) && $result['uid'] == $uid) {
             if (is_array($result['changes'])) {
                 $rcmail = $this->rc;
                 $dtformat = $this->rc->config->get('date_format') . ' ' . $this->rc->config->get('time_format');
                 array_walk($result['changes'], function(&$change) use ($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('contact_render_changelog', $result['changes']);
         }
         else {
             $this->rc->output->command('contact_render_changelog', false);
         }
 
         $this->rc->output->send();
     }
 
     /**
      * Handler for audit trail diff view requests
      */
     public function contact_diff()
     {
         if (empty($this->bonnie_api)) {
             return false;
         }
 
         $contact = rcube_utils::get_input_value('cid', rcube_utils::INPUT_POST, true);
         $source = rcube_utils::get_input_value('source', rcube_utils::INPUT_POST);
         $rev1 = rcube_utils::get_input_value('rev1', rcube_utils::INPUT_POST);
         $rev2 = rcube_utils::get_input_value('rev2', rcube_utils::INPUT_POST);
 
         list($uid, $mailbox, $msguid) = $this->_resolve_contact_identity($contact, $source);
 
         $result = $this->bonnie_api->diff('contact', $uid, $rev1, $rev2, $mailbox, $msguid);
         if (is_array($result) && $result['uid'] == $uid) {
             $result['rev1'] = $rev1;
             $result['rev2'] = $rev2;
             $result['cid'] = $contact;
 
             // convert some properties, similar to rcube_kolab_contacts::_to_rcube_contact()
             $keymap = array(
                 'lastmodified-date' => 'changed',
                 'additional' => 'middlename',
                 'fn' => 'name',
                 'tel' => 'phone',
                 'url' => 'website',
                 'bday' => 'birthday',
                 'note' => 'notes',
                 'role' => 'profession',
                 'title' => 'jobtitle',
             );
 
             $propmap = array('email' => 'address', 'website' => 'url', 'phone' => 'number');
             $date_format = $this->rc->config->get('date_format', 'Y-m-d');
 
             // map kolab object properties to keys and values the client expects
             array_walk($result['changes'], function(&$change, $i) use ($keymap, $propmap, $date_format) {
                 if (array_key_exists($change['property'], $keymap)) {
                     $change['property'] = $keymap[$change['property']];
                 }
 
                 // format date-time values
                 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_);
                     }
                 }
                 // format dates
                 else if ($change['property'] == 'birthday' || $change['property'] == 'anniversary') {
                     if ($old_ = rcube_utils::anytodatetime($change['old'])) {
                         $change['old_'] = $this->rc->format_date($old_, $date_format);
                     }
                     if ($new_ = rcube_utils::anytodatetime($change['new'])) {
                         $change['new_'] = $this->rc->format_date($new_, $date_format);
                     }
                 }
                 // convert email, website, phone values
                 else if (array_key_exists($change['property'], $propmap)) {
                     $propname = $propmap[$change['property']];
                     foreach (array('old','new') as $k) {
                         $k_ = $k . '_';
                         if (!empty($change[$k])) {
                             $change[$k_] = html::quote($change[$k][$propname] ?: '--');
                             if ($change[$k]['type']) {
                                 $change[$k_] .= '&nbsp;' . html::span('subtype', rcmail_get_type_label($change[$k]['type']));
                             }
                             $change['ishtml'] = true;
                         }
                     }
                 }
                 // serialize address structs
                 if ($change['property'] == 'address') {
                     foreach (array('old','new') as $k) {
                         $k_ = $k . '_';
                         $change[$k]['zipcode'] = $change[$k]['code'];
                         $template = $this->rc->config->get('address_template', '{'.join('} {', array_keys($change[$k])).'}');
                         $composite = array();
                         foreach ($change[$k] as $p => $val) {
                             if (strlen($val))
                                 $composite['{'.$p.'}'] = $val;
                         }
                         $change[$k_] = preg_replace('/\{\w+\}/', '', strtr($template, $composite));
                         if ($change[$k]['type']) {
                             $change[$k_] .= html::div('subtype', rcmail_get_type_label($change[$k]['type']));
                         }
                         $change['ishtml'] = true;
                     }
 
                     $change['diff_'] = libkolab::html_diff($change['old_'], $change['new_'], true);
                 }
                 // localize gender values
                 else if ($change['property'] == 'gender') {
                     if ($change['old']) $change['old_'] = $this->rc->gettext($change['old']);
                     if ($change['new']) $change['new_'] = $this->rc->gettext($change['new']);
                 }
                 // translate 'key' entries in individual properties
                 else if ($change['property'] == 'key') {
                     $p = $change['old'] ?: $change['new'];
                     $t = $p['type'];
                     $change['property'] = $t . 'publickey';
                     $change['old'] = $change['old'] ? $change['old']['key'] : '';
                     $change['new'] = $change['new'] ? $change['new']['key'] : '';
                 }
                 // compute a nice diff of notes
                 else if ($change['property'] == 'notes') {
                     $change['diff_'] = libkolab::html_diff($change['old'], $change['new'], false);
                 }
             });
 
             $this->rc->output->command('contact_show_diff', $result);
         }
         else {
             $this->rc->output->command('display_message', $this->gettext('objectdiffnotavailable'), 'error');
         }
 
         $this->rc->output->send();
     }
 
     /**
      * Handler for audit trail revision restore requests
      */
     public function contact_restore()
     {
         if (empty($this->bonnie_api)) {
             return false;
         }
 
         $success = false;
         $contact = rcube_utils::get_input_value('cid', rcube_utils::INPUT_POST, true);
         $source = rcube_utils::get_input_value('source', rcube_utils::INPUT_POST);
         $rev = rcube_utils::get_input_value('rev', rcube_utils::INPUT_POST);
 
         list($uid, $mailbox, $msguid) = $this->_resolve_contact_identity($contact, $source, $folder);
 
         if ($folder && ($raw_msg = $this->bonnie_api->rawdata('contact', $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();
             }
         }
 
         if ($success) {
             $this->rc->output->command('display_message', $this->gettext(array('name' => 'objectrestoresuccess', 'vars' => array('rev' => $rev))), 'confirmation');
             $this->rc->output->command('close_contact_history_dialog', $contact);
         }
         else {
             $this->rc->output->command('display_message', $this->gettext('objectrestoreerror'), 'error');
         }
 
         $this->rc->output->send();
     }
 
     /**
      * Get a previous revision of the given contact record from the Bonnie API
      */
     public function get_revision($cid, $source, $rev)
     {
         if (empty($this->bonnie_api)) {
             return false;
         }
 
         list($uid, $mailbox, $msguid) = $this->_resolve_contact_identity($cid, $source);
 
         // call Bonnie API
         $result = $this->bonnie_api->get('contact', $uid, $rev, $mailbox, $msguid);
         if (is_array($result) && $result['uid'] == $uid && !empty($result['xml'])) {
             $format = kolab_format::factory('contact');
             $format->load($result['xml']);
             $rec = $format->to_array();
 
             if ($format->is_valid()) {
                 $rec['rev'] = $result['rev'];
                 return $rec;
             }
         }
 
         return false;
     }
 
 
     /**
      * Helper method to resolved the given contact identifier into uid and mailbox
      *
      * @return array (uid,mailbox,msguid) tuple
      */
     private function _resolve_contact_identity($id, $abook, &$folder = null)
     {
         $mailbox = $msguid = null;
 
         $source = $this->get_address_book(array('id' => $abook));
         if ($source['instance']) {
             $uid = $source['instance']->id2uid($id);
             $list = kolab_storage::id_decode($abook);
         }
         else {
             return array(null, $mailbox, $msguid);
         }
 
         // get resolve message UID and mailbox identifier
         if ($folder = kolab_storage::get_folder($list)) {
             $mailbox = $folder->get_mailbox_id();
             $msguid = $folder->cache->uid2msguid($uid);
         }
 
         return array($uid, $mailbox, $msguid);
     }
 
     /**
      *
      */
     private function _sort_form_fields($contents, $source)
     {
       $block = array();
 
       foreach (array_keys($source->coltypes) as $col) {
           if (isset($contents[$col]))
               $block[$col] = $contents[$col];
       }
 
       return $block;
     }
 
 
     /**
      * Handler for user preferences form (preferences_list hook)
      *
      * @param array $args Hash array with hook parameters
      *
      * @return array Hash array with modified hook parameters
      */
     public function prefs_list($args)
     {
         if ($args['section'] != 'addressbook') {
             return $args;
         }
 
         $ldap_public = $this->rc->config->get('ldap_public');
         $abook_type  = $this->rc->config->get('address_book_type');
 
         // Hide option if there's no global addressbook
         if (empty($ldap_public) || $abook_type != 'ldap') {
             return $args;
         }
 
         // Check that configuration is not disabled
         $dont_override = (array) $this->rc->config->get('dont_override', array());
         $prio          = $this->addressbook_prio();
 
         if (!in_array('kolab_addressbook_prio', $dont_override)) {
             // Load localization
             $this->add_texts('localization');
 
             $field_id = '_kolab_addressbook_prio';
             $select   = new html_select(array('name' => $field_id, 'id' => $field_id));
 
             $select->add($this->gettext('globalfirst'), self::GLOBAL_FIRST);
             $select->add($this->gettext('personalfirst'), self::PERSONAL_FIRST);
             $select->add($this->gettext('globalonly'), self::GLOBAL_ONLY);
             $select->add($this->gettext('personalonly'), self::PERSONAL_ONLY);
 
             $args['blocks']['main']['options']['kolab_addressbook_prio'] = array(
-                'title' => html::label($field_id, Q($this->gettext('addressbookprio'))),
+                'title' => html::label($field_id, rcube::Q($this->gettext('addressbookprio'))),
                 'content' => $select->show($prio),
             );
         }
 
         return $args;
     }
 
     /**
      * Handler for user preferences save (preferences_save hook)
      *
      * @param array $args Hash array with hook parameters
      *
      * @return array Hash array with modified hook parameters
      */
     public function prefs_save($args)
     {
         if ($args['section'] != 'addressbook') {
             return $args;
         }
 
         // Check that configuration is not disabled
         $dont_override = (array) $this->rc->config->get('dont_override', array());
         $key           = 'kolab_addressbook_prio';
 
         if (!in_array('kolab_addressbook_prio', $dont_override) || !isset($_POST['_'.$key])) {
             $args['prefs'][$key] = (int) rcube_utils::get_input_value('_'.$key, rcube_utils::INPUT_POST);
         }
 
         return $args;
     }
 
 
     /**
      * Handler for plugin actions
      */
     public function book_actions()
     {
         $action = trim(rcube_utils::get_input_value('_act', rcube_utils::INPUT_GPC));
 
         if ($action == 'create') {
             $this->ui->book_edit();
         }
         else if ($action == 'edit') {
             $this->ui->book_edit();
         }
         else if ($action == 'delete') {
             $this->book_delete();
         }
     }
 
 
     /**
      * Handler for address book create/edit form submit
      */
     public function book_save()
     {
         $prop = array(
             'name'    => trim(rcube_utils::get_input_value('_name', rcube_utils::INPUT_POST)),
             'oldname' => trim(rcube_utils::get_input_value('_oldname', rcube_utils::INPUT_POST, true)), // UTF7-IMAP
             'parent'  => trim(rcube_utils::get_input_value('_parent', rcube_utils::INPUT_POST, true)), // UTF7-IMAP
             'type'    => 'contact',
             'subscribed' => true,
         );
 
         $result = $error = false;
         $type = strlen($prop['oldname']) ? 'update' : 'create';
         $prop = $this->rc->plugins->exec_hook('addressbook_'.$type, $prop);
 
         if (!$prop['abort']) {
             if ($newfolder = kolab_storage::folder_update($prop)) {
                 $folder = $newfolder;
                 $result = true;
             }
             else {
                 $error = kolab_storage::$last_error;
             }
         }
         else {
             $result = $prop['result'];
             $folder = $prop['name'];
         }
 
         if ($result) {
             $kolab_folder = kolab_storage::get_folder($folder);
 
             // get folder/addressbook properties
             $abook = new rcube_kolab_contacts($folder);
             $props = $this->abook_prop(kolab_storage::folder_id($folder, true), $abook);
             $props['parent'] = kolab_storage::folder_id($kolab_folder->get_parent(), true);
 
             $this->rc->output->show_message('kolab_addressbook.book'.$type.'d', 'confirmation');
             $this->rc->output->command('book_update', $props, kolab_storage::folder_id($prop['oldname'], true));
             $this->rc->output->send('iframe');
         }
 
         if (!$error)
             $error = $plugin['message'] ? $plugin['message'] : 'kolab_addressbook.book'.$type.'error';
 
         $this->rc->output->show_message($error, 'error');
         // display the form again
         $this->ui->book_edit();
     }
 
     /**
      *
      */
     public function book_search()
     {
         $results = array();
         $query = rcube_utils::get_input_value('q', rcube_utils::INPUT_GPC);
         $source = rcube_utils::get_input_value('source', rcube_utils::INPUT_GPC);
 
         kolab_storage::$encode_ids = true;
         $search_more_results = false;
         $this->sources = array();
         $this->folders = array();
 
         // find unsubscribed IMAP folders that have "event" type
         if ($source == 'folders') {
             foreach ((array)kolab_storage::search_folders('contact', $query, array('other')) as $folder) {
                 $this->folders[$folder->id] = $folder;
                 $this->sources[$folder->id] = new rcube_kolab_contacts($folder->name);
             }
         }
         // 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 contact folders shared by this user
                 foreach (kolab_storage::list_user_folders($user, 'contact', false) as $foldername) {
                     $folders[] = new kolab_storage_folder($foldername, 'contact');
                 }
 
                 if (count($folders)) {
                     $userfolder = new kolab_storage_folder_user($user['kolabtargetfolder'], '', $user);
                     $this->folders[$userfolder->id] = $userfolder;
                     $this->sources[$userfolder->id] = $userfolder;
 
                     foreach ($folders as $folder) {
                         $this->folders[$folder->id] = $folder;
                         $this->sources[$folder->id] = new rcube_kolab_contacts($folder->name);;
                         $count++;
                     }
                 }
 
                 if ($count >= $limit) {
                     $search_more_results = true;
                     break;
                 }
             }
         }
 
         $delim = $this->rc->get_storage()->get_hierarchy_delimiter();
 
         // build results list
         foreach ($this->sources as $id => $source) {
             $folder = $this->folders[$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());
             }
 
             $prop = $this->abook_prop($id, $source);
             $prop['parent'] = $parent_id;
 
             $html = $this->addressbook_list_item($id, $prop, $jsdata, true);
             unset($prop['group']);
             $prop += (array)$jsdata[$id];
             $prop['html'] = $html;
 
             $results[] = $prop;
         }
 
         // report more results available
         if ($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));
     }
 
     /**
      *
      */
     public function book_subscribe()
     {
         $success = false;
         $id = rcube_utils::get_input_value('_source', rcube_utils::INPUT_GPC);
 
         if ($id && ($folder = kolab_storage::get_folder(kolab_storage::id_decode($id)))) {
             if (isset($_POST['_permanent']))
                 $success |= $folder->subscribe(intval($_POST['_permanent']));
             if (isset($_POST['_active']))
                 $success |= $folder->activate(intval($_POST['_active']));
 
             // list groups for this address book
             if (!empty($_POST['_groups'])) {
                 $abook = new rcube_kolab_contacts($folder->name);
                 foreach ((array)$abook->list_groups() as $prop) {
                     $prop['source'] = $id;
                     $prop['id'] = $prop['ID'];
                     unset($prop['ID']);
                     $this->rc->output->command('insert_contact_group', $prop);
                 }
             }
         }
 
         if ($success) {
             $this->rc->output->show_message('successfullysaved', 'confirmation');
         }
         else {
             $this->rc->output->show_message($this->gettext('errorsaving'), 'error');
         }
 
         $this->rc->output->send();
     }
 
 
     /**
      * Handler for address book delete action (AJAX)
      */
     private function book_delete()
     {
         $folder = trim(rcube_utils::get_input_value('_source', rcube_utils::INPUT_GPC, true, 'UTF7-IMAP'));
 
         if (kolab_storage::folder_delete($folder)) {
             $storage = $this->rc->get_storage();
             $delimiter = $storage->get_hierarchy_delimiter();
 
             $this->rc->output->show_message('kolab_addressbook.bookdeleted', 'confirmation');
             $this->rc->output->set_env('pagecount', 0);
             $this->rc->output->command('set_rowcount', rcmail_get_rowcount_text(new rcube_result_set()));
             $this->rc->output->command('set_env', 'delimiter', $delimiter);
             $this->rc->output->command('list_contacts_clear');
             $this->rc->output->command('book_delete_done', kolab_storage::folder_id($folder, true));
         }
         else {
             $this->rc->output->show_message('kolab_addressbook.bookdeleteerror', 'error');
         }
 
         $this->rc->output->send();
     }
 
     /**
      * Returns value of kolab_addressbook_prio setting
      */
     private function addressbook_prio()
     {
         // Load configuration
         if (!$this->config_loaded) {
             $this->load_config();
             $this->config_loaded = true;
         }
 
         $abook_prio = (int) $this->rc->config->get('kolab_addressbook_prio');
 
         // Make sure any global addressbooks are defined
         if ($abook_prio == 0 || $abook_prio == 2) {
             $ldap_public = $this->rc->config->get('ldap_public');
             $abook_type  = $this->rc->config->get('address_book_type');
 
             if (empty($ldap_public) || $abook_type != 'ldap') {
                 $abook_prio = 1;
             }
         }
 
         return $abook_prio;
     }
 
     /**
      * Hook for (contact) folder deletion
      */
     function prefs_folder_delete($args)
     {
         // ignore...
         if ($args['abort'] && !$args['result']) {
             return $args;
         }
 
         $this->_contact_folder_rename($args['name'], false);
     }
 
     /**
      * Hook for (contact) folder renaming
      */
     function prefs_folder_rename($args)
     {
         // ignore...
         if ($args['abort'] && !$args['result']) {
             return $args;
         }
 
         $this->_contact_folder_rename($args['oldname'], $args['newname']);
     }
 
     /**
      * Hook for (contact) folder updates. Forward to folder_rename handler if name was changed
      */
     function prefs_folder_update($args)
     {
         // ignore...
         if ($args['abort'] && !$args['result']) {
             return $args;
         }
 
         if ($args['record']['name'] != $args['record']['oldname']) {
             $this->_contact_folder_rename($args['record']['oldname'], $args['record']['name']);
         }
     }
 
     /**
      * Apply folder renaming or deletion to the registered birthday calendar address books
      */
     private function _contact_folder_rename($oldname, $newname = false)
     {
         $update = false;
         $delimiter = $this->rc->get_storage()->get_hierarchy_delimiter();
         $bday_addressbooks = (array)$this->rc->config->get('calendar_birthday_adressbooks', array());
 
         foreach ($bday_addressbooks as $i => $id) {
             $folder_name = kolab_storage::id_decode($id);
             if ($oldname === $folder_name || strpos($folder_name, $oldname.$delimiter) === 0) {
                 if ($newname) {  // rename
                     $new_folder = $newname . substr($folder_name, strlen($oldname));
                     $bday_addressbooks[$i] = kolab_storage::id_encode($new_folder);
                 }
                 else {  // delete
                     unset($bday_addressbooks[$i]);
                 }
                 $update = true;
             }
         }
 
         if ($update) {
             $this->rc->user->save_prefs(array('calendar_birthday_adressbooks' => $bday_addressbooks));
         }
     }
 
 }
diff --git a/plugins/kolab_addressbook/lib/kolab_addressbook_ui.php b/plugins/kolab_addressbook/lib/kolab_addressbook_ui.php
index 04f56d4f..5fab1540 100644
--- a/plugins/kolab_addressbook/lib/kolab_addressbook_ui.php
+++ b/plugins/kolab_addressbook/lib/kolab_addressbook_ui.php
@@ -1,340 +1,340 @@
 <?php
 
 /**
  * Kolab address book UI
  *
  * @author Aleksander Machniak <machniak@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 kolab_addressbook_ui
 {
     private $plugin;
     private $rc;
 
     /**
      * Class constructor
      *
      * @param kolab_addressbook $plugin Plugin object
      */
     public function __construct($plugin)
     {
         $this->rc     = rcube::get_instance();
         $this->plugin = $plugin;
 
         $this->init_ui();
     }
 
     /**
      * Adds folders management functionality to Addressbook UI
      */
     private function init_ui()
     {
         if (!empty($this->rc->action) && !preg_match('/^plugin\.book/', $this->rc->action) && $this->rc->action != 'show') {
             return;
         }
 
         // Include script
         $this->plugin->include_script('kolab_addressbook.js');
 
         if (empty($this->rc->action)) {
             // Include stylesheet (for directorylist)
             $this->plugin->include_stylesheet($this->plugin->local_skin_path().'/kolab_addressbook.css');
 
             // include kolab folderlist widget if available
             if (in_array('libkolab', $this->plugin->api->loaded_plugins())) {
                 $this->plugin->api->include_script('libkolab/js/folderlist.js');
             }
 
             // Add actions on address books
             $options = array('book-create', 'book-edit', 'book-delete', 'book-remove');
             $idx     = 0;
 
             if ($this->rc->config->get('kolab_addressbook_carddav_url')) {
               $options[] = 'book-showurl';
               $this->rc->output->set_env('kolab_addressbook_carddav_url', true);
             }
 
             foreach ($options as $command) {
                 $content = html::tag('li', $idx ? null : array('class' => 'separator_above'),
                     $this->plugin->api->output->button(array(
                         'label'    => 'kolab_addressbook.'.str_replace('-', '', $command),
                         'domain'   => $this->ID,
                         'classact' => 'active',
                         'command'  => $command
                 )));
                 $this->plugin->api->add_content($content, 'groupoptions');
                 $idx++;
             }
 
             // Link to Settings/Folders
             $content = html::tag('li', array('class' => 'separator_above'),
                 $this->plugin->api->output->button(array(
                     'label'    => 'managefolders',
                     'type'     => 'link',
                     'classact' => 'active',
                     'command'  => 'folders',
                     'task'     => 'settings',
             )));
             $this->plugin->api->add_content($content, 'groupoptions');
 
             $this->rc->output->add_label('kolab_addressbook.bookdeleteconfirm',
                 'kolab_addressbook.bookdeleting', 'kolab_addressbook.bookshowurl',
                 'kolab_addressbook.carddavurldescription',
                 'kolab_addressbook.bookedit',
                 'kolab_addressbook.bookdelete',
                 'kolab_addressbook.bookshowurl',
                 'kolab_addressbook.findaddressbooks',
                 'kolab_addressbook.searchterms',
                 'kolab_addressbook.foldersearchform',
                 'kolab_addressbook.listsearchresults',
                 'kolab_addressbook.nraddressbooksfound',
                 'kolab_addressbook.noaddressbooksfound',
                 'kolab_addressbook.foldersubscribe',
                 'resetsearch');
 
 
             if ($this->plugin->bonnie_api) {
                 $this->rc->output->set_env('kolab_audit_trail', true);
                 $this->plugin->api->include_script('libkolab/js/audittrail.js');
 
                 $this->rc->output->add_label(
                     'kolab_addressbook.showhistory',
                     'kolab_addressbook.objectchangelog',
                     'kolab_addressbook.objectdiff',
                     'kolab_addressbook.objectdiffnotavailable',
                     'kolab_addressbook.objectchangelognotavailable',
                     'kolab_addressbook.revisionrestoreconfirm'
                 );
 
                 $this->plugin->add_hook('render_page', array($this, 'render_audittrail_page'));
                 $this->plugin->register_handler('plugin.object_changelog_table', array('libkolab', 'object_changelog_table'));
             }
         }
         // include stylesheet for audit trail
         else if ($this->rc->action == 'show' && $this->plugin->bonnie_api) {
             $this->plugin->include_stylesheet($this->plugin->local_skin_path().'/kolab_addressbook.css');
             $this->rc->output->add_label('kolab_addressbook.showhistory');
         }
         // book create/edit form
         else {
             $this->rc->output->add_label('kolab_addressbook.nobooknamewarning',
                 'kolab_addressbook.booksaving');
         }
     }
 
 
     /**
      * Handler for address book create/edit action
      */
     public function book_edit()
     {
         $this->rc->output->add_handler('bookdetails', array($this, 'book_form'));
         $this->rc->output->send('kolab_addressbook.bookedit');
     }
 
 
     /**
      * Handler for 'bookdetails' object returning form content for book create/edit
      *
      * @param array $attr Object attributes
      *
      * @return string HTML output
      */
     public function book_form($attrib)
     {
         $action = trim(rcube_utils::get_input_value('_act', rcube_utils::INPUT_GPC));
         $folder = trim(rcube_utils::get_input_value('_source', rcube_utils::INPUT_GPC, true)); // UTF8
 
         $hidden_fields[] = array('name' => '_source', 'value' => $folder);
 
         $folder  = rcube_charset::convert($folder, RCUBE_CHARSET, 'UTF7-IMAP');
         $storage = $this->rc->get_storage();
         $delim   = $storage->get_hierarchy_delimiter();
 
         if ($this->rc->action == 'plugin.book-save') {
             // save error
             $name      = trim(rcube_utils::get_input_value('_name', rcube_utils::INPUT_GPC, true)); // UTF8
             $old       = trim(rcube_utils::get_input_value('_oldname', rcube_utils::INPUT_GPC, true)); // UTF7-IMAP
             $path_imap = trim(rcube_utils::get_input_value('_parent', rcube_utils::INPUT_GPC, true)); // UTF7-IMAP
 
             $hidden_fields[] = array('name' => '_oldname', 'value' => $old);
 
             $folder = $old;
         }
         else if ($action == 'edit') {
             $path_imap = explode($delim, $folder);
             $name      = rcube_charset::convert(array_pop($path_imap), 'UTF7-IMAP');
             $path_imap = implode($path_imap, $delim);
         }
         else { // create
             $path_imap = $folder;
             $name      = '';
             $folder    = '';
         }
 
         // Store old name, get folder options
         if (strlen($folder)) {
             $hidden_fields[] = array('name' => '_oldname', 'value' => $folder);
 
             $options = $storage->folder_info($folder);
         }
 
         $form   = array();
 
         // General tab
         $form['props'] = array(
             'name' => $this->rc->gettext('properties'),
         );
 
         if (!empty($options) && ($options['norename'] || $options['protected'])) {
-            $foldername = Q(str_replace($delim, ' &raquo; ', kolab_storage::object_name($folder)));
+            $foldername = rcube::Q(str_replace($delim, ' &raquo; ', kolab_storage::object_name($folder)));
         }
         else {
             $foldername = new html_inputfield(array('name' => '_name', 'id' => '_name', 'size' => 30));
             $foldername = $foldername->show($name);
         }
 
         $form['props']['fieldsets']['location'] = array(
             'name'  => $this->rc->gettext('location'),
             'content' => array(
                 'name' => array(
                     'label' => $this->plugin->gettext('bookname'),
                     'value' => $foldername,
                 ),
             ),
         );
 
         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('contact', array('name' => '_parent'), $folder);
 
             $form['props']['fieldsets']['location']['content']['path'] = array(
                 'label' => $this->plugin->gettext('parentbook'),
                 'value' => $select->show(strlen($folder) ? $path_imap : ''),
             );
         }
 
         // Allow plugins to modify address book form content (e.g. with ACL form)
         $plugin = $this->rc->plugins->exec_hook('addressbook_form',
             array('form' => $form, 'options' => $options, 'name' => $folder));
 
         $form = $plugin['form'];
 
         // Set form tags and hidden fields
         list($form_start, $form_end) = $this->get_form_tags($attrib, 'plugin.book-save', null, $hidden_fields);
 
         unset($attrib['form']);
 
         // return the complete edit form as table
         $out = "$form_start\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, Q($fieldset['name'])) . $subcontent) ."\n";
+                        $content .= html::tag('fieldset', null, html::tag('legend', null, rcube::Q($fieldset['name'])) . $subcontent) ."\n";
                     }
                 }
             }
             else {
                 $content = $this->get_form_part($tab);
             }
 
             if ($content) {
-                $out .= html::tag('fieldset', null, html::tag('legend', null, Q($tab['name'])) . $content) ."\n";
+                $out .= html::tag('fieldset', null, html::tag('legend', null, rcube::Q($tab['name'])) . $content) ."\n";
             }
         }
 
         $out .= "\n$form_end";
 
         return $out;
     }
 
     /**
      *
      */
     public function render_audittrail_page($p)
     {
         // append audit trail UI elements to contact page
         if ($p['template'] === 'addressbook' && !$p['kolab-audittrail']) {
             $this->rc->output->add_footer($this->rc->output->parse('kolab_addressbook.audittrail', false, false));
             $p['kolab-audittrail'] = true;
         }
 
         return $p;
     }
 
 
     private function get_form_part($form)
     {
         $content = '';
 
         if (is_array($form['content']) && !empty($form['content'])) {
             $table = new html_table(array('cols' => 2, 'class' => 'propform'));
             foreach ($form['content'] as $col => $colprop) {
                 $colprop['id'] = '_'.$col;
                 $label = !empty($colprop['label']) ? $colprop['label'] : rcube_label($col);
 
-                $table->add('title', sprintf('<label for="%s">%s</label>', $colprop['id'], Q($label)));
+                $table->add('title', sprintf('<label for="%s">%s</label>', $colprop['id'], rcube::Q($label)));
                 $table->add(null, $colprop['value']);
             }
             $content = $table->show();
         }
         else {
             $content = $form['content'];
         }
 
         return $content;
     }
 
 
     private function get_form_tags($attrib, $action, $id = null, $hidden = null)
     {
         $form_start = $form_end = '';
 
         $request_key = $action . (isset($id) ? '.'.$id : '');
         $form_start = $this->rc->output->request_form(array(
             'name'    => 'form',
             'method'  => 'post',
             'task'    => $this->rc->task,
             'action'  => $action,
             'request' => $request_key,
             'noclose' => true,
         ) + $attrib);
 
         if (is_array($hidden)) {
             foreach ($hidden as $field) {
                 $hiddenfield = new html_hiddenfield($field);
                 $form_start .= $hiddenfield->show();
             }
         }
 
         $form_end = !strlen($attrib['form']) ? '</form>' : '';
 
         $EDIT_FORM = !empty($attrib['form']) ? $attrib['form'] : 'form';
         $this->rc->output->add_gui_object('editform', $EDIT_FORM);
 
         return array($form_start, $form_end);
     }
 
 }
diff --git a/plugins/kolab_auth/kolab_auth.php b/plugins/kolab_auth/kolab_auth.php
index 033d5b17..42f1aca7 100644
--- a/plugins/kolab_auth/kolab_auth.php
+++ b/plugins/kolab_auth/kolab_auth.php
@@ -1,788 +1,788 @@
 <?php
 
 /**
  * Kolab Authentication (based on ldap_authentication plugin)
  *
  * Authenticates on LDAP server, finds canonized authentication ID for IMAP
  * and for new users creates identity based on LDAP information.
  *
  * Supports impersonate feature (login as another user). To use this feature
  * imap_auth_type/smtp_auth_type must be set to DIGEST-MD5 or PLAIN.
  *
  * @version @package_version@
  * @author Aleksander Machniak <machniak@kolabsys.com>
  *
  * Copyright (C) 2011-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_auth extends rcube_plugin
 {
     static $ldap;
     private $username;
     private $data = array();
 
     public function init()
     {
         $rcmail = rcube::get_instance();
 
         $this->load_config();
 
         $this->add_hook('authenticate', array($this, 'authenticate'));
         $this->add_hook('startup', array($this, 'startup'));
         $this->add_hook('user_create', array($this, 'user_create'));
 
         // Hook for password change
         $this->add_hook('password_ldap_bind', array($this, 'password_ldap_bind'));
 
         // Hooks related to "Login As" feature
         $this->add_hook('template_object_loginform', array($this, 'login_form'));
         $this->add_hook('storage_connect', array($this, 'imap_connect'));
         $this->add_hook('managesieve_connect', array($this, 'imap_connect'));
         $this->add_hook('smtp_connect', array($this, 'smtp_connect'));
         $this->add_hook('identity_form', array($this, 'identity_form'));
 
         // Hook to modify some configuration, e.g. ldap
         $this->add_hook('config_get', array($this, 'config_get'));
 
         // Hook to modify logging directory
         $this->add_hook('write_log', array($this, 'write_log'));
         $this->username = $_SESSION['username'];
 
         // Enable debug logs (per-user), when logged as another user
         if (!empty($_SESSION['kolab_auth_admin']) && $rcmail->config->get('kolab_auth_auditlog')) {
             $rcmail->config->set('debug_level', 1);
             $rcmail->config->set('devel_mode', true);
             $rcmail->config->set('smtp_log', true);
             $rcmail->config->set('log_logins', true);
             $rcmail->config->set('log_session', true);
             $rcmail->config->set('memcache_debug', true);
             $rcmail->config->set('imap_debug', true);
             $rcmail->config->set('ldap_debug', true);
             $rcmail->config->set('smtp_debug', true);
             $rcmail->config->set('sql_debug', true);
 
             // SQL debug need to be set directly on DB object
             // setting config variable will not work here because
             // the object is already initialized/configured
             if ($db = $rcmail->get_dbh()) {
                 $db->set_debug(true);
             }
         }
     }
 
     /**
      * Startup hook handler
      */
     public function startup($args)
     {
         // Check access rights when logged in as another user
         if (!empty($_SESSION['kolab_auth_admin']) && $args['task'] != 'login' && $args['task'] != 'logout') {
             // access to specified task is forbidden,
             // redirect to the first task on the list
             if (!empty($_SESSION['kolab_auth_allowed_tasks'])) {
                 $tasks = (array)$_SESSION['kolab_auth_allowed_tasks'];
                 if (!in_array($args['task'], $tasks) && !in_array('*', $tasks)) {
                     header('Location: ?_task=' . array_shift($tasks));
                     die;
                 }
 
                 // add script that will remove disabled taskbar buttons
                 if (!in_array('*', $tasks)) {
                     $this->add_hook('render_page', array($this, 'render_page'));
                 }
             }
         }
 
         // load per-user settings
         $this->load_user_role_plugins_and_settings();
 
         return $args;
     }
 
     /**
      * Modify some configuration according to LDAP user record
      */
     public function config_get($args)
     {
         // Replaces ldap_vars (%dc, etc) in public kolab ldap addressbooks
         // config based on the users base_dn. (for multi domain support)
         if ($args['name'] == 'ldap_public' && !empty($args['result'])) {
             $rcmail      = rcube::get_instance();
             $kolab_books = (array) $rcmail->config->get('kolab_auth_ldap_addressbooks');
 
             foreach ($args['result'] as $name => $config) {
                 if (in_array($name, $kolab_books) || in_array('*', $kolab_books)) {
                     $args['result'][$name] = $this->patch_ldap_config($config);
                 }
             }
         }
         else if ($args['name'] == 'kolab_users_directory' && !empty($args['result'])) {
             $args['result'] = $this->patch_ldap_config($args['result']);
         }
 
         return $args;
     }
 
     /**
      * Helper method to patch the given LDAP directory config with user-specific values
      */
     protected function patch_ldap_config($config)
     {
         if (is_array($config)) {
             $config['base_dn']        = self::parse_ldap_vars($config['base_dn']);
             $config['search_base_dn'] = self::parse_ldap_vars($config['search_base_dn']);
             $config['bind_dn']        = str_replace('%dn', $_SESSION['kolab_dn'], $config['bind_dn']);
 
             if (!empty($config['groups'])) {
                 $config['groups']['base_dn'] = self::parse_ldap_vars($config['groups']['base_dn']);
             }
         }
 
         return $config;
     }
 
     /**
      * Modifies list of plugins and settings according to
      * specified LDAP roles
      */
     public function load_user_role_plugins_and_settings()
     {
         if (empty($_SESSION['user_roledns'])) {
             return;
         }
 
         $rcmail = rcube::get_instance();
 
         // Example 'kolab_auth_role_plugins' =
         //
         //  Array(
         //      '<role_dn>' => Array('plugin1', 'plugin2'),
         //  );
         //
         // NOTE that <role_dn> may in fact be something like: 'cn=role,%dc'
 
         $role_plugins = $rcmail->config->get('kolab_auth_role_plugins');
 
         // Example $rcmail_config['kolab_auth_role_settings'] =
         //
         //  Array(
         //      '<role_dn>' => Array(
         //          '$setting' => Array(
         //              'mode' => '(override|merge)', (default: override)
         //              'value' => <>,
         //              'allow_override' => (true|false) (default: false)
         //          ),
         //      ),
         //  );
         //
         // NOTE that <role_dn> may in fact be something like: 'cn=role,%dc'
 
         $role_settings = $rcmail->config->get('kolab_auth_role_settings');
 
         if (!empty($role_plugins)) {
             foreach ($role_plugins as $role_dn => $plugins) {
                 $role_dn = self::parse_ldap_vars($role_dn);
                 if (!empty($role_plugins[$role_dn])) {
                     $role_plugins[$role_dn] = array_unique(array_merge((array)$role_plugins[$role_dn], $plugins));
                 } else {
                     $role_plugins[$role_dn] = $plugins;
                 }
             }
         }
 
         if (!empty($role_settings)) {
             foreach ($role_settings as $role_dn => $settings) {
                 $role_dn = self::parse_ldap_vars($role_dn);
                 if (!empty($role_settings[$role_dn])) {
                     $role_settings[$role_dn] = array_merge((array)$role_settings[$role_dn], $settings);
                 } else {
                     $role_settings[$role_dn] = $settings;
                 }
             }
         }
 
         foreach ($_SESSION['user_roledns'] as $role_dn) {
             if (!empty($role_settings[$role_dn]) && is_array($role_settings[$role_dn])) {
                 foreach ($role_settings[$role_dn] as $setting_name => $setting) {
                     if (!isset($setting['mode'])) {
                         $setting['mode'] = 'override';
                     }
 
                     if ($setting['mode'] == "override") {
                         $rcmail->config->set($setting_name, $setting['value']);
                     } elseif ($setting['mode'] == "merge") {
                         $orig_setting = $rcmail->config->get($setting_name);
 
                         if (!empty($orig_setting)) {
                             if (is_array($orig_setting)) {
                                 $rcmail->config->set($setting_name, array_merge($orig_setting, $setting['value']));
                             }
                         } else {
                             $rcmail->config->set($setting_name, $setting['value']);
                         }
                     }
 
                     $dont_override = (array) $rcmail->config->get('dont_override');
 
                     if (empty($setting['allow_override'])) {
                         $rcmail->config->set('dont_override', array_merge($dont_override, array($setting_name)));
                     }
                     else {
                         if (in_array($setting_name, $dont_override)) {
                             $_dont_override = array();
                             foreach ($dont_override as $_setting) {
                                 if ($_setting != $setting_name) {
                                     $_dont_override[] = $_setting;
                                 }
                             }
                             $rcmail->config->set('dont_override', $_dont_override);
                         }
                     }
 
                     if ($setting_name == 'skin') {
                         if ($rcmail->output->type == 'html') {
                             $rcmail->output->set_skin($setting['value']);
                             $rcmail->output->set_env('skin', $setting['value']);
                         }
                     }
                 }
             }
 
             if (!empty($role_plugins[$role_dn])) {
                 foreach ((array)$role_plugins[$role_dn] as $plugin) {
                     $this->api->load_plugin($plugin);
                 }
             }
         }
     }
 
     /**
      * Logging method replacement to print debug/errors into
      * a separate (sub)folder for each user
      */
     public function write_log($args)
     {
         $rcmail = rcube::get_instance();
 
         if ($rcmail->config->get('log_driver') == 'syslog') {
             return $args;
         }
 
         // log_driver == 'file' is assumed here
         $log_dir  = $rcmail->config->get('log_dir', RCUBE_INSTALL_PATH . 'logs');
 
         // Append original username + target username for audit-logging
         if ($rcmail->config->get('kolab_auth_auditlog') && !empty($_SESSION['kolab_auth_admin'])) {
             $args['dir'] = $log_dir . '/' . strtolower($_SESSION['kolab_auth_admin']) . '/' . strtolower($this->username);
 
             // Attempt to create the directory
             if (!is_dir($args['dir'])) {
                 @mkdir($args['dir'], 0750, true);
             }
         }
         // Define the user log directory if a username is provided
         else if ($rcmail->config->get('per_user_logging') && !empty($this->username)) {
             $user_log_dir = $log_dir . '/' . strtolower($this->username);
             if (is_writable($user_log_dir)) {
                 $args['dir'] = $user_log_dir;
             }
             else if ($args['name'] != 'errors') {
                 $args['abort'] = true;  // don't log if unauthenticed
             }
         }
 
         return $args;
     }
 
     /**
      * Sets defaults for new user.
      */
     public function user_create($args)
     {
         if (!empty($this->data['user_email'])) {
             // addresses list is supported
             if (array_key_exists('email_list', $args)) {
                 $email_list = array_unique($this->data['user_email']);
 
                 // add organization to the list
                 if (!empty($this->data['user_organization'])) {
                     foreach ($email_list as $idx => $email) {
                         $email_list[$idx] = array(
                             'organization' => $this->data['user_organization'],
                             'email'        => $email,
                         );
                     }
                 }
 
                 $args['email_list'] = $email_list;
             }
             else {
                 $args['user_email'] = $this->data['user_email'][0];
             }
         }
 
         if (!empty($this->data['user_name'])) {
             $args['user_name'] = $this->data['user_name'];
         }
 
         return $args;
     }
 
     /**
      * Modifies login form adding additional "Login As" field
      */
     public function login_form($args)
     {
         $this->add_texts('localization/');
 
         $rcmail      = rcube::get_instance();
         $admin_login = $rcmail->config->get('kolab_auth_admin_login');
         $group       = $rcmail->config->get('kolab_auth_group');
         $role_attr   = $rcmail->config->get('kolab_auth_role');
 
         // Show "Login As" input
         if (empty($admin_login) || (empty($group) && empty($role_attr))) {
             return $args;
         }
 
         $input = new html_inputfield(array('name' => '_loginas', 'id' => 'rcmloginas',
             'type' => 'text', 'autocomplete' => 'off'));
         $row = html::tag('tr', null,
-            html::tag('td', 'title', html::label('rcmloginas', Q($this->gettext('loginas'))))
+            html::tag('td', 'title', html::label('rcmloginas', rcube::Q($this->gettext('loginas'))))
             . html::tag('td', 'input', $input->show(trim(rcube_utils::get_input_value('_loginas', rcube_utils::INPUT_POST))))
         );
         $args['content'] = preg_replace('/<\/tbody>/i', $row . '</tbody>', $args['content']);
 
         return $args;
     }
 
     /**
      * Find user credentials In LDAP.
      */
     public function authenticate($args)
     {
         // get username and host
         $host    = $args['host'];
         $user    = $args['user'];
         $pass    = $args['pass'];
         $loginas = trim(rcube_utils::get_input_value('_loginas', rcube_utils::INPUT_POST));
 
         if (empty($user) || empty($pass)) {
             $args['abort'] = true;
             return $args;
         }
 
         // temporarily set the current username to the one submitted
         $this->username = $user;
 
         $ldap = self::ldap();
         if (!$ldap || !$ldap->ready) {
             $args['abort'] = true;
             $args['kolab_ldap_error'] = true;
             $message = sprintf(
                     'Login failure for user %s from %s in session %s (error %s)',
                     $user,
                     rcube_utils::remote_ip(),
                     session_id(),
                     "LDAP not ready"
                 );
 
             rcube::write_log('userlogins', $message);
 
             return $args;
         }
 
         // Find user record in LDAP
         $record = $ldap->get_user_record($user, $host);
 
         if (empty($record)) {
             $args['abort'] = true;
             $message = sprintf(
                     'Login failure for user %s from %s in session %s (error %s)',
                     $user,
                     rcube_utils::remote_ip(),
                     session_id(),
                     "No user record found"
                 );
 
             rcube::write_log('userlogins', $message);
 
             return $args;
         }
 
         $rcmail      = rcube::get_instance();
         $admin_login = $rcmail->config->get('kolab_auth_admin_login');
         $admin_pass  = $rcmail->config->get('kolab_auth_admin_password');
         $login_attr  = $rcmail->config->get('kolab_auth_login');
         $name_attr   = $rcmail->config->get('kolab_auth_name');
         $email_attr  = $rcmail->config->get('kolab_auth_email');
         $org_attr    = $rcmail->config->get('kolab_auth_organization');
         $role_attr   = $rcmail->config->get('kolab_auth_role');
         $imap_attr   = $rcmail->config->get('kolab_auth_mailhost');
 
         if (!empty($role_attr) && !empty($record[$role_attr])) {
             $_SESSION['user_roledns'] = (array)($record[$role_attr]);
         }
 
         if (!empty($imap_attr) && !empty($record[$imap_attr])) {
             $default_host = $rcmail->config->get('default_host');
             if (!empty($default_host)) {
                 rcube::write_log("errors", "Both default host and kolab_auth_mailhost set. Incompatible.");
             } else {
                 $args['host'] = "tls://" . $record[$imap_attr];
             }
         }
 
         // Login As...
         if (!empty($loginas) && $admin_login) {
             // Authenticate to LDAP
             $result = $ldap->bind($record['dn'], $pass);
 
             if (!$result) {
                 $args['abort'] = true;
                 $message = sprintf(
                         'Login failure for user %s from %s in session %s (error %s)',
                         $user,
                         rcube_utils::remote_ip(),
                         session_id(),
                         "Unable to bind with '" . $record['dn'] . "'"
                     );
 
                 rcube::write_log('userlogins', $message);
 
                 return $args;
             }
 
             $isadmin = false;
             $admin_rights = $rcmail->config->get('kolab_auth_admin_rights', array());
 
             // @deprecated: fall-back to the old check if the original user has/belongs to administrative role/group
             if (empty($admin_rights)) {
                 $group   = $rcmail->config->get('kolab_auth_group');
                 $role_dn = $rcmail->config->get('kolab_auth_role_value');
 
                 // check role attribute
                 if (!empty($role_attr) && !empty($role_dn) && !empty($record[$role_attr])) {
                     $role_dn = $ldap->parse_vars($role_dn, $user, $host);
                     if (in_array($role_dn, (array)$record[$role_attr])) {
                         $isadmin = true;
                     }
                 }
 
                 // check group
                 if (!$isadmin && !empty($group)) {
                     $groups = $ldap->get_user_groups($record['dn'], $user, $host);
                     if (in_array($group, $groups)) {
                         $isadmin = true;
                     }
                 }
 
                 if ($isadmin) {
                     // user has admin privileges privilage, get "login as" user credentials
                     $target_entry = $ldap->get_user_record($loginas, $host);
                     $allowed_tasks = $rcmail->config->get('kolab_auth_allowed_tasks');
                 }
             }
             else {
                 // get "login as" user credentials
                 $target_entry = $ldap->get_user_record($loginas, $host);
 
                 if (!empty($target_entry)) {
                     // get effective rights to determine login-as permissions
                     $effective_rights = (array)$ldap->effective_rights($target_entry['dn']);
 
                     if (!empty($effective_rights)) {
                         $effective_rights['attrib'] = $effective_rights['attributeLevelRights'];
                         $effective_rights['entry']  = $effective_rights['entryLevelRights'];
 
                         // compare the rights with the permissions mapping
                         $allowed_tasks = array();
                         foreach ($admin_rights as $task => $perms) {
                             $perms_ = explode(':', $perms);
                             $type   = array_shift($perms_);
                             $req    = array_pop($perms_);
                             $attrib = array_pop($perms_);
 
                             if (array_key_exists($type, $effective_rights)) {
                                 if ($type == 'entry' && in_array($req, $effective_rights[$type])) {
                                     $allowed_tasks[] = $task;
                                 }
                                 else if ($type == 'attrib' && array_key_exists($attrib, $effective_rights[$type]) &&
                                         in_array($req, $effective_rights[$type][$attrib])) {
                                     $allowed_tasks[] = $task;
                                 }
                             }
                         }
 
                         $isadmin = !empty($allowed_tasks);
                     }
                 }
             }
 
             // Save original user login for log (see below)
             if ($login_attr) {
                 $origname = is_array($record[$login_attr]) ? $record[$login_attr][0] : $record[$login_attr];
             }
             else {
                 $origname = $user;
             }
 
             if (!$isadmin || empty($target_entry)) {
                 $this->add_texts('localization/');
 
                 $args['abort'] = true;
                 $args['error'] = $this->gettext(array(
                     'name' => 'loginasnotallowed',
-                    'vars' => array('user' => Q($loginas)),
+                    'vars' => array('user' => rcube::Q($loginas)),
                 ));
 
                 $message = sprintf(
                         'Login failure for user %s (as user %s) from %s in session %s (error %s)',
                         $user,
                         $loginas,
                         rcube_utils::remote_ip(),
                         session_id(),
                         "No privileges to login as '" . $loginas . "'"
                     );
 
                 rcube::write_log('userlogins', $message);
 
                 return $args;
             }
 
             // replace $record with target entry
             $record = $target_entry;
 
             $args['user'] = $this->username = $loginas;
 
             // Mark session to use SASL proxy for IMAP authentication
             $_SESSION['kolab_auth_admin']    = strtolower($origname);
             $_SESSION['kolab_auth_login']    = $rcmail->encrypt($admin_login);
             $_SESSION['kolab_auth_password'] = $rcmail->encrypt($admin_pass);
             $_SESSION['kolab_auth_allowed_tasks'] = $allowed_tasks;
         }
 
         // Store UID and DN of logged user in session for use by other plugins
         $_SESSION['kolab_uid'] = is_array($record['uid']) ? $record['uid'][0] : $record['uid'];
         $_SESSION['kolab_dn']  = $record['dn'];
 
         // Store LDAP replacement variables used for current user
         // This improves performance of load_user_role_plugins_and_settings()
         // which is executed on every request (via startup hook) and where
         // we don't like to use LDAP (connection + bind + search)
         $_SESSION['kolab_auth_vars'] = $ldap->get_parse_vars();
 
         // Set user login
         if ($login_attr) {
             $this->data['user_login'] = is_array($record[$login_attr]) ? $record[$login_attr][0] : $record[$login_attr];
         }
         if ($this->data['user_login']) {
             $args['user'] = $this->username = $this->data['user_login'];
         }
 
         // User name for identity (first log in)
         foreach ((array)$name_attr as $field) {
             $name = is_array($record[$field]) ? $record[$field][0] : $record[$field];
             if (!empty($name)) {
                 $this->data['user_name'] = $name;
                 break;
             }
         }
         // User email(s) for identity (first log in)
         foreach ((array)$email_attr as $field) {
             $email = is_array($record[$field]) ? array_filter($record[$field]) : $record[$field];
             if (!empty($email)) {
                 $this->data['user_email'] = array_merge((array)$this->data['user_email'], (array)$email);
             }
         }
         // Organization name for identity (first log in)
         foreach ((array)$org_attr as $field) {
             $organization = is_array($record[$field]) ? $record[$field][0] : $record[$field];
             if (!empty($organization)) {
                 $this->data['user_organization'] = $organization;
                 break;
             }
         }
 
         // Log "Login As" usage
         if (!empty($origname)) {
             rcube::write_log('userlogins', sprintf('Admin login for %s by %s from %s',
                 $args['user'], $origname, rcube_utils::remote_ip()));
         }
 
         // load per-user settings/plugins
         $this->load_user_role_plugins_and_settings();
 
         return $args;
     }
 
     /**
      * Set user DN for password change (password plugin with ldap_simple driver)
      */
     public function password_ldap_bind($args)
     {
         $args['user_dn'] = $_SESSION['kolab_dn'];
 
         $rcmail = rcube::get_instance();
 
         $rcmail->config->set('password_ldap_method', 'user');
 
         return $args;
     }
 
     /**
      * Sets SASL Proxy login/password for IMAP and Managesieve auth
      */
     public function imap_connect($args)
     {
         if (!empty($_SESSION['kolab_auth_admin'])) {
             $rcmail      = rcube::get_instance();
             $admin_login = $rcmail->decrypt($_SESSION['kolab_auth_login']);
             $admin_pass  = $rcmail->decrypt($_SESSION['kolab_auth_password']);
 
             $args['auth_cid'] = $admin_login;
             $args['auth_pw']  = $admin_pass;
         }
 
         return $args;
     }
 
     /**
      * Sets SASL Proxy login/password for SMTP auth
      */
     public function smtp_connect($args)
     {
         if (!empty($_SESSION['kolab_auth_admin'])) {
             $rcmail      = rcube::get_instance();
             $admin_login = $rcmail->decrypt($_SESSION['kolab_auth_login']);
             $admin_pass  = $rcmail->decrypt($_SESSION['kolab_auth_password']);
 
             $args['smtp_auth_cid'] = $admin_login;
             $args['smtp_auth_pw']  = $admin_pass;
         }
 
         return $args;
     }
 
     /**
      * Hook to replace the plain text input field for email address by a drop-down list
      * with all email addresses (including aliases) from this user's LDAP record.
      */
     public function identity_form($args)
     {
         $rcmail      = rcube::get_instance();
         $ident_level = intval($rcmail->config->get('identities_level', 0));
 
         // do nothing if email address modification is disabled
         if ($ident_level == 1 || $ident_level == 3) {
             return $args;
         }
 
         $ldap = self::ldap();
         if (!$ldap || !$ldap->ready || empty($_SESSION['kolab_dn'])) {
             return $args;
         }
 
         $emails      = array();
         $user_record = $ldap->get_record($_SESSION['kolab_dn']);
 
         foreach ((array)$rcmail->config->get('kolab_auth_email', array()) as $col) {
             $values = rcube_addressbook::get_col_values($col, $user_record, true);
             if (!empty($values))
                 $emails = array_merge($emails, array_filter($values));
         }
 
         // kolab_delegation might want to modify this addresses list
         $plugin = $rcmail->plugins->exec_hook('kolab_auth_emails', array('emails' => $emails));
         $emails = $plugin['emails'];
 
         if (!empty($emails)) {
             $args['form']['addressing']['content']['email'] = array(
                 'type' => 'select',
                 'options' => array_combine($emails, $emails),
             );
         }
 
         return $args;
     }
 
     /**
      * Action executed before the page is rendered to add an onload script
      * that will remove all taskbar buttons for disabled tasks
      */
     public function render_page($args)
     {
         $rcmail  = rcube::get_instance();
         $tasks   = (array)$_SESSION['kolab_auth_allowed_tasks'];
         $tasks[] = 'logout';
 
         // disable buttons in taskbar
         $script = "
         \$('a').filter(function() {
             var ev = \$(this).attr('onclick');
             return ev && ev.match(/'switch-task','([a-z]+)'/)
                 && \$.inArray(RegExp.\$1, " . json_encode($tasks) . ") < 0;
         }).remove();
         ";
 
         $rcmail->output->add_script($script, 'docready');
     }
 
     /**
      * Initializes LDAP object and connects to LDAP server
      */
     public static function ldap()
     {
         if (self::$ldap) {
             return self::$ldap;
         }
 
         $rcmail      = rcube::get_instance();
         $addressbook = $rcmail->config->get('kolab_auth_addressbook');
 
         if (!is_array($addressbook)) {
             $ldap_config = (array)$rcmail->config->get('ldap_public');
             $addressbook = $ldap_config[$addressbook];
         }
 
         if (empty($addressbook)) {
             return null;
         }
 
         require_once __DIR__ . '/kolab_auth_ldap.php';
 
         self::$ldap = new kolab_auth_ldap($addressbook);
 
         return self::$ldap;
     }
 
     /**
      * Parses LDAP DN string with replacing supported variables.
      * See kolab_auth_ldap::parse_vars()
      *
      * @param string $str LDAP DN string
      *
      * @return string Parsed DN string
      */
     public static function parse_ldap_vars($str)
     {
         if (!empty($_SESSION['kolab_auth_vars'])) {
             $str = strtr($str, $_SESSION['kolab_auth_vars']);
         }
 
         return $str;
     }
 }
diff --git a/plugins/kolab_delegation/kolab_delegation.php b/plugins/kolab_delegation/kolab_delegation.php
index c828093c..31e55d34 100644
--- a/plugins/kolab_delegation/kolab_delegation.php
+++ b/plugins/kolab_delegation/kolab_delegation.php
@@ -1,547 +1,547 @@
 <?php
 
 /**
  * Delegation configuration utility for Kolab accounts
  *
  * @version @package_version@
  * @author Aleksander Machniak <machniak@kolabsys.com>
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2011-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 kolab_delegation extends rcube_plugin
 {
     public $task = 'login|mail|settings|calendar';
 
     private $rc;
     private $engine;
 
 
     /**
      * Plugin initialization.
      */
     public function init()
     {
         $this->rc = rcube::get_instance();
 
         $this->require_plugin('libkolab');
         $this->require_plugin('kolab_auth');
 
         // on-login delegation initialization
         $this->add_hook('login_after', array($this, 'login_hook'));
         // on-check-recent delegation support
         $this->add_hook('check_recent', array($this, 'check_recent_hook'));
 
         // on-message-send delegation support
         $this->add_hook('message_before_send', array($this, 'message_before_send'));
 
         // delegation support in Calendar plugin
         $this->add_hook('message_load', array($this, 'message_load'));
         $this->add_hook('calendar_user_emails', array($this, 'calendar_user_emails'));
         $this->add_hook('calendar_list_filter', array($this, 'calendar_list_filter'));
         $this->add_hook('calendar_load_itip', array($this, 'calendar_load_itip'));
 
         // delegation support in kolab_auth plugin
         $this->add_hook('kolab_auth_emails', array($this, 'kolab_auth_emails'));
 
         if ($this->rc->task == 'settings') {
             // delegation management interface
             $this->register_action('plugin.delegation',              array($this, 'controller_ui'));
             $this->register_action('plugin.delegation-delete',       array($this, 'controller_action'));
             $this->register_action('plugin.delegation-save',         array($this, 'controller_action'));
             $this->register_action('plugin.delegation-autocomplete', array($this, 'controller_action'));
 
             $this->add_hook('settings_actions', array($this, 'settings_actions'));
 
             if ($this->rc->action == 'plugin.delegation' || empty($_REQUEST['_framed'])) {
                 $this->add_texts('localization/', array('deleteconfirm', 'savingdata', 'yes', 'no'));
 
                 if ($this->rc->action == 'plugin.delegation') {
                     $this->include_script('kolab_delegation.js');
                 }
 
                 $this->skin_path = $this->local_skin_path();
                 $this->include_stylesheet($this->skin_path . '/style.css');
             }
         }
         // Calendar plugin UI bindings
         else if ($this->rc->task == 'calendar' && empty($_REQUEST['_framed'])) {
             if ($this->rc->output->type == 'html') {
                 $this->calendar_ui();
             }
         }
     }
 
     /**
      * Adds Delegation section in Settings
      */
     function settings_actions($args)
     {
         $args['actions'][] = array(
             'action' => 'plugin.delegation',
             'class'  => 'delegation',
             'label'  => 'tabtitle',
             'domain' => 'kolab_delegation',
             'title'  => 'delegationtitle',
         );
 
         return $args;
     }
 
     /**
      * Engine object getter
      */
     private function engine()
     {
         if (!$this->engine) {
             require_once $this->home . '/kolab_delegation_engine.php';
 
             $this->load_config();
             $this->engine = new kolab_delegation_engine();
         }
 
         return $this->engine;
     }
 
     /**
      * On-login action
      */
     public function login_hook($args)
     {
         // Manage (create) identities for delegator's email addresses
         // and subscribe to delegator's folders. Also remove identities
         // after delegation is removed
 
         $engine = $this->engine();
         $engine->delegation_init();
 
         return $args;
     }
 
     /**
      * Check-recent action
      */
     public function check_recent_hook($args)
     {
         // Checking for new messages shall be extended to Inbox folders of all
         // delegators if 'check_all_folders' is set to false.
 
         if ($this->rc->task != 'mail') {
             return $args;
         }
 
         if (!empty($args['all'])) {
             return $args;
         }
 
         if (empty($_SESSION['delegators'])) {
             return $args;
         }
 
         $storage  = $this->rc->get_storage();
         $other_ns = $storage->get_namespace('other');
         $folders  = $storage->list_folders_subscribed('', '*', 'mail');
 
         foreach (array_keys($_SESSION['delegators']) as $uid) {
             foreach ($other_ns as $ns) {
                 $folder = $ns[0] . $uid;
                 if (in_array($folder, $folders) && !in_array($folder, $args['folders'])) {
                     $args['folders'][] = $folder;
                 }
             }
         }
 
         return $args;
     }
 
     /**
      * Mail send action
      */
     public function message_before_send($args)
     {
         // Checking headers of email being send, we'll add
         // Sender: header if mail is send on behalf of someone else
 
         if (!empty($_SESSION['delegators'])) {
             $engine = $this->engine();
             $engine->delegator_delivery_filter($args);
         }
 
         return $args;
     }
 
     /**
      * E-mail message loading action
      */
     public function message_load($args)
     {
         // This is a place where we detect delegate context
         // So we can handle event invitations on behalf of delegator
         // @TODO: should we do this only in delegators' folders?
 
         // skip invalid messages or Kolab objects (for better performance)
         if (empty($args['object']->headers) || $args['object']->headers->get('x-kolab-type', false)) {
             return $args;
         }
 
         $engine = $this->engine();
         $context = $engine->delegator_context_from_message($args['object']);
 
         if ($context) {
             $this->rc->output->set_env('delegator_context', $context);
             $this->include_script('kolab_delegation.js');
         }
 
         return $args;
     }
 
     /**
      * calendar::get_user_emails() handler
      */
     public function calendar_user_emails($args)
     {
         // In delegator context we'll use delegator's addresses
         // instead of current user addresses
 
         if (!empty($_SESSION['delegators'])) {
             $engine = $this->engine();
             $engine->delegator_emails_filter($args);
         }
 
         return $args;
     }
 
     /**
      * calendar_driver::list_calendars() handler
      */
     public function calendar_list_filter($args)
     {
         // In delegator context we'll use delegator's folders
         // instead of current user folders
 
         if (!empty($_SESSION['delegators'])) {
             $engine = $this->engine();
             $engine->delegator_folder_filter($args);
         }
 
         return $args;
     }
 
     /**
      * calendar::load_itip() handler
      */
     public function calendar_load_itip($args)
     {
         // In delegator context we'll use delegator's address/name
         // for invitation responses
 
         if (!empty($_SESSION['delegators'])) {
             $engine = $this->engine();
             $engine->delegator_identity_filter($args);
         }
 
         return $args;
     }
 
     /**
      * Delegation support in Calendar plugin UI
      */
     public function calendar_ui()
     {
         // Initialize handling of delegators' identities in event form
 
         if (!empty($_SESSION['delegators'])) {
             $engine = $this->engine();
             $this->rc->output->set_env('namespace', $engine->namespace_js());
             $this->rc->output->set_env('delegators', $engine->list_delegators_js());
             $this->include_script('kolab_delegation.js');
         }
     }
 
     /**
      * Delegation support in kolab_auth plugin
      */
     public function kolab_auth_emails($args)
     {
         // Add delegators addresses to address selector in user identity form
 
         if (!empty($_SESSION['delegators'])) {
             // @TODO: Consider not adding all delegator addresses to the list.
             // Instead add only address of currently edited identity
             foreach ($_SESSION['delegators'] as $emails) {
                 $args['emails'] = array_merge($args['emails'], $emails);
             }
 
             $args['emails'] = array_unique($args['emails']);
             sort($args['emails']);
         }
 
         return $args;
     }
 
     /**
      * Delegation UI handler
      */
     public function controller_ui()
     {
         // main interface (delegates list)
         if (empty($_REQUEST['_framed'])) {
             $this->register_handler('plugin.delegatelist', array($this, 'delegate_list'));
 
             $this->rc->output->include_script('list.js');
             $this->rc->output->send('kolab_delegation.settings');
         }
         // delegate frame
         else {
             $this->register_handler('plugin.delegateform', array($this, 'delegate_form'));
             $this->register_handler('plugin.delegatefolders', array($this, 'delegate_folders'));
 
             $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');
 
             $this->rc->output->send('kolab_delegation.editform');
         }
     }
 
     /**
      * Delegation action handler
      */
     public function controller_action()
     {
         $this->add_texts('localization/');
 
         $engine = $this->engine();
 
         // Delegate delete
         if ($this->rc->action == 'plugin.delegation-delete') {
             $id      = rcube_utils::get_input_value('id', rcube_utils::INPUT_GPC);
             $success = $engine->delegate_delete($id, (bool) rcube_utils::get_input_value('acl', rcube_utils::INPUT_GPC));
 
             if ($success) {
                 $this->rc->output->show_message($this->gettext('deletesuccess'), 'confirmation');
                 $this->rc->output->command('plugin.delegate_save_complete', array('deleted' => $id));
             }
             else {
                 $this->rc->output->show_message($this->gettext('deleteerror'), 'error');
             }
         }
         // Delegate add/update
         else if ($this->rc->action == 'plugin.delegation-save') {
             $id  = rcube_utils::get_input_value('id', rcube_utils::INPUT_GPC);
             $acl = rcube_utils::get_input_value('folders', rcube_utils::INPUT_GPC);
 
             // update
             if ($id) {
                 $delegate = $engine->delegate_get($id);
                 $success  = $engine->delegate_acl_update($delegate['uid'], $acl);
 
                 if ($success) {
                     $this->rc->output->show_message($this->gettext('updatesuccess'), 'confirmation');
                     $this->rc->output->command('plugin.delegate_save_complete', array('updated' => $id));
                 }
                 else {
                     $this->rc->output->show_message($this->gettext('updateerror'), 'error');
                 }
             }
             // new
             else {
                 $login    = rcube_utils::get_input_value('newid', rcube_utils::INPUT_GPC);
                 $delegate = $engine->delegate_get_by_name($login);
                 $success  = $engine->delegate_add($delegate, $acl);
 
                 if ($success) {
                     $this->rc->output->show_message($this->gettext('createsuccess'), 'confirmation');
                     $this->rc->output->command('plugin.delegate_save_complete', array(
                         'created' => $delegate['ID'],
                         'name'    => $delegate['name'],
                     ));
                 }
                 else {
                     $this->rc->output->show_message($this->gettext('createerror'), 'error');
                 }
             }
         }
         // Delegate autocompletion
         else if ($this->rc->action == 'plugin.delegation-autocomplete') {
             $search = rcube_utils::get_input_value('_search', rcube_utils::INPUT_GPC, true);
             $reqid  = rcube_utils::get_input_value('_reqid', rcube_utils::INPUT_GPC);
             $users  = $engine->list_users($search);
 
             $this->rc->output->command('ksearch_query_results', $users, $search, $reqid);
         }
 
         $this->rc->output->send();
     }
 
     /**
      * Template object of delegates list
      */
     public function delegate_list($attrib = array())
     {
         $attrib += array('id' => 'delegate-list');
 
         $engine = $this->engine();
         $list   = $engine->list_delegates();
         $table  = new html_table();
 
         // sort delegates list
         asort($list, SORT_LOCALE_STRING);
 
         foreach ($list as $id => $delegate) {
             $table->add_row(array('id' => 'rcmrow' . $id));
-            $table->add(null, Q($delegate));
+            $table->add(null, rcube::Q($delegate));
         }
 
         $this->rc->output->add_gui_object('delegatelist', $attrib['id']);
         $this->rc->output->set_env('delegatecount', count($list));
 
         return $table->show($attrib);
     }
 
     /**
      * Template object of delegate form
      */
     public function delegate_form($attrib = array())
     {
         $engine   = $this->engine();
         $table    = new html_table(array('cols' => 2));
         $id       = rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC);
         $field_id = 'delegate';
 
         if ($id) {
             $delegate = $engine->delegate_get($id);
         }
 
         if ($delegate) {
             $input = new html_hiddenfield(array('name' => $field_id, 'id' => $field_id, 'size' => 40));
-            $input = Q($delegate['name']) . $input->show($id);
+            $input = rcube::Q($delegate['name']) . $input->show($id);
 
             $this->rc->output->set_env('active_delegate', $id);
             $this->rc->output->command('parent.enable_command','delegate-delete', true);
         }
         else {
             $input = new html_inputfield(array('name' => $field_id, 'id' => $field_id, 'size' => 40));
             $input = $input->show();
         }
 
         $table->add('title', html::label($field_id, $this->gettext('delegate')));
         $table->add(null, $input);
 
         if ($attrib['form']) {
             $this->rc->output->add_gui_object('editform', $attrib['form']);
         }
 
         return $table->show($attrib);
     }
 
     /**
      * Template object of folders list
      */
     public function delegate_folders($attrib = array())
     {
         if (!$attrib['id']) {
             $attrib['id'] = 'delegatefolders';
         }
 
         $engine = $this->engine();
         $id     = rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC);
 
         if ($id) {
             $delegate = $engine->delegate_get($id);
         }
 
         $folder_data   = $engine->list_folders($delegate['uid']);
         $rights        = array();
         $folder_groups = array();
 
         foreach ($folder_data as $folder_name => $folder) {
             $folder_groups[$folder['type']][] = $folder_name;
             $rights[$folder_name] = $folder['rights'];
         }
 
         // build block for every folder type
         foreach ($folder_groups as $type => $group) {
             if (empty($group)) {
                 continue;
             }
             $attrib['type'] = $type;
             $html .= html::div('foldersblock',
                 html::tag('h3', $type, $this->gettext($type)) .
                     $this->delegate_folders_block($group, $attrib, $rights));
         }
 
         $this->rc->output->add_gui_object('folderslist', $attrib['id']);
 
         return html::div($attrib, $html);
     }
 
     /**
      * List of folders in specified group
      */
     private function delegate_folders_block($a_folders, $attrib, $rights)
     {
         $path      = 'plugins/kolab_delegation/' . $this->skin_path . '/';
         $read_ico  = $attrib['readicon'] ? html::img(array('src' =>  $path . $attrib['readicon'], 'title' => $this->gettext('read'))) : '';
         $write_ico = $attrib['writeicon'] ? html::img(array('src' => $path . $attrib['writeicon'], 'title' => $this->gettext('write'))) : '';
 
         $table = new html_table(array('cellspacing' => 0));
         $table->add_header(array('class' => 'read', 'title' => $this->gettext('read'), 'tabindex' => 0), $read_ico);
         $table->add_header(array('class' => 'write', 'title' => $this->gettext('write'), 'tabindex' => 0), $write_ico);
         $table->add_header('foldername', $this->rc->gettext('folder'));
 
         $checkbox_read  = new html_checkbox(array('name' => 'read[]', 'class' => 'read'));
         $checkbox_write = new html_checkbox(array('name' => 'write[]', 'class' => 'write'));
 
         $names = array();
         foreach ($a_folders as $folder) {
             $foldername = $origname = preg_replace('/^INBOX &raquo;\s+/', '', kolab_storage::object_name($folder));
 
             // find folder prefix to truncate (the same code as in kolab_addressbook plugin)
             for ($i = count($names)-1; $i >= 0; $i--) {
                 if (strpos($foldername, $names[$i].' &raquo; ') === 0) {
                     $length = strlen($names[$i].' &raquo; ');
                     $prefix = substr($foldername, 0, $length);
                     $count  = count(explode(' &raquo; ', $prefix));
                     $foldername = str_repeat('&nbsp;&nbsp;', $count-1) . '&raquo; ' . substr($foldername, $length);
                     break;
                 }
             }
 
-            $folder_id = 'rcmf' . html_identifier($folder);
+            $folder_id = 'rcmf' . rcube_utils::html_identifier($folder);
             $names[] = $origname;
             $classes = array('mailbox');
 
             if ($folder_class = $this->rc->folder_classname($folder)) {
                 $foldername = html::quote($this->rc->gettext($folder_class));
                 $classes[] = $folder_class;
             }
 
             $table->add_row();
             $table->add('read', $checkbox_read->show(
                 $rights[$folder] >= kolab_delegation_engine::ACL_READ ? $folder : null,
                 array('value' => $folder)));
             $table->add('write', $checkbox_write->show(
                 $rights[$folder] >= kolab_delegation_engine::ACL_WRITE ? $folder : null,
                 array('value' => $folder, 'id' => $folder_id)));
 
             $table->add(join(' ', $classes), html::label($folder_id, $foldername));
         }
 
         return $table->show();
     }
 }
diff --git a/plugins/kolab_notes/kolab_notes.php b/plugins/kolab_notes/kolab_notes.php
index 6d17e197..20341359 100644
--- a/plugins/kolab_notes/kolab_notes.php
+++ b/plugins/kolab_notes/kolab_notes.php
@@ -1,1426 +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),
                     'listname' => $listname,
                     'virtual'  => true,
                     'editable' => false,
                     'rights'   => 'l',
                     'group'    => $folder->get_namespace(),
                     'parent'   => $parent_id,
                 );
             }
             else {
                 if (!$this->lists[$list_id]) {
                     $this->lists[$list_id] = $this->folder_props($folder);
                     $this->folders[$list_id] = $folder;
                 }
                 $this->lists[$list_id]['parent'] = $parent_id;
                 $lists[$list_id] = $this->lists[$list_id];
             }
         }
 
         return $lists;
     }
 
     /**
      * Search for shared or otherwise not listed folders the user has access
      *
      * @param string Search string
      * @param string Section/source to search
      * @return array List of notes folders
      */
     protected function search_lists($query, $source)
     {
         if (!kolab_storage::setup()) {
             return array();
         }
 
         $this->search_more_results = false;
         $this->lists = $this->folders = array();
 
         // find unsubscribed IMAP folders that have "event" type
         if ($source == 'folders') {
             foreach ((array)kolab_storage::search_folders('note', $query, array('other')) as $folder) {
                 $this->folders[$folder->id] = $folder;
                 $this->lists[$folder->id] = $this->folder_props($folder);
             }
         }
         // search other user's namespace via LDAP
         else if ($source == 'users') {
             $limit = $this->rc->config->get('autocomplete_max', 15) * 2;  // we have slightly more space, so display twice the number
             foreach (kolab_storage::search_users($query, 0, array(), $limit * 10) as $user) {
                 $folders = array();
                 // search for note folders shared by this user
                 foreach (kolab_storage::list_user_folders($user, 'note', false) as $foldername) {
                     $folders[] = new kolab_storage_folder($foldername, 'note');
                 }
 
                 if (count($folders)) {
                     $userfolder = new kolab_storage_folder_user($user['kolabtargetfolder'], '', $user);
                     $this->folders[$userfolder->id] = $userfolder;
                     $this->lists[$userfolder->id] = $this->folder_props($userfolder);
 
                     foreach ($folders as $folder) {
                         $this->folders[$folder->id] = $folder;
                         $this->lists[$folder->id] = $this->folder_props($folder);
                         $count++;
                     }
                 }
 
                 if ($count >= $limit) {
                     $this->search_more_results = true;
                     break;
                 }
             }
 
         }
 
         return $this->get_lists();
     }
 
     /**
      * Derive list properties from the given kolab_storage_folder object
      */
     protected function folder_props($folder)
     {
         if ($folder->get_namespace() == 'personal') {
             $norename = false;
             $editable = true;
             $rights = 'lrswikxtea';
             $alarms = true;
         }
         else {
             $alarms = false;
             $rights = 'lr';
             $editable = false;
             if (($myrights = $folder->get_myrights()) && !PEAR::isError($myrights)) {
                 $rights = $myrights;
                 if (strpos($rights, 't') !== false || strpos($rights, 'd') !== false)
                     $editable = strpos($rights, 'i');
             }
             $info = $folder->get_folder_info();
             $norename = $readonly || $info['norename'] || $info['protected'];
         }
 
         $list_id = $folder->id;
         return array(
             'id' => $list_id,
             'name' => $folder->get_name(),
             'listname' => $folder->get_foldername(),
             'editname' => $folder->get_foldername(),
             'editable' => $editable,
             'rights'   => $rights,
             'norename' => $norename,
             'parentfolder' => $folder->get_parent(),
             'subscribed' => (bool)$folder->is_subscribed(),
             'default'  => $folder->default,
             'group'    => $folder->default ? 'default' : $folder->get_namespace(),
             'class'    => trim($folder->get_namespace() . ($folder->default ? ' default' : '')),
         );
     }
 
     /**
      * Get the kolab_calendar instance for the given calendar ID
      *
      * @param string List identifier (encoded imap folder name)
      * @return object kolab_storage_folder Object nor null if list doesn't exist
      */
     public function get_folder($id)
     {
         // create list and folder instance if necesary
         if (!$this->lists[$id]) {
             $folder = kolab_storage::get_folder(kolab_storage::id_decode($id));
             if ($folder->type) {
                 $this->folders[$id] = $folder;
                 $this->lists[$id] = $this->folder_props($folder);
             }
         }
 
         return $this->folders[$id];
     }
 
     /*******  UI functions  ********/
 
     /**
      * Render main view of the tasklist task
      */
     public function notes_view()
     {
         $this->ui->init();
         $this->ui->init_templates();
         $this->rc->output->set_pagetitle($this->gettext('navtitle'));
         $this->rc->output->send('kolab_notes.notes');
     }
 
     /**
      * Deliver a rediced UI for inline (dialog)
      */
     public function dialog_view()
     {
         // resolve message reference
         if ($msgref = rcube_utils::get_input_value('_msg', rcube_utils::INPUT_GPC, true)) {
             $storage = $this->rc->get_storage();
             list($uid, $folder) = explode('-', $msgref, 2);
             if ($message = $storage->get_message_headers($msgref)) {
                 $this->rc->output->set_env('kolab_notes_template', array(
                     '_from_mail' => true,
                     'title' => $message->get('subject'),
                     'links' => array(kolab_storage_config::get_message_reference(
                         kolab_storage_config::get_message_uri($message, $folder),
                         'note'
                     )),
                 ));
             }
         }
 
         $this->ui->init_templates();
         $this->rc->output->send('kolab_notes.dialogview');
     }
 
     /**
      * Handler to retrieve note records for the given list and/or search query
      */
     public function notes_fetch()
     {
         $search = rcube_utils::get_input_value('_q', rcube_utils::INPUT_GPC, true);
         $list   = rcube_utils::get_input_value('_list', rcube_utils::INPUT_GPC);
 
         $data = $this->notes_data($this->list_notes($list, $search), $tags);
 
         $this->rc->output->command('plugin.data_ready', array(
                 'list'   => $list,
                 'search' => $search,
                 'data'   => $data,
                 'tags'   => array_values($tags)
         ));
     }
 
     /**
      * Convert the given note records for delivery to the client
      */
     protected function notes_data($records, &$tags)
     {
         $config = kolab_storage_config::get_instance();
         $tags   = $config->apply_tags($records);
 
         foreach ($records as $i => $rec) {
             unset($records[$i]['description']);
             $this->_client_encode($records[$i]);
         }
 
         return $records;
     }
 
     /**
      * Read note records for the given list from the storage backend
      */
     protected function list_notes($list_id, $search = null)
     {
         $results = array();
 
         // query Kolab storage
         $query = array();
 
         // full text search (only works with cache enabled)
         if (strlen($search)) {
             $words = array_filter(rcube_utils::normalize_string(mb_strtolower($search), true));
             foreach ($words as $word) {
                 if (strlen($word) > 2) {  // only words > 3 chars are stored in DB
                     $query[] = array('words', '~', $word);
                 }
             }
         }
 
         $this->_read_lists();
         if ($folder = $this->get_folder($list_id)) {
             foreach ($folder->select($query) as $record) {
                 // post-filter search results
                 if (strlen($search)) {
                     $matches = 0;
                     $contents = mb_strtolower(
                         $record['title'] .
                         ($this->is_html($record) ? strip_tags($record['description']) : $record['description'])
                     );
                     foreach ($words as $word) {
                         if (mb_strpos($contents, $word) !== false) {
                             $matches++;
                         }
                     }
 
                     // skip records not matching all search words
                     if ($matches < count($words)) {
                         continue;
                     }
                 }
                 $record['list'] = $list_id;
                 $results[] = $record;
             }
         }
 
         return $results;
     }
 
     /**
      * Handler for delivering a full note record to the client
      */
     public function note_record()
     {
         $data = $this->get_note(array(
             'uid'  => rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC),
             'list' => rcube_utils::get_input_value('_list', rcube_utils::INPUT_GPC),
         ));
 
         // encode for client use
         if (is_array($data)) {
             $this->_client_encode($data, true);
         }
 
         $this->rc->output->command('plugin.render_note', $data);
     }
 
     /**
      * Get the full note record identified by the given UID + Lolder identifier
      */
     public function get_note($note)
     {
         if (is_array($note)) {
             $uid = $note['uid'] ?: $note['id'];
             $list_id = $note['list'];
         }
         else {
             $uid = $note;
         }
 
         // deliver from in-memory cache
         $key = $list_id . ':' . $uid;
         if ($this->cache[$key]) {
             return $this->cache[$key];
         }
 
         $result = false;
 
         $this->_read_lists();
         if ($list_id) {
             if ($folder = $this->get_folder($list_id)) {
                 $result = $folder->get_object($uid);
             }
         }
         // iterate over all calendar folders and search for the event ID
         else {
             foreach ($this->folders as $list_id => $folder) {
                 if ($result = $folder->get_object($uid)) {
                     $result['list'] = $list_id;
                     break;
                 }
             }
         }
 
         if ($result) {
             // get note tags
             $result['tags'] = $this->get_tags($result['uid']);
         }
 
         return $result;
     }
 
     /**
      * Helper method to encode the given note record for use in the client
      */
     private function _client_encode(&$note, $resolve = false)
     {
         foreach ($note as $key => $prop) {
             if ($key[0] == '_' || $key == 'x-custom') {
                 unset($note[$key]);
             }
         }
 
         foreach (array('created','changed') as $key) {
             if (is_object($note[$key]) && $note[$key] instanceof DateTime) {
                 $note[$key.'_'] = $note[$key]->format('U');
                 $note[$key] = $this->rc->format_date($note[$key]);
             }
         }
 
         // clean HTML contents
         if (!empty($note['description']) && $this->is_html($note)) {
             $note['html'] = $this->_wash_html($note['description']);
         }
 
         // resolve message links
         $note['links'] = array_map(function($link) {
                 return kolab_storage_config::get_message_reference($link, 'note') ?: array('uri' => $link);
             }, $this->get_links($note['uid']));
 
         return $note;
     }
 
     /**
      * Handler for client-initiated actions on a single note record
      */
     public function note_action()
     {
         $action = rcube_utils::get_input_value('_do', rcube_utils::INPUT_POST);
         $note   = rcube_utils::get_input_value('_data', rcube_utils::INPUT_POST, true);
 
         $success = $silent = false;
         switch ($action) {
             case 'new':
                 $temp_id = $rec['tempid'];
 
             case 'edit':
                 if ($success = $this->save_note($note)) {
                     $refresh = $this->get_note($note);
                     $refresh['tempid'] = $temp_id;
                 }
                 break;
 
             case 'move':
                 $uids = explode(',', $note['uid']);
                 foreach ($uids as $uid) {
                     $note['uid'] = $uid;
                     if (!($success = $this->move_note($note, $note['to']))) {
                         $refresh = $this->get_note($note);
                         break;
                     }
                 }
                 break;
 
             case 'delete':
                 $uids = explode(',', $note['uid']);
                 foreach ($uids as $uid) {
                     $note['uid'] = $uid;
                     if (!($success = $this->delete_note($note))) {
                         $refresh = $this->get_note($note);
                         break;
                     }
                 }
                 break;
 
             case 'changelog':
                 $data = $this->get_changelog($note);
                 if (is_array($data) && !empty($data)) {
                     $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) {
-            raise_error(array(
+            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);
                 }
                 else {
                     $success = true;
                     $update_cmd = 'plugin.update_list';
                     $list['newid'] = kolab_storage::folder_id($newfolder);
                     $list['_reload'] = $list['parent'] != $oldparent;
 
                     // compose the new display name
                     $delim = $this->rc->get_storage()->get_hierarchy_delimiter();
                     $path_imap = explode($delim, $newfolder);
                     $list['name'] = kolab_storage::object_name($newfolder);
                     $list['editname'] = rcube_charset::convert(array_pop($path_imap), 'UTF7-IMAP');
                     $list['listname'] = str_repeat('&nbsp;&nbsp;&nbsp;', count($path_imap)) . '&raquo; ' . $list['editname'];
                 }
                 break;
 
             case 'delete':
                 $this->_read_lists();
                 $folder = $this->get_folder($list['id']);
                 if ($folder && kolab_storage::folder_delete($folder->name)) {
                     $success = true;
                     $update_cmd = 'plugin.destroy_list';
                 }
                 else {
                     $save_error = $this->gettext(kolab_storage::$last_error);
                 }
                 break;
 
             case 'search':
                 $this->load_ui();
                 $results = array();
                 foreach ((array)$this->search_lists(rcube_utils::get_input_value('q', rcube_utils::INPUT_GPC), rcube_utils::get_input_value('source', rcube_utils::INPUT_GPC)) as $id => $prop) {
                     $editname = $prop['editname'];
                     unset($prop['editname']);  // force full name to be displayed
 
                     // let the UI generate HTML and CSS representation for this calendar
                     $html = $this->ui->folder_list_item($id, $prop, $jsenv, true);
                     $prop += (array)$jsenv[$id];
                     $prop['editname'] = $editname;
                     $prop['html'] = $html;
 
                     $results[] = $prop;
                 }
                 // report more results available
                 if ($this->driver->search_more_results) {
                     $this->rc->output->show_message('autocompletemore', 'info');
                 }
 
                 $this->rc->output->command('multi_thread_http_response', $results, rcube_utils::get_input_value('_reqid', rcube_utils::INPUT_GPC));
                 return;
 
             case 'subscribe':
                 $success = false;
                 if ($list['id'] && ($folder = $this->get_folder($list['id']))) {
                     if (isset($list['permanent']))
                         $success |= $folder->subscribe(intval($list['permanent']));
                     if (isset($list['active']))
                         $success |= $folder->activate(intval($list['active']));
 
                     // apply to child folders, too
                     if ($list['recursive']) {
                         foreach ((array)kolab_storage::list_folders($folder->name, '*', 'node') as $subfolder) {
                             if (isset($list['permanent']))
                                 ($list['permanent'] ? kolab_storage::folder_subscribe($subfolder) : kolab_storage::folder_unsubscribe($subfolder));
                             if (isset($list['active']))
                                 ($list['active'] ? kolab_storage::folder_activate($subfolder) : kolab_storage::folder_deactivate($subfolder));
                         }
                     }
                 }
                 break;
         }
 
         $this->rc->output->command('plugin.unlock_saving');
 
         if ($success) {
             $this->rc->output->show_message('successfullysaved', 'confirmation');
 
             if ($update_cmd) {
                 $this->rc->output->command($update_cmd, $list);
             }
         }
         else {
             $error_msg = $this->gettext('errorsaving') . ($save_error ? ': ' . $save_error :'');
             $this->rc->output->show_message($error_msg, 'error');
         }
     }
 
     /**
      * Hook to add note attachments to message compose if the according parameter is present.
      * This completes the 'send note by mail' feature.
      */
     public function mail_message_compose($args)
     {
         if (!empty($args['param']['with_notes'])) {
             $uids = explode(',', $args['param']['with_notes']);
             $list = $args['param']['notes_list'];
 
             foreach ($uids as $uid) {
                 if ($note = $this->get_note(array('uid' => $uid, 'list' => $list))) {
                     $args['attachments'][] = array(
                         'name'     => abbreviate_string($note['title'], 50, ''),
                         'mimetype' => 'message/rfc822',
                         'data'     => $this->note2message($note),
                     );
 
                     if (empty($args['param']['subject'])) {
                         $args['param']['subject'] = $note['title'];
                     }
                 }
             }
 
             unset($args['param']['with_notes'], $args['param']['notes_list']);
         }
 
         return $args;
     }
 
     /**
      * Lookup backend storage and find notes associated with the given message
      */
     public function mail_message_load($p)
     {
         if (!$p['object']->headers->others['x-kolab-type']) {
             $this->message_notes = $this->get_message_notes($p['object']->headers, $p['object']->folder);
         }
     }
 
     /**
      * Handler for 'messagebody_html' hook
      */
     public function mail_messagebody_html($args)
     {
         $html = '';
         foreach ($this->message_notes as $note) {
             $html .= html::a(array(
                 'href' => $this->rc->url(array('task' => 'notes', '_list' => $note['list'], '_id' => $note['uid'])),
                 'class' => 'kolabnotesref',
                 'rel' => $note['uid'] . '@' . $note['list'],
                 'target' => '_blank',
-            ), Q($note['title']));
+            ), 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);
     }
 
     /**
      * Find messages assigned to specified note
      */
     private function get_links($uid)
     {
         $config = kolab_storage_config::get_instance();
         return $config->get_object_links($uid);
     }
 
     /**
      * Get note tags
      */
     private function get_tags($uid)
     {
         $config = kolab_storage_config::get_instance();
         $tags   = $config->get_tags($uid);
         $tags   = array_map(function($v) { return $v['name']; }, $tags);
 
         return $tags;
     }
 
     /**
      * Find notes assigned to specified message
      */
     private function get_message_notes($message, $folder)
     {
         $config = kolab_storage_config::get_instance();
         $result = $config->get_message_relations($message, $folder, 'note');
 
         foreach ($result as $idx => $note) {
             $result[$idx]['list'] = kolab_storage::folder_id($note['_mailbox']);
         }
 
         return $result;
     }
 
     /**
      * Update note tags
      */
     private function save_tags($uid, $tags)
     {
         $config = kolab_storage_config::get_instance();
         $config->save_tags($uid, $tags);
     }
 
     /**
      * Process the given note data (submitted by the client) before saving it
      */
     private function _write_preprocess($note, $old = array())
     {
         $object = $note;
 
         // TODO: handle attachments
 
         // convert link references into simple URIs
         if (array_key_exists('links', $note)) {
             $object['links'] = array_map(function($link){ return is_array($link) ? $link['uri'] : strval($link); }, $note['links']);
         }
         else {
             $object['links'] = $old['links'];
         }
 
         // clean up HTML content
         $object['description'] = $this->_wash_html($note['description']);
         $is_html = true;
 
         // try to be smart and convert to plain-text if no real formatting is detected
         if (preg_match('!<body><(?:p|pre)>(.*)</(?:p|pre)></body>!Uims', $object['description'], $m)) {
             if (!preg_match('!<(a|b|i|strong|em|p|span|div|pre|li)(\s+[a-z]|>)!im', $m[1], $n) || !strpos($m[1], '</'.$n[1].'>')) {
                 // $converter = new rcube_html2text($m[1], false, true, 0);
                 // $object['description'] = rtrim($converter->get_text());
                 $object['description'] = html_entity_decode(preg_replace('!<br(\s+/)>!', "\n", $m[1]));
                 $is_html = false;
             }
         }
 
         // Add proper HTML header, otherwise Kontact renders it as plain text
         if ($is_html) {
             $object['description'] = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">'."\n" .
                 str_replace('<head>', '<head><meta name="qrichtext" content="1" />', $object['description']);
         }
 
         // copy meta data (starting with _) from old object
         foreach ((array)$old as $key => $val) {
             if (!isset($object[$key]) && $key[0] == '_')
                 $object[$key] = $val;
         }
 
         // make list of categories unique
         if (is_array($object['tags'])) {
             $object['tags'] = array_unique(array_filter($object['tags']));
         }
 
         unset($object['list'], $object['tempid'], $object['created'], $object['changed'], $object['created_'], $object['changed_']);
         return $object;
     }
 
     /**
      * Sanity checks/cleanups HTML content
      */
     private function _wash_html($html)
     {
         // Add header with charset spec., washtml cannot work without that
         $html = '<html><head>'
             . '<meta http-equiv="Content-Type" content="text/html; charset='.RCUBE_CHARSET.'" />'
             . '</head><body>' . $html . '</body></html>';
 
         // clean HTML with washtml by Frederic Motte
         $wash_opts = array(
             'show_washed'   => false,
             'allow_remote'  => 1,
             'charset'       => RCUBE_CHARSET,
             'html_elements' => array('html', 'head', 'meta', 'body', 'link'),
             'html_attribs'  => array('rel', 'type', 'name', 'http-equiv'),
         );
 
         // initialize HTML washer
         $washer = new rcube_washtml($wash_opts);
 
         $washer->add_callback('form', array($this, '_washtml_callback'));
         $washer->add_callback('a',    array($this, '_washtml_callback'));
 
         // Remove non-UTF8 characters
         $html = rcube_charset::clean($html);
 
         $html = $washer->wash($html);
 
         // remove unwanted comments (produced by washtml)
         $html = preg_replace('/<!--[^>]+-->/', '', $html);
 
         return $html;
     }
 
     /**
      * Callback function for washtml cleaning class
      */
     public function _washtml_callback($tagname, $attrib, $content, $washtml)
     {
         switch ($tagname) {
         case 'form':
             $out = html::div('form', $content);
             break;
 
         case 'a':
             // strip temporary link tags from plain-text markup
             $attrib = html::parse_attrib_string($attrib);
             if (!empty($attrib['class']) && strpos($attrib['class'], 'x-templink') !== false) {
                 // remove link entirely
                 if (strpos($attrib['href'], html_entity_decode($content)) !== false) {
                     $out = $content;
                     break;
                 }
                 $attrib['class'] = trim(str_replace('x-templink', '', $attrib['class']));
             }
             $out = html::a($attrib, $content);
             break;
 
         default:
             $out = '';
         }
 
         return $out;
     }
 
 }
 
diff --git a/plugins/kolab_notes/kolab_notes_ui.php b/plugins/kolab_notes/kolab_notes_ui.php
index 394d138a..99cce46a 100644
--- a/plugins/kolab_notes/kolab_notes_ui.php
+++ b/plugins/kolab_notes/kolab_notes_ui.php
@@ -1,439 +1,439 @@
 <?php
 
 class kolab_notes_ui
 {
     private $rc;
     private $plugin;
     private $ready = false;
 
     function __construct($plugin)
     {
         $this->plugin = $plugin;
         $this->rc = $plugin->rc;
     }
 
     /**
     * Calendar UI initialization and requests handlers
     */
     public function init()
     {
         if ($this->ready)  // already done
             return;
 
         // add taskbar button
         $this->plugin->add_button(array(
             'command' => 'notes',
             'class'   => 'button-notes',
             'classsel' => 'button-notes button-selected',
             'innerclass' => 'button-inner',
             'label'   => 'kolab_notes.navtitle',
         ), 'taskbar');
 
         $this->plugin->include_stylesheet($this->plugin->local_skin_path() . '/notes.css');
 
         $this->plugin->register_action('print', array($this, 'print_template'));
         $this->plugin->register_action('folder-acl', array($this, 'folder_acl'));
 
         $this->ready = true;
   }
 
     /**
     * Register handler methods for the template engine
     */
     public function init_templates()
     {
         $this->plugin->register_handler('plugin.tagslist', array($this, 'tagslist'));
         $this->plugin->register_handler('plugin.notebooks', array($this, 'folders'));
         #$this->plugin->register_handler('plugin.folders_select', array($this, 'folders_select'));
         $this->plugin->register_handler('plugin.searchform', array($this->rc->output, 'search_form'));
         $this->plugin->register_handler('plugin.listing', array($this, 'listing'));
         $this->plugin->register_handler('plugin.editform', array($this, 'editform'));
         $this->plugin->register_handler('plugin.notetitle', array($this, 'notetitle'));
         $this->plugin->register_handler('plugin.detailview', array($this, 'detailview'));
         $this->plugin->register_handler('plugin.attachments_list', array($this, 'attachments_list'));
         $this->plugin->register_handler('plugin.object_changelog_table', array('libkolab', 'object_changelog_table'));
 
         $this->rc->output->include_script('list.js');
         $this->rc->output->include_script('treelist.js');
         $this->plugin->include_script('notes.js');
 
         jqueryui::tagedit();
 
         // include kolab folderlist widget if available
         if (in_array('libkolab', $this->plugin->api->loaded_plugins())) {
             $this->plugin->api->include_script('libkolab/js/folderlist.js');
             $this->plugin->api->include_script('libkolab/js/audittrail.js');
         }
 
         // load config options and user prefs relevant for the UI
         $settings = array(
             'sort_col' => $this->rc->config->get('kolab_notes_sort_col', 'changed'),
             'print_template' => $this->rc->url('print'),
         );
 
         if ($list = rcube_utils::get_input_value('_list', rcube_utils::INPUT_GPC)) {
             $settings['selected_list'] = $list;
         }
         if ($uid = rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC)) {
             $settings['selected_uid'] = $uid;
         }
 
         $lang_codes = array($_SESSION['language']);
 
         if ($pos = strpos($_SESSION['language'], '_')) {
             $lang_codes[] = substr($_SESSION['language'], 0, $pos);
         }
 
         foreach ($lang_codes as $code) {
             if (file_exists(INSTALL_PATH . "program/js/tinymce/langs/$code.js")) {
                 $lang = $code;
                 break;
             }
         }
 
         if (empty($lang)) {
             $lang = 'en';
         }
 
         $settings['editor'] = array(
             'lang'       => $lang,
             'spellcheck' => intval($this->rc->config->get('enable_spellcheck')),
             'spelldict'  => intval($this->rc->config->get('spellcheck_dictionary'))
         );
 
         $this->rc->output->set_env('kolab_notes_settings', $settings);
 
         $this->rc->output->add_label('save','cancel','delete','close');
     }
 
     public function folders($attrib)
     {
         $attrib += array('id' => 'rcmkolabnotebooks');
 
         if ($attrib['type'] == 'select') {
             $attrib['is_escaped'] = true;
             $select = new html_select($attrib);
         }
 
         $tree = $attrib['type'] != 'select' ? true : null;
         $lists = $this->plugin->get_lists($tree);
         $jsenv = array();
 
         if (is_object($tree)) {
             $html = $this->folder_tree_html($tree, $lists, $jsenv, $attrib);
         }
         else {
             $html = '';
             foreach ($lists as $prop) {
                 $id = $prop['id'];
 
                 if (!$prop['virtual']) {
                     unset($prop['user_id']);
                     $jsenv[$id] = $prop;
                 }
 
                 if ($attrib['type'] == 'select') {
                     if ($prop['editable'] || strpos($prop['rights'], 'i') !== false) {
                         $select->add($prop['name'], $prop['id']);
                     }
                 }
                 else {
                     $html .= html::tag('li', array('id' => 'rcmliknb' . rcube_utils::html_identifier($id), 'class' => $prop['group']),
                         $this->folder_list_item($id, $prop, $jsenv)
                     );
                 }
             }
         }
 
         $this->rc->output->set_env('kolab_notebooks', $jsenv);
         $this->rc->output->add_gui_object('notebooks', $attrib['id']);
 
         return $attrib['type'] == 'select' ? $select->show() : html::tag('ul', $attrib, $html, html::$common_attrib);
     }
 
     /**
      * Return html for a structured list <ul> for the folder tree
      */
     public function folder_tree_html($node, $data, &$jsenv, $attrib)
     {
         $out = '';
         foreach ($node->children as $folder) {
             $id = $folder->id;
             $prop = $data[$id];
             $is_collapsed = false; // TODO: determine this somehow?
 
             $content = $this->folder_list_item($id, $prop, $jsenv);
 
             if (!empty($folder->children)) {
                 $content .= html::tag('ul', array('style' => ($is_collapsed ? "display:none;" : null)),
                     $this->folder_tree_html($folder, $data, $jsenv, $attrib));
             }
 
             if (strlen($content)) {
                 $out .= html::tag('li', array(
                       'id' => 'rcmliknb' . rcube_utils::html_identifier($id),
                       'class' => $prop['group'] . ($prop['virtual'] ? ' virtual' : ''),
                     ),
                     $content);
             }
         }
 
         return $out;
     }
 
     /**
      * Helper method to build a tasklist item (HTML content and js data)
      */
     public function folder_list_item($id, $prop, &$jsenv, $checkbox = false)
     {
         if (!$prop['virtual']) {
             unset($prop['user_id']);
             $jsenv[$id] = $prop;
         }
 
         $classes = array('folder');
         if ($prop['virtual']) {
             $classes[] = 'virtual';
         }
         else if (!$prop['editable']) {
             $classes[] = 'readonly';
         }
         if ($prop['subscribed']) {
             $classes[] = 'subscribed';
         }
         if ($prop['class']) {
             $classes[] = $prop['class'];
         }
 
         $title = $prop['title'] ?: ($prop['name'] != $prop['listname'] || strlen($prop['name']) > 25 ?
           html_entity_decode($prop['name'], ENT_COMPAT, RCUBE_CHARSET) : '');
 
         $label_id = 'nl:' . $id;
         $attr = $prop['virtual'] ? array('tabindex' => '0') : array('href' => $this->rc->url(array('_list' => $id)));
         return html::div(join(' ', $classes),
             html::a($attr + array('class' => 'listname', 'title' => $title, 'id' => $label_id), $prop['listname'] ?: $prop['name']) .
             ($prop['virtual'] ? '' :
                 ($checkbox ?
                     html::tag('input', array('type' => 'checkbox', 'name' => '_list[]', 'value' => $id, 'checked' => $prop['active'], 'aria-labelledby' => $label_id)) :
                     ''
                 ) .
                 html::span('handle', '') .
                 html::span('actions',
                     (!$prop['default'] ?
                         html::a(array('href' => '#', 'class' => 'remove', 'title' => $this->plugin->gettext('removelist')), ' ') :
                         ''
                     ) .
                     (isset($prop['subscribed']) ?
                         html::a(array('href' => '#', 'class' => 'subscribed', 'title' => $this->plugin->gettext('foldersubscribe'), 'role' => 'checkbox', 'aria-checked' => $prop['subscribed'] ? 'true' : 'false'), ' ') :
                         ''
                     )
                 )
             )
         );
 
         return '';
     }
 
     public function listing($attrib)
     {
         $attrib += array('id' => 'rcmkolabnoteslist');
         $this->rc->output->add_gui_object('noteslist', $attrib['id']);
         return html::tag('ul', $attrib, '', html::$common_attrib);
     }
 
     public function tagslist($attrib)
     {
         $attrib += array('id' => 'rcmkolabnotestagslist');
         $this->rc->output->add_gui_object('notestagslist', $attrib['id']);
         return html::tag('ul', $attrib, '', html::$common_attrib);
     }
 
     public function editform($attrib)
     {
         $attrib += array('action' => '#', 'id' => 'rcmkolabnoteseditform');
 
         $this->rc->output->add_gui_object('noteseditform', $attrib['id']);
         $this->rc->output->include_script('tinymce/tinymce.min.js');
 
         $textarea = new html_textarea(array('name' => 'content', 'id' => 'notecontent', 'cols' => 60, 'rows' => 20, 'tabindex' => 0));
         return html::tag('form', $attrib, $textarea->show(), array_merge(html::$common_attrib, array('action')));
     }
 
     public function detailview($attrib)
     {
         $attrib += array('id' => 'rcmkolabnotesdetailview');
         $this->rc->output->add_gui_object('notesdetailview', $attrib['id']);
         return html::div($attrib, '');
     }
 
     public function notetitle($attrib)
     {
         $attrib += array('id' => 'rcmkolabnotestitle');
         $this->rc->output->add_gui_object('noteviewtitle', $attrib['id']);
 
         $summary = new html_inputfield(array('name' => 'summary', 'class' => 'notetitle inline-edit', 'size' => 60, 'tabindex' => 0));
 
         $html = $summary->show();
         $html .= html::div(array('class' => 'tagline tagedit', 'style' => 'display:none'), '&nbsp;');
         $html .= html::div(array('class' => 'dates', 'style' => 'display:none'),
             html::label(array(), $this->plugin->gettext('created')) .
             html::span('notecreated', '') .
             html::label(array(), $this->plugin->gettext('changed')) .
             html::span('notechanged', '')
         );
 
         return html::div($attrib, $html);
     }
 
     public function attachments_list($attrib)
     {
         $attrib += array('id' => 'rcmkolabnotesattachmentslist');
         $this->rc->output->add_gui_object('notesattachmentslist', $attrib['id']);
         return html::tag('ul', $attrib, '', html::$common_attrib);
     }
 
     /**
      * Render edit for notes lists (folders)
      */
     public function list_editform($action, $list, $folder)
     {
         if (is_object($folder)) {
             $folder_name = $folder->name; // UTF7
         }
         else {
             $folder_name = '';
         }
 
         $hidden_fields[] = array('name' => 'oldname', 'value' => $folder_name);
 
         $storage = $this->rc->get_storage();
         $delim   = $storage->get_hierarchy_delimiter();
         $form   = array();
 
         if (strlen($folder_name)) {
             $options = $storage->folder_info($folder_name);
 
             $path_imap = explode($delim, $folder_name);
             array_pop($path_imap);  // pop off name part
             $path_imap = implode($path_imap, $delim);
         }
         else {
             $path_imap = '';
             $options = array();
         }
 
         // General tab
         $form['properties'] = array(
             'name' => $this->rc->gettext('properties'),
             'fields' => array(),
         );
 
         // folder name (default field)
         $input_name = new html_inputfield(array('name' => 'name', 'id' => 'noteslist-name', 'size' => 20));
         $form['properties']['fields']['name'] = array(
             'label' => $this->plugin->gettext('listname'),
             'value' => $input_name->show($list['editname'], array('disabled' => ($options['norename'] || $options['protected']))),
             'id' => 'noteslist-name',
         );
 
         // prevent user from moving folder
         if (!empty($options) && ($options['norename'] || $options['protected'])) {
             $hidden_fields[] = array('name' => 'parent', 'value' => $path_imap);
         }
         else {
             $select = kolab_storage::folder_selector('note', array('name' => 'parent', 'id' => 'parent-folder'), $folder_name);
             $form['properties']['fields']['path'] = array(
                 'label' => $this->plugin->gettext('parentfolder'),
                 'value' => $select->show(strlen($folder_name) ? $path_imap : ''),
                 'id' => 'parent-folder',
             );
         }
 
         // add folder ACL tab
         if ($action != 'form-new') {
             $form['sharing'] = array(
-                'name'    => Q($this->plugin->gettext('tabsharing')),
+                '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'], Q($label)));
+                    $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, Q($tab['name'])) . $content) . "\n";
+                $form_html .= html::tag('fieldset', null, html::tag('legend', null, rcube::Q($tab['name'])) . $content) . "\n";
             }
         }
 
         return html::tag('form', array('action' => "#", 'method' => "post", 'id' => "noteslistpropform"), $form_html);
     }
 
     /**
      * Handler to render ACL form for a notes folder
      */
     public function folder_acl()
     {
         $this->plugin->require_plugin('acl');
         $this->rc->output->add_handler('folderacl', array($this, 'folder_acl_form'));
         $this->rc->output->send('kolab_notes.kolabacl');
     }
 
     /**
      * Handler for ACL form template object
      */
     public function folder_acl_form()
     {
         $folder = rcube_utils::get_input_value('_folder', rcube_utils::INPUT_GPC);
 
         if (strlen($folder)) {
             $storage = $this->rc->get_storage();
             $options = $storage->folder_info($folder);
 
             // get sharing UI from acl plugin
             $acl = $this->rc->plugins->exec_hook('folder_form',
                 array('form' => array(), 'options' => $options, 'name' => $folder));
         }
 
         return $acl['form']['sharing']['content'] ?: html::div('hint', $this->plugin->gettext('aclnorights'));
     }
 
     /**
      * Render the template for printing with placeholders
      */
     public function print_template()
     {
         header('Content-Type: text/html; charset=' . RCUBE_CHARSET);
         $this->rc->output->reset(true);
         echo $this->rc->output->parse('kolab_notes.print', false, false);
         exit;
     }
 
 }
 
diff --git a/plugins/kolab_zpush/kolab_zpush.php b/plugins/kolab_zpush/kolab_zpush.php
index e9d1170e..6107f2c0 100644
--- a/plugins/kolab_zpush/kolab_zpush.php
+++ b/plugins/kolab_zpush/kolab_zpush.php
@@ -1,349 +1,349 @@
 <?php
 
 /**
  * Z-Push configuration utility for Kolab accounts
  *
  * @version 0.2
  * @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 kolab_zpush extends rcube_plugin
 {
     public $task = 'settings';
     public $urlbase;
 
     private $rc;
     private $ui;
     private $cache;
     private $devices;
     private $folders;
     private $folders_meta;
     private $root_meta;
 
     const ROOT_MAILBOX = 'INBOX';
     const CTYPE_KEY = '/shared/vendor/kolab/folder-type';
     const ACTIVESYNC_KEY = '/private/vendor/kolab/activesync';
 
     /**
      * Plugin initialization.
      */
     public function init()
     {
         $this->rc = rcube::get_instance();
 
         $this->require_plugin('jqueryui');
         $this->add_texts('localization/', true);
 
         $this->include_script('kolab_zpush.js');
 
         $this->register_action('plugin.zpushconfig', array($this, 'config_view'));
         $this->register_action('plugin.zpushjson', array($this, 'json_command'));
 
         if ($this->rc->action == 'plugin.zpushconfig') {
             $this->require_plugin('libkolab');
         }
     }
 
 
     /**
      * Establish IMAP connection
      */
     public function init_imap()
     {
         $storage = $this->rc->get_storage();
 
         // @TODO: Metadata is already cached by rcube storage, get rid of cache here
 
         $this->cache = $this->rc->get_cache('zpush', 'db', 900);
         $this->cache->expunge();
 
         if ($meta = $storage->get_metadata(self::ROOT_MAILBOX, self::ACTIVESYNC_KEY)) {
             // clear cache if device config changed
             if (($oldmeta = $this->cache->read('devicemeta')) && $oldmeta != $meta)
                 $this->cache->remove();
 
             $this->root_meta = $this->unserialize_metadata($meta[self::ROOT_MAILBOX][self::ACTIVESYNC_KEY]);
             $this->cache->remove('devicemeta');
             $this->cache->write('devicemeta', $meta);
         }
     }
 
 
     /**
      * Handle JSON requests
      */
     public function json_command()
     {
         $storage = $this->rc->get_storage();
         $cmd     = rcube_utils::get_input_value('cmd', rcube_utils::INPUT_GPC);
         $imei    = rcube_utils::get_input_value('id', rcube_utils::INPUT_GPC);
 
         switch ($cmd) {
         case 'load':
             $result = array();
             $devices = $this->list_devices();
             if ($device = $devices[$imei]) {
                 $result['id'] = $imei;
                 $result['devicealias'] = $device['ALIAS'];
                 $result['syncmode'] = intval($device['MODE']);
                 $result['laxpic'] = intval($device['LAXPIC']);
                 $result['subscribed'] = array();
 
                 foreach ($this->folders_meta() as $folder => $meta) {
                     if ($meta[$imei]['S'])
                         $result['subscribed'][$folder] = intval($meta[$imei]['S']);
                 }
 
                 $this->rc->output->command('plugin.zpush_data_ready', $result);
             }
             else {
                 $this->rc->output->show_message($this->gettext('devicenotfound'), 'error');
             }
             break;
 
         case 'save':
             $syncmode     = intval(rcube_utils::get_input_value('syncmode', rcube_utils::INPUT_POST));
             $laxpic       = intval(rcube_utils::get_input_value('laxpic', rcube_utils::INPUT_POST));
             $devicealias  = rcube_utils::get_input_value('devicealias', rcube_utils::INPUT_POST, true);
             $subsciptions = rcube_utils::get_input_value('subscribed', rcube_utils::INPUT_POST);
             $devices = $this->list_devices();
             $err     = false;
 
             if ($device = $devices[$imei]) {
                 // update device config if changed
                 if ($devicealias != $this->root_meta['DEVICE'][$imei]['ALIAS']  ||
                        $syncmode != $this->root_meta['DEVICE'][$imei]['MODE']   ||
                        $laxpic   != $this->root_meta['DEVICE'][$imei]['LAXPIC'] ||
                        $subsciptions[self::ROOT_MAILBOX] != $this->root_meta['FOLDER'][$imei]['S']) {
                     $this->root_meta['DEVICE'][$imei]['MODE'] = $syncmode;
                     $this->root_meta['DEVICE'][$imei]['ALIAS'] = $devicealias;
                     $this->root_meta['DEVICE'][$imei]['LAXPIC'] = $laxpic;
                     $this->root_meta['FOLDER'][$imei]['S'] = intval($subsciptions[self::ROOT_MAILBOX]);
 
                     $err = !$storage->set_metadata(self::ROOT_MAILBOX,
                         array(self::ACTIVESYNC_KEY => $this->serialize_metadata($this->root_meta)));
 
                     // update cached meta data
                     if (!$err) {
                         $this->cache->remove('devicemeta');
                         $this->cache->write('devicemeta', $storage->get_metadata(self::ROOT_MAILBOX, self::ACTIVESYNC_KEY));
                     }
                 }
                 // iterate over folders list and update metadata if necessary
                 foreach ($this->folders_meta() as $folder => $meta) {
                     // skip root folder (already handled above)
                     if ($folder == self::ROOT_MAILBOX)
                         continue;
 
                     if ($subsciptions[$folder] != $meta[$imei]['S']) {
                         $meta[$imei]['S'] = intval($subsciptions[$folder]);
                         $this->folders_meta[$folder] = $meta;
                         unset($meta['TYPE']);
 
                         // read metadata first
                         $folderdata = $storage->get_metadata($folder, array(self::ACTIVESYNC_KEY));
                         if ($asyncdata = $folderdata[$folder][self::ACTIVESYNC_KEY])
                             $metadata = $this->unserialize_metadata($asyncdata);
                         $metadata['FOLDER'] = $meta;
 
                         $err |= !$storage->set_metadata($folder, array(self::ACTIVESYNC_KEY => $this->serialize_metadata($metadata)));
                     }
                 }
 
                 // update cache
                 $this->cache->remove('folders');
                 $this->cache->write('folders', $this->folders_meta);
 
-                $this->rc->output->command('plugin.zpush_save_complete', array('success' => !$err, 'id' => $imei, 'devicealias' => Q($devicealias)));
+                $this->rc->output->command('plugin.zpush_save_complete', array('success' => !$err, 'id' => $imei, 'devicealias' => rcube::Q($devicealias)));
             }
 
             if ($err)
                 $this->rc->output->show_message($this->gettext('savingerror'), 'error');
             else
                 $this->rc->output->show_message($this->gettext('successfullysaved'), 'confirmation');
 
             break;
 
         case 'delete':
             $devices = $this->list_devices();
 
             if ($device = $devices[$imei]) {
                 unset($this->root_meta['DEVICE'][$imei], $this->root_meta['FOLDER'][$imei]);
 
                 // update annotation and cached meta data
                 if ($success = $storage->set_metadata(self::ROOT_MAILBOX, array(self::ACTIVESYNC_KEY => $this->serialize_metadata($this->root_meta)))) {
                     $this->cache->remove('devicemeta');
                     $this->cache->write('devicemeta', $storage->get_metadata(self::ROOT_MAILBOX, self::ACTIVESYNC_KEY));
 
                     // remove device annotation in every folder
                     foreach ($this->folders_meta() as $folder => $meta) {
                         // skip root folder (already handled above)
                         if ($folder == self::ROOT_MAILBOX)
                             continue;
 
                         if (isset($meta[$imei])) {
                             $type = $meta['TYPE'];  // remember folder type
                             unset($meta[$imei], $meta['TYPE']);
 
                             // read metadata first and update FOLDER property
                             $folderdata = $storage->get_metadata($folder, array(self::ACTIVESYNC_KEY));
                             if ($asyncdata = $folderdata[$folder][self::ACTIVESYNC_KEY])
                                 $metadata = $this->unserialize_metadata($asyncdata);
                             $metadata['FOLDER'] = $meta;
 
                             if ($storage->set_metadata($folder, array(self::ACTIVESYNC_KEY => $this->serialize_metadata($metadata)))) {
                                 $this->folders_meta[$folder] = $metadata;
                                 $this->folders_meta[$folder]['TYPE'] = $type;
                             }
                         }
                     }
 
                     // update cache
                     $this->cache->remove('folders');
                     $this->cache->write('folders', $this->folders_meta);
                 }
             }
 
             if ($success) {
                 $this->rc->output->show_message($this->gettext('successfullydeleted'), 'confirmation');
                 $this->rc->output->redirect(array('action' => 'plugin.zpushconfig'));  // reload UI
             }
             else
                 $this->rc->output->show_message($this->gettext('savingerror'), 'error');
 
             break;
         }
 
         $this->rc->output->send();
     }
 
 
     /**
      * Render main UI for device configuration
      */
     public function config_view()
     {
         require_once $this->home . '/kolab_zpush_ui.php';
 
         $storage = $this->rc->get_storage();
 
         // checks if IMAP server supports any of METADATA, ANNOTATEMORE, ANNOTATEMORE2
         if (!($storage->get_capability('METADATA') || $storage->get_capability('ANNOTATEMORE') || $storage->get_capability('ANNOTATEMORE2'))) {
             $this->rc->output->show_message($this->gettext('notsupported'), 'error');
         }
 
         $this->ui = new kolab_zpush_ui($this);
 
         $this->register_handler('plugin.devicelist', array($this->ui, 'device_list'));
         $this->register_handler('plugin.deviceconfigform', array($this->ui, 'device_config_form'));
         $this->register_handler('plugin.foldersubscriptions', array($this->ui, 'folder_subscriptions'));
 
         $this->rc->output->set_env('devicecount', count($this->list_devices()));
         $this->rc->output->send('kolab_zpush.config');
     }
 
 
     /**
      * List known devices
      *
      * @return array Device list as hash array
      */
     public function list_devices()
     {
         if (!isset($this->devices)) {
             $this->init_imap();
             $this->devices = (array)$this->root_meta['DEVICE'];
         }
 
         return $this->devices;
     }
 
 
     /**
      * Get list of all folders available for sync
      *
      * @return array List of mailbox folders
      */
     public function list_folders()
     {
         if (!isset($this->folders)) {
             // read cached folder meta data
             if ($cached_folders = $this->cache->read('folders')) {
                 $this->folders_meta = $cached_folders;
                 $this->folders = array_keys($this->folders_meta);
             }
             // fetch folder data from server
             else {
                 $storage       = $this->rc->get_storage();
                 $this->folders = $storage->list_folders();
 
                 foreach ($this->folders as $folder) {
                     $folderdata = $storage->get_metadata($folder, array(self::ACTIVESYNC_KEY, self::CTYPE_KEY));
                     $foldertype = explode('.', $folderdata[$folder][self::CTYPE_KEY]);
 
                     if ($asyncdata = $folderdata[$folder][self::ACTIVESYNC_KEY]) {
                         $metadata = $this->unserialize_metadata($asyncdata);
                         $this->folders_meta[$folder] = $metadata['FOLDER'];
                     }
                     $this->folders_meta[$folder]['TYPE'] = !empty($foldertype[0]) ? $foldertype[0] : 'mail';
                 }
 
                 // cache it!
                 $this->cache->write('folders', $this->folders_meta);
             }
         }
 
         return $this->folders;
     }
 
     /**
      * Getter for folder metadata
      *
      * @return array Hash array with meta data for each folder
      */
     public function folders_meta()
     {
         if (!isset($this->folders_meta))
             $this->list_folders();
 
         return $this->folders_meta;
     }
 
     /**
      * Helper method to decode saved IMAP metadata
      */
     private function unserialize_metadata($str)
     {
         if (!empty($str))
             return @json_decode(base64_decode($str), true);
 
         return null;
     }
 
     /**
      * Helper method to encode IMAP metadata for saving
      */
     private function serialize_metadata($data)
     {
         if (is_array($data))
             return base64_encode(json_encode($data));
 
         return '';
     }
 
 }
diff --git a/plugins/kolab_zpush/kolab_zpush_ui.php b/plugins/kolab_zpush/kolab_zpush_ui.php
index 0e8e6e9d..780426d9 100644
--- a/plugins/kolab_zpush/kolab_zpush_ui.php
+++ b/plugins/kolab_zpush/kolab_zpush_ui.php
@@ -1,169 +1,169 @@
 <?php
 
 /**
  * Z-Push configuration user interface builder
  *
  * @version 0.2
  * @author Thomas Bruederli <bruederli@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/>.
  */
 
 class kolab_zpush_ui
 {
     private $rc;
     private $config;
 
     public function __construct($config)
     {
         $this->config = $config;
         $this->rc = rcube::get_instance();
 
         $skin = $this->rc->config->get('skin');
         $this->config->include_stylesheet('skins/' . $skin . '/config.css');
         $this->rc->output->include_script('list.js');
         $this->skin_path = $this->config->urlbase . 'skins/' . $skin . '/';
     }
 
 
     public function device_list($attrib = array())
     {
         $attrib += array('id' => 'devices-list');
 
         $devices = $this->config->list_devices();
         $table = new html_table();
 
         foreach ($devices as $id => $device) {
             $name = $device['ALIAS'] ? $device['ALIAS'] : $id;
             $table->add_row(array('id' => 'rcmrow' . $id));
-            $table->add(null, html::span('devicealias', Q($name)) . html::span('devicetype', Q($device['TYPE'])));
+            $table->add(null, html::span('devicealias', rcube::Q($name)) . html::span('devicetype', rcube::Q($device['TYPE'])));
         }
 
         $this->rc->output->add_gui_object('devicelist', $attrib['id']);
         $this->rc->output->set_env('devices', $devices);
 
         return $table->show($attrib);
     }
 
 
     public function device_config_form($attrib = array())
     {
         $table = new html_table(array('cols' => 2));
 
         $field_id = 'config-device-alias';
         $input = new html_inputfield(array('name' => 'devicealias', 'id' => $field_id, 'size' => 40));
         $table->add('title', html::label($field_id, $this->config->gettext('devicealias')));
         $table->add(null, $input->show());
 
         $field_id = 'config-device-mode';
         $select = new html_select(array('name' => 'syncmode', 'id' => $field_id));
         $select->add(array($this->config->gettext('modeauto'), $this->config->gettext('modeflat'), $this->config->gettext('modefolder')), array('-1', '0', '1'));
         $table->add('title', html::label($field_id, $this->config->gettext('syncmode')));
         $table->add(null, $select->show('-1'));
 
         $field_id = 'config-device-laxpic';
         $checkbox = new html_checkbox(array('name' => 'laxpic', 'value' => '1', 'id' => $field_id));
         $table->add('title', $this->config->gettext('imageformat'));
         $table->add(null, html::label($field_id, $checkbox->show() . ' ' . $this->config->gettext('laxpiclabel')));
 
         if ($attrib['form'])
             $this->rc->output->add_gui_object('editform', $attrib['form']);
 
         return $table->show($attrib);
     }
 
 
     public function folder_subscriptions($attrib = array())
     {
         if (!$attrib['id'])
             $attrib['id'] = 'foldersubscriptions';
 
         // group folders by type (show only known types)
         $folder_groups = array('mail' => array(), 'contact' => array(), 'event' => array(), 'task' => array());
         $folder_meta = $this->config->folders_meta();
         foreach ($this->config->list_folders() as $folder) {
             $type = $folder_meta[$folder]['TYPE'] ? $folder_meta[$folder]['TYPE'] : 'mail';
             if (is_array($folder_groups[$type]))
                 $folder_groups[$type][] = $folder;
         }
 
         // build block for every folder type
         foreach ($folder_groups as $type => $group) {
             if (empty($group))
                 continue;
             $attrib['type'] = $type;
             $html .= html::div('subscriptionblock',
                 html::tag('h3', $type, $this->config->gettext($type)) .
                 $this->folder_subscriptions_block($group, $attrib));
         }
         
         $this->rc->output->add_gui_object('subscriptionslist', $attrib['id']);
 
         return html::div($attrib, $html);
     }
 
     public function folder_subscriptions_block($a_folders, $attrib)
     {
         $alarms = ($attrib['type'] == 'event' || $attrib['type'] == 'task');
 
         $table = new html_table(array('cellspacing' => 0));
         $table->add_header('subscription', $attrib['syncicon'] ? html::img(array('src' => $this->skin_path . $attrib['syncicon'], 'title' => $this->config->gettext('synchronize'))) : '');
         $table->add_header('alarm', $alarms && $attrib['alarmicon'] ? html::img(array('src' => $this->skin_path . $attrib['alarmicon'], 'title' => $this->config->gettext('withalarms'))) : '');
         $table->add_header('foldername', $this->config->gettext('folder'));
 
         $checkbox_sync = new html_checkbox(array('name' => 'subscribed[]', 'class' => 'subscription'));
         $checkbox_alarm = new html_checkbox(array('name' => 'alarm[]', 'class' => 'alarm'));
 
         $names = array();
         foreach ($a_folders as $folder) {
             $foldername = $origname = preg_replace('/^INBOX &raquo;\s+/', '', kolab_storage::object_name($folder));
 
             // find folder prefix to truncate (the same code as in kolab_addressbook plugin)
             for ($i = count($names)-1; $i >= 0; $i--) {
                 if (strpos($foldername, $names[$i].' &raquo; ') === 0) {
                     $length = strlen($names[$i].' &raquo; ');
                     $prefix = substr($foldername, 0, $length);
                     $count  = count(explode(' &raquo; ', $prefix));
                     $foldername = str_repeat('&nbsp;&nbsp;', $count-1) . '&raquo; ' . substr($foldername, $length);
                     break;
                 }
             }
 
             $names[] = $origname;
             $classes = array('mailbox');
 
             if ($folder_class = $this->rc->folder_classname($folder)) {
                 $foldername = $this->rc->gettext($folder_class);
                 $classes[] = $folder_class;
             }
 
-            $folder_id = 'rcmf' . html_identifier($folder);
+            $folder_id = 'rcmf' . rcube_utils::html_identifier($folder);
 
             $table->add_row();
             $table->add('subscription', $checkbox_sync->show('', array('value' => $folder, 'id' => $folder_id)));
 
             if ($alarms)
                 $table->add('alarm', $checkbox_alarm->show('', array('value' => $folder, 'id' => $folder_id.'_alarm')));
             else
                 $table->add('alarm', '');
 
-            $table->add(join(' ', $classes), html::label($folder_id, Q($foldername)));
+            $table->add(join(' ', $classes), html::label($folder_id, rcube::Q($foldername)));
         }
 
         return $table->show();
     }
 
 }
diff --git a/plugins/libcalendaring/lib/libcalendaring_itip.php b/plugins/libcalendaring/lib/libcalendaring_itip.php
index 6a70d261..d00e0990 100644
--- a/plugins/libcalendaring/lib/libcalendaring_itip.php
+++ b/plugins/libcalendaring/lib/libcalendaring_itip.php
@@ -1,817 +1,817 @@
 <?php
 
 /**
  * iTIP functions for the calendar-based Roudncube plugins
  *
  * Class providing functionality to manage iTIP invitations
  *
  * @author Thomas Bruederli <bruederli@kolabsys.com>
  *
  * Copyright (C) 2011-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 libcalendaring_itip
 {
     protected $rc;
     protected $lib;
     protected $plugin;
     protected $sender;
     protected $domain;
     protected $itip_send = false;
     protected $rsvp_actions = array('accepted','tentative','declined','delegated');
     protected $rsvp_status  = array('accepted','tentative','declined','delegated');
 
     function __construct($plugin, $domain = 'libcalendaring')
     {
         $this->plugin = $plugin;
         $this->rc = rcube::get_instance();
         $this->lib = libcalendaring::get_instance();
         $this->domain = $domain;
 
         $hook = $this->rc->plugins->exec_hook('calendar_load_itip',
             array('identity' => $this->rc->user->list_emails(true)));
         $this->sender = $hook['identity'];
 
         $this->plugin->add_hook('message_before_send', array($this, 'before_send_hook'));
         $this->plugin->add_hook('smtp_connect', array($this, 'smtp_connect_hook'));
     }
 
     public function set_sender_email($email)
     {
         if (!empty($email))
             $this->sender['email'] = $email;
     }
 
     public function set_rsvp_actions($actions)
     {
         $this->rsvp_actions = (array)$actions;
         $this->rsvp_status = array_merge($this->rsvp_actions, array('delegated'));
     }
 
     public function set_rsvp_status($status)
     {
         $this->rsvp_status = $status;
     }
 
     /**
      * Wrapper for rcube_plugin::gettext()
      * Checking for a label in different domains
      *
      * @see rcube::gettext()
      */
     public function gettext($p)
     {
         $label = is_array($p) ? $p['name'] : $p;
         $domain = $this->domain;
         if (!$this->rc->text_exists($label, $domain)) {
             $domain = 'libcalendaring';
         }
         return $this->rc->gettext($p, $domain);
     }
 
     /**
      * Send an iTip mail message
      *
      * @param array   Event object to send
      * @param string  iTip method (REQUEST|REPLY|CANCEL)
      * @param array   Hash array with recipient data (name, email)
      * @param string  Mail subject
      * @param string  Mail body text label
      * @param object  Mail_mime object with message data
      * @param boolean Request RSVP
      * @return boolean True on success, false on failure
      */
     public function send_itip_message($event, $method, $recipient, $subject, $bodytext, $message = null, $rsvp = true)
     {
         if (!$this->sender['name'])
             $this->sender['name'] = $this->sender['email'];
 
         if (!$message) {
             libcalendaring::identify_recurrence_instance($event);
             $message = $this->compose_itip_message($event, $method, $rsvp);
         }
 
-        $mailto = rcube_idn_to_ascii($recipient['email']);
+        $mailto = rcube_utils::idn_to_ascii($recipient['email']);
 
         $headers = $message->headers();
         $headers['To'] = format_email_recipient($mailto, $recipient['name']);
         $headers['Subject'] = $this->gettext(array(
             'name' => $subject,
             'vars' => array(
                 'title' => $event['title'],
                 'name' => $this->sender['name']
             )
         ));
 
         // compose a list of all event attendees
         $attendees_list = array();
         foreach ((array)$event['attendees'] as $attendee) {
             $attendees_list[] = ($attendee['name'] && $attendee['email']) ?
                 $attendee['name'] . ' <' . $attendee['email'] . '>' :
                 ($attendee['name'] ? $attendee['name'] : $attendee['email']);
         }
 
         $recurrence_info = '';
         if (!empty($event['recurrence_id'])) {
             $recurrence_info = "\n\n** " . $this->gettext($event['thisandfuture'] ? 'itipmessagefutureoccurrence' : 'itipmessagesingleoccurrence') . ' **';
         }
         else if (!empty($event['recurrence'])) {
             $recurrence_info = sprintf("\n%s: %s", $this->gettext('recurring'), $this->lib->recurrence_text($event['recurrence']));
         }
 
         $mailbody = $this->gettext(array(
             'name' => $bodytext,
             'vars' => array(
                 'title' => $event['title'],
                 'date' => $this->lib->event_date_text($event, true) . $recurrence_info,
                 'attendees' => join(",\n ", $attendees_list),
                 'sender' => $this->sender['name'],
                 'organizer' => $this->sender['name'],
             )
         ));
 
         // if (!empty($event['comment'])) {
         //     $mailbody .= "\n\n" . $this->gettext('itipsendercomment') . $event['comment'];
         // }
 
         // append links for direct invitation replies
         if ($method == 'REQUEST' && $rsvp && ($token = $this->store_invitation($event, $recipient['email']))) {
             $mailbody .= "\n\n" . $this->gettext(array(
                 'name' => 'invitationattendlinks',
                 'vars' => array('url' => $this->plugin->get_url(array('action' => 'attend', 't' => $token))),
             ));
         }
         else if ($method == 'CANCEL' && $event['cancelled']) {
             $this->cancel_itip_invitation($event);
         }
 
         $message->headers($headers, true);
         $message->setTXTBody(rcube_mime::format_flowed($mailbody, 79));
 
         if ($this->rc->config->get('libcalendaring_itip_debug', false)) {
             console('iTip ' . $method, $message->txtHeaders() . "\n\r" . $message->get());
         }
 
         // finally send the message
         $this->itip_send = true;
         $sent = $this->rc->deliver_message($message, $headers['X-Sender'], $mailto, $smtp_error);
         $this->itip_send = false;
 
         return $sent;
     }
 
     /**
      * Plugin hook triggered by rcube::deliver_message() before delivering a message.
      * Here we can set the 'smtp_server' config option to '' in order to use
      * PHP's mail() function for unauthenticated email sending.
      */
     public function before_send_hook($p)
     {
         if ($this->itip_send && !$this->rc->user->ID && $this->rc->config->get('calendar_itip_smtp_server', null) === '') {
             $this->rc->config->set('smtp_server', '');
         }
 
         return $p;
     }
 
     /**
      * Plugin hook to alter SMTP authentication.
      * This is used if iTip messages are to be sent from an unauthenticated session
      */
     public function smtp_connect_hook($p)
     {
         // replace smtp auth settings if we're not in an authenticated session
         if ($this->itip_send && !$this->rc->user->ID) {
             foreach (array('smtp_server', 'smtp_user', 'smtp_pass') as $prop) {
                 $p[$prop] = $this->rc->config->get("calendar_itip_$prop", $p[$prop]);
             }
         }
 
       return $p;
     }
 
     /**
      * Helper function to build a Mail_mime object to send an iTip message
      *
      * @param array   Event object to send
      * @param string  iTip method (REQUEST|REPLY|CANCEL)
      * @param boolean Request RSVP
      * @return object Mail_mime object with message data
      */
     public function compose_itip_message($event, $method, $rsvp = true)
     {
-        $from = rcube_idn_to_ascii($this->sender['email']);
+        $from     = rcube_utils::idn_to_ascii($this->sender['email']);
         $from_utf = rcube_utils::idn_to_utf8($from);
-        $sender = format_email_recipient($from, $this->sender['name']);
+        $sender   = format_email_recipient($from, $this->sender['name']);
 
         // truncate list attendees down to the recipient of the iTip Reply.
         // constraints for a METHOD:REPLY according to RFC 5546
         if ($method == 'REPLY') {
             $replying_attendee = null;
             $reply_attendees = array();
             foreach ($event['attendees'] as $attendee) {
                 if ($attendee['role'] == 'ORGANIZER') {
                     $reply_attendees[] = $attendee;
                 }
                 else if (strcasecmp($attendee['email'], $from) == 0 || strcasecmp($attendee['email'], $from_utf) == 0) {
                     $replying_attendee = $attendee;
                     if ($attendee['status'] != 'DELEGATED') {
                         unset($replying_attendee['rsvp']);  // unset the RSVP attribute
                     }
                 }
                 // include attendees relevant for delegation (RFC 5546, Section 4.2.5)
                 else if ((!empty($attendee['delegated-to']) &&
                             (strcasecmp($attendee['delegated-to'], $from) == 0 || strcasecmp($attendee['delegated-to'], $from_utf) == 0)) ||
                          (!empty($attendee['delegated-from']) &&
                             (strcasecmp($attendee['delegated-from'], $from) == 0 || strcasecmp($attendee['delegated-from'], $from_utf) == 0))) {
                     $reply_attendees[] = $attendee;
                 }
             }
             if ($replying_attendee) {
                 array_unshift($reply_attendees, $replying_attendee);
                 $event['attendees'] = $reply_attendees;
             }
             if ($event['recurrence']) {
                 unset($event['recurrence']['EXCEPTIONS']);
             }
         }
         // set RSVP for every attendee
         else if ($method == 'REQUEST') {
             foreach ($event['attendees'] as $i => $attendee) {
                 if (($rsvp || !isset($attendee['rsvp'])) && ($attendee['status'] != 'DELEGATED' && $attendee['role'] != 'NON-PARTICIPANT')) {
                     $event['attendees'][$i]['rsvp']= (bool)$rsvp;
                 }
             }
         }
         else if ($method == 'CANCEL') {
             if ($event['recurrence']) {
                 unset($event['recurrence']['EXCEPTIONS']);
             }
         }
 
         // compose multipart message using PEAR:Mail_Mime
         $message = new Mail_mime("\r\n");
         $message->setParam('text_encoding', 'quoted-printable');
         $message->setParam('head_encoding', 'quoted-printable');
         $message->setParam('head_charset', RCUBE_CHARSET);
         $message->setParam('text_charset', RCUBE_CHARSET . ";\r\n format=flowed");
         $message->setContentType('multipart/alternative');
 
         // compose common headers array
         $headers = array(
             'From' => $sender,
             'Date' => $this->rc->user_date(),
             'Message-ID' => $this->rc->gen_message_id(),
             'X-Sender' => $from,
         );
         if ($agent = $this->rc->config->get('useragent')) {
             $headers['User-Agent'] = $agent;
         }
 
         $message->headers($headers);
 
         // attach ics file for this event
         $ical = libcalendaring::get_ical();
         $ics = $ical->export(array($event), $method, false, $method == 'REQUEST' && $this->plugin->driver ? array($this->plugin->driver, 'get_attachment_body') : false);
         $filename = $event['_type'] == 'task' ? 'todo.ics' : 'event.ics';
         $message->addAttachment($ics, 'text/calendar', $filename, false, '8bit', '', RCUBE_CHARSET . "; method=" . $method);
 
         return $message;
     }
 
     /**
      * Forward the given iTip event as delegation to another person
      *
      * @param array Event object to delegate
      * @param mixed Delegatee as string or hash array with keys 'name' and 'mailto'
      * @param boolean The delegator's RSVP flag
      * @param array List with indexes of new/updated attendees
      * @return boolean True on success, False on failure
      */
     public function delegate_to(&$event, $delegate, $rsvp = false, &$attendees = array())
     {
         if (is_string($delegate)) {
             $delegates = rcube_mime::decode_address_list($delegate, 1, false);
             if (count($delegates) > 0) {
                 $delegate = reset($delegates);
             }
         }
 
         $emails = $this->lib->get_user_emails();
         $me     = $this->rc->user->list_emails(true);
 
         // find/create the delegate attendee
         $delegate_attendee = array(
             'email' => $delegate['mailto'],
             'name'  => $delegate['name'],
             'role'  => 'REQ-PARTICIPANT',
         );
         $delegate_index = count($event['attendees']);
 
         foreach ($event['attendees'] as $i => $attendee) {
           // set myself the DELEGATED-TO parameter
           if ($attendee['email'] && in_array(strtolower($attendee['email']), $emails)) {
               $event['attendees'][$i]['delegated-to'] = $delegate['mailto'];
               $event['attendees'][$i]['status'] = 'DELEGATED';
               $event['attendees'][$i]['role'] = 'NON-PARTICIPANT';
               $event['attendees'][$i]['rsvp'] = $rsvp;
 
               $me['email'] = $attendee['email'];
               $delegate_attendee['role'] = $attendee['role'];
           }
           // the disired delegatee is already listed as an attendee
           else if (stripos($delegate['mailto'], $attendee['email']) !== false && $attendee['role'] != 'ORGANIZER') {
               $delegate_attendee = $attendee;
               $delegate_index = $i;
               break;
           }
           // TODO: remove previous delegatee (i.e. attendee that has DELEGATED-FROM == $me)
         }
 
         // set/add delegate attendee with RSVP=TRUE and DELEGATED-FROM parameter
         $delegate_attendee['rsvp'] = true;
         $delegate_attendee['status'] = 'NEEDS-ACTION';
         $delegate_attendee['delegated-from'] = $me['email'];
         $event['attendees'][$delegate_index] = $delegate_attendee;
 
         $attendees[] = $delegate_index;
 
         $this->set_sender_email($me['email']);
         return $this->send_itip_message($event, 'REQUEST', $delegate_attendee, 'itipsubjectdelegatedto', 'itipmailbodydelegatedto');
     }
 
     /**
      * Handler for calendar/itip-status requests
      */
     public function get_itip_status($event, $existing = null)
     {
       $action = $event['rsvp'] ? 'rsvp' : '';
       $status = $event['fallback'];
       $latest = false;
       $html = '';
 
       if (is_numeric($event['changed']))
         $event['changed'] = new DateTime('@'.$event['changed']);
 
       // check if the given itip object matches the last state
       if ($existing) {
         $latest = (isset($event['sequence']) && intval($existing['sequence']) == intval($event['sequence'])) ||
                   (!isset($event['sequence']) && $existing['changed'] && $existing['changed'] >= $event['changed']);
       }
 
       // determine action for REQUEST
       if ($event['method'] == 'REQUEST') {
         $html = html::div('rsvp-status', $this->gettext('acceptinvitation'));
 
         if ($existing) {
           $rsvp = $event['rsvp'];
           $emails = $this->lib->get_user_emails();
           foreach ($existing['attendees'] as $attendee) {
             if ($attendee['email'] && in_array(strtolower($attendee['email']), $emails)) {
               $status = strtoupper($attendee['status']);
               break;
             }
           }
         }
         else {
           $rsvp = $event['rsvp'] && $this->rc->config->get('calendar_allow_itip_uninvited', true);
         }
 
         $status_lc = strtolower($status);
 
         if ($status_lc == 'unknown' && !$this->rc->config->get('calendar_allow_itip_uninvited', true)) {
           $html = html::div('rsvp-status', $this->gettext('notanattendee'));
           $action = 'import';
         }
         else if (in_array($status_lc, $this->rsvp_status)) {
           $status_text = $this->gettext(($latest ? 'youhave' : 'youhavepreviously') . $status_lc);
 
           if ($existing && ($existing['sequence'] > $event['sequence'] || (!isset($event['sequence']) && $existing['changed'] && $existing['changed'] > $event['changed']))) {
             $action = '';  // nothing to do here, outdated invitation
             if ($status_lc == 'needs-action')
               $status_text = $this->gettext('outdatedinvitation');
           }
           else if (!$existing && !$rsvp) {
             $action = 'import';
           }
           else if ($latest && $status_lc != 'needs-action') {
             $action = 'update';
           }
 
           $html = html::div('rsvp-status ' . $status_lc, $status_text);
         }
       }
       // determine action for REPLY
       else if ($event['method'] == 'REPLY') {
         // check whether the sender already is an attendee
         if ($existing) {
           $action = $this->rc->config->get('calendar_allow_itip_uninvited', true) ? 'accept' : '';
           $listed = false;
           foreach ($existing['attendees'] as $attendee) {
             if ($attendee['role'] != 'ORGANIZER' && strcasecmp($attendee['email'], $event['attendee']) == 0) {
               $status_lc = strtolower($status);
               if (in_array($status_lc, $this->rsvp_status)) {
                 $html = html::div('rsvp-status ' . $status_lc, $this->gettext(array(
                     'name' => 'attendee' . $status_lc,
                     'vars' => array(
-                        'delegatedto' => Q($event['delegated-to'] ?: ($attendee['delegated-to'] ?: '?')),
+                        'delegatedto' => rcube::Q($event['delegated-to'] ?: ($attendee['delegated-to'] ?: '?')),
                     )
                 )));
               }
               $action = $attendee['status'] == $status || !$latest ? '' : 'update';
               $listed = true;
               break;
             }
           }
 
           if (!$listed) {
             $html = html::div('rsvp-status', $this->gettext('itipnewattendee'));
           }
         }
         else {
           $html = html::div('rsvp-status hint', $this->gettext('itipobjectnotfound'));
           $action = '';
         }
       }
       else if ($event['method'] == 'CANCEL') {
         if (!$existing) {
           $html = html::div('rsvp-status hint', $this->gettext('itipobjectnotfound'));
           $action = '';
         }
       }
 
       return array(
           'uid' => $event['uid'],
           'id' => asciiwords($event['uid'], true),
           'existing' => $existing ? true : false,
           'saved' => $existing ? true : false,
           'latest' => $latest,
           'status' => $status,
           'action' => $action,
           'html' => $html,
       );
     }
 
     /**
      * Build inline UI elements for iTip messages
      */
     public function mail_itip_inline_ui($event, $method, $mime_id, $task, $message_date = null, $preview_url = null)
     {
         $buttons = array();
         $dom_id = asciiwords($event['uid'], true);
         $rsvp_status = 'unknown';
 
         // pass some metadata about the event and trigger the asynchronous status check
         $changed = is_object($event['changed']) ? $event['changed'] : $message_date;
         $metadata = array(
             'uid'      => $event['uid'],
             '_instance' => $event['_instance'],
             'changed'  => $changed ? $changed->format('U') : 0,
             'sequence' => intval($event['sequence']),
             'method'   => $method,
             'task'     => $task,
         );
 
         // create buttons to be activated from async request checking existence of this event in local calendars
         $buttons[] = html::div(array('id' => 'loading-'.$dom_id, 'class' => 'rsvp-status loading'), $this->gettext('loading'));
 
         // on iTip REPLY we have two options:
         if ($method == 'REPLY') {
             $title = $this->gettext('itipreply');
 
             foreach ($event['attendees'] as $attendee) {
                 if (!empty($attendee['email']) && $attendee['role'] != 'ORGANIZER' &&
                       (empty($event['_sender']) || ($attendee['email'] == $event['_sender'] || $attendee['email'] == $event['_sender_utf']))) {
                     $metadata['attendee'] = $attendee['email'];
                     $rsvp_status = strtoupper($attendee['status']);
                     if ($attendee['delegated-to'])
                         $metadata['delegated-to'] = $attendee['delegated-to'];
                     break;
                 }
             }
 
             // 1. update the attendee status on our copy
             $update_button = html::tag('input', array(
                 'type' => 'button',
                 'class' => 'button',
-                'onclick' => "rcube_libcalendaring.add_from_itip_mail('" . JQ($mime_id) . "', '$task')",
+                'onclick' => "rcube_libcalendaring.add_from_itip_mail('" . rcube::JQ($mime_id) . "', '$task')",
                 'value' => $this->gettext('updateattendeestatus'),
             ));
 
             // 2. accept or decline a new or delegate attendee
             $accept_buttons = html::tag('input', array(
                 'type' => 'button',
                 'class' => "button accept",
-                'onclick' => "rcube_libcalendaring.add_from_itip_mail('" . JQ($mime_id) . "', '$task')",
+                'onclick' => "rcube_libcalendaring.add_from_itip_mail('" . rcube::JQ($mime_id) . "', '$task')",
                 'value' => $this->gettext('acceptattendee'),
             ));
             $accept_buttons .= html::tag('input', array(
                 'type' => 'button',
                 'class' => "button decline",
-                'onclick' => "rcube_libcalendaring.decline_attendee_reply('" . JQ($mime_id) . "', '$task')",
+                'onclick' => "rcube_libcalendaring.decline_attendee_reply('" . rcube::JQ($mime_id) . "', '$task')",
                 'value' => $this->gettext('declineattendee'),
             ));
 
             $buttons[] = html::div(array('id' => 'update-'.$dom_id, 'style' => 'display:none'), $update_button);
             $buttons[] = html::div(array('id' => 'accept-'.$dom_id, 'style' => 'display:none'), $accept_buttons);
         }
         // when receiving iTip REQUEST messages:
         else if ($method == 'REQUEST') {
             $emails = $this->lib->get_user_emails();
             $title = $event['sequence'] > 0 ? $this->gettext('itipupdate') : $this->gettext('itipinvitation');
             $metadata['rsvp'] = true;
             $metadata['sensitivity'] = $event['sensitivity'];
 
             if (is_object($event['start'])) {
                 $metadata['date'] = $event['start']->format('U');
             }
 
             // check for X-KOLAB-INVITATIONTYPE property and only show accept/decline buttons
             if (self::get_custom_property($event, 'X-KOLAB-INVITATIONTYPE') == 'CONFIRMATION') {
                 $this->rsvp_actions = array('accepted','declined');
                 $metadata['nosave'] = true;
             }
 
             // 1. display RSVP buttons (if the user was invited)
             foreach ($this->rsvp_actions as $method) {
                 $rsvp_buttons .= html::tag('input', array(
                     'type' => 'button',
                     'class' => "button $method",
-                    'onclick' => "rcube_libcalendaring.add_from_itip_mail('" . JQ($mime_id) . "', '$task', '$method', '$dom_id')",
+                    'onclick' => "rcube_libcalendaring.add_from_itip_mail('" . rcube::JQ($mime_id) . "', '$task', '$method', '$dom_id')",
                     'value' => $this->gettext('itip' . $method),
                 ));
             }
 
             // add button to open calendar/preview
             if (!empty($preview_url)) {
               $msgref = $this->lib->ical_message->folder . '/' . $this->lib->ical_message->uid . '#' . $mime_id;
               $rsvp_buttons .= html::tag('input', array(
                   'type' => 'button',
                   'class' => "button preview",
-                  'onclick' => "rcube_libcalendaring.open_itip_preview('" . JQ($preview_url) . "', '" . JQ($msgref) . "')",
+                  'onclick' => "rcube_libcalendaring.open_itip_preview('" . rcube::JQ($preview_url) . "', '" . rcube::JQ($msgref) . "')",
                   'value' => $this->gettext('openpreview'),
               ));
             }
 
             // 2. update the local copy with minor changes
             $update_button = html::tag('input', array(
                 'type' => 'button',
                 'class' => 'button',
-                'onclick' => "rcube_libcalendaring.add_from_itip_mail('" . JQ($mime_id) . "', '$task')",
+                'onclick' => "rcube_libcalendaring.add_from_itip_mail('" . rcube::JQ($mime_id) . "', '$task')",
                 'value' => $this->gettext('updatemycopy'),
             ));
 
             // 3. Simply import the event without replying
             $import_button = html::tag('input', array(
                 'type' => 'button',
                 'class' => 'button',
-                'onclick' => "rcube_libcalendaring.add_from_itip_mail('" . JQ($mime_id) . "', '$task')",
+                'onclick' => "rcube_libcalendaring.add_from_itip_mail('" . rcube::JQ($mime_id) . "', '$task')",
                 'value' => $this->gettext('importtocalendar'),
             ));
 
             // check my status
             foreach ($event['attendees'] as $attendee) {
                 if ($attendee['email'] && in_array(strtolower($attendee['email']), $emails)) {
                     $metadata['attendee'] = $attendee['email'];
                     $metadata['rsvp'] = $attendee['rsvp'] || $attendee['role'] != 'NON-PARTICIPANT';
                     $rsvp_status = !empty($attendee['status']) ? strtoupper($attendee['status']) : 'NEEDS-ACTION';
                     break;
                 }
             }
 
             // add itip reply message controls
             $rsvp_buttons .= html::div('itip-reply-controls', $this->itip_rsvp_options_ui($dom_id, $metadata['nosave']));
 
             $buttons[] = html::div(array('id' => 'rsvp-'.$dom_id, 'class' => 'rsvp-buttons', 'style' => 'display:none'), $rsvp_buttons);
             $buttons[] = html::div(array('id' => 'update-'.$dom_id, 'style' => 'display:none'), $update_button);
 
             // prepare autocompletion for delegation dialog
             if (in_array('delegated', $this->rsvp_actions)) {
                 $this->rc->autocomplete_init();
             }
         }
         // for CANCEL messages, we can:
         else if ($method == 'CANCEL') {
             $title = $this->gettext('itipcancellation');
             $event_prop = array_filter(array(
               'uid' => $event['uid'],
               '_instance' => $event['_instance'],
               '_savemode' => $event['_savemode'],
             ));
 
             // 1. remove the event from our calendar
             $button_remove = html::tag('input', array(
                 'type' => 'button',
                 'class' => 'button',
-                'onclick' => "rcube_libcalendaring.remove_from_itip(" . rcube_output::json_serialize($event_prop) . ", '$task', '" . JQ($event['title']) . "')",
+                'onclick' => "rcube_libcalendaring.remove_from_itip(" . rcube_output::json_serialize($event_prop) . ", '$task', '" . rcube::JQ($event['title']) . "')",
                 'value' => $this->gettext('removefromcalendar'),
             ));
 
             // 2. update our copy with status=cancelled
             $button_update = html::tag('input', array(
               'type' => 'button',
               'class' => 'button',
-              'onclick' => "rcube_libcalendaring.add_from_itip_mail('" . JQ($mime_id) . "', '$task')",
+              'onclick' => "rcube_libcalendaring.add_from_itip_mail('" . rcube::JQ($mime_id) . "', '$task')",
               'value' => $this->gettext('updatemycopy'),
             ));
 
             $buttons[] = html::div(array('id' => 'rsvp-'.$dom_id, 'style' => 'display:none'), $button_remove . $button_update);
 
             $rsvp_status = 'CANCELLED';
             $metadata['rsvp'] = true;
         }
 
         // append generic import button
         if ($import_button) {
             $buttons[] = html::div(array('id' => 'import-'.$dom_id, 'style' => 'display:none'), $import_button);
         }
 
         // pass some metadata about the event and trigger the asynchronous status check
         $metadata['fallback'] = $rsvp_status;
         $metadata['rsvp'] = intval($metadata['rsvp']);
 
         $this->rc->output->add_script("rcube_libcalendaring.fetch_itip_object_status(" . json_serialize($metadata) . ")", 'docready');
 
         // get localized texts from the right domain
         foreach (array('savingdata','deleteobjectconfirm','declinedeleteconfirm','declineattendee',
             'cancel','itipdelegated','declineattendeeconfirm','itipcomment','delegateinvitation',
             'delegateto','delegatersvpme','delegateinvalidaddress') as $label) {
           $this->rc->output->command('add_label', "itip.$label", $this->gettext($label));
         }
 
         // show event details with buttons
         return $this->itip_object_details_table($event, $title) .
             html::div(array('class' => 'itip-buttons', 'id' => 'itip-buttons-' . asciiwords($metadata['uid'], true)), join('', $buttons));
     }
 
     /**
      * Render an RSVP UI widget with buttons to respond on iTip invitations
      */
     function itip_rsvp_buttons($attrib = array(), $actions = null)
     {
         $attrib += array('type' => 'button');
 
         if (!$actions)
             $actions = $this->rsvp_actions;
 
         foreach ($actions as $method) {
             $buttons .= html::tag('input', array(
                 'type'  => $attrib['type'],
                 'name'  => $attrib['iname'],
                 'class' => 'button',
                 'rel'   => $method,
                 'value' => $this->gettext('itip' . $method),
             ));
         }
 
         // add localized texts for the delegation dialog
         if (in_array('delegated', $actions)) {
             foreach (array('itipdelegated','itipcomment','delegateinvitation',
                   'delegateto','delegatersvpme','delegateinvalidaddress','cancel') as $label) {
                 $this->rc->output->command('add_label', "itip.$label", $this->gettext($label));
             }
         }
 
         foreach (array('all','current','future') as $mode) {
             $this->rc->output->command('add_label', "rsvpmode$mode", $this->gettext("rsvpmode$mode"));
         }
 
         $savemode_radio = new html_radiobutton(array('name' => '_rsvpmode', 'class' => 'rsvp-replymode'));
 
         return html::div($attrib,
             html::div('label', $this->gettext('acceptinvitation')) .
             html::div('rsvp-buttons',
                 $buttons .
                 html::div('itip-reply-controls', $this->itip_rsvp_options_ui($attrib['id']))
             )
         );
     }
 
     /**
      * Render UI elements to control iTip reply message sending
      */
     public function itip_rsvp_options_ui($dom_id, $disable = false)
     {
         $itip_sending = $this->rc->config->get('calendar_itip_send_option', 3);
 
         // itip sending is entirely disabled
         if ($itip_sending === 0) {
             return '';
         }
         // add checkbox to suppress itip reply message
         else if ($itip_sending >= 2) {
             $rsvp_additions = html::label(array('class' => 'noreply-toggle'),
                 html::tag('input', array('type' => 'checkbox', 'id' => 'noreply-'.$dom_id, 'value' => 1, 'disabled' => $disable, 'checked' => ($itip_sending & 1) == 0))
                 . ' ' . $this->gettext('itipsuppressreply')
             );
         }
 
         // add input field for reply comment
         $rsvp_additions .= html::a(array('href' => '#toggle', 'class' => 'reply-comment-toggle'), $this->gettext('itipeditresponse'));
         $rsvp_additions .= html::div('itip-reply-comment',
             html::tag('textarea', array('id' => 'reply-comment-'.$dom_id, 'name' => '_comment', 'cols' => 40, 'rows' => 6, 'style' => 'display:none', 'placeholder' => $this->gettext('itipcomment')), '')
         );
 
         return $rsvp_additions;
     }
 
     /**
      * Render event/task details in a table
      */
     function itip_object_details_table($event, $title)
     {
         $table = new html_table(array('cols' => 2, 'border' => 0, 'class' => 'calendar-eventdetails'));
         $table->add('ititle', $title);
-        $table->add('title', Q($event['title']));
+        $table->add('title', rcube::Q($event['title']));
         if ($event['start'] && $event['end']) {
             $table->add('label', $this->gettext('date'));
-            $table->add('date', Q($this->lib->event_date_text($event)));
+            $table->add('date', rcube::Q($this->lib->event_date_text($event)));
         }
         else if ($event['due'] && $event['_type'] == 'task') {
             $table->add('label', $this->gettext('date'));
-            $table->add('date', Q($this->lib->event_date_text($event)));
+            $table->add('date', rcube::Q($this->lib->event_date_text($event)));
         }
         if (!empty($event['recurrence_date'])) {
             $table->add('label', '');
             $table->add('recurrence-id', $this->gettext($event['thisandfuture'] ? 'itipfutureoccurrence' : 'itipsingleoccurrence'));
         }
         else if (!empty($event['recurrence'])) {
             $table->add('label', $this->gettext('recurring'));
             $table->add('recurrence', $this->lib->recurrence_text($event['recurrence']));
         }
         if ($event['location']) {
             $table->add('label', $this->gettext('location'));
-            $table->add('location', Q($event['location']));
+            $table->add('location', rcube::Q($event['location']));
         }
         if ($event['sensitivity'] && $event['sensitivity'] != 'public') {
             $table->add('label', $this->gettext('sensitivity'));
             $table->add('sensitivity', ucfirst($this->gettext($event['sensitivity'])) . '!');
         }
         if ($event['status'] == 'COMPLETED' || $event['status'] == 'CANCELLED') {
             $table->add('label', $this->gettext('status'));
             $table->add('status', $this->gettext('status-' . strtolower($event['status'])));
         }
         if ($event['comment']) {
             $table->add('label', $this->gettext('comment'));
-            $table->add('location', Q($event['comment']));
+            $table->add('location', rcube::Q($event['comment']));
         }
 
         return $table->show();
     }
 
 
     /**
      * Create iTIP invitation token for later replies via URL
      *
      * @param array Hash array with event properties
      * @param string Attendee email address
      * @return string Invitation token
      */
     public function store_invitation($event, $attendee)
     {
         // empty stub
         return false;
     }
 
     /**
      * Mark invitations for the given event as cancelled
      *
      * @param array Hash array with event properties
      */
     public function cancel_itip_invitation($event)
     {
         // empty stub
         return false;
     }
 
     /**
      * Utility function to get the value of a custom property
      */
     public static function get_custom_property($event, $name)
     {
       $ret = false;
 
       if (is_array($event['x-custom'])) {
           array_walk($event['x-custom'], function($prop, $i) use ($name, &$ret) {
               if (strcasecmp($prop[0], $name) === 0) {
                   $ret = $prop[1];
               }
           });
       }
 
       return $ret;
     }
 
 }
diff --git a/plugins/libcalendaring/libcalendaring.php b/plugins/libcalendaring/libcalendaring.php
index 7ca0b3ea..30690eb6 100644
--- a/plugins/libcalendaring/libcalendaring.php
+++ b/plugins/libcalendaring/libcalendaring.php
@@ -1,1650 +1,1650 @@
 <?php
 
 /**
  * Library providing common functions for calendaring plugins
  *
  * Provides utility functions for calendar-related modules such as
  * - alarms display and dismissal
  * - attachment handling
  * - recurrence computation and UI elements
  * - ical parsing and exporting
  * - itip scheduling protocol
  *
  * @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 libcalendaring extends rcube_plugin
 {
     public $rc;
     public $timezone;
     public $gmt_offset;
     public $dst_active;
     public $timezone_offset;
     public $ical_parts = array();
     public $ical_message;
 
     public $defaults = array(
       'calendar_date_format'  => "yyyy-MM-dd",
       'calendar_date_short'   => "M-d",
       'calendar_date_long'    => "MMM d yyyy",
       'calendar_date_agenda'  => "ddd MM-dd",
       'calendar_time_format'  => "HH:mm",
       'calendar_first_day'    => 1,
       'calendar_first_hour'   => 6,
       'calendar_date_format_sets' => array(
         'yyyy-MM-dd' => array('MMM d yyyy',   'M-d',  'ddd MM-dd'),
         'dd-MM-yyyy' => array('d MMM yyyy',   'd-M',  'ddd dd-MM'),
         'yyyy/MM/dd' => array('MMM d yyyy',   'M/d',  'ddd MM/dd'),
         'MM/dd/yyyy' => array('MMM d yyyy',   'M/d',  'ddd MM/dd'),
         'dd/MM/yyyy' => array('d MMM yyyy',   'd/M',  'ddd dd/MM'),
         'dd.MM.yyyy' => array('dd. MMM yyyy', 'd.M',  'ddd dd.MM.'),
         'd.M.yyyy'   => array('d. MMM yyyy',  'd.M',  'ddd d.MM.'),
       ),
     );
 
     private static $instance;
     private static $email_regex = '/([a-z0-9][a-z0-9\-\.\+\_]*@[^&@"\'.][^@&"\']*\\.([^\\x00-\\x40\\x5b-\\x60\\x7b-\\x7f]{2,}|xn--[a-z0-9]{2,}))/';
 
     private $mail_ical_parser;
 
     /**
      * Singleton getter to allow direct access from other plugins
      */
     public static function get_instance()
     {
         return self::$instance;
     }
 
     /**
      * Required plugin startup method
      */
     public function init()
     {
         self::$instance = $this;
 
         $this->rc = rcube::get_instance();
 
         // set user's timezone
         try {
             $this->timezone = new DateTimeZone($this->rc->config->get('timezone', 'GMT'));
         }
         catch (Exception $e) {
             $this->timezone = new DateTimeZone('GMT');
         }
 
         $now = new DateTime('now', $this->timezone);
 
         $this->gmt_offset      = $now->getOffset();
         $this->dst_active      = $now->format('I');
         $this->timezone_offset = $this->gmt_offset / 3600 - $this->dst_active;
 
         $this->add_texts('localization/', false);
 
         // include client scripts and styles
         if ($this->rc->output) {
             // add hook to display alarms
             $this->add_hook('refresh', array($this, 'refresh'));
             $this->register_action('plugin.alarms', array($this, 'alarms_action'));
             $this->register_action('plugin.expand_attendee_group', array($this, 'expand_attendee_group'));
         }
 
         // proceed initialization in startup hook
         $this->add_hook('startup', array($this, 'startup'));
     }
 
     /**
      * Startup hook
      */
     public function startup($args)
     {
         if ($this->rc->output && $this->rc->output->type == 'html') {
             $this->rc->output->set_env('libcal_settings', $this->load_settings());
             $this->include_script('libcalendaring.js');
             $this->include_stylesheet($this->local_skin_path() . '/libcal.css');
         }
 
         if ($args['task'] == 'mail') {
             if ($args['action'] == 'show' || $args['action'] == 'preview') {
                 $this->add_hook('message_load', array($this, 'mail_message_load'));
             }
         }
     }
 
     /**
      * Load iCalendar functions
      */
     public static function get_ical()
     {
         $self = self::get_instance();
         require_once($self->home . '/libvcalendar.php');
         return new libvcalendar();
     }
 
     /**
      * Load iTip functions
      */
     public static function get_itip($domain = 'libcalendaring')
     {
         $self = self::get_instance();
         require_once($self->home . '/lib/libcalendaring_itip.php');
         return new libcalendaring_itip($self, $domain);
     }
 
     /**
      * Load recurrence computation engine
      */
     public static function get_recurrence()
     {
         $self = self::get_instance();
         require_once($self->home . '/lib/libcalendaring_recurrence.php');
         return new libcalendaring_recurrence($self);
     }
 
     /**
      * Shift dates into user's current timezone
      *
      * @param mixed Any kind of a date representation (DateTime object, string or unix timestamp)
      * @return object DateTime object in user's timezone
      */
     public function adjust_timezone($dt, $dateonly = false)
     {
         if (is_numeric($dt))
             $dt = new DateTime('@'.$dt);
         else if (is_string($dt))
             $dt = rcube_utils::anytodatetime($dt);
 
         if ($dt instanceof DateTime && !($dt->_dateonly || $dateonly)) {
             $dt->setTimezone($this->timezone);
         }
 
         return $dt;
     }
 
 
     /**
      *
      */
     public function load_settings()
     {
         $this->date_format_defaults();
         $settings = array();
 
         // configuration
         $settings['date_format'] = (string)$this->rc->config->get('calendar_date_format', $this->defaults['calendar_date_format']);
         $settings['time_format'] = (string)$this->rc->config->get('calendar_time_format', $this->defaults['calendar_time_format']);
         $settings['date_short']  = (string)$this->rc->config->get('calendar_date_short', $this->defaults['calendar_date_short']);
         $settings['date_long']   = (string)$this->rc->config->get('calendar_date_long', $this->defaults['calendar_date_long']);
         $settings['dates_long']  = str_replace(' yyyy', '[ yyyy]', $settings['date_long']) . "{ '&mdash;' " . $settings['date_long'] . '}';
         $settings['first_day']   = (int)$this->rc->config->get('calendar_first_day', $this->defaults['calendar_first_day']);
 
         $settings['timezone'] = $this->timezone_offset;
         $settings['dst'] = $this->dst_active;
 
         // localization
         $settings['days'] = array(
             $this->rc->gettext('sunday'),   $this->rc->gettext('monday'),
             $this->rc->gettext('tuesday'),  $this->rc->gettext('wednesday'),
             $this->rc->gettext('thursday'), $this->rc->gettext('friday'),
             $this->rc->gettext('saturday')
         );
         $settings['days_short'] = array(
             $this->rc->gettext('sun'), $this->rc->gettext('mon'),
             $this->rc->gettext('tue'), $this->rc->gettext('wed'),
             $this->rc->gettext('thu'), $this->rc->gettext('fri'),
             $this->rc->gettext('sat')
         );
         $settings['months'] = array(
             $this->rc->gettext('longjan'), $this->rc->gettext('longfeb'),
             $this->rc->gettext('longmar'), $this->rc->gettext('longapr'),
             $this->rc->gettext('longmay'), $this->rc->gettext('longjun'),
             $this->rc->gettext('longjul'), $this->rc->gettext('longaug'),
             $this->rc->gettext('longsep'), $this->rc->gettext('longoct'),
             $this->rc->gettext('longnov'), $this->rc->gettext('longdec')
         );
         $settings['months_short'] = array(
             $this->rc->gettext('jan'), $this->rc->gettext('feb'),
             $this->rc->gettext('mar'), $this->rc->gettext('apr'),
             $this->rc->gettext('may'), $this->rc->gettext('jun'),
             $this->rc->gettext('jul'), $this->rc->gettext('aug'),
             $this->rc->gettext('sep'), $this->rc->gettext('oct'),
             $this->rc->gettext('nov'), $this->rc->gettext('dec')
         );
         $settings['today'] = $this->rc->gettext('today');
 
         // define list of file types which can be displayed inline
         // same as in program/steps/mail/show.inc
         $settings['mimetypes'] = (array)$this->rc->config->get('client_mimetypes');
 
         return $settings;
     }
 
 
     /**
      * Helper function to set date/time format according to config and user preferences
      */
     private function date_format_defaults()
     {
         static $defaults = array();
 
         // nothing to be done
         if (isset($defaults['date_format']))
           return;
 
         $defaults['date_format'] = $this->rc->config->get('calendar_date_format', self::from_php_date_format($this->rc->config->get('date_format')));
         $defaults['time_format'] = $this->rc->config->get('calendar_time_format', self::from_php_date_format($this->rc->config->get('time_format')));
 
         // override defaults
         if ($defaults['date_format'])
             $this->defaults['calendar_date_format'] = $defaults['date_format'];
         if ($defaults['time_format'])
             $this->defaults['calendar_time_format'] = $defaults['time_format'];
 
         // derive format variants from basic date format
         $format_sets = $this->rc->config->get('calendar_date_format_sets', $this->defaults['calendar_date_format_sets']);
         if ($format_set = $format_sets[$this->defaults['calendar_date_format']]) {
             $this->defaults['calendar_date_long'] = $format_set[0];
             $this->defaults['calendar_date_short'] = $format_set[1];
             $this->defaults['calendar_date_agenda'] = $format_set[2];
         }
     }
 
     /**
      * Compose a date string for the given event
      */
     public function event_date_text($event, $tzinfo = false)
     {
         $fromto = '--';
 
         // handle task objects
         if ($event['_type'] == 'task' && is_object($event['due'])) {
             $date_format = $event['due']->_dateonly ? self::to_php_date_format($this->rc->config->get('calendar_date_format', $this->defaults['calendar_date_format'])) : null;
             $fromto = $this->rc->format_date($event['due'], $date_format, false);
 
             // add timezone information
             if ($fromto && $tzinfo && ($tzname = $this->timezone->getName())) {
                 $fromto .= ' (' . strtr($tzname, '_', ' ') . ')';
             }
 
             return $fromto;
         }
 
         // abort if no valid event dates are given
         if (!is_object($event['start']) || !is_a($event['start'], 'DateTime') || !is_object($event['end']) || !is_a($event['end'], 'DateTime')) {
             return $fromto;
         }
 
         $duration = $event['start']->diff($event['end'])->format('s');
 
         $this->date_format_defaults();
         $date_format = self::to_php_date_format($this->rc->config->get('calendar_date_format', $this->defaults['calendar_date_format']));
         $time_format = self::to_php_date_format($this->rc->config->get('calendar_time_format', $this->defaults['calendar_time_format']));
 
         if ($event['allday']) {
-            $fromto = format_date($event['start'], $date_format);
-            if (($todate = format_date($event['end'], $date_format)) != $fromto)
+            $fromto = $this->rc->format_date($event['start'], $date_format);
+            if (($todate = $this->rc->format_date($event['end'], $date_format)) != $fromto)
                 $fromto .= ' - ' . $todate;
         }
         else if ($duration < 86400 && $event['start']->format('d') == $event['end']->format('d')) {
-            $fromto = format_date($event['start'], $date_format) . ' ' . format_date($event['start'], $time_format) .
-                ' - ' . format_date($event['end'], $time_format);
+            $fromto = $this->rc->format_date($event['start'], $date_format) . ' ' . $this->rc->format_date($event['start'], $time_format) .
+                ' - ' . $this->rc->format_date($event['end'], $time_format);
         }
         else {
-            $fromto = format_date($event['start'], $date_format) . ' ' . format_date($event['start'], $time_format) .
-                ' - ' . format_date($event['end'], $date_format) . ' ' . format_date($event['end'], $time_format);
+            $fromto = $this->rc->format_date($event['start'], $date_format) . ' ' . $this->rc->format_date($event['start'], $time_format) .
+                ' - ' . $this->rc->format_date($event['end'], $date_format) . ' ' . $this->rc->format_date($event['end'], $time_format);
         }
 
         // add timezone information
         if ($tzinfo && ($tzname = $this->timezone->getName())) {
             $fromto .= ' (' . strtr($tzname, '_', ' ') . ')';
         }
 
         return $fromto;
     }
 
 
     /**
      * Render HTML form for alarm configuration
      */
     public function alarm_select($attrib, $alarm_types, $absolute_time = true)
     {
         unset($attrib['name']);
 
         $input_value = new html_inputfield(array('name' => 'alarmvalue[]', 'class' => 'edit-alarm-value', 'size' => 3));
         $input_date  = new html_inputfield(array('name' => 'alarmdate[]', 'class' => 'edit-alarm-date', 'size' => 10));
         $input_time  = new html_inputfield(array('name' => 'alarmtime[]', 'class' => 'edit-alarm-time', 'size' => 6));
         $select_type    = new html_select(array('name' => 'alarmtype[]', 'class' => 'edit-alarm-type', 'id' => $attrib['id']));
         $select_offset  = new html_select(array('name' => 'alarmoffset[]', 'class' => 'edit-alarm-offset'));
         $select_related = new html_select(array('name' => 'alarmrelated[]', 'class' => 'edit-alarm-related'));
         $object_type    = $attrib['_type'] ?: 'event';
 
         $select_type->add($this->gettext('none'), '');
         foreach ($alarm_types as $type)
             $select_type->add($this->gettext(strtolower("alarm{$type}option")), $type);
 
         foreach (array('-M','-H','-D','+M','+H','+D') as $trigger)
             $select_offset->add($this->gettext('trigger' . $trigger), $trigger);
 
         $select_offset->add($this->gettext('trigger0'), '0');
         if ($absolute_time)
             $select_offset->add($this->gettext('trigger@'), '@');
 
         $select_related->add($this->gettext('relatedstart'), 'start');
         $select_related->add($this->gettext('relatedend' . $object_type), 'end');
 
         // pre-set with default values from user settings
         $preset = self::parse_alarm_value($this->rc->config->get('calendar_default_alarm_offset', '-15M'));
         $hidden = array('style' => 'display:none');
         $html = html::span('edit-alarm-set',
             $select_type->show($this->rc->config->get('calendar_default_alarm_type', '')) . ' ' .
             html::span(array('class' => 'edit-alarm-values', 'style' => 'display:none'),
                 $input_value->show($preset[0]) . ' ' .
                 $select_offset->show($preset[1]) . ' ' .
                 $select_related->show() . ' ' .
                 $input_date->show('', $hidden) . ' ' .
                 $input_time->show('', $hidden)
             )
         );
 
         // TODO: support adding more alarms
         #$html .= html::a(array('href' => '#', 'id' => 'edit-alam-add', 'title' => $this->gettext('addalarm')),
         #  $attrib['addicon'] ? html::img(array('src' => $attrib['addicon'], 'alt' => 'add')) : '(+)');
 
         return $html;
     }
 
     /**
      * Get a list of email addresses of the given user (from login and identities)
      *
      * @param string User Email (default to current user)
      * @return array Email addresses related to the user
      */
     public function get_user_emails($user = null)
     {
         static $_emails = array();
 
         if (empty($user)) {
             $user = $this->rc->user->get_username();
         }
 
         // return cached result
         if (is_array($_emails[$user])) {
             return $_emails[$user];
         }
 
         $emails = array($user);
         $plugin = $this->rc->plugins->exec_hook('calendar_user_emails', array('emails' => $emails));
         $emails = array_map('strtolower', $plugin['emails']);
 
         // add all emails from the current user's identities
         if (!$plugin['abort'] && ($user == $this->rc->user->get_username())) {
             foreach ($this->rc->user->list_emails() as $identity) {
                 $emails[] = strtolower($identity['email']);
             }
         }
 
         $_emails[$user] = array_unique($emails);
         return $_emails[$user];
     }
 
     /**
      * Set the given participant status to the attendee matching the current user's identities
      *
      * @param array   Hash array with event struct
      * @param string  The PARTSTAT value to set
      * @return mixed  Email address of the updated attendee or False if none matching found
      */
     public function set_partstat(&$event, $status, $recursive = true)
     {
         $success = false;
         $emails = $this->get_user_emails();
         foreach ((array)$event['attendees'] as $i => $attendee) {
             if ($attendee['email'] && in_array(strtolower($attendee['email']), $emails)) {
                 $event['attendees'][$i]['status'] = strtoupper($status);
                 $success = $attendee['email'];
             }
         }
 
         // apply partstat update to each existing exception
         if ($event['recurrence'] && is_array($event['recurrence']['EXCEPTIONS'])) {
             foreach ($event['recurrence']['EXCEPTIONS'] as $i => $exception) {
                 $this->set_partstat($event['recurrence']['EXCEPTIONS'][$i], $status, false);
             }
 
             // set link to top-level exceptions
             $event['exceptions'] = &$event['recurrence']['EXCEPTIONS'];
         }
 
         return $success;
     }
 
 
     /*********  Alarms handling  *********/
 
     /**
      * Helper function to convert alarm trigger strings
      * into two-field values (e.g. "-45M" => 45, "-M")
      */
     public static function parse_alarm_value($val)
     {
         if ($val[0] == '@') {
             return array(new DateTime($val));
         }
         else if (preg_match('/([+-]?)P?(T?\d+[HMSDW])+/', $val, $m) && preg_match_all('/T?(\d+)([HMSDW])/', $val, $m2, PREG_SET_ORDER)) {
             if ($m[1] == '')
                 $m[1] = '+';
             foreach ($m2 as $seg) {
                 $prefix = $seg[2] == 'D' || $seg[2] == 'W' ? 'P' : 'PT';
                 if ($seg[1] > 0) {  // ignore zero values
                     // convert seconds to minutes
                     if ($seg[2] == 'S') {
                         $seg[2] = 'M';
                         $seg[1] = max(1, round($seg[1]/60));
                     }
 
                     return array($seg[1], $m[1].$seg[2], $m[1].$seg[1].$seg[2], $m[1].$prefix.$seg[1].$seg[2]);
                 }
             }
 
             // return zero value nevertheless
             return array($seg[1], $m[1].$seg[2], $m[1].$seg[1].$seg[2], $m[1].$prefix.$seg[1].$seg[2]);
         }
 
         return false;
     }
 
     /**
      * Convert the alarms list items to be processed on the client
      */
     public static function to_client_alarms($valarms)
     {
         return array_map(function($alarm){
             if ($alarm['trigger'] instanceof DateTime) {
                 $alarm['trigger'] = '@' . $alarm['trigger']->format('U');
             }
             else if ($trigger = libcalendaring::parse_alarm_value($alarm['trigger'])) {
                 $alarm['trigger'] = $trigger[2];
             }
             return $alarm;
         }, (array)$valarms);
     }
 
     /**
      * Process the alarms values submitted by the client
      */
     public static function from_client_alarms($valarms)
     {
         return array_map(function($alarm){
             if ($alarm['trigger'][0] == '@') {
                 try {
                     $alarm['trigger'] = new DateTime($alarm['trigger']);
                     $alarm['trigger']->setTimezone(new DateTimeZone('UTC'));
                 }
                 catch (Exception $e) { /* handle this ? */ }
             }
             else if ($trigger = libcalendaring::parse_alarm_value($alarm['trigger'])) {
                 $alarm['trigger'] = $trigger[3];
             }
             return $alarm;
         }, (array)$valarms);
     }
 
     /**
      * Render localized text for alarm settings
      */
     public static function alarms_text($alarms)
     {
         if (is_array($alarms) && is_array($alarms[0])) {
             $texts = array();
             foreach ($alarms as $alarm) {
                 if ($text = self::alarm_text($alarm))
                     $texts[] = $text;
             }
 
             return join(', ', $texts);
         }
         else {
             return self::alarm_text($alarms);
         }
     }
 
     /**
      * Render localized text for a single alarm property
      */
     public static function alarm_text($alarm)
     {
         if (is_string($alarm)) {
             list($trigger, $action) = explode(':', $alarm);
         }
         else {
             $trigger = $alarm['trigger'];
             $action  = $alarm['action'];
             $related = $alarm['related'];
         }
 
         $text  = '';
         $rcube = rcube::get_instance();
 
         switch ($action) {
         case 'EMAIL':
             $text = $rcube->gettext('libcalendaring.alarmemail');
             break;
         case 'DISPLAY':
             $text = $rcube->gettext('libcalendaring.alarmdisplay');
             break;
         case 'AUDIO':
             $text = $rcube->gettext('libcalendaring.alarmaudio');
             break;
         }
 
         if ($trigger instanceof DateTime) {
             $text .= ' ' . $rcube->gettext(array(
                 'name' => 'libcalendaring.alarmat',
                 'vars' => array('datetime' => $rcube->format_date($trigger))
             ));
         }
         else if (preg_match('/@(\d+)/', $trigger, $m)) {
             $text .= ' ' . $rcube->gettext(array(
                 'name' => 'libcalendaring.alarmat',
                 'vars' => array('datetime' => $rcube->format_date($m[1]))
             ));
         }
         else if ($val = self::parse_alarm_value($trigger)) {
             $r = strtoupper($related ?: 'start') == 'END' ? 'end' : '';
             // TODO: for all-day events say 'on date of event at XX' ?
             if ($val[0] == 0) {
                 $text .= ' ' . $rcube->gettext('libcalendaring.triggerattime' . $r);
             }
             else {
                 $label = 'libcalendaring.trigger' . $r . $val[1];
                 $text .= ' ' . intval($val[0]) . ' ' . $rcube->gettext($label);
             }
         }
         else {
             return false;
         }
 
         return $text;
     }
 
     /**
      * Get the next alarm (time & action) for the given event
      *
      * @param array Record data
      * @return array Hash array with alarm time/type or null if no alarms are configured
      */
     public static function get_next_alarm($rec, $type = 'event')
     {
         if (!($rec['valarms'] || $rec['alarms']) || $rec['cancelled'] || $rec['status'] == 'CANCELLED')
             return null;
 
         if ($type == 'task') {
             $timezone = self::get_instance()->timezone;
             if ($rec['startdate'])
                 $rec['start'] = new DateTime($rec['startdate'] . ' ' . ($rec['starttime'] ?: '12:00'), $timezone);
             if ($rec['date'])
                 $rec[($rec['start'] ? 'end' : 'start')] = new DateTime($rec['date'] . ' ' . ($rec['time'] ?: '12:00'), $timezone);
         }
 
         if (!$rec['end'])
             $rec['end'] = $rec['start'];
 
         // support legacy format
         if (!$rec['valarms']) {
             list($trigger, $action) = explode(':', $rec['alarms'], 2);
             if ($alarm = self::parse_alarm_value($trigger)) {
                 $rec['valarms'] = array(array('action' => $action, 'trigger' => $alarm[3] ?: $alarm[0]));
             }
         }
 
         $expires  = new DateTime('now - 12 hours');
         $alarm_id = $rec['id'];  // alarm ID eq. record ID by default to keep backwards compatibility
 
         // handle multiple alarms
         $notify_at = null;
         foreach ($rec['valarms'] as $alarm) {
             $notify_time = null;
 
             if ($alarm['trigger'] instanceof DateTime) {
                 $notify_time = $alarm['trigger'];
             }
             else if (is_string($alarm['trigger'])) {
                 $refdate = $alarm['related'] == 'END' ? $rec['end'] : $rec['start'];
 
                 // abort if no reference date is available to compute notification time
                 if (!is_a($refdate, 'DateTime'))
                     continue;
 
                 // TODO: for all-day events, take start @ 00:00 as reference date ?
 
                 try {
                     $interval = new DateInterval(trim($alarm['trigger'], '+-'));
                     $interval->invert = $alarm['trigger'][0] == '-';
                     $notify_time = clone $refdate;
                     $notify_time->add($interval);
                 }
                 catch (Exception $e) {
                     rcube::raise_error($e, true);
                     continue;
                 }
             }
 
             if ($notify_time && (!$notify_at || ($notify_time > $notify_at && $notify_time > $expires))) {
                 $notify_at  = $notify_time;
                 $action     = $alarm['action'];
                 $alarm_prop = $alarm;
 
                 // generate a unique alarm ID if multiple alarms are set
                 if (count($rec['valarms']) > 1) {
                     $alarm_id = substr(md5($rec['id']), 0, 16) . '-' . $notify_at->format('Ymd\THis');
                 }
             }
         }
 
         return !$notify_at ? null : array(
             'time'   => $notify_at->format('U'),
             'action' => $action ? strtoupper($action) : 'DISPLAY',
             'id'     => $alarm_id,
             'prop'   => $alarm_prop,
         );
     }
 
     /**
      * Handler for keep-alive requests
      * This will check for pending notifications and pass them to the client
      */
     public function refresh($attr)
     {
         // collect pending alarms from all providers (e.g. calendar, tasks)
         $plugin = $this->rc->plugins->exec_hook('pending_alarms', array(
             'time' => time(),
             'alarms' => array(),
         ));
 
         if (!$plugin['abort'] && !empty($plugin['alarms'])) {
             // make sure texts and env vars are available on client
             $this->add_texts('localization/', true);
             $this->rc->output->add_label('close');
             $this->rc->output->set_env('snooze_select', $this->snooze_select());
             $this->rc->output->command('plugin.display_alarms', $this->_alarms_output($plugin['alarms']));
         }
     }
 
     /**
      * Handler for alarm dismiss/snooze requests
      */
     public function alarms_action()
     {
 //        $action = rcube_utils::get_input_value('action', rcube_utils::INPUT_GPC);
         $data  = rcube_utils::get_input_value('data', rcube_utils::INPUT_POST, true);
 
         $data['ids'] = explode(',', $data['id']);
         $plugin = $this->rc->plugins->exec_hook('dismiss_alarms', $data);
 
         if ($plugin['success'])
             $this->rc->output->show_message('successfullysaved', 'confirmation');
         else
             $this->rc->output->show_message('calendar.errorsaving', 'error');
     }
 
     /**
      * Generate reduced and streamlined output for pending alarms
      */
     private function _alarms_output($alarms)
     {
         $out = array();
         foreach ($alarms as $alarm) {
             $out[] = array(
                 'id'       => $alarm['id'],
                 'start'    => $alarm['start'] ? $this->adjust_timezone($alarm['start'])->format('c') : '',
                 'end'      => $alarm['end']   ? $this->adjust_timezone($alarm['end'])->format('c') : '',
                 'allDay'   => ($alarm['allday'] == 1)?true:false,
                 'title'    => $alarm['title'],
                 'location' => $alarm['location'],
                 'calendar' => $alarm['calendar'],
             );
         }
 
         return $out;
     }
 
     /**
      * Render a dropdown menu to choose snooze time
      */
     private function snooze_select($attrib = array())
     {
         $steps = array(
              5 => 'repeatinmin',
             10 => 'repeatinmin',
             15 => 'repeatinmin',
             20 => 'repeatinmin',
             30 => 'repeatinmin',
             60 => 'repeatinhr',
             120 => 'repeatinhrs',
             1440 => 'repeattomorrow',
             10080 => 'repeatinweek',
         );
 
         $items = array();
         foreach ($steps as $n => $label) {
             $items[] = html::tag('li', null, html::a(array('href' => "#" . ($n * 60), 'class' => 'active'),
                 $this->gettext(array('name' => $label, 'vars' => array('min' => $n % 60, 'hrs' => intval($n / 60))))));
         }
 
         return html::tag('ul', $attrib + array('class' => 'toolbarmenu'), join("\n", $items), html::$common_attrib);
     }
 
 
     /*********  Recurrence rules handling ********/
 
     /**
      * Render localized text describing the recurrence rule of an event
      */
     public function recurrence_text($rrule)
     {
         // derive missing FREQ and INTERVAL from RDATE list
         if (empty($rrule['FREQ']) && !empty($rrule['RDATE'])) {
             $first = $rrule['RDATE'][0];
             $second = $rrule['RDATE'][1];
             $third  = $rrule['RDATE'][2];
             if (is_a($first, 'DateTime') && is_a($second, 'DateTime')) {
                 $diff = $first->diff($second);
                 foreach (array('y' => 'YEARLY', 'm' => 'MONTHLY', 'd' => 'DAILY') as $k => $freq) {
                     if ($diff->$k != 0) {
                         $rrule['FREQ'] = $freq;
                         $rrule['INTERVAL'] = $diff->$k;
 
                         // verify interval with next item
                         if (is_a($third, 'DateTime')) {
                             $diff2 = $second->diff($third);
                             if ($diff2->$k != $diff->$k) {
                                 unset($rrule['INTERVAL']);
                             }
                         }
                         break;
                     }
                 }
             }
             if (!$rrule['INTERVAL']) {
                 $rrule['FREQ'] = 'RDATE';
             }
             $rrule['UNTIL'] = end($rrule['RDATE']);
         }
 
         $freq = sprintf('%s %d ', $this->gettext('every'), $rrule['INTERVAL']);
         $details = '';
         switch ($rrule['FREQ']) {
             case 'DAILY':
                 $freq .= $this->gettext('days');
                 break;
             case 'WEEKLY':
                 $freq .= $this->gettext('weeks');
                 break;
             case 'MONTHLY':
                 $freq .= $this->gettext('months');
                 break;
             case 'YEARLY':
                 $freq .= $this->gettext('years');
                 break;
         }
 
         if ($rrule['INTERVAL'] <= 1) {
             $freq = $this->gettext(strtolower($rrule['FREQ']));
         }
 
         if ($rrule['COUNT']) {
             $until =  $this->gettext(array('name' => 'forntimes', 'vars' => array('nr' => $rrule['COUNT'])));
         }
         else if ($rrule['UNTIL']) {
-            $until = $this->gettext('recurrencend') . ' ' . format_date($rrule['UNTIL'], self::to_php_date_format($this->rc->config->get('calendar_date_format', $this->defaults['calendar_date_format'])));
+            $until = $this->gettext('recurrencend') . ' ' . $this->rc->format_date($rrule['UNTIL'], self::to_php_date_format($this->rc->config->get('calendar_date_format', $this->defaults['calendar_date_format'])));
         }
         else {
             $until = $this->gettext('forever');
         }
 
         $except = '';
         if (is_array($rrule['EXDATE']) && !empty($rrule['EXDATE'])) {
           $format = self::to_php_date_format($this->rc->config->get('calendar_date_format', $this->defaults['calendar_date_format']));
           $exdates = array_map(
-            function($dt) use ($format) { return format_date($dt, $format); },
+            function($dt) use ($format) { return rcmail::get_instance()->format_date($dt, $format); },
             array_slice($rrule['EXDATE'], 0, 10)
           );
           $except = '; ' . $this->gettext('except') . ' ' . join(', ', $exdates);
         }
 
         return rtrim($freq . $details . ', ' . $until . $except);
     }
 
     /**
      * Generate the form for recurrence settings
      */
     public function recurrence_form($attrib = array())
     {
         switch ($attrib['part']) {
             // frequency selector
             case 'frequency':
                 $select = new html_select(array('name' => 'frequency', 'id' => 'edit-recurrence-frequency'));
                 $select->add($this->gettext('never'),   '');
                 $select->add($this->gettext('daily'),   'DAILY');
                 $select->add($this->gettext('weekly'),  'WEEKLY');
                 $select->add($this->gettext('monthly'), 'MONTHLY');
                 $select->add($this->gettext('yearly'),  'YEARLY');
                 $select->add($this->gettext('rdate'),   'RDATE');
                 $html = html::label('edit-recurrence-frequency', $this->gettext('frequency')) . $select->show('');
                 break;
 
             // daily recurrence
             case 'daily':
                 $select = $this->interval_selector(array('name' => 'interval', 'class' => 'edit-recurrence-interval', 'id' => 'edit-recurrence-interval-daily'));
                 $html = html::div($attrib, html::label('edit-recurrence-interval-daily', $this->gettext('every')) . $select->show(1) . html::span('label-after', $this->gettext('days')));
                 break;
 
             // weekly recurrence form
             case 'weekly':
                 $select = $this->interval_selector(array('name' => 'interval', 'class' => 'edit-recurrence-interval', 'id' => 'edit-recurrence-interval-weekly'));
                 $html = html::div($attrib, html::label('edit-recurrence-interval-weekly', $this->gettext('every')) . $select->show(1) . html::span('label-after', $this->gettext('weeks')));
                 // weekday selection
                 $daymap = array('sun','mon','tue','wed','thu','fri','sat');
                 $checkbox = new html_checkbox(array('name' => 'byday', 'class' => 'edit-recurrence-weekly-byday'));
                 $first = $this->rc->config->get('calendar_first_day', 1);
                 for ($weekdays = '', $j = $first; $j <= $first+6; $j++) {
                     $d = $j % 7;
                     $weekdays .= html::label(array('class' => 'weekday'),
                         $checkbox->show('', array('value' => strtoupper(substr($daymap[$d], 0, 2)))) .
                         $this->gettext($daymap[$d])
                     ) . ' ';
                 }
                 $html .= html::div($attrib, html::label(null, $this->gettext('bydays')) . $weekdays);
                 break;
 
             // monthly recurrence form
             case 'monthly':
                 $select = $this->interval_selector(array('name' => 'interval', 'class' => 'edit-recurrence-interval', 'id' => 'edit-recurrence-interval-monthly'));
                 $html = html::div($attrib, html::label('edit-recurrence-interval-monthly', $this->gettext('every')) . $select->show(1) . html::span('label-after', $this->gettext('months')));
 
                 $checkbox = new html_checkbox(array('name' => 'bymonthday', 'class' => 'edit-recurrence-monthly-bymonthday'));
                 for ($monthdays = '', $d = 1; $d <= 31; $d++) {
                     $monthdays .= html::label(array('class' => 'monthday'), $checkbox->show('', array('value' => $d)) . $d);
                     $monthdays .= $d % 7 ? ' ' : html::br();
                 }
 
                 // rule selectors
                 $radio = new html_radiobutton(array('name' => 'repeatmode', 'class' => 'edit-recurrence-monthly-mode'));
                 $table = new html_table(array('cols' => 2, 'border' => 0, 'cellpadding' => 0, 'class' => 'formtable'));
                 $table->add('label', html::label(null, $radio->show('BYMONTHDAY', array('value' => 'BYMONTHDAY')) . ' ' . $this->gettext('each')));
                 $table->add(null, $monthdays);
                 $table->add('label', html::label(null, $radio->show('', array('value' => 'BYDAY')) . ' ' . $this->gettext('onevery')));
                 $table->add(null, $this->rrule_selectors($attrib['part']));
 
                 $html .= html::div($attrib, $table->show());
                 break;
 
             // annually recurrence form
             case 'yearly':
                 $select = $this->interval_selector(array('name' => 'interval', 'class' => 'edit-recurrence-interval', 'id' => 'edit-recurrence-interval-yearly'));
                 $html = html::div($attrib, html::label('edit-recurrence-interval-yearly', $this->gettext('every')) . $select->show(1) . html::span('label-after', $this->gettext('years')));
                 // month selector
                 $monthmap = array('','jan','feb','mar','apr','may','jun','jul','aug','sep','oct','nov','dec');
                 $checkbox = new html_checkbox(array('name' => 'bymonth', 'class' => 'edit-recurrence-yearly-bymonth'));
                 for ($months = '', $m = 1; $m <= 12; $m++) {
                     $months .= html::label(array('class' => 'month'), $checkbox->show(null, array('value' => $m)) . $this->gettext($monthmap[$m]));
                     $months .= $m % 4 ? ' ' : html::br();
                 }
                 $html .= html::div($attrib + array('id' => 'edit-recurrence-yearly-bymonthblock'), $months);
 
                 // day rule selection
                 $html .= html::div($attrib, html::label(null, $this->gettext('onevery')) . $this->rrule_selectors($attrib['part'], '---'));
                 break;
 
             // end of recurrence form
             case 'until':
                 $radio = new html_radiobutton(array('name' => 'repeat', 'class' => 'edit-recurrence-until'));
                 $select = $this->interval_selector(array('name' => 'times', 'id' => 'edit-recurrence-repeat-times'));
                 $input = new html_inputfield(array('name' => 'untildate', 'id' => 'edit-recurrence-enddate', 'size' => "10"));
 
                 $html = html::div('line first',
                     html::label(null, $radio->show('', array('value' => '', 'id' => 'edit-recurrence-repeat-forever')) . ' ' .
                         $this->gettext('forever'))
                 );
 
                 $forntimes = $this->gettext(array(
                     'name' => 'forntimes',
                     'vars' => array('nr' => '%s'))
                 );
                 $html .= html::div('line',
                     $radio->show('', array('value' => 'count', 'id' => 'edit-recurrence-repeat-count', 'aria-label' => sprintf($forntimes, 'N'))) . ' ' .
                         sprintf($forntimes, $select->show(1))
                 );
 
                 $html .= html::div('line',
                     $radio->show('', array('value' => 'until', 'id' => 'edit-recurrence-repeat-until', 'aria-label' => $this->gettext('untilenddate'))) . ' ' .
                         $this->gettext('untildate') . ' ' . $input->show('', array('aria-label' => $this->gettext('untilenddate')))
                 );
 
                 $html = html::div($attrib, html::label(null, ucfirst($this->gettext('recurrencend'))) . $html);
                 break;
 
             case 'rdate':
                 $ul = html::tag('ul', array('id' => 'edit-recurrence-rdates'), '');
                 $input = new html_inputfield(array('name' => 'rdate', 'id' => 'edit-recurrence-rdate-input', 'size' => "10"));
                 $button = new html_inputfield(array('type' => 'button', 'class' => 'button add', 'value' => $this->gettext('addrdate')));
                 $html .= html::div($attrib, $ul . html::div('inputform', $input->show() . $button->show()));
                 break;
         }
 
         return $html;
     }
 
     /**
      * Input field for interval selection
      */
     private function interval_selector($attrib)
     {
         $select = new html_select($attrib);
         $select->add(range(1,30), range(1,30));
         return $select;
     }
 
     /**
      * Drop-down menus for recurrence rules like "each last sunday of"
      */
     private function rrule_selectors($part, $noselect = null)
     {
         // rule selectors
         $select_prefix = new html_select(array('name' => 'bydayprefix', 'id' => "edit-recurrence-$part-prefix"));
         if ($noselect) $select_prefix->add($noselect, '');
         $select_prefix->add(array(
                 $this->gettext('first'),
                 $this->gettext('second'),
                 $this->gettext('third'),
                 $this->gettext('fourth'),
                 $this->gettext('last')
             ),
             array(1, 2, 3, 4, -1));
 
         $select_wday = new html_select(array('name' => 'byday', 'id' => "edit-recurrence-$part-byday"));
         if ($noselect) $select_wday->add($noselect, '');
 
         $daymap = array('sunday','monday','tuesday','wednesday','thursday','friday','saturday');
         $first = $this->rc->config->get('calendar_first_day', 1);
         for ($j = $first; $j <= $first+6; $j++) {
             $d = $j % 7;
             $select_wday->add($this->gettext($daymap[$d]), strtoupper(substr($daymap[$d], 0, 2)));
         }
 
         return $select_prefix->show() . '&nbsp;' . $select_wday->show();
     }
 
     /**
      * Convert the recurrence settings to be processed on the client
      */
     public function to_client_recurrence($recurrence, $allday = false)
     {
         if ($recurrence['UNTIL'])
             $recurrence['UNTIL'] = $this->adjust_timezone($recurrence['UNTIL'], $allday)->format('c');
 
         // format RDATE values
         if (is_array($recurrence['RDATE'])) {
             $libcal = $this;
             $recurrence['RDATE'] = array_map(function($rdate) use ($libcal) {
                 return $libcal->adjust_timezone($rdate, true)->format('c');
             }, $recurrence['RDATE']);
         }
 
         unset($recurrence['EXCEPTIONS']);
 
         return $recurrence;
     }
 
     /**
      * Process the alarms values submitted by the client
      */
     public function from_client_recurrence($recurrence, $start = null)
     {
         if (is_array($recurrence) && !empty($recurrence['UNTIL'])) {
             $recurrence['UNTIL'] = new DateTime($recurrence['UNTIL'], $this->timezone);
         }
 
         if (is_array($recurrence) && is_array($recurrence['RDATE'])) {
             $tz = $this->timezone;
             $recurrence['RDATE'] = array_map(function($rdate) use ($tz, $start) {
                 try {
                     $dt = new DateTime($rdate, $tz);
                     if (is_a($start, 'DateTime'))
                         $dt->setTime($start->format('G'), $start->format('i'));
                     return $dt;
                 }
                 catch (Exception $e) {
                     return null;
                 }
             }, $recurrence['RDATE']);
         }
 
         return $recurrence;
     }
 
 
     /*********  Attachments handling  *********/
 
     /**
      * Handler for attachment uploads
      */
     public function attachment_upload($session_key, $id_prefix = '')
     {
         // Upload progress update
         if (!empty($_GET['_progress'])) {
             $this->rc->upload_progress();
         }
 
         $recid = $id_prefix . rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC);
         $uploadid = rcube_utils::get_input_value('_uploadid', rcube_utils::INPUT_GPC);
 
         if (!is_array($_SESSION[$session_key]) || $_SESSION[$session_key]['id'] != $recid) {
             $_SESSION[$session_key] = array();
             $_SESSION[$session_key]['id'] = $recid;
             $_SESSION[$session_key]['attachments'] = array();
         }
 
         // clear all stored output properties (like scripts and env vars)
         $this->rc->output->reset();
 
         if (is_array($_FILES['_attachments']['tmp_name'])) {
             foreach ($_FILES['_attachments']['tmp_name'] as $i => $filepath) {
               // Process uploaded attachment if there is no error
               $err = $_FILES['_attachments']['error'][$i];
 
               if (!$err) {
                 $attachment = array(
                     'path' => $filepath,
                     'size' => $_FILES['_attachments']['size'][$i],
                     'name' => $_FILES['_attachments']['name'][$i],
                     'mimetype' => rcube_mime::file_content_type($filepath, $_FILES['_attachments']['name'][$i], $_FILES['_attachments']['type'][$i]),
                     'group' => $recid,
                 );
 
                 $attachment = $this->rc->plugins->exec_hook('attachment_upload', $attachment);
               }
 
               if (!$err && $attachment['status'] && !$attachment['abort']) {
                   $id = $attachment['id'];
 
                   // store new attachment in session
                   unset($attachment['status'], $attachment['abort']);
                   $_SESSION[$session_key]['attachments'][$id] = $attachment;
 
                   if (($icon = $_SESSION[$session_key . '_deleteicon']) && is_file($icon)) {
                       $button = html::img(array(
                           'src' => $icon,
                           'alt' => $this->rc->gettext('delete')
                       ));
                   }
                   else {
-                      $button = Q($this->rc->gettext('delete'));
+                      $button = rcube::Q($this->rc->gettext('delete'));
                   }
 
                   $content = html::a(array(
                       'href' => "#delete",
                       'class' => 'delete',
                       'onclick' => sprintf("return %s.remove_from_attachment_list('rcmfile%s')", rcmail_output::JS_OBJECT_NAME, $id),
                       'title' => $this->rc->gettext('delete'),
                       'aria-label' => $this->rc->gettext('delete') . ' ' . $attachment['name'],
                   ), $button);
 
-                  $content .= Q($attachment['name']);
+                  $content .= rcube::Q($attachment['name']);
 
                   $this->rc->output->command('add2attachment_list', "rcmfile$id", array(
                       'html' => $content,
                       'name' => $attachment['name'],
                       'mimetype' => $attachment['mimetype'],
                       'classname' => rcube_utils::file2class($attachment['mimetype'], $attachment['name']),
                       'complete' => true), $uploadid);
               }
               else {  // upload failed
                   if ($err == UPLOAD_ERR_INI_SIZE || $err == UPLOAD_ERR_FORM_SIZE) {
                     $msg = $this->rc->gettext(array('name' => 'filesizeerror', 'vars' => array(
-                        'size' => show_bytes(parse_bytes(ini_get('upload_max_filesize'))))));
+                        'size' => $this->rc->show_bytes(parse_bytes(ini_get('upload_max_filesize'))))));
                   }
                   else if ($attachment['error']) {
                       $msg = $attachment['error'];
                   }
                   else {
                       $msg = $this->rc->gettext('fileuploaderror');
                   }
 
                   $this->rc->output->command('display_message', $msg, 'error');
                   $this->rc->output->command('remove_from_attachment_list', $uploadid);
                 }
             }
         }
         else if ($_SERVER['REQUEST_METHOD'] == 'POST') {
             // if filesize exceeds post_max_size then $_FILES array is empty,
             // show filesizeerror instead of fileuploaderror
             if ($maxsize = ini_get('post_max_size'))
                 $msg = $this->rc->gettext(array('name' => 'filesizeerror', 'vars' => array(
-                    'size' => show_bytes(parse_bytes($maxsize)))));
+                    'size' => $this->rc->show_bytes(parse_bytes($maxsize)))));
             else
                 $msg = $this->rc->gettext('fileuploaderror');
 
             $this->rc->output->command('display_message', $msg, 'error');
             $this->rc->output->command('remove_from_attachment_list', $uploadid);
         }
 
         $this->rc->output->send('iframe');
     }
 
 
     /**
      * Deliver an event/task attachment to the client
      * (similar as in Roundcube core program/steps/mail/get.inc)
      */
     public function attachment_get($attachment)
     {
         ob_end_clean();
 
         if ($attachment && $attachment['body']) {
             // allow post-processing of the attachment body
             $part = new rcube_message_part;
             $part->filename  = $attachment['name'];
             $part->size      = $attachment['size'];
             $part->mimetype  = $attachment['mimetype'];
 
             $plugin = $this->rc->plugins->exec_hook('message_part_get', array(
                 'body'     => $attachment['body'],
                 'mimetype' => strtolower($attachment['mimetype']),
                 'download' => !empty($_GET['_download']),
                 'part'     => $part,
             ));
 
             if ($plugin['abort'])
                 exit;
 
             $mimetype = $plugin['mimetype'];
             list($ctype_primary, $ctype_secondary) = explode('/', $mimetype);
 
             $browser = $this->rc->output->browser;
 
             // send download headers
             if ($plugin['download']) {
                 header("Content-Type: application/octet-stream");
                 if ($browser->ie)
                     header("Content-Type: application/force-download");
             }
             else if ($ctype_primary == 'text') {
                 header("Content-Type: text/$ctype_secondary");
             }
             else {
                 header("Content-Type: $mimetype");
                 header("Content-Transfer-Encoding: binary");
             }
 
             // display page, @TODO: support text/plain (and maybe some other text formats)
             if ($mimetype == 'text/html' && empty($_GET['_download'])) {
                 $OUTPUT = new rcmail_html_page();
                 // @TODO: use washtml on $body
                 $OUTPUT->write($plugin['body']);
             }
             else {
                 // don't kill the connection if download takes more than 30 sec.
                 @set_time_limit(0);
 
                 $filename = $attachment['name'];
                 $filename = preg_replace('[\r\n]', '', $filename);
 
                 if ($browser->ie && $browser->ver < 7)
                     $filename = rawurlencode(abbreviate_string($filename, 55));
                 else if ($browser->ie)
                     $filename = rawurlencode($filename);
                 else
                     $filename = addcslashes($filename, '"');
 
                 $disposition = !empty($_GET['_download']) ? 'attachment' : 'inline';
                 header("Content-Disposition: $disposition; filename=\"$filename\"");
 
                 echo $plugin['body'];
             }
 
             exit;
         }
 
         // if we arrive here, the requested part was not found
         header('HTTP/1.1 404 Not Found');
         exit;
     }
 
     /**
      * Show "loading..." page in attachment iframe
      */
     public function attachment_loading_page()
     {
         $url = str_replace('&_preload=1', '', $_SERVER['REQUEST_URI']);
         $message = $this->rc->gettext('loadingdata');
 
         header('Content-Type: text/html; charset=' . RCUBE_CHARSET);
         print "<html>\n<head>\n"
-            . '<meta http-equiv="refresh" content="0; url='.Q($url).'">' . "\n"
+            . '<meta http-equiv="refresh" content="0; url='.rcube::Q($url).'">' . "\n"
             . '<meta http-equiv="content-type" content="text/html; charset='.RCUBE_CHARSET.'">' . "\n"
             . "</head>\n<body>\n$message\n</body>\n</html>";
         exit;
     }
 
     /**
      * Template object for attachment display frame
      */
     public function attachment_frame($attrib = array())
     {
         $mimetype = strtolower($this->attachment['mimetype']);
         list($ctype_primary, $ctype_secondary) = explode('/', $mimetype);
 
         $attrib['src'] = './?' . str_replace('_frame=', ($ctype_primary == 'text' ? '_show=' : '_preload='), $_SERVER['QUERY_STRING']);
 
         $this->rc->output->add_gui_object('attachmentframe', $attrib['id']);
 
         return html::iframe($attrib);
     }
 
     /**
      *
      */
     public function attachment_header($attrib = array())
     {
         $rcmail = rcmail::get_instance();
         $dl_link = strtolower($attrib['downloadlink']) == 'true';
         $dl_url = $this->rc->url(array('_frame' => null, '_download' => 1) + $_GET);
 
         $table = new html_table(array('cols' => $dl_link ? 3 : 2));
 
         if (!empty($this->attachment['name'])) {
-            $table->add('title', Q($this->rc->gettext('filename')));
-            $table->add('header', Q($this->attachment['name']));
+            $table->add('title', rcube::Q($this->rc->gettext('filename')));
+            $table->add('header', rcube::Q($this->attachment['name']));
             if ($dl_link) {
-                $table->add('download-link', html::a($dl_url, Q($this->rc->gettext('download'))));
+                $table->add('download-link', html::a($dl_url, rcube::Q($this->rc->gettext('download'))));
             }
         }
 
         if (!empty($this->attachment['mimetype'])) {
-            $table->add('title', Q($this->rc->gettext('type')));
-            $table->add('header', Q($this->attachment['mimetype']));
+            $table->add('title', rcube::Q($this->rc->gettext('type')));
+            $table->add('header', rcube::Q($this->attachment['mimetype']));
         }
 
         if (!empty($this->attachment['size'])) {
-            $table->add('title', Q($this->rc->gettext('filesize')));
-            $table->add('header', Q(show_bytes($this->attachment['size'])));
+            $table->add('title', rcube::Q($this->rc->gettext('filesize')));
+            $table->add('header', rcube::Q($this->rc->show_bytes($this->attachment['size'])));
         }
 
         $this->rc->output->set_env('attachment_download_url', $dl_url);
 
         return $table->show($attrib);
     }
 
 
     /*********  iTip message detection  *********/
 
     /**
      * Check mail message structure of there are .ics files attached
      */
     public function mail_message_load($p)
     {
         $this->ical_message = $p['object'];
         $itip_part     = null;
 
         // check all message parts for .ics files
         foreach ((array)$this->ical_message->mime_parts as $part) {
             if (self::part_is_vcalendar($part)) {
                 if ($part->ctype_parameters['method'])
                     $itip_part = $part->mime_id;
                 else
                     $this->ical_parts[] = $part->mime_id;
             }
         }
 
         // priorize part with method parameter
         if ($itip_part) {
             $this->ical_parts = array($itip_part);
         }
     }
 
     /**
      * Getter for the parsed iCal objects attached to the current email message
      *
      * @return object libvcalendar parser instance with the parsed objects
      */
     public function get_mail_ical_objects()
     {
         // create parser and load ical objects
         if (!$this->mail_ical_parser) {
             $this->mail_ical_parser = $this->get_ical();
 
             foreach ($this->ical_parts as $mime_id) {
                 $part    = $this->ical_message->mime_parts[$mime_id];
                 $charset = $part->ctype_parameters['charset'] ?: RCUBE_CHARSET;
                 $this->mail_ical_parser->import($this->ical_message->get_part_body($mime_id, true), $charset);
 
                 // check if the parsed object is an instance of a recurring event/task
                 array_walk($this->mail_ical_parser->objects, 'libcalendaring::identify_recurrence_instance');
 
                 // stop on the part that has an iTip method specified
                 if (count($this->mail_ical_parser->objects) && $this->mail_ical_parser->method) {
                     $this->mail_ical_parser->message_date = $this->ical_message->headers->date;
                     $this->mail_ical_parser->mime_id = $mime_id;
 
                     // store the message's sender address for comparisons
                     $this->mail_ical_parser->sender = preg_match(self::$email_regex, $this->ical_message->headers->from, $m) ? $m[1] : '';
                     if (!empty($this->mail_ical_parser->sender)) {
                         foreach ($this->mail_ical_parser->objects as $i => $object) {
                             $this->mail_ical_parser->objects[$i]['_sender'] = $this->mail_ical_parser->sender;
                             $this->mail_ical_parser->objects[$i]['_sender_utf'] = rcube_utils::idn_to_utf8($this->mail_ical_parser->sender);
                         }
                     }
                     break;
                 }
             }
         }
 
         return $this->mail_ical_parser;
     }
 
     /**
      * Read the given mime message from IMAP and parse ical data
      *
      * @param string Mailbox name
      * @param string Message UID
      * @param string Message part ID and object index (e.g. '1.2:0')
      * @param string Object type filter (optional)
      *
      * @return array Hash array with the parsed iCal 
      */
     public function mail_get_itip_object($mbox, $uid, $mime_id, $type = null)
     {
         $charset = RCUBE_CHARSET;
 
         // establish imap connection
         $imap = $this->rc->get_storage();
         $imap->set_mailbox($mbox);
 
         if ($uid && $mime_id) {
             list($mime_id, $index) = explode(':', $mime_id);
 
             $part    = $imap->get_message_part($uid, $mime_id);
             $headers = $imap->get_message_headers($uid);
             $parser  = $this->get_ical();
 
             if ($part->ctype_parameters['charset']) {
                 $charset = $part->ctype_parameters['charset'];
             }
 
             if ($part) {
                 $objects = $parser->import($part, $charset);
             }
         }
 
         // successfully parsed events/tasks?
         if (!empty($objects) && ($object = $objects[$index]) && (!$type || $object['_type'] == $type)) {
             if ($parser->method)
                 $object['_method'] = $parser->method;
 
             // store the message's sender address for comparisons
             $object['_sender'] = preg_match(self::$email_regex, $headers->from, $m) ? $m[1] : '';
             $object['_sender_utf'] = rcube_utils::idn_to_utf8($object['_sender']);
 
             // check if this is an instance of a recurring event/task
             self::identify_recurrence_instance($object);
 
             return $object;
         }
 
         return null;
     }
 
     /**
      * Checks if specified message part is a vcalendar data
      *
      * @param rcube_message_part Part object
      * @return boolean True if part is of type vcard
      */
     public static function part_is_vcalendar($part)
     {
         return (
             in_array($part->mimetype, array('text/calendar', 'text/x-vcalendar', 'application/ics')) ||
             // Apple sends files as application/x-any (!?)
             ($part->mimetype == 'application/x-any' && $part->filename && preg_match('/\.ics$/i', $part->filename))
         );
     }
 
     /**
      * Single occourrences of recurring events are identified by their RECURRENCE-ID property
      * in iCal which is represented as 'recurrence_date' in our internal data structure.
      *
      * Check if such a property exists and derive the '_instance' identifier and '_savemode'
      * attributes which are used in the storage backend to identify the nested exception item.
      */
     public static function identify_recurrence_instance(&$object)
     {
         // for savemode=all, remove recurrence instance identifiers
         if (!empty($object['_savemode']) && $object['_savemode'] == 'all' && $object['recurrence']) {
             unset($object['_instance'], $object['recurrence_date']);
         }
         // set instance and 'savemode' according to recurrence-id
         else if (!empty($object['recurrence_date']) && is_a($object['recurrence_date'], 'DateTime')) {
             $object['_instance'] = self::recurrence_instance_identifier($object);
             $object['_savemode'] = $object['thisandfuture'] ? 'future' : 'current';
         }
         else if (!empty($object['recurrence_id']) && !empty($object['_instance'])) {
             if (strlen($object['_instance']) > 4) {
                 $object['recurrence_date'] = rcube_utils::anytodatetime($object['_instance'], $object['start']->getTimezone());
             }
             else {
                 $object['recurrence_date'] = clone $object['start'];
             }
         }
     }
 
     /**
      * Return a date() format string to render identifiers for recurrence instances
      *
      * @param array Hash array with event properties
      * @return string Format string
      */
     public static function recurrence_id_format($event)
     {
         return $event['allday'] ? 'Ymd' : 'Ymd\THis';
     }
 
     /**
      * Return the identifer for the given instance of a recurring event
      *
      * @param array Hash array with event properties
      * @return mixed Format string or null if identifier cannot be generated
      */
     public static function recurrence_instance_identifier($event)
     {
         $instance_date = $event['recurrence_date'] ?: $event['start'];
 
         if ($instance_date && is_a($instance_date, 'DateTime')) {
           $recurrence_id_format = $event['allday'] ? 'Ymd' : 'Ymd\THis';
           return $instance_date->format($recurrence_id_format);
         }
 
         return null;
     }
 
 
     /*********  Attendee handling functions  *********/
 
     /**
      * Handler for attendee group expansion requests
      */
     public function expand_attendee_group()
     {
         $id     = rcube_utils::get_input_value('id', rcube_utils::INPUT_POST);
         $data   = rcube_utils::get_input_value('data', rcube_utils::INPUT_POST, true);
         $result = array('id' => $id, 'members' => array());
         $maxnum = 500;
 
         // iterate over all autocomplete address books (we don't know the source of the group)
         foreach ((array)$this->rc->config->get('autocomplete_addressbooks', 'sql') as $abook_id) {
             if (($abook = $this->rc->get_address_book($abook_id)) && $abook->groups) {
                 foreach ($abook->list_groups($data['name'], 1) as $group) {
                     // this is the matching group to expand
                     if (in_array($data['email'], (array)$group['email'])) {
                         $abook->set_pagesize($maxnum);
                         $abook->set_group($group['ID']);
 
                         // get all members
                         $res = $abook->list_records($this->rc->config->get('contactlist_fields'));
 
                         // handle errors (e.g. sizelimit, timelimit)
                         if ($abook->get_error()) {
                             $result['error'] = $this->rc->gettext('expandattendeegrouperror', 'libcalendaring');
                             $res = false;
                         }
                         // check for maximum number of members (we don't wanna bloat the UI too much)
                         else if ($res->count > $maxnum) {
                             $result['error'] = $this->rc->gettext('expandattendeegroupsizelimit', 'libcalendaring');
                             $res = false;
                         }
 
                         while ($res && ($member = $res->iterate())) {
                             $emails = (array)$abook->get_col_values('email', $member, true);
                             if (!empty($emails) && ($email = array_shift($emails))) {
                                 $result['members'][] = array(
                                     'email' => $email,
                                     'name' => rcube_addressbook::compose_list_name($member),
                                 );
                             }
                         }
 
                         break 2;
                     }
                 }
             }
         }
 
         $this->rc->output->command('plugin.expand_attendee_callback', $result);
     }
 
 
     /*********  Static utility functions  *********/
 
     /**
      * Convert the internal structured data into a vcalendar rrule 2.0 string
      */
     public static function to_rrule($recurrence, $allday = false)
     {
         if (is_string($recurrence))
             return $recurrence;
 
         $rrule = '';
         foreach ((array)$recurrence as $k => $val) {
             $k = strtoupper($k);
             switch ($k) {
             case 'UNTIL':
                 // convert to UTC according to RFC 5545
                 if (is_a($val, 'DateTime')) {
                     if (!$allday && !$val->_dateonly) {
                         $until = clone $val;
                         $until->setTimezone(new DateTimeZone('UTC'));
                         $val = $until->format('Ymd\THis\Z');
                     }
                     else {
                         $val = $val->format('Ymd');
                     }
                 }
                 break;
             case 'RDATE':
             case 'EXDATE':
                 foreach ((array)$val as $i => $ex) {
                     if (is_a($ex, 'DateTime'))
                         $val[$i] = $ex->format('Ymd\THis');
                 }
                 $val = join(',', (array)$val);
                 break;
             case 'EXCEPTIONS':
                 continue 2;
             }
 
             if (strlen($val))
                 $rrule .= $k . '=' . $val . ';';
         }
 
         return rtrim($rrule, ';');
     }
 
     /**
      * Convert from fullcalendar date format to PHP date() format string
      */
     public static function to_php_date_format($from)
     {
         // "dd.MM.yyyy HH:mm:ss" => "d.m.Y H:i:s"
         return strtr(strtr($from, array(
             'yyyy' => 'Y',
             'yy'   => 'y',
             'MMMM' => 'F',
             'MMM'  => 'M',
             'MM'   => 'm',
             'M'    => 'n',
             'dddd' => 'l',
             'ddd'  => 'D',
             'dd'   => 'd',
             'd'    => 'j',
             'HH'   => '**',
             'hh'   => '%%',
             'H'    => 'G',
             'h'    => 'g',
             'mm'   => 'i',
             'ss'   => 's',
             'TT'   => 'A',
             'tt'   => 'a',
             'T'    => 'A',
             't'    => 'a',
             'u'    => 'c',
         )), array(
             '**'   => 'H',
             '%%'   => 'h',
         ));
     }
 
     /**
      * Convert from PHP date() format to fullcalendar format string
      */
     public static function from_php_date_format($from)
     {
         // "d.m.Y H:i:s" => "dd.MM.yyyy HH:mm:ss"
         return strtr($from, array(
             'y' => 'yy',
             'Y' => 'yyyy',
             'M' => 'MMM',
             'F' => 'MMMM',
             'm' => 'MM',
             'n' => 'M',
             'j' => 'd',
             'd' => 'dd',
             'D' => 'ddd',
             'l' => 'dddd',
             'H' => 'HH',
             'h' => 'hh',
             'G' => 'H',
             'g' => 'h',
             'i' => 'mm',
             's' => 'ss',
             'A' => 'TT',
             'a' => 'tt',
             'c' => 'u',
         ));
     }
 
 }
diff --git a/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php b/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php
index de702677..614799bc 100644
--- a/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php
+++ b/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php
@@ -1,1731 +1,1731 @@
 <?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->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)
             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;
         }
     }
 
     /**
      * 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)
     {
         // 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(),
                     'listname' => $listname,
                     'title'    => $folder->get_title(),
                     'virtual'  => true,
                     'editable' => false,
                     'rights'   => 'l',
                     'group'    => 'other virtual',
                     'class'    => 'user',
                     'parent'   => $parent_id,
                 );
             }
             else if ($folder->virtual) {
                 $lists[$list_id] = array(
                     'id'       => $list_id,
                     'name'     => kolab_storage::object_name($fullname),
                     'listname' => $listname,
                     'virtual'  => true,
                     'editable' => false,
                     'rights'   => 'l',
                     'group'    => $folder->get_namespace(),
                     '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)
     {
         // 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;
         }
 
         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))
             $lists = explode(',', $lists);
 
         $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');
 
         $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 taks 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))
             $lists = explode(',', $lists);
 
         $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);
 
                 // TODO: post-filter tasks returned from storage
 
                 $results[] = $task;
             }
         }
 
         // 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->_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);
         $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'));
         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);
     }
 
     /**
      * 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,
         );
 
         // we can sometimes skip this expensive operation
         if ($all) {
             $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;
         $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))) {
-            raise_error(array(
+            rcube::raise_error(array(
                 'code' => 600, 'type' => 'php',
                 'file' => __FILE__, 'line' => __LINE__,
                 'message' => "Invalid list identifer to save taks: " . var_dump($list_id, true)),
                 true, false);
             return false;
         }
 
         // email links and tags are stored separately
         $links = $task['links'];
         $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) {
-            raise_error(array(
+            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)
     {
         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'    => Q($this->plugin->gettext('tabsharing')),
+                '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'], Q($label)));
+                    $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, Q($tab['name'])) . $content) . "\n";
+                $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'));
     }
 }