No OneTemporary
Actions

Size

485 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/plugins/calendar/calendar.php b/plugins/calendar/calendar.php
	index 7793f34a..5794e01e 100644
	--- a/plugins/calendar/calendar.php
	+++ b/plugins/calendar/calendar.php
	@@ -1,2932 +1,2943 @@
	<?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, 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;
	private $ics_parts = array();


	/**
	* 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('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('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','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($writeable = false, $confidential = false)
	{
	$default_id = $this->rc->config->get('calendar_default_calendar');
	$calendars = $this->driver->list_calendars(false, true);
	$calendar = $calendars[$default_id] ?: null;
	if (!$calendar \|\| $confidential \|\| ($writeable && $calendar['readonly'])) {
	foreach ($calendars as $cal) {
	if ($confidential && $cal['subtype'] == 'confidential') {
	$calendar = $cal;
	break;
	}
	if ($cal['default']) {
	$calendar = $cal;
	if (!$confidential)
	break;
	}
	if (!$writeable \|\| !$cal['readonly']) {
	$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 = get_input_value('view', RCUBE_INPUT_GPC);
	+ $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 = get_input_value('date', RCUBE_INPUT_GPC))
	+ if ($date = rcube_utils::get_input_value('date', rcube_utils::INPUT_GPC))
	$this->rc->output->set_env('date', $date);

	- if ($msgref = get_input_value('itip', RCUBE_INPUT_GPC))
	+ 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'))),
	'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'))),
	'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'))),
	'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'))),
	'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'))),
	'content' => $select_hours->show($this->rc->config->get('calendar_work_start', $this->defaults['calendar_work_start']), array('name' => '_work_start', 'id' => $field_id)) .
	' — ' . $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'))),
	'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'))),
	'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_alaram_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'))),
	'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(false, true) 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'))),
	'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'))),
	'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) . ' ' . $category_color->show($color) . ' ' . $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('') . ' ' . $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(" ").append(color).append(" ").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'])) . ' ' . 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_alaram_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]) . ' ' . $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 = get_input_value('_alarm_offset', RCUBE_INPUT_POST);
	- $default_alarm = $alarm_offset[0] . intval(get_input_value('_alarm_value', RCUBE_INPUT_POST)) . $alarm_offset[1];
	+ $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 = get_input_value('_birthdays_alarm_offset', RCUBE_INPUT_POST);
	- $birthdays_alarm_value = $birthdays_alarm_offset[0] . intval(get_input_value('_birthdays_alarm_value', RCUBE_INPUT_POST)) . $birthdays_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' => get_input_value('_default_view', RCUBE_INPUT_POST),
	- 'calendar_timeslots' => intval(get_input_value('_timeslots', RCUBE_INPUT_POST)),
	- 'calendar_first_day' => intval(get_input_value('_first_day', RCUBE_INPUT_POST)),
	- 'calendar_first_hour' => intval(get_input_value('_first_hour', RCUBE_INPUT_POST)),
	- 'calendar_work_start' => intval(get_input_value('_work_start', RCUBE_INPUT_POST)),
	- 'calendar_work_end' => intval(get_input_value('_work_end', RCUBE_INPUT_POST)),
	- 'calendar_event_coloring' => intval(get_input_value('_event_coloring', RCUBE_INPUT_POST)),
	- 'calendar_default_alarm_type' => get_input_value('_alarm_type', RCUBE_INPUT_POST),
	+ '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' => get_input_value('_default_calendar', RCUBE_INPUT_POST),
	+ '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' => get_input_value('_contact_birthdays', RCUBE_INPUT_POST) ? true : false,
	- 'calendar_birthday_adressbooks' => (array)get_input_value('_birthday_adressbooks', RCUBE_INPUT_POST),
	- 'calendar_birthdays_alarm_type' => get_input_value('_birthdays_alarm_type', RCUBE_INPUT_POST),
	+ '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(get_input_value('_after_action', RCUBE_INPUT_POST)),
	+ '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'] = get_input_value('_after_action_folder', RCUBE_INPUT_POST, true);
	+ $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) get_input_value('_categories', RCUBE_INPUT_POST);
	- $colors = (array) get_input_value('_colors', RCUBE_INPUT_POST);
	+ $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 = get_input_value('action', RCUBE_INPUT_GPC);
	- $cal = get_input_value('c', RCUBE_INPUT_GPC);
	+ $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();
	+ $results = array();
	$color_mode = $this->rc->config->get('calendar_event_coloring', $this->defaults['calendar_event_coloring']);
	- foreach ((array)$this->driver->search_calendars(get_input_value('q', RCUBE_INPUT_GPC), get_input_value('source', RCUBE_INPUT_GPC)) as $id => $prop) {
	+ $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, get_input_value('_reqid', RCUBE_INPUT_GPC));
	+ $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 = get_input_value('action', RCUBE_INPUT_GPC);
	- $event = get_input_value('e', RCUBE_INPUT_POST, true);
	+ $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;

	// don't notify if modifying a recurring instance (really?)
	if ($event['_savemode'] && $event['_savemode'] != 'all' && $event['_notify'])
	unset($event['_notify']);
	// force notify if hidden + active
	else 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);

	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'];
	$this->cleanup_event($event);
	}
	$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);
	$reload = $success && ($event['recurrence'] \|\| $event['_savemode'] \|\| $event['_fromcalendar']) ? 2 : 1;
	break;

	case "resize":
	$this->write_preprocess($event, $action);
	$success = $this->driver->resize_event($event);
	$reload = $event['_savemode'] ? 2 : 1;
	break;

	case "move":
	$this->write_preprocess($event, $action);
	$success = $this->driver->move_event($event);
	$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, true))) {
	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'))",
	JS_OBJECT_NAME, JS_OBJECT_NAME)), rcube_label('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 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'];
	}
	}

	$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');
	}
	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 = get_input_value('status', RCUBE_INPUT_GPC);
	+ $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_GPC);
	$reply_comment = $event['comment'];
	+
	$ev = $this->driver->get_event($event);
	$ev['attendees'] = $event['attendees'];
	$event = $ev;

	if ($success = $this->driver->edit_rsvp($event, $status)) {
	- $noreply = intval(get_input_value('noreply', RCUBE_INPUT_GPC)) \|\| $status == 'needs-action' \|\| $itip_sending === 0;
	- $reload = $event['calendar'] != $ev['calendar'] ? 2 : 1;
	+ $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'] ? 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;
	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');
	}
	}
	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;
	array_walk($data, function(&$change) use ($lib) {
	if ($change['date']) {
	$dt = $lib->adjust_timezone($change['date']);
	if ($dt instanceof DateTime)
	$change['date'] = $dt->format('c');
	}
	});
	$this->rc->output->command('plugin.render_event_changelog', $data);
	}
	else {
	$this->rc->output->command('plugin.render_event_changelog', false);
	$this->rc->output->command('display_message', $this->gettext('eventchangelognotavailable'), 'error');
	}
	$got_msg = true;
	$reload = false;
	break;

	case "diff":
	$data = $this->driver->get_event_diff($event, $event['rev']);
	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'] = $this->lib->adjust_timezone($change['old'], strlen($change['old']) == 10)->format('c');
	$change['new'] = $this->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('eventdiffnotavailable'), '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('eventnotfound'), 'error');
	}
	$got_msg = true;
	$reload = false;
	break;

	case "restore":
	if ($success = $this->driver->restore_event_revision($event, $event['rev'])) {

	}
	else {
	$this->rc->output->command('display_message', 'Not implemented yet', 'error');
	$got_msg = true;
	}
	$reload = false;
	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');
	}

	// send out notifications
	if ($success && $event['_notify'] && ($event['attendees'] \|\| $old['attendees'])) {
	// make sure we have the complete record
	$event = $action == 'remove' ? $old : $this->driver->get_event($event);

	// 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');
	}
	}

	// 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);
	}
	}

	/**
	* Handler for load-requests from fullcalendar
	* This will return pure JSON formatted output
	*/
	function load_events()
	{
	$events = $this->driver->load_events(
	- get_input_value('start', RCUBE_INPUT_GET),
	- get_input_value('end', RCUBE_INPUT_GET),
	- ($query = get_input_value('q', RCUBE_INPUT_GET)),
	- get_input_value('source', RCUBE_INPUT_GET)
	+ 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;
	}

	/**
	* 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);
	}

	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;
	}

	foreach ($this->driver->list_calendars(true) as $cal) {
	$events = $this->driver->load_events(
	- get_input_value('start', RCUBE_INPUT_GPC),
	- get_input_value('end', RCUBE_INPUT_GPC),
	- get_input_value('q', RCUBE_INPUT_GPC),
	+ 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)));
	}
	}
	}

	/**
	* 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 = get_input_value('calendar', RCUBE_INPUT_GPC);
	+ $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 = get_input_value('start', RCUBE_INPUT_GET);
	- $end = get_input_value('end', RCUBE_INPUT_GET);
	+ $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 = get_input_value('id', RCUBE_INPUT_GET);
	- $attachments = get_input_value('attachments', RCUBE_INPUT_GET);
	- $calid = $filename = get_input_value('source', RCUBE_INPUT_GET);
	+ $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))) {
	$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()
	{
	// 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 = get_input_value('_cal', RCUBE_INPUT_GET);
	+ $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
	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_identities() 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']);
	}

	foreach ((array)$event['attachments'] as $k => $attachment) {
	$event['attachments'][$k]['classname'] = rcube_utils::file2class($attachment['mimetype'], $attachment['name']);
	}

	// check for organizer in attendees list
	$organizer = null;
	foreach ((array)$event['attendees'] as $i => $attendee) {
	if ($attendee['role'] == 'ORGANIZER') {
	$organizer = $attendee;
	break;
	}
	}

	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);
	}

	// 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
	*/
	public function generate_randomdata()
	{
	$num = $_REQUEST['_num'] ? intval($_REQUEST['_num']) : 100;
	$cats = array_keys($this->driver->list_categories());
	$cals = $this->driver->list_calendars(true);
	$count = 0;

	while ($count++ < $num) {
	$start = round((time() + rand(-2600, 2600) * 1000) / 300) * 300;
	$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 = get_input_value('_event', RCUBE_INPUT_GPC);
	- $calendar = get_input_value('_cal', RCUBE_INPUT_GPC);
	- $id = get_input_value('_id', RCUBE_INPUT_GPC);
	+ $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);

	$event = array('id' => $event_id, 'calendar' => $calendar);
	$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;
	}


	/**
	* 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);

	// 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;

	// 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;
	else 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']);
	}
	else if ($organizer === false && $action == 'new' && ($identity = $this->rc->user->get_identity($event['_identity'])) && $identity['email']) {
	array_unshift($event['attendees'], array('role' => 'ORGANIZER', 'name' => $identity['name'], 'email' => $identity['email'], 'status' => 'ACCEPTED'));
	}
	}

	// 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)
	{
	if ($action == 'remove' \|\| ($event['status'] == 'CANCELLED' && $old['status'] != $event['status'])) {
	$event['cancelled'] = true;
	$is_cancelled = true;
	}

	$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;

	// compose multipart message using PEAR:Mail_Mime
	$method = $action == 'remove' ? 'CANCEL' : 'REQUEST';
	$message = $itip->compose_itip_message($event, $method);

	// 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;

	// 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;
	}

	// 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 = get_input_value('email', RCUBE_INPUT_GPC);
	- $start = get_input_value('start', RCUBE_INPUT_GPC);
	- $end = get_input_value('end', RCUBE_INPUT_GPC);
	-
	+ $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 = get_input_value('email', RCUBE_INPUT_GPC);
	- $start = get_input_value('start', RCUBE_INPUT_GPC);
	- $end = get_input_value('end', RCUBE_INPUT_GPC);
	- $interval = intval(get_input_value('interval', RCUBE_INPUT_GPC));
	+ $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 = get_input_value('view', RCUBE_INPUT_GPC);
	+
	+ $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 = get_input_value('date', RCUBE_INPUT_GPC))
	+
	+ if ($date = rcube_utils::get_input_value('date', rcube_utils::INPUT_GPC))
	$this->rc->output->set_env('date', $date);

	- if ($range = get_input_value('range', RCUBE_INPUT_GPC))
	+ 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', get_input_value('sections', RCUBE_INPUT_GPC));
	-
	- if ($search = get_input_value('search', RCUBE_INPUT_GPC)) {
	+ $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] && $a[$key] != $b[$key])
	$diff[] = $key;
	}

	// only compare number of attachments
	if (count($a['attachments']) != count($b['attachments']))
	$diff[] = 'attachments';

	return $diff;
	}


	/** 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_INPUT_GET),
	- rcube_utils::get_input_value('end', RCUBE_INPUT_GET));
	+ 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 = get_input_value('data', RCUBE_INPUT_POST, true);
	+ $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, true, false, true);

	$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(false, true);
	$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['readonly']) {
	$calendar_select->add($calendar['name'], $calendar['id']);
	$numcals++;
	}
	}
	if ($numcals <= 1)
	$calendar_select = null;
	}

	if ($calendar_select) {
	$default_calendar = $this->get_default_calendar(true, $data['sensitivity'] == 'confidential');
	$response['select'] = html::span('folder-select', $this->gettext('saveincalendar') . ' ' .
	$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(false, true);
	$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);

	// search for event if only UID is given
	- if ($event = $this->driver->get_event(array('uid' => get_input_value('uid', RCUBE_INPUT_POST)), true)) {
	+ if ($event = $this->driver->get_event(array('uid' => $uid), true)) {
	$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 = get_input_value('_t', RCUBE_INPUT_GPC);
	-
	+ $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
	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(true, $invitation['event']['sensitivity'] == 'confidential'))) {
	$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->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['all-day'] ? $this->gettext('allday') :
	$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']))
	);
	}

	/**
	*
	*/
	public function mail_messages_list($p)
	{
	if (in_array('attachment', (array)$p['cols']) && !empty($p['messages'])) {
	foreach ($p['messages'] as $i => $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 = get_input_value('_uid', RCUBE_INPUT_POST);
	- $mbox = get_input_value('_mbox', RCUBE_INPUT_POST);
	- $mime_id = get_input_value('_part', RCUBE_INPUT_POST);
	- $status = get_input_value('_status', RCUBE_INPUT_POST);
	- $delete = intval(get_input_value('_del', RCUBE_INPUT_POST));
	- $noreply = intval(get_input_value('_noreply', RCUBE_INPUT_POST)) \|\| $status == 'needs-action' \|\| $itip_sending === 0;
	+ $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;

	$error_msg = $this->gettext('errorimportingevent');
	$success = false;

	// successfully parsed events?
	if ($event = $this->lib->mail_get_itip_object($mbox, $uid, $mime_id, 'event')) {
	// find writeable calendar to store event
	- $cal_id = !empty($_REQUEST['_folder']) ? get_input_value('_folder', RCUBE_INPUT_POST) : null;
	+ $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(false, true);
	$calendar = $calendars[$cal_id];

	// select default calendar except user explicitly selected 'none'
	if (!$calendar && !$dontsave)
	$calendar = $this->get_default_calendar(true, $event['sensitivity'] == 'confidential');

	$metadata = array(
	'uid' => $event['uid'],
	'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 ($event['attendees'][$i]['status'] != 'NEEDS-ACTION')
	unset($event['attendees'][$i]['rsvp']); // remove RSVP attribute
	$metadata['attendee'] = $attendee['email'];
	$metadata['rsvp'] = $attendee['role'] != 'NON-PARTICIPANT';
	$reply_sender = $attendee['email'];
	}
	}

	// add attendee with this user's default identity if not listed
	if (!$reply_sender) {
	$sender_identity = $this->rc->user->get_identity();
	$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['readonly']) {
	$event['calendar'] = $calendar['id'];

	// check for existing event with the same UID
	$existing = $this->driver->get_event($event['uid'], true, false, true);

	if ($existing) {
	// only update attendee status
	if ($event['_method'] == 'REPLY') {
	// try to identify the attendee using the email sender address
	$existing_attendee = -1;
	foreach ($existing['attendees'] as $i => $attendee) {
	if ($event['_sender'] && ($attendee['email'] == $event['_sender'] \|\| $attendee['email'] == $event['_sender_utf'])) {
	$existing_attendee = $i;
	break;
	}
	}
	$event_attendee = null;
	foreach ($event['attendees'] as $attendee) {
	if ($event['_sender'] && ($attendee['email'] == $event['_sender'] \|\| $attendee['email'] == $event['_sender_utf'])) {
	$event_attendee = $attendee;
	$metadata['fallback'] = $attendee['status'];
	$metadata['attendee'] = $attendee['email'];
	$metadata['rsvp'] = $attendee['rsvp'] \|\| $attendee['role'] != 'NON-PARTICIPANT';
	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->edit_event($existing);
	}
	// update the entire attendees block
	else if (($event['sequence'] >= $existing['sequence'] \|\| $event['changed'] >= $existing['changed']) && $event_attendee) {
	$existing['attendees'][] = $event_attendee;
	$success = $this->driver->edit_event($existing);
	}
	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['free_busy'] = 'free';

	$success = $this->driver->edit_event($event);
	}
	else if (!empty($status)) {
	$existing['attendees'] = $event['attendees'];
	if ($status == 'declined') // show me as free when declined (#1670)
	$existing['free_busy'] = 'free';
	$success = $this->driver->edit_event($existing);
	}
	else
	$error_msg = $this->gettext('newerversionexists');
	}
	else if (!$existing && ($status != 'declined' \|\| $this->rc->config->get('kolab_invitation_calendars'))) {
	$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'] = get_input_value('_comment', RCUBE_INPUT_POST);
	+ $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 = get_input_value('_uid', RCUBE_INPUT_POST);
	- $mbox = get_input_value('_mbox', RCUBE_INPUT_POST);
	- $mime_id = get_input_value('_part', RCUBE_INPUT_POST);
	+ $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'] = get_input_value('_comment', RCUBE_INPUT_POST);
	+ $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');
	}
	}

	/**
	* Import the full payload from a mail message attachment
	*/
	public function mail_import_attachment()
	{
	- $uid = get_input_value('_uid', RCUBE_INPUT_POST);
	- $mbox = get_input_value('_mbox', RCUBE_INPUT_POST);
	- $mime_id = get_input_value('_part', RCUBE_INPUT_POST);
	+ $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 = RCMAIL_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']) ? get_input_value('_calendar', RCUBE_INPUT_POST) : null;
	+ $cal_id = !empty($_REQUEST['_calendar']) ? rcube_utils::get_input_value('_calendar', rcube_utils::INPUT_POST) : null;
	$calendars = $this->driver->list_calendars(false, true);

	foreach ($events as $event) {
	// save to calendar
	$calendar = $calendars[$cal_id] ?: $this->get_default_calendar(true, $event['sensitivity'] == 'confidential');
	if ($calendar && !$calendar['readonly'] && $event['_type'] == 'event') {
	$event['calendar'] = $calendar['id'];

	if (!$this->driver->get_event($event['uid'], true, false)) {
	$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 = get_input_value('_uid', RCUBE_INPUT_POST);
	- $mbox = get_input_value('_mbox', RCUBE_INPUT_POST);
	+ $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());

	// copy mail attachments to event
	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)
	{
	$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 8b38d716..da653d23 100644
	--- a/plugins/calendar/drivers/kolab/kolab_driver.php
	+++ b/plugins/calendar/drivers/kolab/kolab_driver.php
	@@ -1,1797 +1,1797 @@
	<?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-2014, Kolab Systems AG <contact@kolabsys.com>
	*
	* This program is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Affero General Public License as
	* published by the Free Software Foundation, either version 3 of the
	* License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU Affero General Public License for more details.
	*
	* You should have received a copy of the GNU Affero General Public License
	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	*/

	class kolab_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
	if ($bonnie_config = $this->cal->rc->config->get('kolab_bonnie_api', false))
	$this->bonnie_api = new kolab_bonnie_api($bonnie_config);

	// 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->readonly)
	$this->has_writeable = true;
	}
	}

	return $this->calendars;
	}

	/**
	* Get a list of available calendars from this source
	*
	* @param bool $active Return only active calendars
	* @param bool $personal Return only personal calendars
	* @param object $tree Reference to hierarchical folder tree object
	*
	* @return array List of calendars
	*/
	public function list_calendars($active = false, $personal = false, &$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(false, $active, $personal);
	$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,
	'readonly' => true,
	'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,
	'readonly' => true,
	'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(),
	'readonly' => $cal->readonly,
	'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 (!$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(),
	'readonly' => $cal->readonly,
	'showalarms' => $cal->alarms,
	'history' => !empty($this->bonnie_api),
	'group' => 'x-invitations',
	'default' => false,
	'active' => $cal->is_active(),
	'owner' => $cal->get_owner(),
	'children' => false,
	);

	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 (!$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',
	'readonly' => true,
	'default' => false,
	'children' => false,
	'history' => false,
	);
	}
	}

	return $calendars;
	}

	/**
	* Get list of calendars according to specified filters
	*
	* @param bool $writeable Return only writeable calendars
	* @param bool $active Return only active calendars
	* @param bool $personal Return only personal calendars
	*
	* @return array List of calendars
	*/
	protected function filter_calendars($writeable = false, $active = false, $personal = false)
	{
	$calendars = array();

	$plugin = $this->rc->plugins->exec_hook('calendar_list_filter', array(
	'list' => $this->calendars, 'calendars' => $calendars,
	'writeable' => $writeable, 'active' => $active, 'personal' => $personal,
	));

	if ($plugin['abort']) {
	return $plugin['calendars'];
	}

	foreach ($this->calendars as $cal) {
	if (!$cal->ready) {
	continue;
	}
	if ($writeable && $cal->readonly) {
	continue;
	}
	if ($active && !$cal->is_active()) {
	continue;
	}
	if ($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, $writeable = false, $active = false, $personal = false)
	{
	if (is_array($event)) {
	$id = $event['id'] ? $event['id'] : $event['uid'];
	$cal = $event['calendar'];
	}
	else {
	$id = $event;
	}

	if ($cal) {
	if ($storage = $this->get_calendar($cal)) {
	return $storage->get_event($id);
	}
	// 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($writeable, $active, $personal) as $calendar) {
	if ($result = $calendar->get_event($id)) {
	return $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;

	$cid = $event['calendar'] ? $event['calendar'] : reset(array_keys($this->calendars));
	if ($storage = $this->get_calendar($cid)) {
	// handle attachments to add
	if (!empty($event['attachments'])) {
	foreach ($event['attachments'] as $idx => $attachment) {
	// we'll read file contacts into memory, Horde/Kolab classes does the same
	// So we cannot save memory, rcube_imap class can do this better
	$event['attachments'][$idx]['content'] = $attachment['data'] ? $attachment['data'] : file_get_contents($attachment['path']);
	}
	}

	$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)
	{
	return $this->update_event($event);
	}

	/**
	* Extended event editing with possible changes to the argument
	*
	* @param array Hash array with event properties
	* @param string New participant status
	* @return boolean True on success, False on error
	*/
	public function edit_rsvp(&$event, $status)
	{
	if (($ret = $this->update_event($event)) && $this->rc->config->get('kolab_invitation_calendars')) {
	// re-assign to the according (virtual) calendar
	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;
	}


	/**
	* 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']);
	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']);
	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)
	{
	$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']) {
	$master = $event['recurrence_id'] ? $storage->get_event($event['recurrence_id']) : $event;
	$savemode = $event['_savemode'];
	}

	// removing an exception instance
	if ($event['recurrence_id']) {
	$i = $event['_instance'] - 1;
	if (!empty($master['recurrence']['EXCEPTIONS'][$i])) {
	unset($master['recurrence']['EXCEPTIONS'][$i]);
	}
	}

	switch ($savemode) {
	case 'current':
	$_SESSION['calendar_restore_event_data'] = $master;

	// removing the first instance => just move to next occurence
	if ($master['id'] == $event['id']) {
	$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':
	if ($master['id'] != $event['id']) {
	$_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);
	break;
	}

	default: // 'all' is default
	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;
	}

	/**
	* 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;

	if ($event['_savemode'] != 'new') {
	if (!$fromcalendar->storage->move($event['id'], $storage->get_realname()))
	return false;

	$fromcalendar = $storage;
	}
	}
	else
	$fromcalendar = $storage;

	$success = false;
	$savemode = 'all';
	$attachments = array();
	$old = $master = $fromcalendar->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;
	}

	// delete existing attachment(s)
	if (!empty($event['deleted_attachments'])) {
	foreach ($event['deleted_attachments'] as $attachment) {
	if (!empty($old['attachments'])) {
	foreach ($old['attachments'] as $idx => $att) {
	if ($att['id'] == $attachment) {
	$old['attachments'][$idx]['_deleted'] = true;
	}
	}
	}
	}
	unset($event['deleted_attachments']);
	}

	// handle attachments to add
	if (!empty($event['attachments'])) {
	foreach ($event['attachments'] as $attachment) {
	// skip entries without content (could be existing ones)
	if (!$attachment['data'] && !$attachment['path'])
	continue;

	$attachments[] = array(
	'name' => $attachment['name'],
	'mimetype' => $attachment['mimetype'],
	'content' => $attachment['data'],
	'path' => $attachment['path'],
	);
	}
	}

	$event['attachments'] = array_merge((array)$old['attachments'], $attachments);

	// modify a recurring event, check submitted savemode to do the right things
	if ($old['recurrence'] \|\| $old['recurrence_id']) {
	$master = $old['recurrence_id'] ? $fromcalendar->get_event($old['recurrence_id']) : $old;
	$savemode = $event['_savemode'];
	}

	// keep saved exceptions (not submitted by the client)
	if ($old['recurrence']['EXDATE'])
	$event['recurrence']['EXDATE'] = $old['recurrence']['EXDATE'];
	if ($old['recurrence']['EXCEPTIONS'])
	$event['recurrence']['EXCEPTIONS'] = $old['recurrence']['EXCEPTIONS'];

	switch ($savemode) {
	case 'new':
	// save submitted data as new (non-recurring) event
	$event['recurrence'] = array();
	$event['uid'] = $this->cal->generate_uid();

	// copy attachment data to new event
	foreach ((array)$event['attachments'] as $idx => $attachment) {
	if (!$attachment['data'])
	$attachment['data'] = $fromcalendar->get_attachment_body($attachment['id'], $event);
	}

	$success = $storage->insert_event($event);
	break;

	case 'future':
	case 'current':
	// recurring instances shall not store recurrence rules
	$event['recurrence'] = array();
	$event['thisandfuture'] = $savemode == 'future';

	// remove some internal properties which should not be saved
	unset($event['_savemode'], $event['_fromcalendar'], $event['_identity']);

	// save properties to a recurrence exception instance
	if ($old['recurrence_id']) {
	$i = $old['_instance'] - 1;
	if (!empty($master['recurrence']['EXCEPTIONS'][$i])) {
	$master['recurrence']['EXCEPTIONS'][$i] = $event;
	$success = $storage->update_event($master, $old['id']);
	break;
	}
	}

	$add_exception = true;

	// adjust matching RDATE entry if dates changed
	if ($savemode == 'current' && $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) {
	$master['recurrence']['EXCEPTIONS'][] = $event;
	}
	$success = $storage->update_event($master);
	break;

	default: // 'all' is default
	$event['id'] = $master['id'];
	$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;

	// shifted or resized
	if ($diff && ($old_start_date == $new_start_date \|\| $old_duration == $new_duration)) {
	$event['start'] = $master['start']->add($old['start']->diff($event['start']));
	$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 ($event['start'] == $old['start'] && $event['end'] == $old['end']) {
	$event['start'] = $master['start'];
	$event['end'] = $master['end'];
	}

	// unset _dateonly flags in (cached) date objects
	unset($event['start']->_dateonly, $event['end']->_dateonly);

	$success = $storage->update_event($event);
	break;
	}

	if ($success && $this->freebusy_trigger)
	$this->rc->output->command('plugin.ping_url', array('action' => 'calendar/push-freebusy', 'source' => $storage->id));

	return $success;
	}

	/**
	* 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));
	}

	return $events;
	}

	/**
	* 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;

	$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;

	return $cal->storage->get_attachment($event['id'], $id);
	}

	/**
	* 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);
	}

	/**
	* 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 = get_input_value('source', RCUBE_INPUT_GPC);
	+ $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 Kolab_Format to internal representation
	*/
	public static function to_rcube_event($record)
	{
	$record['id'] = $record['uid'];

	// all-day events go from 12:00 - 13:00
	if ($record['end'] <= $record['start'] && $record['allday']) {
	$record['end'] = clone $record['start'];
	$record['end']->add(new DateInterval('PT1H'));
	}

	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']);

	// remove internals
	unset($record['_mailbox'], $record['_msguid'], $record['_formatobj'], $record['_attachments'], $record['x-custom']);

	return $record;
	}


	/**
	* 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) = $this->_resolve_event_identity($event);

	$result = $this->bonnie_api->changelog('event', $uid, $mailbox);
	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 $rev Revisions: "from:to"
	*
	* @return array List of property changes, each as a hash array
	* @see calendar_driver::get_event_diff()
	*/
	public function get_event_diff($event, $rev)
	{
	if (empty($this->bonnie_api)) {
	return false;
	}

	list($uid, $mailbox) = $this->_resolve_event_identity($event);

	// call Bonnie API
	$result = $this->bonnie_api->diff('event', $uid, $rev, $mailbox);
	if (is_array($result) && $result['uid'] == $uid) {
	$result['rev'] = $rev;

	$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)
	{
	if (empty($this->bonnie_api)) {
	return false;
	}

	$calid = $event['calendar'];
	list($uid, $mailbox) = $this->_resolve_event_identity($event);

	// call Bonnie API
	$result = $this->bonnie_api->get('event', $uid, $rev, $mailbox);
	if (is_array($result) && $result['uid'] == $uid && !empty($result['xml'])) {
	$format = kolab_format::factory('event');
	$format->load($result['xml']);
	$event = $format->to_array();

	if ($format->is_valid()) {
	$event['calendar'] = $calid;
	$event['rev'] = $result['rev'];
	return self::to_rcube_event($event);
	}
	}

	return false;
	}

	/**
	* Helper method to resolved the given event identifier into uid and folder
	*
	* @return array (uid,folder) tuple
	*/
	private function _resolve_event_identity($event)
	{
	$mailbox = null;
	if (is_array($event)) {
	$uid = $event['id'] ?: $event['uid'];
	if (($cal = $this->get_calendar($event['calendar'])) && !($cal instanceof kolab_invitation_calendar)) {
	$mailbox = $cal->get_mailbox_id();
	}
	}
	else {
	$uid = $event;
	}

	return array($uid, $mailbox);
	}

	/**
	* 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')),
	'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";
	}
	}
	}
	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";
	}
	}

	// 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(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 = get_input_value('_id', RCUBE_INPUT_GPC);
	+ $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/kolab_activesync/kolab_activesync.php b/plugins/kolab_activesync/kolab_activesync.php
	index dc363839..b28e7cd3 100644
	--- a/plugins/kolab_activesync/kolab_activesync.php
	+++ b/plugins/kolab_activesync/kolab_activesync.php
	@@ -1,573 +1,573 @@
	<?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'];
	$myrights = $args['options']['rights'];

	// 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 = get_input_value('cmd', RCUBE_INPUT_POST);
	- $imei = get_input_value('id', RCUBE_INPUT_POST);
	+ $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) get_input_value('subscribed', RCUBE_INPUT_POST);
	- $devicealias = get_input_value('devicealias', RCUBE_INPUT_POST, true);
	+ $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)));
	}

	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) get_input_value('flag', RCUBE_INPUT_POST);
	- $folder = get_input_value('folder', RCUBE_INPUT_POST);
	+ $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->rc->output->send('kolab_activesync.configempty');
	}

	$this->register_handler('plugin.deviceconfigform', array($this->ui, 'device_config_form'));
	$this->register_handler('plugin.foldersubscriptions', array($this->ui, 'folder_subscriptions'));

	- $imei = get_input_value('_id', RCUBE_INPUT_GPC);
	+ $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_addressbook/kolab_addressbook.php b/plugins/kolab_addressbook/kolab_addressbook.php
	index 25bd9105..13a32e61 100644
	--- a/plugins/kolab_addressbook/kolab_addressbook.php
	+++ b/plugins/kolab_addressbook/kolab_addressbook.php
	@@ -1,891 +1,891 @@
	<?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, 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;

	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('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'));

	// 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();
	$undelete = $this->rc->config->get('undo_timeout');

	// 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);
	}

	// 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,
	'editable' => false,
	'kolab' => true,
	'virtual' => true,
	);
	}
	else {
	return array(
	'id' => $id,
	'name' => $abook->get_name(),
	'listname' => $abook->get_foldername(),
	'readonly' => $abook->readonly,
	'editable' => $abook->editable,
	'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,
	);
	}
	}

	/**
	*
	*/
	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);

	if (!empty($child_html) && preg_match('!</ul>\n*$!', $content)) {
	$content = preg_replace('!</ul>\n*$!', $child_html . '</ul>', $content);
	}
	else if (!empty($child_html)) {
	$content .= html::tag('ul', array('style' => ($is_collapsed ? "display:none;" : null)), $child_html);
	}
	}

	$out .= $content . '</li>';
	}

	return $out;
	}

	/**
	*
	*/
	protected function addressbook_list_item($id, $source, &$jsdata, $search_mode = false)
	{
	- $folder = $this->folders[$id];
	+ $folder = $this->folders[$id];
	$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);
	}

	// set class name(s)
	$classes = array($source['group'] ?: '000', 'addressbook');
	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' => $prop['active'],
	'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']) {
	$this->_list_sources();
	if ($this->sources[$p['id']]) {
	$p['instance'] = $this->sources[$p['id']];
	}
	else {
	$id = kolab_storage::id_decode($p['id']);
	if (preg_match('![^A-Za-z0-9=/+&._ -]!', $id)) // check for falsely base64 decoded identifier
	$id = $p['id'];
	$folder = kolab_storage::get_folder($id);
	if ($folder->type != 'contact' && $id != $p['id']) { // try with unencoded (old-style) identifier
	$folder = kolab_storage::get_folder($p['id']);
	}
	if ($folder->type) {
	$this->sources[$p['id']] = new rcube_kolab_contacts($folder->name);
	$p['instance'] = $this->sources[$p['id']];
	}
	}
	}

	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
	$names = array();
	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']);
	$p['form']['personal']['content'] = $this->_sort_form_fields($p['form']['personal']['content']);

	/* 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),
	)
	);
	*/
	}

	return $p;
	}


	private function _sort_form_fields($contents)
	{
	$block = array();
	$contacts = reset($this->sources);

	foreach (array_keys($contacts->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'))),
	'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) get_input_value('_'.$key, RCUBE_INPUT_POST);
	+ $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(get_input_value('_act', RCUBE_INPUT_GPC));
	+ $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(get_input_value('_name', RCUBE_INPUT_POST)),
	- 'oldname' => trim(get_input_value('_oldname', RCUBE_INPUT_POST, true)), // UTF7-IMAP
	- 'parent' => trim(get_input_value('_parent', RCUBE_INPUT_POST, true)), // UTF7-IMAP
	+ '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('set_env', 'delimiter', $delimiter);
	$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_INPUT_GPC);
	- $source = rcube_utils::get_input_value('source', RCUBE_INPUT_GPC);
	+ $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_INPUT_GPC));
	+ $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_INPUT_GPC);
	+ $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(get_input_value('_source', RCUBE_INPUT_GPC, true, 'UTF7-IMAP'));
	+ $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 e8f7c03b..e154c75a 100644
	--- a/plugins/kolab_addressbook/lib/kolab_addressbook_ui.php
	+++ b/plugins/kolab_addressbook/lib/kolab_addressbook_ui.php
	@@ -1,303 +1,303 @@
	<?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)) {
	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 (is_readable($this->plugin->api->dir . 'libkolab/js/folderlist.js')) {
	$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');
	}
	// 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(get_input_value('_act', RCUBE_INPUT_GPC));
	- $folder = trim(get_input_value('_source', RCUBE_INPUT_GPC, true)); // UTF8
	+ $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, RCMAIL_CHARSET, 'UTF7-IMAP');
	$storage = $this->rc->get_storage();
	$delim = $storage->get_hierarchy_delimiter();

	if ($this->rc->action == 'plugin.book-save') {
	// save error
	- $name = trim(get_input_value('_name', RCUBE_INPUT_GPC, true)); // UTF8
	- $old = trim(get_input_value('_oldname', RCUBE_INPUT_GPC, true)); // UTF7-IMAP
	- $path_imap = trim(get_input_value('_parent', RCUBE_INPUT_GPC, true)); // UTF7-IMAP
	+ $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, ' » ', 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";
	}
	}
	}
	else {
	$content = $this->get_form_part($tab);
	}

	if ($content) {
	$out .= html::tag('fieldset', null, html::tag('legend', null, Q($tab['name'])) . $content) ."\n";
	}
	}

	$out .= "\n$form_end";

	return $out;
	}


	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(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_delegation/kolab_delegation.php b/plugins/kolab_delegation/kolab_delegation.php
	index a43fb5dd..8596009e 100644
	--- a/plugins/kolab_delegation/kolab_delegation.php
	+++ b/plugins/kolab_delegation/kolab_delegation.php
	@@ -1,545 +1,545 @@
	<?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'])) {
	$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 = get_input_value('id', RCUBE_INPUT_GPC);
	- $success = $engine->delegate_delete($id, (bool) get_input_value('acl', RCUBE_INPUT_GPC));
	+ $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 = get_input_value('id', RCUBE_INPUT_GPC);
	- $acl = get_input_value('folders', RCUBE_INPUT_GPC);
	+ $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 = get_input_value('newid', RCUBE_INPUT_GPC);
	+ $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 = get_input_value('_search', RCUBE_INPUT_GPC, true);
	- $reqid = get_input_value('_reqid', RCUBE_INPUT_GPC);
	+ $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));
	}

	$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 = get_input_value('_id', RCUBE_INPUT_GPC);
	+ $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);

	$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 = get_input_value('_id', RCUBE_INPUT_GPC);
	+ $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 »\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].' » ') === 0) {
	$length = strlen($names[$i].' » ');
	$prefix = substr($foldername, 0, $length);
	$count = count(explode(' » ', $prefix));
	$foldername = str_repeat('  ', $count-1) . '» ' . substr($foldername, $length);
	break;
	}
	}

	$folder_id = 'rcmf' . 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_folders/kolab_folders.php b/plugins/kolab_folders/kolab_folders.php
	index 2acf5c5f..b3c2e8ef 100644
	--- a/plugins/kolab_folders/kolab_folders.php
	+++ b/plugins/kolab_folders/kolab_folders.php
	@@ -1,638 +1,638 @@
	<?php

	/**
	* Type-aware folder management/listing for Kolab
	*
	* @version @package_version@
	* @author Aleksander Machniak <machniak@kolabsys.com>
	*
	* Copyright (C) 2011, Kolab Systems AG <contact@kolabsys.com>
	*
	* This program is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Affero General Public License as
	* published by the Free Software Foundation, either version 3 of the
	* License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU Affero General Public License for more details.
	*
	* You should have received a copy of the GNU Affero General Public License
	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	*/

	class kolab_folders extends rcube_plugin
	{
	public $task = '?(?!login).*';

	public $types = array('mail', 'event', 'journal', 'task', 'note', 'contact', 'configuration', 'file', 'freebusy');
	public $subtypes = array(
	'mail' => array('inbox', 'drafts', 'sentitems', 'outbox', 'wastebasket', 'junkemail'),
	'event' => array('default', 'confidential'),
	'task' => array('default', 'confidential'),
	'journal' => array('default'),
	'note' => array('default'),
	'contact' => array('default'),
	'configuration' => array('default'),
	'file' => array('default'),
	'freebusy' => array('default'),
	);
	public $act_types = array('event', 'task');

	private $rc;
	private static $instance;


	/**
	* Plugin initialization.
	*/
	function init()
	{
	self::$instance = $this;
	$this->rc = rcube::get_instance();

	// load required plugin
	$this->require_plugin('libkolab');

	// Folder listing hooks
	$this->add_hook('storage_folders', array($this, 'mailboxes_list'));

	// Folder manager hooks
	$this->add_hook('folder_form', array($this, 'folder_form'));
	$this->add_hook('folder_update', array($this, 'folder_save'));
	$this->add_hook('folder_create', array($this, 'folder_save'));
	$this->add_hook('folder_delete', array($this, 'folder_save'));
	$this->add_hook('folder_rename', array($this, 'folder_save'));
	$this->add_hook('folders_list', array($this, 'folders_list'));

	// Special folders setting
	$this->add_hook('preferences_save', array($this, 'prefs_save'));
	}

	/**
	* Handler for mailboxes_list hook. Enables type-aware lists filtering.
	*/
	function mailboxes_list($args)
	{
	// infinite loop prevention
	if ($this->is_processing) {
	return $args;
	}

	if (!$this->metadata_support()) {
	return $args;
	}

	$this->is_processing = true;

	// get folders
	$folders = kolab_storage::list_folders($args['root'], $args['name'], $args['filter'], $args['mode'] == 'LSUB', $folderdata);

	$this->is_processing = false;

	if (!is_array($folders)) {
	return $args;
	}

	// Create default folders
	if ($args['root'] == '' && $args['name'] = '*') {
	$this->create_default_folders($folders, $args['filter'], $folderdata, $args['mode'] == 'LSUB');
	}

	$args['folders'] = $folders;

	return $args;
	}

	/**
	* Handler for folders_list hook. Add css classes to folder rows.
	*/
	function folders_list($args)
	{
	if (!$this->metadata_support()) {
	return $args;
	}

	// load translations
	$this->add_texts('localization/', false);

	// Add javascript script to the client
	$this->include_script('kolab_folders.js');

	$this->add_label('folderctype');
	foreach ($this->types as $type) {
	$this->add_label('foldertype' . $type);
	}

	$skip_namespace = $this->rc->config->get('kolab_skip_namespace');
	$skip_roots = array();

	if (!empty($skip_namespace)) {
	$storage = $this->rc->get_storage();
	foreach ((array)$skip_namespace as $ns) {
	foreach((array)$storage->get_namespace($ns) as $root) {
	$skip_roots[] = rtrim($root[0], $root[1]);
	}
	}
	}

	$this->rc->output->set_env('skip_roots', $skip_roots);
	$this->rc->output->set_env('foldertypes', $this->types);

	// get folders types
	$folderdata = kolab_storage::folders_typedata();

	if (!is_array($folderdata)) {
	return $args;
	}

	// Add type-based style for table rows
	// See kolab_folders::folder_class_name()
	if ($table = $args['table']) {
	for ($i=1, $cnt=$table->size(); $i<=$cnt; $i++) {
	$attrib = $table->get_row_attribs($i);
	$folder = $attrib['foldername']; // UTF7-IMAP
	$type = $folderdata[$folder];

	if (!$type) {
	$type = 'mail';
	}

	$class_name = self::folder_class_name($type);
	$attrib['class'] = trim($attrib['class'] . ' ' . $class_name);
	$table->set_row_attribs($attrib, $i);
	}
	}

	// Add type-based class for list items
	if (is_array($args['list'])) {
	foreach ((array)$args['list'] as $k => $item) {
	$folder = $item['folder_imap']; // UTF7-IMAP
	$type = $folderdata[$folder];

	if (!$type) {
	$type = 'mail';
	}

	$class_name = self::folder_class_name($type);
	$args['list'][$k]['class'] = trim($item['class'] . ' ' . $class_name);
	}
	}

	return $args;
	}

	/**
	* Handler for folder info/edit form (folder_form hook).
	* Adds folder type selector.
	*/
	function folder_form($args)
	{
	if (!$this->metadata_support()) {
	return $args;
	}
	// load translations
	$this->add_texts('localization/', false);

	// INBOX folder is of type mail.inbox and this cannot be changed
	if ($args['name'] == 'INBOX') {
	$args['form']['props']['fieldsets']['settings']['content']['foldertype'] = array(
	'label' => $this->gettext('folderctype'),
	'value' => sprintf('%s (%s)', $this->gettext('foldertypemail'), $this->gettext('inbox')),
	);

	return $args;
	}

	if ($args['options']['is_root']) {
	return $args;
	}

	$mbox = strlen($args['name']) ? $args['name'] : $args['parent_name'];

	if (isset($_POST['_ctype'])) {
	- $new_ctype = trim(get_input_value('_ctype', RCUBE_INPUT_POST));
	- $new_subtype = trim(get_input_value('_subtype', RCUBE_INPUT_POST));
	+ $new_ctype = trim(rcube_utils::get_input_value('_ctype', rcube_utils::INPUT_POST));
	+ $new_subtype = trim(rcube_utils::get_input_value('_subtype', rcube_utils::INPUT_POST));
	}

	// Get type of the folder or the parent
	if (strlen($mbox)) {
	list($ctype, $subtype) = $this->get_folder_type($mbox);
	if (strlen($args['parent_name']) && $subtype == 'default')
	$subtype = ''; // there can be only one
	}

	if (!$ctype) {
	$ctype = 'mail';
	}

	$storage = $this->rc->get_storage();

	// Don't allow changing type of shared folder, according to ACL
	if (strlen($mbox)) {
	$options = $storage->folder_info($mbox);
	if ($options['namespace'] != 'personal' && !in_array('a', (array)$options['rights'])) {
	if (in_array($ctype, $this->types)) {
	$value = $this->gettext('foldertype'.$ctype);
	}
	else {
	$value = $ctype;
	}
	if ($subtype) {
	$value .= ' ('. ($subtype == 'default' ? $this->gettext('default') : $subtype) .')';
	}

	$args['form']['props']['fieldsets']['settings']['content']['foldertype'] = array(
	'label' => $this->gettext('folderctype'),
	'value' => $value,
	);

	return $args;
	}
	}

	// Add javascript script to the client
	$this->include_script('kolab_folders.js');

	// build type SELECT fields
	$type_select = new html_select(array('name' => '_ctype', 'id' => '_ctype'));
	$sub_select = new html_select(array('name' => '_subtype', 'id' => '_subtype'));
	$sub_select->add('', '');

	foreach ($this->types as $type) {
	$type_select->add($this->gettext('foldertype'.$type), $type);
	}
	// add non-supported type
	if (!in_array($ctype, $this->types)) {
	$type_select->add($ctype, $ctype);
	}

	$sub_types = array();
	foreach ($this->subtypes as $ftype => $subtypes) {
	$sub_types[$ftype] = array_combine($subtypes, array_map(array($this, 'gettext'), $subtypes));

	// fill options for the current folder type
	if ($ftype == $ctype \|\| $ftype == $new_ctype) {
	$sub_select->add(array_values($sub_types[$ftype]), $subtypes);
	}
	}

	$args['form']['props']['fieldsets']['settings']['content']['foldertype'] = array(
	'label' => $this->gettext('folderctype'),
	'value' => $type_select->show(isset($new_ctype) ? $new_ctype : $ctype)
	. $sub_select->show(isset($new_subtype) ? $new_subtype : $subtype),
	);

	$this->rc->output->set_env('kolab_folder_subtypes', $sub_types);
	$this->rc->output->set_env('kolab_folder_subtype', isset($new_subtype) ? $new_subtype : $subtype);

	return $args;
	}

	/**
	* Handler for folder update/create action (folder_update/folder_create hook).
	*/
	function folder_save($args)
	{
	// Folder actions from folders list
	if (empty($args['record'])) {
	return $args;
	}

	// Folder create/update with form
	- $ctype = trim(get_input_value('_ctype', RCUBE_INPUT_POST));
	- $subtype = trim(get_input_value('_subtype', RCUBE_INPUT_POST));
	+ $ctype = trim(rcube_utils::get_input_value('_ctype', rcube_utils::INPUT_POST));
	+ $subtype = trim(rcube_utils::get_input_value('_subtype', rcube_utils::INPUT_POST));
	$mbox = $args['record']['name'];
	$old_mbox = $args['record']['oldname'];
	$subscribe = $args['record']['subscribe'];

	if (empty($ctype)) {
	return $args;
	}

	// load translations
	$this->add_texts('localization/', false);

	// Skip folder creation/rename in core
	// @TODO: Maybe we should provide folder_create_after and folder_update_after hooks?
	// Using create_mailbox/rename_mailbox here looks bad
	$args['abort'] = true;

	// There can be only one default folder of specified type
	if ($subtype == 'default') {
	$default = $this->get_default_folder($ctype);

	if ($default !== null && $old_mbox != $default) {
	$args['result'] = false;
	$args['message'] = $this->gettext('defaultfolderexists');
	return $args;
	}
	}
	// Subtype sanity-checks
	else if ($subtype && (!($subtypes = $this->subtypes[$ctype]) \|\| !in_array($subtype, $subtypes))) {
	$subtype = '';
	}

	$ctype .= $subtype ? '.'.$subtype : '';

	$storage = $this->rc->get_storage();

	// Create folder
	if (!strlen($old_mbox)) {
	// By default don't subscribe to non-mail folders
	if ($subscribe)
	$subscribe = (bool) preg_match('/^mail/', $ctype);

	$result = $storage->create_folder($mbox, $subscribe);
	// Set folder type
	if ($result) {
	$this->set_folder_type($mbox, $ctype);
	}
	}
	// Rename folder
	else {
	if ($old_mbox != $mbox) {
	$result = $storage->rename_folder($old_mbox, $mbox);
	}
	else {
	$result = true;
	}

	if ($result) {
	list($oldtype, $oldsubtype) = $this->get_folder_type($mbox);
	$oldtype .= $oldsubtype ? '.'.$oldsubtype : '';

	if ($ctype != $oldtype) {
	$this->set_folder_type($mbox, $ctype);
	}
	}
	}

	$args['record']['class'] = self::folder_class_name($ctype);
	$args['record']['subscribe'] = $subscribe;
	$args['result'] = $result;

	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'] != 'folders') {
	return $args;
	}

	$dont_override = (array) $this->rc->config->get('dont_override', array());

	// map config option name to kolab folder type annotation
	$opts = array(
	'drafts_mbox' => 'mail.drafts',
	'sent_mbox' => 'mail.sentitems',
	'junk_mbox' => 'mail.junkemail',
	'trash_mbox' => 'mail.wastebasket',
	);

	// check if any of special folders has been changed
	foreach ($opts as $opt_name => $type) {
	$new = $args['prefs'][$opt_name];
	$old = $this->rc->config->get($opt_name);
	if (!strlen($new) \|\| $new === $old \|\| in_array($opt_name, $dont_override)) {
	unset($opts[$opt_name]);
	}
	}

	if (empty($opts)) {
	return $args;
	}

	$folderdata = kolab_storage::folders_typedata();

	if (!is_array($folderdata)) {
	return $args;
	}

	foreach ($opts as $opt_name => $type) {
	$foldername = $args['prefs'][$opt_name];

	// get all folders of specified type
	$folders = array_intersect($folderdata, array($type));

	// folder already annotated with specified type
	if (!empty($folders[$foldername])) {
	continue;
	}

	// set type to the new folder
	$this->set_folder_type($foldername, $type);

	// unset old folder(s) type annotation
	list($maintype, $subtype) = explode('.', $type);
	foreach (array_keys($folders) as $folder) {
	$this->set_folder_type($folder, $maintype);
	}
	}

	return $args;
	}

	/**
	* Checks if IMAP server supports any of METADATA, ANNOTATEMORE, ANNOTATEMORE2
	*
	* @return boolean
	*/
	function metadata_support()
	{
	$storage = $this->rc->get_storage();

	return $storage->get_capability('METADATA') \|\|
	$storage->get_capability('ANNOTATEMORE') \|\|
	$storage->get_capability('ANNOTATEMORE2');
	}

	/**
	* Checks if IMAP server supports any of METADATA, ANNOTATEMORE, ANNOTATEMORE2
	*
	* @param string $folder Folder name
	*
	* @return array Folder content-type
	*/
	function get_folder_type($folder)
	{
	return explode('.', (string)kolab_storage::folder_type($folder));
	}

	/**
	* Sets folder content-type.
	*
	* @param string $folder Folder name
	* @param string $type Content type
	*
	* @return boolean True on success
	*/
	function set_folder_type($folder, $type = 'mail')
	{
	return kolab_storage::set_folder_type($folder, $type);
	}

	/**
	* Returns the name of default folder
	*
	* @param string $type Folder type
	*
	* @return string Folder name
	*/
	function get_default_folder($type)
	{
	$folderdata = kolab_storage::folders_typedata();

	if (!is_array($folderdata)) {
	return null;
	}

	// get all folders of specified type
	$folderdata = array_intersect($folderdata, array($type.'.default'));

	return key($folderdata);
	}

	/**
	* Returns CSS class name for specified folder type
	*
	* @param string $type Folder type
	*
	* @return string Class name
	*/
	static function folder_class_name($type)
	{
	list($ctype, $subtype) = explode('.', $type);

	$class[] = 'type-' . ($ctype ? $ctype : 'mail');

	if ($subtype)
	$class[] = 'subtype-' . $subtype;

	return implode(' ', $class);
	}

	/**
	* Creates default folders if they doesn't exist
	*/
	private function create_default_folders(&$folders, $filter, $folderdata = null, $lsub = false)
	{
	$storage = $this->rc->get_storage();
	$namespace = $storage->get_namespace();
	$defaults = array();
	$prefix = '';

	// Find personal namespace prefix
	if (is_array($namespace['personal']) && count($namespace['personal']) == 1) {
	$prefix = $namespace['personal'][0][0];
	}

	$this->load_config();

	// get configured defaults
	foreach ($this->types as $type) {
	foreach ((array)$this->subtypes[$type] as $subtype) {
	$opt_name = 'kolab_folders_' . $type . '_' . $subtype;
	if ($folder = $this->rc->config->get($opt_name)) {
	// convert configuration value to UTF7-IMAP charset
	$folder = rcube_charset::convert($folder, RCUBE_CHARSET, 'UTF7-IMAP');
	// and namespace prefix if needed
	if ($prefix && strpos($folder, $prefix) === false && $folder != 'INBOX') {
	$folder = $prefix . $folder;
	}
	$defaults[$type . '.' . $subtype] = $folder;
	}
	}
	}

	if (empty($defaults)) {
	return;
	}

	if ($folderdata === null) {
	$folderdata = kolab_storage::folders_typedata();
	}

	if (!is_array($folderdata)) {
	return;
	}

	// find default folders
	foreach ($defaults as $type => $foldername) {
	// get all folders of specified type
	$_folders = array_intersect($folderdata, array($type));

	// default folder found
	if (!empty($_folders)) {
	continue;
	}

	list($type1, $type2) = explode('.', $type);

	$activate = in_array($type1, $this->act_types);
	$exists = false;
	$result = false;

	// check if folder exists
	if (!empty($folderdata[$foldername]) \|\| $foldername == 'INBOX') {
	$exists = true;
	}
	else if ((!$filter \|\| $filter == $type1) && in_array($foldername, $folders)) {
	// this assumes also that subscribed folder exists
	$exists = true;
	}
	else {
	$exists = $storage->folder_exists($foldername);
	}

	// create folder
	if (!$exists) {
	$exists = $storage->create_folder($foldername);
	}

	// set type + subscribe + activate
	if ($exists) {
	if ($result = kolab_storage::set_folder_type($foldername, $type)) {
	// check if folder is subscribed
	if ((!$filter \|\| $filter == $type1) && $lsub && in_array($foldername, $folders)) {
	// already subscribed
	$subscribed = true;
	}
	else {
	$subscribed = $storage->subscribe($foldername);
	}

	// activate folder
	if ($activate) {
	kolab_storage::folder_activate($foldername, true);
	}
	}
	}

	// add new folder to the result
	if ($result && (!$filter \|\| $filter == $type1) && (!$lsub \|\| $subscribed)) {
	$folders[] = $foldername;
	}
	}
	}

	/**
	* Static getter for default folder of the given type
	*
	* @param string $type Folder type
	* @return string Folder name
	*/
	public static function default_folder($type)
	{
	return self::$instance->get_default_folder($type);
	}
	}
	diff --git a/plugins/kolab_notes/kolab_notes.php b/plugins/kolab_notes/kolab_notes.php
	index 9637be28..259f26d6 100644
	--- a/plugins/kolab_notes/kolab_notes.php
	+++ b/plugins/kolab_notes/kolab_notes.php
	@@ -1,1261 +1,1261 @@
	<?php

	/**
	* Kolab notes module
	*
	* Adds simple notes management features to the web client
	*
	* @version @package_version@
	* @author Thomas Bruederli <bruederli@kolabsys.com>
	*
	* Copyright (C) 2014, Kolab Systems AG <contact@kolabsys.com>
	*
	* 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();

	/**
	* 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('notes_disabled', false) \|\| !$this->rc->config->get('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();
	}

	// 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,
	'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,
	'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;
	$readonly = false;
	$alarms = true;
	}
	else {
	$alarms = false;
	$readonly = true;
	if (($rights = $folder->get_myrights()) && !PEAR::isError($rights)) {
	if (strpos($rights, 'i') !== false)
	$readonly = false;
	}
	$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' => !$readonly,
	'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_INPUT_GPC, true)) {
	+ 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($this->get_message_reference(kolab_storage_config::get_message_uri($message, $folder))),
	));
	}
	}

	$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_INPUT_GPC, true);
	- $list = rcube_utils::get_input_value('_list', RCUBE_INPUT_GPC);
	+ $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_INPUT_GPC),
	- 'list' => rcube_utils::get_input_value('_list', RCUBE_INPUT_GPC),
	+ '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
	$me = $this;
	$note['links'] = array_map(function($link) use ($me, $resolve) {
	return $me->get_message_reference($link, $resolve) ?: 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_INPUT_POST);
	- $note = rcube_utils::get_input_value('_data', RCUBE_INPUT_POST, true);
	+ $action = rcube_utils::get_input_value('_do', rcube_utils::INPUT_POST);
	+ $note = rcube_utils::get_input_value('_data', rcube_utils::INPUT_POST, true);

	$success = false;
	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;
	}

	// show confirmation/error message
	if ($success) {
	$this->rc->output->show_message('successfullysaved', 'confirmation');
	}
	else {
	$this->rc->output->show_message('errorsaving', 'error');
	}

	// unlock client
	$this->rc->output->command('plugin.unlock_saving');

	if ($refresh) {
	$this->rc->output->command('plugin.update_note', $this->_client_encode($refresh));
	}
	}

	/**
	* Update an note record with the given data
	*
	* @param array Hash array with note properties (id, list)
	* @return boolean True on success, False on error
	*/
	private function save_note(&$note)
	{
	$this->_read_lists();

	$list_id = $note['list'];
	if (!$list_id \|\| !($folder = $this->get_folder($list_id)))
	return false;

	// moved from another folder
	if ($note['_fromlist'] && ($fromfolder = $this->get_folder($note['_fromlist']))) {
	if (!$fromfolder->move($note['uid'], $folder->name))
	return false;

	unset($note['_fromlist']);
	}

	// load previous version of this record to merge
	if ($note['uid']) {
	$old = $folder->get_object($note['uid']);
	if (!$old \|\| PEAR::isError($old))
	return false;

	// merge existing properties if the update isn't complete
	if (!isset($note['title']) \|\| !isset($note['description']))
	$note += $old;
	}

	// generate new note object from input
	$object = $this->_write_preprocess($note, $old);

	// email links and tags are handled separately
	$links = $object['links'];
	$tags = $object['tags'];

	unset($object['links']);
	unset($object['tags']);

	$saved = $folder->save($object, 'note', $note['uid']);

	if (!$saved) {
	raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Error saving note object to Kolab server"),
	true, false);
	$saved = false;
	}
	else {
	// save links in configuration.relation object
	$this->save_links($object['uid'], $links);
	// save tags in configuration.relation object
	$this->save_tags($object['uid'], $tags);

	$note = $object;
	$note['list'] = $list_id;
	$note['tags'] = (array) $tags;

	// cache this in memory for later read
	$key = $list_id . ':' . $note['uid'];
	$this->cache[$key] = $note;
	}

	return $saved;
	}

	/**
	* Move the given note to another folder
	*/
	function move_note($note, $list_id)
	{
	$this->_read_lists();

	$tofolder = $this->get_folder($list_id);
	$fromfolder = $this->get_folder($note['list']);

	if ($fromfolder && $tofolder) {
	return $fromfolder->move($note['uid'], $tofolder->name);
	}

	return false;
	}

	/**
	* Remove a single note record from the backend
	*
	* @param array Hash array with note properties (id, list)
	* @param boolean Remove record irreversible (mark as deleted otherwise)
	* @return boolean True on success, False on error
	*/
	public function delete_note($note, $force = true)
	{
	$this->_read_lists();

	$list_id = $note['list'];
	if (!$list_id \|\| !($folder = $this->get_folder($list_id))) {
	return false;
	}

	$status = $folder->delete($note['uid'], $force);

	if ($status) {
	$this->save_links($note['uid'], null);
	$this->save_tags($note['uid'], null);
	}

	return $status;
	}

	/**
	* Handler for client requests to list (aka folder) actions
	*/
	public function list_action()
	{
	- $action = rcube_utils::get_input_value('_do', RCUBE_INPUT_GPC);
	- $list = rcube_utils::get_input_value('_list', RCUBE_INPUT_GPC, true);
	+ $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_INPUT_GPC);
	+ $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('   ', count($path_imap)) . '» ' . $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_INPUT_GPC), rcube_utils::get_input_value('source', RCUBE_INPUT_GPC)) as $id => $prop) {
	+ 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_INPUT_GPC));
	+ $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'];
	$attachments = array();
	foreach ($uids as $uid) {
	if ($note = $this->get_note(array('uid' => $uid, 'list' => $list))) {
	$args['attachments'][] = array(
	'name' => abbreviate_string($note['title'], 50, ''),
	'mimetype' => 'message/rfc822',
	'data' => $this->note2message($note),
	);

	if (empty($args['param']['subject'])) {
	$args['param']['subject'] = $note['title'];
	}
	}
	}

	unset($args['param']['with_notes'], $args['param']['notes_list']);
	}

	return $args;
	}

	/**
	* Lookup backend storage and find notes associated with the given message
	*/
	public function mail_message_load($p)
	{
	if (!$p['object']->headers->others['x-kolab-type']) {
	$this->message_notes = $this->get_message_notes($p['object']->headers, $p['object']->folder);
	}
	}

	/**
	* Handler for 'messagebody_html' hook
	*/
	public function mail_messagebody_html($args)
	{
	$html = '';
	foreach ($this->message_notes as $note) {
	$html .= html::a(array(
	'href' => $this->rc->url(array('task' => 'notes', '_list' => $note['list'], '_id' => $note['uid'])),
	'class' => 'kolabnotesref',
	'rel' => $note['uid'] . '@' . $note['list'],
	'target' => '_blank',
	), Q($note['title']));
	}

	// prepend note links to message body
	if ($html) {
	$this->load_ui();
	$args['content'] = html::div('kolabmessagenotes', $html) . $args['content'];
	}

	return $args;
	}

	/**
	* Determine whether the given note is HTML formatted
	*/
	private function is_html($note)
	{
	// check for opening and closing <html> or <body> tags
	return (preg_match('/<(html\|body)(\s+[a-z]\|>)/', $note['description'], $m) && strpos($note['description'], '</'.$m[1].'>') > 0);
	}

	/**
	* Build an RFC 822 message from the given note
	*/
	private function note2message($note)
	{
	$message = new Mail_mime("\r\n");

	$message->setParam('text_encoding', '8bit');
	$message->setParam('html_encoding', 'quoted-printable');
	$message->setParam('head_encoding', 'quoted-printable');
	$message->setParam('head_charset', RCUBE_CHARSET);
	$message->setParam('html_charset', RCUBE_CHARSET);
	$message->setParam('text_charset', RCUBE_CHARSET);

	$message->headers(array(
	'Subject' => $note['title'],
	'Date' => $note['changed']->format('r'),
	));

	if ($this->is_html($note)) {
	$message->setHTMLBody($note['description']);

	// add a plain text version of the note content as an alternative part.
	$h2t = new rcube_html2text($note['description'], false, true, 0, RCUBE_CHARSET);
	$plain_part = rcube_mime::wordwrap($h2t->get_text(), $this->rc->config->get('line_length', 72), "\r\n", false, RCUBE_CHARSET);
	$plain_part = trim(wordwrap($plain_part, 998, "\r\n", true));

	// make sure all line endings are CRLF
	$plain_part = preg_replace('/\r?\n/', "\r\n", $plain_part);

	$message->setTXTBody($plain_part);
	}
	else {
	$message->setTXTBody($note['description']);
	}

	return $message->getMessage();
	}

	private function save_links($uid, $links)
	{
	$config = kolab_storage_config::get_instance();
	$search = kolab_storage_config::build_member_url($uid);
	$relations = $this->get_relations($uid);

	// @TODO: here we support only one-way relations, i.e.
	// such relation can contain only note and mail members
	// So, when we remove a note member the whole relation
	// will be removed

	foreach ($relations as $relation) {
	if (empty($links)) {
	$config->delete($relation['uid']);
	}
	else {
	// make relation members up-to-date
	kolab_storage_config::resolve_members($relation);

	// assign all links to one relation, others will be removed
	$members = array_merge($links, array($search));
	$diff1 = array_diff($members, $relation['members']);
	$diff1 = array_diff($relation['members'], $members);

	if (count($diff1) \|\| count($diff2)) {
	$relation['members'] = $members;
	$config->save($relation, 'relation');
	}

	$links = null;
	}
	}

	// create a new relation
	if (!empty($links)) {
	$relation = array(
	'members' => array_merge($links, array($search)),
	'category' => 'generic',
	);

	$config->save($relation, 'relation');
	}
	}

	/**
	* Find messages assigned to specified note
	*/
	private function get_links($uid)
	{
	$result = array();
	$search = kolab_storage_config::build_member_url($uid);

	foreach ($this->get_relations($uid) as $relation) {
	if (in_array($search, (array) $relation['members'])) {
	// make relation members up-to-date
	kolab_storage_config::resolve_members($relation);

	foreach ($relation['members'] as $member) {
	if ($member != $search) {
	$result[] = $member;
	}
	}
	}
	}

	return array_unique($result);
	}

	/**
	* 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;
	}

	/**
	* Find relation objects referring to specified note
	*/
	private function get_relations($uid)
	{
	$config = kolab_storage_config::get_instance();
	$default = true;
	$filter = array(
	array('type', '=', 'relation'),
	array('category', '=', 'generic'),
	array('member', '=', $uid),
	);

	return $config->get_objects($filter, $default, 100);
	}

	/**
	* Resolve the email message reference from the given URI
	*/
	public function get_message_reference($uri, $resolve = false)
	{
	if ($linkref = kolab_storage_config::parse_member_url($uri)) {
	$linkref['subject'] = $linkref['params']['subject'];
	$linkref['uri'] = $uri;
	$linkref['mailurl'] = $this->rc->url(array(
	'task' => 'mail',
	'action' => 'show',
	'mbox' => $linkref['folder'],
	'uid' => $linkref['uid'],
	'rel' => 'note',
	));

	unset($linkref['params']);
	}

	return $linkref;
	}

	/**
	* 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 817a228e..17269805 100644
	--- a/plugins/kolab_notes/kolab_notes_ui.php
	+++ b/plugins/kolab_notes/kolab_notes_ui.php
	@@ -1,437 +1,437 @@
	<?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->rc->output->include_script('list.js');
	$this->rc->output->include_script('treelist.js');
	$this->plugin->include_script('notes.js');
	$this->plugin->include_script('jquery.tagedit.js');

	// include kolab folderlist widget if available
	if (is_readable($this->plugin->api->dir . 'libkolab/js/folderlist.js')) {
	$this->plugin->api->include_script('libkolab/js/folderlist.js');
	}

	$this->plugin->include_stylesheet($this->plugin->local_skin_path() . '/tagedit.css');

	// 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_INPUT_GPC)) {
	+ 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_INPUT_GPC)) {
	+ 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');
	}

	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']) {
	$select->add($prop['name'], $prop['id']);
	}
	}
	else {
	$html .= html::tag('li', array('id' => 'rcmliknb' . rcube_utils::html_identifier($id), 'class' => $prop['group']),
	$this->folder_list_item($id, $prop, $jsenv)
	);
	}
	}
	}

	$this->rc->output->set_env('kolab_notebooks', $jsenv);
	$this->rc->output->add_gui_object('notebooks', $attrib['id']);

	return $attrib['type'] == 'select' ? $select->show() : html::tag('ul', $attrib, $html, html::$common_attrib);
	}

	/**
	* Return html for a structured list <ul> for the folder tree
	*/
	public function folder_tree_html($node, $data, &$jsenv, $attrib)
	{
	$out = '';
	foreach ($node->children as $folder) {
	$id = $folder->id;
	$prop = $data[$id];
	$is_collapsed = false; // TODO: determine this somehow?

	$content = $this->folder_list_item($id, $prop, $jsenv);

	if (!empty($folder->children)) {
	$content .= html::tag('ul', array('style' => ($is_collapsed ? "display:none;" : null)),
	$this->folder_tree_html($folder, $data, $jsenv, $attrib));
	}

	if (strlen($content)) {
	$out .= html::tag('li', array(
	'id' => 'rcmliknb' . rcube_utils::html_identifier($id),
	'class' => $prop['group'] . ($prop['virtual'] ? ' virtual' : ''),
	),
	$content);
	}
	}

	return $out;
	}

	/**
	* Helper method to build a tasklist item (HTML content and js data)
	*/
	public function folder_list_item($id, $prop, &$jsenv, $checkbox = false)
	{
	if (!$prop['virtual']) {
	unset($prop['user_id']);
	$jsenv[$id] = $prop;
	}

	$classes = array('folder');
	if ($prop['virtual']) {
	$classes[] = 'virtual';
	}
	else if (!$prop['editable']) {
	$classes[] = 'readonly';
	}
	if ($prop['subscribed']) {
	$classes[] = 'subscribed';
	}
	if ($prop['class']) {
	$classes[] = $prop['class'];
	}

	$title = $prop['title'] ?: ($prop['name'] != $prop['listname'] \|\| strlen($prop['name']) > 25 ?
	html_entity_decode($prop['name'], ENT_COMPAT, RCMAIL_CHARSET) : '');

	$label_id = 'nl:' . $id;
	$attr = $prop['virtual'] ? array('tabindex' => '0') : array('href' => $this->rc->url(array('_list' => $id)));
	return html::div(join(' ', $classes),
	html::a($attr + array('class' => 'listname', 'title' => $title, 'id' => $label_id), $prop['listname'] ?: $prop['name']) .
	($prop['virtual'] ? '' :
	($checkbox ?
	html::tag('input', array('type' => 'checkbox', 'name' => '_list[]', 'value' => $id, 'checked' => $prop['active'], 'aria-labelledby' => $label_id)) :
	''
	) .
	html::span('handle', '') .
	html::span('actions',
	(!$prop['default'] ?
	html::a(array('href' => '#', 'class' => 'remove', 'title' => $this->plugin->gettext('removelist')), ' ') :
	''
	) .
	(isset($prop['subscribed']) ?
	html::a(array('href' => '#', 'class' => 'subscribed', 'title' => $this->plugin->gettext('foldersubscribe'), 'role' => 'checkbox', 'aria-checked' => $prop['subscribed'] ? 'true' : 'false'), ' ') :
	''
	)
	)
	)
	);

	return '';
	}

	public function listing($attrib)
	{
	$attrib += array('id' => 'rcmkolabnoteslist');
	$this->rc->output->add_gui_object('noteslist', $attrib['id']);
	return html::tag('ul', $attrib, '', html::$common_attrib);
	}

	public function tagslist($attrib)
	{
	$attrib += array('id' => 'rcmkolabnotestagslist');
	$this->rc->output->add_gui_object('notestagslist', $attrib['id']);
	return html::tag('ul', $attrib, '', html::$common_attrib);
	}

	public function editform($attrib)
	{
	$attrib += array('action' => '#', 'id' => 'rcmkolabnoteseditform');

	$this->rc->output->add_gui_object('noteseditform', $attrib['id']);
	$this->rc->output->include_script('tinymce/tinymce.min.js');

	$textarea = new html_textarea(array('name' => 'content', 'id' => 'notecontent', 'cols' => 60, 'rows' => 20, 'tabindex' => 0));
	return html::tag('form', $attrib, $textarea->show(), array_merge(html::$common_attrib, array('action')));
	}

	public function detailview($attrib)
	{
	$attrib += array('id' => 'rcmkolabnotesdetailview');
	$this->rc->output->add_gui_object('notesdetailview', $attrib['id']);
	return html::div($attrib, '');
	}

	public function notetitle($attrib)
	{
	$attrib += array('id' => 'rcmkolabnotestitle');
	$this->rc->output->add_gui_object('noteviewtitle', $attrib['id']);

	$summary = new html_inputfield(array('name' => 'summary', 'class' => 'notetitle inline-edit', 'size' => 60, 'tabindex' => 0));

	$html = $summary->show();
	$html .= html::div(array('class' => 'tagline tagedit', 'style' => 'display:none'), ' ');
	$html .= html::div(array('class' => 'dates', 'style' => 'display:none'),
	html::label(array(), $this->plugin->gettext('created')) .
	html::span('notecreated', '') .
	html::label(array(), $this->plugin->gettext('changed')) .
	html::span('notechanged', '')
	);

	return html::div($attrib, $html);
	}

	public function attachments_list($attrib)
	{
	$attrib += array('id' => 'rcmkolabnotesattachmentslist');
	$this->rc->output->add_gui_object('notesattachmentslist', $attrib['id']);
	return html::tag('ul', $attrib, '', html::$common_attrib);
	}

	/**
	* Render edit for notes lists (folders)
	*/
	public function list_editform($action, $list, $folder)
	{
	if (is_object($folder)) {
	$folder_name = $folder->name; // UTF7
	}
	else {
	$folder_name = '';
	}

	$hidden_fields[] = array('name' => 'oldname', 'value' => $folder_name);

	$storage = $this->rc->get_storage();
	$delim = $storage->get_hierarchy_delimiter();
	$form = array();

	if (strlen($folder_name)) {
	$options = $storage->folder_info($folder_name);

	$path_imap = explode($delim, $folder_name);
	array_pop($path_imap); // pop off name part
	$path_imap = implode($path_imap, $delim);
	}
	else {
	$path_imap = '';
	$options = array();
	}

	// General tab
	$form['properties'] = array(
	'name' => $this->rc->gettext('properties'),
	'fields' => array(),
	);

	// folder name (default field)
	$input_name = new html_inputfield(array('name' => 'name', 'id' => 'noteslist-name', 'size' => 20));
	$form['properties']['fields']['name'] = array(
	'label' => $this->plugin->gettext('listname'),
	'value' => $input_name->show($list['editname'], array('disabled' => ($options['norename'] \|\| $options['protected']))),
	'id' => 'noteslist-name',
	);

	// prevent user from moving folder
	if (!empty($options) && ($options['norename'] \|\| $options['protected'])) {
	$hidden_fields[] = array('name' => 'parent', 'value' => $path_imap);
	}
	else {
	$select = kolab_storage::folder_selector('note', array('name' => 'parent', 'id' => 'parent-folder'), $folder_name);
	$form['properties']['fields']['path'] = array(
	'label' => $this->plugin->gettext('parentfolder'),
	'value' => $select->show(strlen($folder_name) ? $path_imap : ''),
	'id' => 'parent-folder',
	);
	}

	// add folder ACL tab
	if ($action != 'form-new') {
	$form['sharing'] = array(
	'name' => Q($this->plugin->gettext('tabsharing')),
	'content' => html::tag('iframe', array(
	'src' => $this->rc->url(array('_action' => 'folder-acl', '_folder' => $folder_name, 'framed' => 1)),
	'width' => '100%',
	'height' => 280,
	'border' => 0,
	'style' => 'border:0'),
	'')
	);
	}

	$form_html = '';
	if (is_array($hidden_fields)) {
	foreach ($hidden_fields as $field) {
	$hiddenfield = new html_hiddenfield($field);
	$form_html .= $hiddenfield->show() . "\n";
	}
	}

	// create form output
	foreach ($form as $tab) {
	if (is_array($tab['fields']) && empty($tab['content'])) {
	$table = new html_table(array('cols' => 2));
	foreach ($tab['fields'] as $col => $colprop) {
	$label = !empty($colprop['label']) ? $colprop['label'] : $this->plugin->gettext($col);

	$table->add('title', html::label($colprop['id'], Q($label)));
	$table->add(null, $colprop['value']);
	}
	$content = $table->show();
	}
	else {
	$content = $tab['content'];
	}

	if (!empty($content)) {
	$form_html .= html::tag('fieldset', null, html::tag('legend', null, Q($tab['name'])) . $content) . "\n";
	}
	}

	return html::tag('form', array('action' => "#", 'method' => "post", 'id' => "noteslistpropform"), $form_html);
	}

	/**
	* Handler to render ACL form for a notes folder
	*/
	public function folder_acl()
	{
	$this->plugin->require_plugin('acl');
	$this->rc->output->add_handler('folderacl', array($this, 'folder_acl_form'));
	$this->rc->output->send('kolab_notes.kolabacl');
	}

	/**
	* Handler for ACL form template object
	*/
	public function folder_acl_form()
	{
	- $folder = rcube_utils::get_input_value('_folder', RCUBE_INPUT_GPC);
	+ $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()
	{
	$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 6f38182f..e9d1170e 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 = get_input_value('cmd', RCUBE_INPUT_GPC);
	- $imei = get_input_value('id', RCUBE_INPUT_GPC);
	+ $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();
	- $syncmode = intval(get_input_value('syncmode', RCUBE_INPUT_POST));
	- $devicealias = get_input_value('devicealias', RCUBE_INPUT_POST, true);
	- $laxpic = intval(get_input_value('laxpic', RCUBE_INPUT_POST));
	- $subsciptions = get_input_value('subscribed', RCUBE_INPUT_POST);
	- $err = false;
	+ $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)));
	}

	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/tasklist/drivers/kolab/tasklist_kolab_driver.php b/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php
	index fe85d5c1..0e2ecab4 100644
	--- a/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php
	+++ b/plugins/tasklist/drivers/kolab/tasklist_kolab_driver.php
	@@ -1,1302 +1,1302 @@
	<?php

	/**
	* Kolab Groupware driver for the Tasklist plugin
	*
	* @version @package_version@
	* @author Thomas Bruederli <bruederli@kolabsys.com>
	*
	* Copyright (C) 2012, Kolab Systems AG <contact@kolabsys.com>
	*
	* This program is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Affero General Public License as
	* published by the Free Software Foundation, either version 3 of the
	* License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU Affero General Public License for more details.
	*
	* You should have received a copy of the GNU Affero General Public License
	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	*/

	class tasklist_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();


	/**
	* 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;

	$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, $delim, $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, $delim, $prefs)
	{
	if ($folder->get_namespace() == 'personal') {
	$norename = false;
	$readonly = false;
	$alarms = true;
	}
	else {
	$alarms = false;
	$readonly = true;
	if (($rights = $folder->get_myrights()) && !PEAR::isError($rights)) {
	if (strpos($rights, 'i') !== false)
	$readonly = false;
	}
	$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' => !$readonly,
	'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' : '')),
	);
	}

	/**
	* 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,
	'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,
	'group' => $folder->get_namespace(),
	'class' => 'folder',
	'parent' => $parent_id,
	);
	}
	else {
	if (!$this->lists[$list_id]) {
	$this->lists[$list_id] = $this->folder_props($folder, $delim, $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->get_storage()->get_hierarchy_delimiter(), $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, $this->rc->get_storage()->get_hierarchy_delimiter(), 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();

	$delim = $this->rc->get_storage()->get_hierarchy_delimiter();

	// 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, $delim, 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, $delim, array());

	foreach ($folders as $folder) {
	$this->folders[$folder->id] = $folder;
	$this->lists[$folder->id] = $this->folder_props($folder, $delim, 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);

	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);
	$task['list'] = $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)
	{
	$id = is_array($prop) ? ($prop['uid'] ?: $prop['id']) : $prop;
	$list_id = is_array($prop) ? $prop['list'] : null;
	$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);
	$this->tasks[$id]['list'] = $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('id' => $task['id'], 'list' => $task['list']);
	}

	$childs = array();
	$list_id = $prop['list'];
	$task_ids = array($prop['id']);
	$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[] = $record['uid'];
	$query_ids[] = $record['uid'];
	}
	}
	}

	if (!$recursive)
	break;

	$task_ids = $query_ids;
	}

	return $childs;
	}

	/**
	* 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);

	// 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);
	}

	/**
	* Convert from Kolab_Format to internal representation
	*/
	private function _to_rcube_task($record)
	{
	$task = array(
	'id' => $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'],
	'recurrence' => $record['recurrence'],
	'attendees' => $record['attendees'],
	'organizer' => $record['organizer'],
	'sequence' => $record['sequence'],
	'tags' => $record['tags'],
	);

	// 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;

	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']);
	}

	$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;

	// 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)) {
	unset($object['sequence']);
	}
	else if (isset($old['sequence'])) {
	$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)
	{
	$list_id = $task['list'];
	if (!$list_id \|\| !($folder = $this->get_folder($list_id)))
	return false;

	// tags are stored separately
	$tags = $task['tags'];
	unset($task['tags']);

	// moved from another folder
	if ($task['_fromlist'] && ($fromfolder = $this->get_folder($task['_fromlist']))) {
	if (!$fromfolder->move($task['id'], $folder->name))
	return false;

	unset($task['_fromlist']);
	}

	// load previous version of this task to merge
	if ($task['id']) {
	$old = $folder->get_object($task['id']);
	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);
	}

	// generate new task object from RC input
	$object = $this->_from_rcube_task($task, $old);
	$saved = $folder->save($object, 'task', $task['id']);

	if (!$saved) {
	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 tags in configuration.relation object
	$this->save_tags($object['uid'], $tags);

	$task = $this->_to_rcube_task($object);
	$task['list'] = $list_id;
	$task['tags'] = (array) $tags;
	$this->tasks[$task['id']] = $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)
	{
	$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['id'], $folder->name);
	}

	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)
	{
	$list_id = $task['list'];
	if (!$list_id \|\| !($folder = $this->get_folder($list_id)))
	return false;

	$status = $folder->delete($task['id']);

	if ($status) {
	// remove tag assignments
	// @TODO: don't do this when undelete feature will be implemented
	$this->save_tags($task['id'], 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
	*
	* @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)
	{
	$task['uid'] = $task['id'];
	$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
	*
	* @return string Attachment body
	*/
	public function get_attachment_body($id, $task)
	{
	if ($storage = $this->get_folder($task['list'])) {
	return $storage->get_attachment($task['id'], $id);
	}

	return false;
	}

	/**
	*
	*/
	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')),
	'content' => html::tag('iframe', array(
	'src' => $this->rc->url(array('_action' => 'folder-acl', '_folder' => $folder_name, 'framed' => 1)),
	'width' => '100%',
	'height' => 280,
	'border' => 0,
	'style' => 'border:0'),
	'')
	);
	}

	$form_html = '';
	if (is_array($hidden_fields)) {
	foreach ($hidden_fields as $field) {
	$hiddenfield = new html_hiddenfield($field);
	$form_html .= $hiddenfield->show() . "\n";
	}
	}

	// create form output
	foreach ($form as $tab) {
	if (is_array($tab['fields']) && empty($tab['content'])) {
	$table = new html_table(array('cols' => 2));
	foreach ($tab['fields'] as $col => $colprop) {
	$label = !empty($colprop['label']) ? $colprop['label'] : $this->plugin->gettext($col);

	$table->add('title', html::label($colprop['id'], Q($label)));
	$table->add(null, $colprop['value']);
	}
	$content = $table->show();
	}
	else {
	$content = $tab['content'];
	}

	if (!empty($content)) {
	$form_html .= html::tag('fieldset', null, html::tag('legend', null, Q($tab['name'])) . $content) . "\n";
	}
	}

	return $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_INPUT_GPC);
	+ $folder = rcube_utils::get_input_value('_folder', rcube_utils::INPUT_GPC);

	if (strlen($folder)) {
	$storage = $this->rc->get_storage();
	$options = $storage->folder_info($folder);

	// get sharing UI from acl plugin
	$acl = $this->rc->plugins->exec_hook('folder_form',
	array('form' => array(), 'options' => $options, 'name' => $folder));
	}

	return $acl['form']['sharing']['content'] ?: html::div('hint', $this->plugin->gettext('aclnorights'));
	}
	}
	diff --git a/plugins/tasklist/tasklist.php b/plugins/tasklist/tasklist.php
	index c5d50f2d..5824527f 100644
	--- a/plugins/tasklist/tasklist.php
	+++ b/plugins/tasklist/tasklist.php
	@@ -1,1929 +1,1932 @@
	<?php

	/**
	* Tasks plugin for Roundcube webmail
	*
	* @version @package_version@
	* @author Thomas Bruederli <bruederli@kolabsys.com>
	*
	* Copyright (C) 2012, Kolab Systems AG <contact@kolabsys.com>
	*
	* This program is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Affero General Public License as
	* published by the Free Software Foundation, either version 3 of the
	* License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU Affero General Public License for more details.
	*
	* You should have received a copy of the GNU Affero General Public License
	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	*/

	class tasklist extends rcube_plugin
	{
	const FILTER_MASK_TODAY = 1;
	const FILTER_MASK_TOMORROW = 2;
	const FILTER_MASK_WEEK = 4;
	const FILTER_MASK_LATER = 8;
	const FILTER_MASK_NODATE = 16;
	const FILTER_MASK_OVERDUE = 32;
	const FILTER_MASK_FLAGGED = 64;
	const FILTER_MASK_COMPLETE = 128;
	const FILTER_MASK_ASSIGNED = 256;
	const FILTER_MASK_MYTASKS = 512;

	const SESSION_KEY = 'tasklist_temp';

	public static $filter_masks = array(
	'today' => self::FILTER_MASK_TODAY,
	'tomorrow' => self::FILTER_MASK_TOMORROW,
	'week' => self::FILTER_MASK_WEEK,
	'later' => self::FILTER_MASK_LATER,
	'nodate' => self::FILTER_MASK_NODATE,
	'overdue' => self::FILTER_MASK_OVERDUE,
	'flagged' => self::FILTER_MASK_FLAGGED,
	'complete' => self::FILTER_MASK_COMPLETE,
	'assigned' => self::FILTER_MASK_ASSIGNED,
	'mytasks' => self::FILTER_MASK_MYTASKS,
	);

	public $task = '?(?!login\|logout).*';
	public $allowed_prefs = array('tasklist_sort_col','tasklist_sort_order');

	public $rc;
	public $lib;
	public $driver;
	public $timezone;
	public $ui;
	public $home; // declare public to be used in other classes

	private $collapsed_tasks = array();
	private $itip;
	private $ical;


	/**
	* Plugin initialization.
	*/
	function init()
	{
	$this->require_plugin('libcalendaring');

	$this->rc = rcube::get_instance();
	$this->lib = libcalendaring::get_instance();

	$this->register_task('tasks', 'tasklist');

	// load plugin configuration
	$this->load_config();

	$this->timezone = $this->lib->timezone;

	// proceed initialization in startup hook
	$this->add_hook('startup', array($this, 'startup'));

	$this->add_hook('user_delete', array($this, 'user_delete'));
	}

	/**
	* Startup hook
	*/
	public function startup($args)
	{
	// the tasks module can be enabled/disabled by the kolab_auth plugin
	if ($this->rc->config->get('tasklist_disabled', false) \|\| !$this->rc->config->get('tasklist_enabled', true))
	return;

	// load localizations
	$this->add_texts('localization/', $args['task'] == 'tasks' && (!$args['action'] \|\| $args['action'] == 'print'));
	$this->rc->load_language($_SESSION['language'], array('tasks.tasks' => $this->gettext('navtitle'))); // add label for task title

	if ($args['task'] == 'tasks' && $args['action'] != 'save-pref') {
	$this->load_driver();

	// register calendar actions
	$this->register_action('index', array($this, 'tasklist_view'));
	$this->register_action('task', array($this, 'task_action'));
	$this->register_action('tasklist', array($this, 'tasklist_action'));
	$this->register_action('counts', array($this, 'fetch_counts'));
	$this->register_action('fetch', array($this, 'fetch_tasks'));
	$this->register_action('inlineui', array($this, 'get_inline_ui'));
	$this->register_action('mail2task', array($this, 'mail_message2task'));
	$this->register_action('get-attachment', array($this, 'attachment_get'));
	$this->register_action('upload', array($this, 'attachment_upload'));
	$this->register_action('mailimportitip', array($this, 'mail_import_itip'));
	$this->register_action('mailimportattach', array($this, 'mail_import_attachment'));
	$this->register_action('itip-status', array($this, 'task_itip_status'));
	$this->register_action('itip-remove', array($this, 'task_itip_remove'));
	$this->register_action('itip-decline-reply', array($this, 'mail_itip_decline_reply'));
	$this->add_hook('refresh', array($this, 'refresh'));

	$this->collapsed_tasks = array_filter(explode(',', $this->rc->config->get('tasklist_collapsed_tasks', '')));
	}
	else if ($args['task'] == 'mail') {
	if ($args['action'] == 'show' \|\| $args['action'] == 'preview') {
	$this->add_hook('template_object_messagebody', array($this, 'mail_messagebody_html'));
	}

	// add 'Create event' item to message menu
	if ($this->api->output->type == 'html') {
	$this->api->add_content(html::tag('li', null,
	$this->api->output->button(array(
	'command' => 'tasklist-create-from-mail',
	'label' => 'tasklist.createfrommail',
	'type' => 'link',
	'classact' => 'icon taskaddlink active',
	'class' => 'icon taskaddlink',
	'innerclass' => 'icon taskadd',
	))),
	'messagemenu');

	$this->api->output->add_label('tasklist.createfrommail');
	}
	}

	if (!$this->rc->output->ajax_call && !$this->rc->output->env['framed']) {
	$this->load_ui();
	$this->ui->init();
	}

	// add hooks for alarms handling
	$this->add_hook('pending_alarms', array($this, 'pending_alarms'));
	$this->add_hook('dismiss_alarms', array($this, 'dismiss_alarms'));
	}

	/**
	*
	*/
	private function load_ui()
	{
	if (!$this->ui) {
	require_once($this->home . '/tasklist_ui.php');
	$this->ui = new tasklist_ui($this);
	}
	}

	/**
	* Helper method to load the backend driver according to local config
	*/
	private function load_driver()
	{
	if (is_object($this->driver))
	return;

	$driver_name = $this->rc->config->get('tasklist_driver', 'database');
	$driver_class = 'tasklist_' . $driver_name . '_driver';

	require_once($this->home . '/drivers/tasklist_driver.php');
	require_once($this->home . '/drivers/' . $driver_name . '/' . $driver_class . '.php');

	switch ($driver_name) {
	case "kolab":
	$this->require_plugin('libkolab');
	default:
	$this->driver = new $driver_class($this);
	break;
	}

	$this->rc->output->set_env('tasklist_driver', $driver_name);
	}


	/**
	* Dispatcher for task-related actions initiated by the client
	*/
	public function task_action()
	{
	- $filter = intval(get_input_value('filter', RCUBE_INPUT_GPC));
	- $action = get_input_value('action', RCUBE_INPUT_GPC);
	- $rec = get_input_value('t', RCUBE_INPUT_POST, true);
	+ $filter = intval(rcube_utils::get_input_value('filter', rcube_utils::INPUT_GPC));
	+ $action = rcube_utils::get_input_value('action', rcube_utils::INPUT_GPC);
	+ $rec = rcube_utils::get_input_value('t', rcube_utils::INPUT_POST, true);
	$oldrec = $rec;
	$success = $refresh = false;

	// force notify if hidden + active
	if ((int)$this->rc->config->get('calendar_itip_send_option', 3) === 1 && empty($rec['_reportpartstat']))
	$rec['_notify'] = 1;

	switch ($action) {
	case 'new':
	$oldrec = null;
	$rec = $this->prepare_task($rec);
	$rec['uid'] = $this->generate_uid();
	$temp_id = $rec['tempid'];
	if ($success = $this->driver->create_task($rec)) {
	$refresh = $this->driver->get_task($rec);
	if ($temp_id) $refresh['tempid'] = $temp_id;
	$this->cleanup_task($rec);
	}
	break;

	case 'edit':
	$rec = $this->prepare_task($rec);
	$clone = $this->handle_recurrence($rec, $this->driver->get_task($rec));
	if ($success = $this->driver->edit_task($rec)) {
	$refresh[] = $this->driver->get_task($rec);
	$this->cleanup_task($rec);

	// add clone from recurring task
	if ($clone && $this->driver->create_task($clone)) {
	$refresh[] = $this->driver->get_task($clone);
	$this->driver->clear_alarms($rec['id']);
	}

	// move all childs if list assignment was changed
	if (!empty($rec['_fromlist']) && !empty($rec['list']) && $rec['_fromlist'] != $rec['list']) {
	foreach ($this->driver->get_childs(array('id' => $rec['id'], 'list' => $rec['_fromlist']), true) as $cid) {
	$child = array('id' => $cid, 'list' => $rec['list'], '_fromlist' => $rec['_fromlist']);
	if ($this->driver->move_task($child)) {
	$r = $this->driver->get_task($child);
	if ((bool)($filter & self::FILTER_MASK_COMPLETE) == $this->driver->is_complete($r)) {
	$refresh[] = $r;
	}
	}
	}
	}
	}
	break;

	case 'move':
	foreach ((array)$rec['id'] as $id) {
	$r = $rec;
	$r['id'] = $id;
	if ($this->driver->move_task($r)) {
	$refresh[] = $this->driver->get_task($r);
	$success = true;

	// move all childs, too
	foreach ($this->driver->get_childs(array('id' => $rec['id'], 'list' => $rec['_fromlist']), true) as $cid) {
	$child = $rec;
	$child['id'] = $cid;
	if ($this->driver->move_task($child)) {
	$r = $this->driver->get_task($child);
	if ((bool)($filter & self::FILTER_MASK_COMPLETE) == $this->driver->is_complete($r)) {
	$refresh[] = $r;
	}
	}
	}
	}
	}
	break;

	case 'delete':
	- $mode = intval(get_input_value('mode', RCUBE_INPUT_POST));
	+ $mode = intval(rcube_utils::get_input_value('mode', rcube_utils::INPUT_POST));
	$oldrec = $this->driver->get_task($rec);
	if ($success = $this->driver->delete_task($rec, false)) {
	// delete/modify all childs
	foreach ($this->driver->get_childs($rec, $mode) as $cid) {
	$child = array('id' => $cid, 'list' => $rec['list']);

	if ($mode == 1) { // delete all childs
	if ($this->driver->delete_task($child, false)) {
	if ($this->driver->undelete)
	$_SESSION['tasklist_undelete'][$rec['id']][] = $cid;
	}
	else
	$success = false;
	}
	else {
	$child['parent_id'] = strval($oldrec['parent_id']);
	$this->driver->edit_task($child);
	}
	}
	// update parent task to adjust list of children
	if (!empty($oldrec['parent_id'])) {
	$refresh[] = $this->driver->get_task(array('id' => $oldrec['parent_id'], 'list' => $rec['list']));
	}
	}

	if (!$success)
	$this->rc->output->command('plugin.reload_data');
	break;

	case 'undelete':
	if ($success = $this->driver->undelete_task($rec)) {
	$refresh[] = $this->driver->get_task($rec);
	foreach ((array)$_SESSION['tasklist_undelete'][$rec['id']] as $cid) {
	if ($this->driver->undelete_task($rec)) {
	$refresh[] = $this->driver->get_task($rec);
	}
	}
	}
	break;

	case 'collapse':
	foreach (explode(',', $rec['id']) as $rec_id) {
	- if (intval(get_input_value('collapsed', RCUBE_INPUT_GPC))) {
	+ if (intval(rcube_utils::get_input_value('collapsed', rcube_utils::INPUT_GPC))) {
	$this->collapsed_tasks[] = $rec_id;
	}
	else {
	$i = array_search($rec_id, $this->collapsed_tasks);
	if ($i !== false)
	unset($this->collapsed_tasks[$i]);
	}
	}

	$this->rc->user->save_prefs(array('tasklist_collapsed_tasks' => join(',', array_unique($this->collapsed_tasks))));
	return; // avoid further actions

	case 'rsvp':
	- $status = get_input_value('status', RCUBE_INPUT_GPC);
	+ $status = rcube_utils::get_input_value('status', rcube_utils::INPUT_GPC);
	$task = $this->driver->get_task($rec);
	$task['attendees'] = $rec['attendees'];
	$rec = $task;

	if ($success = $this->driver->edit_task($rec)) {
	- $noreply = intval(get_input_value('noreply', RCUBE_INPUT_GPC)) \|\| $status == 'needs-action';
	+ $noreply = intval(rcube_utils::get_input_value('noreply', rcube_utils::INPUT_GPC)) \|\| $status == 'needs-action';

	if (!$noreply) {
	// let the reply clause further down send the iTip message
	$rec['_reportpartstat'] = $status;
	}
	}
	break;
	}

	if ($success) {
	$this->rc->output->show_message('successfullysaved', 'confirmation');
	$this->update_counts($oldrec, $refresh);
	}
	else {
	$this->rc->output->show_message('tasklist.errorsaving', 'error');
	}

	// send out notifications
	if ($success && $rec['_notify'] && ($rec['attendees'] \|\| $oldrec['attendees'])) {
	// make sure we have the complete record
	$task = $action == 'delete' ? $oldrec : $this->driver->get_task($rec);

	// only notify if data really changed (TODO: do diff check on client already)
	if (!$oldrec \|\| $action == 'delete' \|\| self::task_diff($task, $oldrec)) {
	$sent = $this->notify_attendees($task, $oldrec, $action, $rec['_comment']);
	if ($sent > 0)
	$this->rc->output->show_message('tasklist.itipsendsuccess', 'confirmation');
	else if ($sent < 0)
	$this->rc->output->show_message('tasklist.errornotifying', 'error');
	}
	}
	else if ($success && $rec['_reportpartstat'] && $rec['_reportpartstat'] != 'NEEDS-ACTION') {
	// get the full record after update
	$task = $this->driver->get_task($rec);

	// send iTip REPLY with the updated partstat
	if ($task['organizer'] && ($idx = $this->is_attendee($task)) !== false) {
	$sender = $task['attendees'][$idx];
	$status = strtolower($sender['status']);

	if (!empty($_POST['comment']))
	- $task['comment'] = get_input_value('comment', RCUBE_INPUT_POST);
	+ $task['comment'] = rcube_utils::get_input_value('comment', rcube_utils::INPUT_POST);

	$itip = $this->load_itip();
	$itip->set_sender_email($sender['email']);

	if ($itip->send_itip_message($this->to_libcal($task), 'REPLY', $task['organizer'], 'itipsubject' . $status, 'itipmailbody' . $status))
	$this->rc->output->command('display_message', $this->gettext(array('name' => 'sentresponseto', 'vars' => array('mailto' => $task['organizer']['name'] ?: $task['organizer']['email']))), 'confirmation');
	else
	$this->rc->output->command('display_message', $this->gettext('itipresponseerror'), 'error');
	}
	}

	// unlock client
	$this->rc->output->command('plugin.unlock_saving');

	if ($refresh) {
	if ($refresh['id']) {
	$this->encode_task($refresh);
	}
	else if (is_array($refresh)) {
	foreach ($refresh as $i => $r)
	$this->encode_task($refresh[$i]);
	}
	$this->rc->output->command('plugin.update_task', $refresh);
	}
	}

	/**
	* Load iTIP functions
	*/
	private function load_itip()
	{
	if (!$this->itip) {
	require_once realpath(__DIR__ . '/../libcalendaring/lib/libcalendaring_itip.php');
	$this->itip = new libcalendaring_itip($this, 'tasklist');
	$this->itip->set_rsvp_actions(array('accepted','declined'));
	$this->itip->set_rsvp_status(array('accepted','tentative','declined','delegated','in-process','completed'));
	}

	return $this->itip;
	}

	/**
	* repares new/edited task properties before save
	*/
	private function prepare_task($rec)
	{
	// try to be smart and extract date from raw input
	if ($rec['raw']) {
	foreach (array('today','tomorrow','sunday','monday','tuesday','wednesday','thursday','friday','saturday','sun','mon','tue','wed','thu','fri','sat') as $word) {
	$locwords[] = '/^' . preg_quote(mb_strtolower($this->gettext($word))) . '\b/i';
	$normwords[] = $word;
	$datewords[] = $word;
	}
	foreach (array('jan','feb','mar','apr','may','jun','jul','aug','sep','oct','now','dec') as $month) {
	$locwords[] = '/(' . preg_quote(mb_strtolower($this->gettext('long'.$month))) . '\|' . preg_quote(mb_strtolower($this->gettext($month))) . ')\b/i';
	$normwords[] = $month;
	$datewords[] = $month;
	}
	foreach (array('on','this','next','at') as $word) {
	$fillwords[] = preg_quote(mb_strtolower($this->gettext($word)));
	$fillwords[] = $word;
	}

	$raw = trim($rec['raw']);
	$date_str = '';

	// translate localized keywords
	$raw = preg_replace('/^(' . join('\|', $fillwords) . ')\s*/i', '', $raw);
	$raw = preg_replace($locwords, $normwords, $raw);

	// find date pattern
	$date_pattern = '!^(\d+[./-]\s*)?((?:\d+[./-])\|' . join('\|', $datewords) . ')\.?(\s+\d{4})?[:;,]?\s+!i';
	if (preg_match($date_pattern, $raw, $m)) {
	$date_str .= $m[1] . $m[2] . $m[3];
	$raw = preg_replace(array($date_pattern, '/^(' . join('\|', $fillwords) . ')\s*/i'), '', $raw);
	// add year to date string
	if ($m[1] && !$m[3])
	$date_str .= date('Y');
	}

	// find time pattern
	$time_pattern = '/^(\d+([:.]\d+)?(\s*[hapm.]+)?),?\s+/i';
	if (preg_match($time_pattern, $raw, $m)) {
	$has_time = true;
	$date_str .= ($date_str ? ' ' : 'today ') . $m[1];
	$raw = preg_replace($time_pattern, '', $raw);
	}

	// yes, raw input matched a (valid) date
	if (strlen($date_str) && strtotime($date_str) && ($date = new DateTime($date_str, $this->timezone))) {
	$rec['date'] = $date->format('Y-m-d');
	if ($has_time)
	$rec['time'] = $date->format('H:i');
	$rec['title'] = $raw;
	}
	else
	$rec['title'] = $rec['raw'];
	}

	// normalize input from client
	if (isset($rec['complete'])) {
	$rec['complete'] = floatval($rec['complete']);
	if ($rec['complete'] > 1)
	$rec['complete'] /= 100;
	}
	if (isset($rec['flagged']))
	$rec['flagged'] = intval($rec['flagged']);

	// fix for garbage input
	if ($rec['description'] == 'null')
	$rec['description'] = '';

	foreach ($rec as $key => $val) {
	if ($val === 'null')
	$rec[$key] = null;
	}

	if (!empty($rec['date'])) {
	$this->normalize_dates($rec, 'date', 'time');
	}

	if (!empty($rec['startdate'])) {
	$this->normalize_dates($rec, 'startdate', 'starttime');
	}

	// convert tags to array, filter out empty entries
	if (isset($rec['tags']) && !is_array($rec['tags'])) {
	$rec['tags'] = array_filter((array)$rec['tags']);
	}

	// convert the submitted alarm values
	if ($rec['valarms']) {
	$valarms = array();
	foreach (libcalendaring::from_client_alarms($rec['valarms']) as $alarm) {
	// alarms can only work with a date (either task start, due or absolute alarm date)
	if (is_a($alarm['trigger'], 'DateTime') \|\| $rec['date'] \|\| $rec['startdate'])
	$valarms[] = $alarm;
	}
	$rec['valarms'] = $valarms;
	}

	// convert the submitted recurrence settings
	if (is_array($rec['recurrence'])) {
	$refdate = null;
	if (!empty($rec['date'])) {
	$refdate = new DateTime($rec['date'] . ' ' . $rec['time'], $this->timezone);
	}
	else if (!empty($rec['startdate'])) {
	$refdate = new DateTime($rec['startdate'] . ' ' . $rec['starttime'], $this->timezone);
	}

	if ($refdate) {
	$rec['recurrence'] = $this->lib->from_client_recurrence($rec['recurrence'], $refdate);

	// translate count into an absolute end date.
	// why? because when shifting completed tasks to the next recurrence,
	// the initial start date to count from gets lost.
	if ($rec['recurrence']['COUNT']) {
	$engine = libcalendaring::get_recurrence();
	$engine->init($rec['recurrence'], $refdate);
	if ($until = $engine->end()) {
	$rec['recurrence']['UNTIL'] = $until;
	unset($rec['recurrence']['COUNT']);
	}
	}
	}
	else { // recurrence requires a reference date
	$rec['recurrence'] = '';
	}
	}

	$attachments = array();
	$taskid = $rec['id'];
	if (is_array($_SESSION[self::SESSION_KEY]) && $_SESSION[self::SESSION_KEY]['id'] == $taskid) {
	if (!empty($_SESSION[self::SESSION_KEY]['attachments'])) {
	foreach ($_SESSION[self::SESSION_KEY]['attachments'] as $id => $attachment) {
	if (is_array($rec['attachments']) && in_array($id, $rec['attachments'])) {
	$attachments[$id] = $this->rc->plugins->exec_hook('attachment_get', $attachment);
	unset($attachments[$id]['abort'], $attachments[$id]['group']);
	}
	}
	}
	}

	$rec['attachments'] = $attachments;

	// convert invalid data
	if (isset($rec['attendees']) && !is_array($rec['attendees']))
	$rec['attendees'] = array();

	// copy the task status to my attendee partstat
	if (!empty($rec['_reportpartstat'])) {
	if (($idx = $this->is_attendee($rec)) !== false) {
	if (!($rec['_reportpartstat'] == 'NEEDS-ACTION' && $rec['attendees'][$idx]['status'] == 'ACCEPTED'))
	$rec['attendees'][$idx]['status'] = $rec['_reportpartstat'];
	else
	unset($rec['_reportpartstat']);
	}
	}

	// set organizer from identity selector
	if ((isset($rec['_identity']) \|\| (!empty($rec['attendees']) && empty($rec['organizer']))) &&
	($identity = $this->rc->user->get_identity($rec['_identity']))) {
	$rec['organizer'] = array('name' => $identity['name'], 'email' => $identity['email']);
	}

	if (is_numeric($rec['id']) && $rec['id'] < 0)
	unset($rec['id']);

	return $rec;
	}

	/**
	* Utility method to convert a tasks date/time values into a normalized format
	*/
	private function normalize_dates(&$rec, $date_key, $time_key)
	{
	try {
	// parse date from user format (#2801)
	$date_format = $this->rc->config->get(empty($rec[$time_key]) ? 'date_format' : 'date_long', 'Y-m-d');
	$date = DateTime::createFromFormat($date_format, trim($rec[$date_key] . ' ' . $rec[$time_key]), $this->timezone);

	// fall back to default strtotime logic
	if (empty($date)) {
	$date = new DateTime($rec[$date_key] . ' ' . $rec[$time_key], $this->timezone);
	}

	$rec[$date_key] = $date->format('Y-m-d');
	if (!empty($rec[$time_key]))
	$rec[$time_key] = $date->format('H:i');

	return true;
	}
	catch (Exception $e) {
	$rec[$date_key] = $rec[$time_key] = null;
	}

	return false;
	}

	/**
	* Releases some resources after successful save
	*/
	private function cleanup_task(&$rec)
	{
	// remove temp. attachment files
	if (!empty($_SESSION[self::SESSION_KEY]) && ($taskid = $_SESSION[self::SESSION_KEY]['id'])) {
	$this->rc->plugins->exec_hook('attachments_cleanup', array('group' => $taskid));
	$this->rc->session->remove(self::SESSION_KEY);
	}
	}

	/**
	* When flagging a recurring task as complete,
	* clone it and shift dates to the next occurrence
	*/
	private function handle_recurrence(&$rec, $old)
	{
	$clone = null;
	if ($this->driver->is_complete($rec) && $old && !$this->driver->is_complete($old) && is_array($rec['recurrence'])) {
	$engine = libcalendaring::get_recurrence();
	$rrule = $rec['recurrence'];
	$updates = array();

	// compute the next occurrence of date attributes
	foreach (array('date'=>'time', 'startdate'=>'starttime') as $date_key => $time_key) {
	if (empty($rec[$date_key]))
	continue;

	$date = new DateTime($rec[$date_key] . ' ' . $rec[$time_key], $this->timezone);
	$engine->init($rrule, $date);
	if ($next = $engine->next()) {
	$updates[$date_key] = $next->format('Y-m-d');
	if (!empty($rec[$time_key]))
	$updates[$time_key] = $next->format('H:i');
	}
	}

	// shift absolute alarm dates
	if (!empty($updates) && is_array($rec['valarms'])) {
	$updates['valarms'] = array();
	unset($rrule['UNTIL'], $rrule['COUNT']); // make recurrence rule unlimited

	foreach ($rec['valarms'] as $i => $alarm) {
	if ($alarm['trigger'] instanceof DateTime) {
	$engine->init($rrule, $alarm['trigger']);
	if ($next = $engine->next()) {
	$alarm['trigger'] = $next;
	}
	}
	$updates['valarms'][$i] = $alarm;
	}
	}

	if (!empty($updates)) {
	// clone task to save a completed copy
	$clone = $rec;
	$clone['uid'] = $this->generate_uid();
	$clone['parent_id'] = $rec['id'];
	unset($clone['id'], $clone['recurrence'], $clone['attachments']);

	// update the task but unset completed flag
	$rec = array_merge($rec, $updates);
	$rec['complete'] = $old['complete'];
	$rec['status'] = $old['status'];
	}
	}

	return $clone;
	}

	/**
	* Send out an invitation/notification to all task attendees
	*/
	private function notify_attendees($task, $old, $action = 'edit', $comment = null)
	{
	if ($action == 'delete' \|\| ($task['status'] == 'CANCELLED' && $old['status'] != $task['status'])) {
	$task['cancelled'] = true;
	$is_cancelled = true;
	}

	$itip = $this->load_itip();
	$emails = $this->lib->get_user_emails();
	$itip_notify = (int)$this->rc->config->get('calendar_itip_send_option', 3);

	// add comment to the iTip attachment
	$task['comment'] = $comment;

	// needed to generate VTODO instead of VEVENT entry
	$task['_type'] = 'task';

	// compose multipart message using PEAR:Mail_Mime
	$method = $action == 'delete' ? 'CANCEL' : 'REQUEST';
	$object = $this->to_libcal($task);
	$message = $itip->compose_itip_message($object, $method);

	// list existing attendees from the $old task
	$old_attendees = array();
	foreach ((array)$old['attendees'] as $attendee) {
	$old_attendees[] = $attendee['email'];
	}

	// send to every attendee
	$sent = 0; $current = array();
	foreach ((array)$task['attendees'] as $attendee) {
	$current[] = strtolower($attendee['email']);

	// skip myself for obvious reasons
	if (!$attendee['email'] \|\| in_array(strtolower($attendee['email']), $emails)) {
	continue;
	}

	// skip if notification is disabled for this attendee
	if ($attendee['noreply'] && $itip_notify & 2) {
	continue;
	}

	// which template to use for mail text
	$is_new = !in_array($attendee['email'], $old_attendees);
	$is_rsvp = $is_new \|\| $task['sequence'] > $old['sequence'];
	$bodytext = $is_cancelled ? 'itipcancelmailbody' : ($is_new ? 'invitationmailbody' : 'itipupdatemailbody');
	$subject = $is_cancelled ? 'itipcancelsubject' : ($is_new ? 'invitationsubject' : ($task['title'] ? 'itipupdatesubject' : 'itipupdatesubjectempty'));

	// finally send the message
	if ($itip->send_itip_message($object, $method, $attendee, $subject, $bodytext, $message, $is_rsvp))
	$sent++;
	else
	$sent = -100;
	}

	// send CANCEL message to removed attendees
	foreach ((array)$old['attendees'] as $attendee) {
	if (!$attendee['email'] \|\| in_array(strtolower($attendee['email']), $current)) {
	continue;
	}

	$vtodo = $this->to_libcal($old);
	$vtodo['cancelled'] = $is_cancelled;
	$vtodo['attendees'] = array($attendee);
	$vtodo['comment'] = $comment;

	if ($itip->send_itip_message($vtodo, 'CANCEL', $attendee, 'itipcancelsubject', 'itipcancelmailbody'))
	$sent++;
	else
	$sent = -100;
	}

	return $sent;
	}

	/**
	* Compare two task objects and return differing properties
	*
	* @param array Event A
	* @param array Event B
	* @return array List of differing task properties
	*/
	public static function task_diff($a, $b)
	{
	$diff = array();
	$ignore = array('changed' => 1, 'attachments' => 1);

	foreach (array_unique(array_merge(array_keys($a), array_keys($b))) as $key) {
	if (!$ignore[$key] && $a[$key] != $b[$key])
	$diff[] = $key;
	}

	// only compare number of attachments
	if (count($a['attachments']) != count($b['attachments']))
	$diff[] = 'attachments';

	return $diff;
	}

	/**
	* Dispatcher for tasklist actions initiated by the client
	*/
	public function tasklist_action()
	{
	- $action = get_input_value('action', RCUBE_INPUT_GPC);
	- $list = get_input_value('l', RCUBE_INPUT_GPC, true);
	+ $action = rcube_utils::get_input_value('action', rcube_utils::INPUT_GPC);
	+ $list = rcube_utils::get_input_value('l', rcube_utils::INPUT_GPC, true);
	$success = false;

	if (isset($list['showalarms']))
	$list['showalarms'] = intval($list['showalarms']);

	switch ($action) {
	case 'form-new':
	case 'form-edit':
	echo $this->ui->tasklist_editform($action, $list);
	exit;

	case 'new':
	$list += array('showalarms' => true, 'active' => true, 'editable' => true);
	if ($insert_id = $this->driver->create_list($list)) {
	$list['id'] = $insert_id;
	if (!$list['_reload']) {
	$this->load_ui();
	$list['html'] = $this->ui->tasklist_list_item($insert_id, $list, $jsenv);
	$list += (array)$jsenv[$insert_id];
	}
	$this->rc->output->command('plugin.insert_tasklist', $list);
	$success = true;
	}
	break;

	case 'edit':
	if ($newid = $this->driver->edit_list($list)) {
	$list['oldid'] = $list['id'];
	$list['id'] = $newid;
	$this->rc->output->command('plugin.update_tasklist', $list);
	$success = true;
	}
	break;

	case 'subscribe':
	$success = $this->driver->subscribe_list($list);
	break;

	case 'delete':
	if (($success = $this->driver->delete_list($list)))
	$this->rc->output->command('plugin.destroy_tasklist', $list);
	break;

	case 'search':
	$this->load_ui();
	$results = array();
	- foreach ((array)$this->driver->search_lists(get_input_value('q', RCUBE_INPUT_GPC), get_input_value('source', RCUBE_INPUT_GPC)) as $id => $prop) {
	+ $query = rcube_utils::get_input_value('q', rcube_utils::INPUT_GPC);
	+ $source = rcube_utils::get_input_value('source', rcube_utils::INPUT_GPC);
	+
	+ foreach ((array)$this->driver->search_lists($query, $source) as $id => $prop) {
	$editname = $prop['editname'];
	unset($prop['editname']); // force full name to be displayed
	$prop['active'] = false;

	// let the UI generate HTML and CSS representation for this calendar
	$html = $this->ui->tasklist_list_item($id, $prop, $jsenv);
	$prop += (array)$jsenv[$id];
	$prop['editname'] = $editname;
	$prop['html'] = $html;

	$results[] = $prop;
	}
	// report more results available
	if ($this->driver->search_more_results) {
	$this->rc->output->show_message('autocompletemore', 'info');
	}

	- $this->rc->output->command('multi_thread_http_response', $results, get_input_value('_reqid', RCUBE_INPUT_GPC));
	+ $this->rc->output->command('multi_thread_http_response', $results, rcube_utils::get_input_value('_reqid', rcube_utils::INPUT_GPC));
	return;
	}

	if ($success)
	$this->rc->output->show_message('successfullysaved', 'confirmation');
	else
	$this->rc->output->show_message('tasklist.errorsaving', 'error');

	$this->rc->output->command('plugin.unlock_saving');
	}

	/**
	* Get counts for active tasks divided into different selectors
	*/
	public function fetch_counts()
	{
	if (isset($_REQUEST['lists'])) {
	- $lists = get_input_value('lists', RCUBE_INPUT_GPC);
	+ $lists = rcube_utils::get_input_value('lists', rcube_utils::INPUT_GPC);
	}
	else {
	foreach ($this->driver->get_lists() as $list) {
	if ($list['active'])
	$lists[] = $list['id'];
	}
	}
	$counts = $this->driver->count_tasks($lists);
	$this->rc->output->command('plugin.update_counts', $counts);
	}

	/**
	* Adjust the cached counts after changing a task
	*/
	public function update_counts($oldrec, $newrec)
	{
	// rebuild counts until this function is finally implemented
	$this->fetch_counts();

	// $this->rc->output->command('plugin.update_counts', $counts);
	}

	/**
	*
	*/
	public function fetch_tasks()
	{
	- $f = intval(get_input_value('filter', RCUBE_INPUT_GPC));
	- $search = get_input_value('q', RCUBE_INPUT_GPC);
	+ $f = intval(rcube_utils::get_input_value('filter', rcube_utils::INPUT_GPC));
	+ $search = rcube_utils::get_input_value('q', rcube_utils::INPUT_GPC);
	+ $lists = rcube_utils::get_input_value('lists', rcube_utils::INPUT_GPC);
	$filter = array('mask' => $f, 'search' => $search);
	- $lists = get_input_value('lists', RCUBE_INPUT_GPC);;
	/*
	// convert magic date filters into a real date range
	switch ($f) {
	case self::FILTER_MASK_TODAY:
	$today = new DateTime('now', $this->timezone);
	$filter['from'] = $filter['to'] = $today->format('Y-m-d');
	break;

	case self::FILTER_MASK_TOMORROW:
	$tomorrow = new DateTime('now + 1 day', $this->timezone);
	$filter['from'] = $filter['to'] = $tomorrow->format('Y-m-d');
	break;

	case self::FILTER_MASK_OVERDUE:
	$yesterday = new DateTime('yesterday', $this->timezone);
	$filter['to'] = $yesterday->format('Y-m-d');
	break;

	case self::FILTER_MASK_WEEK:
	$today = new DateTime('now', $this->timezone);
	$filter['from'] = $today->format('Y-m-d');
	$weekend = new DateTime('now + 7 days', $this->timezone);
	$filter['to'] = $weekend->format('Y-m-d');
	break;

	case self::FILTER_MASK_LATER:
	$date = new DateTime('now + 8 days', $this->timezone);
	$filter['from'] = $date->format('Y-m-d');
	break;

	}
	*/
	$data = $this->tasks_data($this->driver->list_tasks($filter, $lists), $f);
	$this->rc->output->command('plugin.data_ready', array(
	'filter' => $f,
	'lists' => $lists,
	'search' => $search,
	'data' => $data,
	'tags' => $this->driver->get_tags(),
	));
	}

	/**
	* Prepare and sort the given task records to be sent to the client
	*/
	private function tasks_data($records, $f)
	{
	$data = $this->task_tree = $this->task_titles = array();

	foreach ($records as $rec) {
	if ($rec['parent_id']) {
	$this->task_tree[$rec['id']] = $rec['parent_id'];
	}

	$this->encode_task($rec);

	// apply filter; don't trust the driver on this :-)
	if ((!$f && !$this->driver->is_complete($rec)) \|\| ($rec['mask'] & $f))
	$data[] = $rec;
	}

	// assign hierarchy level indicators for later sorting
	array_walk($data, array($this, 'task_walk_tree'));

	return $data;
	}

	/**
	* Prepare the given task record before sending it to the client
	*/
	private function encode_task(&$rec)
	{
	$rec['mask'] = $this->filter_mask($rec);
	$rec['flagged'] = intval($rec['flagged']);
	$rec['complete'] = floatval($rec['complete']);

	if (is_object($rec['created'])) {
	$rec['created_'] = $this->rc->format_date($rec['created']);
	$rec['created'] = $rec['created']->format('U');
	}
	if (is_object($rec['changed'])) {
	$rec['changed_'] = $this->rc->format_date($rec['changed']);
	$rec['changed'] = $rec['changed']->format('U');
	}
	else {
	$rec['changed'] = null;
	}

	if ($rec['date']) {
	try {
	$date = new DateTime($rec['date'] . ' ' . $rec['time'], $this->timezone);
	$rec['datetime'] = intval($date->format('U'));
	$rec['date'] = $date->format($this->rc->config->get('date_format', 'Y-m-d'));
	$rec['_hasdate'] = 1;
	}
	catch (Exception $e) {
	$rec['date'] = $rec['datetime'] = null;
	}
	}
	else {
	$rec['date'] = $rec['datetime'] = null;
	$rec['_hasdate'] = 0;
	}

	if ($rec['startdate']) {
	try {
	$date = new DateTime($rec['startdate'] . ' ' . $rec['starttime'], $this->timezone);
	$rec['startdatetime'] = intval($date->format('U'));
	$rec['startdate'] = $date->format($this->rc->config->get('date_format', 'Y-m-d'));
	}
	catch (Exception $e) {
	$rec['startdate'] = $rec['startdatetime'] = null;
	}
	}

	if ($rec['valarms']) {
	$rec['alarms_text'] = libcalendaring::alarms_text($rec['valarms']);
	$rec['valarms'] = libcalendaring::to_client_alarms($rec['valarms']);
	}

	if ($rec['recurrence']) {
	$rec['recurrence_text'] = $this->lib->recurrence_text($rec['recurrence']);
	$rec['recurrence'] = $this->lib->to_client_recurrence($rec['recurrence'], $rec['time'] \|\| $rec['starttime']);
	}

	foreach ((array)$rec['attachments'] as $k => $attachment) {
	$rec['attachments'][$k]['classname'] = rcube_utils::file2class($attachment['mimetype'], $attachment['name']);
	}

	if (!is_array($rec['tags']))
	$rec['tags'] = (array)$rec['tags'];
	sort($rec['tags'], SORT_LOCALE_STRING);

	if (in_array($rec['id'], $this->collapsed_tasks))
	$rec['collapsed'] = true;

	if (empty($rec['parent_id']))
	$rec['parent_id'] = null;

	$this->task_titles[$rec['id']] = $rec['title'];
	}

	/**
	* Callback function for array_walk over all tasks.
	* Sets tree depth and parent titles
	*/
	private function task_walk_tree(&$rec)
	{
	$rec['_depth'] = 0;
	$parent_id = $this->task_tree[$rec['id']];
	while ($parent_id) {
	$rec['_depth']++;
	$rec['parent_title'] = $this->task_titles[$parent_id];
	$parent_id = $this->task_tree[$parent_id];
	}
	}

	/**
	* Compute the filter mask of the given task
	*
	* @param array Hash array with Task record properties
	* @return int Filter mask
	*/
	public function filter_mask($rec)
	{
	static $today, $tomorrow, $weeklimit;

	if (!$today) {
	$today_date = new DateTime('now', $this->timezone);
	$today = $today_date->format('Y-m-d');
	$tomorrow_date = new DateTime('now + 1 day', $this->timezone);
	$tomorrow = $tomorrow_date->format('Y-m-d');
	$week_date = new DateTime('now + 7 days', $this->timezone);
	$weeklimit = $week_date->format('Y-m-d');
	}

	$mask = 0;
	$start = $rec['startdate'] ?: '1900-00-00';
	$duedate = $rec['date'] ?: '3000-00-00';

	if ($rec['flagged'])
	$mask \|= self::FILTER_MASK_FLAGGED;
	if ($this->driver->is_complete($rec))
	$mask \|= self::FILTER_MASK_COMPLETE;

	if (empty($rec['date']))
	$mask \|= self::FILTER_MASK_NODATE;
	else if ($rec['date'] < $today)
	$mask \|= self::FILTER_MASK_OVERDUE;

	if ($duedate <= $today \|\| ($rec['startdate'] && $start <= $today))
	$mask \|= self::FILTER_MASK_TODAY;
	if ($duedate <= $tomorrow \|\| ($rec['startdate'] && $start <= $tomorrow))
	$mask \|= self::FILTER_MASK_TOMORROW;
	if (($start > $tomorrow && $start <= $weeklimit) \|\| ($duedate > $tomorrow && $duedate <= $weeklimit))
	$mask \|= self::FILTER_MASK_WEEK;
	else if ($start > $weeklimit \|\| ($rec['date'] && $duedate > $weeklimit))
	$mask \|= self::FILTER_MASK_LATER;

	// add masks for assigned tasks
	if ($this->is_organizer($rec) && !empty($rec['attendees']) && $this->is_attendee($rec) === false)
	$mask \|= self::FILTER_MASK_ASSIGNED;
	else if (/empty($rec['attendees']) \|\|/ $this->is_attendee($rec) !== false)
	$mask \|= self::FILTER_MASK_MYTASKS;

	return $mask;
	}

	/**
	* Determine whether the current user is an attendee of the given task
	*/
	public function is_attendee($task)
	{
	$emails = $this->lib->get_user_emails();
	foreach ((array)$task['attendees'] as $i => $attendee) {
	if ($attendee['email'] && in_array(strtolower($attendee['email']), $emails)) {
	return $i;
	}
	}

	return false;
	}

	/**
	* Determine whether the current user is the organizer of the given task
	*/
	public function is_organizer($task)
	{
	$emails = $this->lib->get_user_emails();
	return (empty($task['organizer']) \|\| in_array(strtolower($task['organizer']['email']), $emails));
	}


	/***** UI functions ******/

	/**
	* Render main view of the tasklist task
	*/
	public function tasklist_view()
	{
	$this->ui->init();
	$this->ui->init_templates();

	// set autocompletion env
	$this->rc->output->set_env('autocomplete_threads', (int)$this->rc->config->get('autocomplete_threads', 0));
	$this->rc->output->set_env('autocomplete_max', (int)$this->rc->config->get('autocomplete_max', 15));
	$this->rc->output->set_env('autocomplete_min_length', $this->rc->config->get('autocomplete_min_length'));
	$this->rc->output->add_label('autocompletechars', 'autocompletemore', 'libcalendaring.expandattendeegroup', 'libcalendaring.expandattendeegroupnodata');

	$this->rc->output->set_pagetitle($this->gettext('navtitle'));
	$this->rc->output->send('tasklist.mainview');
	}


	/**
	*
	*/
	public function get_inline_ui()
	{
	foreach (array('save','cancel','savingdata') as $label)
	$texts['tasklist.'.$label] = $this->gettext($label);

	$texts['tasklist.newtask'] = $this->gettext('createfrommail');

	// collect env variables
	$env = array(
	'tasklists' => array(),
	'tasklist_settings' => $this->ui->load_settings(),
	);

	$this->ui->init_templates();
	echo $this->api->output->parse('tasklist.taskedit', false, false);

	$script_add = '';
	foreach ($this->ui->get_gui_objects() as $obj => $id) {
	$script_add .= rcmail_output::JS_OBJECT_NAME . ".gui_object('$obj', '$id');\n";
	}

	echo html::tag('link', array('rel' => 'stylesheet', 'type' => 'text/css', 'href' => $this->url($this->local_skin_path() . '/tagedit.css'), 'nl' => true));
	echo html::tag('script', array('type' => 'text/javascript'),
	rcmail_output::JS_OBJECT_NAME . ".set_env(" . json_encode($env) . ");\n".
	rcmail_output::JS_OBJECT_NAME . ".add_label(" . json_encode($texts) . ");\n".
	$script_add
	);
	exit;
	}

	/**
	* Handler for keep-alive requests
	* This will check for updated data in active lists and sync them to the client
	*/
	public function refresh($attr)
	{
	// refresh the entire list every 10th time to also sync deleted items
	if (rand(0,10) == 10) {
	$this->rc->output->command('plugin.reload_data');
	return;
	}

	$filter = array(
	'since' => $attr['last'],
	- 'search' => get_input_value('q', RCUBE_INPUT_GPC),
	- 'mask' => intval(get_input_value('filter', RCUBE_INPUT_GPC)) & self::FILTER_MASK_COMPLETE,
	+ 'search' => rcube_utils::get_input_value('q', rcube_utils::INPUT_GPC),
	+ 'mask' => intval(rcube_utils::get_input_value('filter', rcube_utils::INPUT_GPC)) & self::FILTER_MASK_COMPLETE,
	);
	- $lists = get_input_value('lists', RCUBE_INPUT_GPC);;
	+ $lists = rcube_utils::get_input_value('lists', rcube_utils::INPUT_GPC);;

	$updates = $this->driver->list_tasks($filter, $lists);
	if (!empty($updates)) {
	$this->rc->output->command('plugin.refresh_tasks', $this->tasks_data($updates, 255), true);

	// update counts
	$counts = $this->driver->count_tasks($lists);
	$this->rc->output->command('plugin.update_counts', $counts);
	}
	}

	/**
	* Handler for pending_alarms plugin hook triggered by the calendar module on keep-alive requests.
	* This will check for pending notifications and pass them to the client
	*/
	public function pending_alarms($p)
	{
	$this->load_driver();
	if ($alarms = $this->driver->pending_alarms($p['time'] ?: time())) {
	foreach ($alarms as $alarm) {
	// encode alarm object to suit the expectations of the calendaring code
	if ($alarm['date'])
	$alarm['start'] = new DateTime($alarm['date'].' '.$alarm['time'], $this->timezone);

	$alarm['id'] = 'task:' . $alarm['id']; // prefix ID with task:
	$alarm['allday'] = empty($alarm['time']) ? 1 : 0;
	$p['alarms'][] = $alarm;
	}
	}

	return $p;
	}

	/**
	* Handler for alarm dismiss hook triggered by the calendar module
	*/
	public function dismiss_alarms($p)
	{
	$this->load_driver();
	foreach ((array)$p['ids'] as $id) {
	if (strpos($id, 'task:') === 0)
	$p['success'] \|= $this->driver->dismiss_alarm(substr($id, 5), $p['snooze']);
	}

	return $p;
	}


	/***** Attachment handling *****/

	/**
	* Handler for attachments upload
	*/
	public function attachment_upload()
	{
	$this->lib->attachment_upload(self::SESSION_KEY);
	}

	/**
	* Handler for attachments download/displaying
	*/
	public function attachment_get()
	{
	// show loading page
	if (!empty($_GET['_preload'])) {
	return $this->lib->attachment_loading_page();
	}

	- $task = get_input_value('_t', RCUBE_INPUT_GPC);
	- $list = get_input_value('_list', RCUBE_INPUT_GPC);
	- $id = get_input_value('_id', RCUBE_INPUT_GPC);
	+ $task = rcube_utils::get_input_value('_t', rcube_utils::INPUT_GPC);
	+ $list = rcube_utils::get_input_value('_list', rcube_utils::INPUT_GPC);
	+ $id = rcube_utils::get_input_value('_id', rcube_utils::INPUT_GPC);

	$task = array('id' => $task, 'list' => $list);
	$attachment = $this->driver->get_attachment($id, $task);

	// show part page
	if (!empty($_GET['_frame'])) {
	$this->lib->attachment = $attachment;
	$this->register_handler('plugin.attachmentframe', array($this->lib, 'attachment_frame'));
	$this->register_handler('plugin.attachmentcontrols', array($this->lib, 'attachment_header'));
	$this->rc->output->send('tasklist.attachment');
	}
	// deliver attachment content
	else if ($attachment) {
	$attachment['body'] = $this->driver->get_attachment_body($id, $task);
	$this->lib->attachment_get($attachment);
	}

	// if we arrive here, the requested part was not found
	header('HTTP/1.1 404 Not Found');
	exit;
	}


	/***** Email related function *****/

	public function mail_message2task()
	{
	- $uid = get_input_value('_uid', RCUBE_INPUT_POST);
	- $mbox = get_input_value('_mbox', RCUBE_INPUT_POST);
	+ $uid = rcube_utils::get_input_value('_uid', rcube_utils::INPUT_POST);
	+ $mbox = rcube_utils::get_input_value('_mbox', rcube_utils::INPUT_POST);
	$task = array();

	// establish imap connection
	$imap = $this->rc->get_storage();
	$imap->set_mailbox($mbox);
	$message = new rcube_message($uid);

	if ($message->headers) {
	$task['title'] = trim($message->subject);
	$task['description'] = trim($message->first_text_part());
	$task['id'] = -$uid;

	$this->load_driver();

	// copy mail attachments to task
	if ($message->attachments && $this->driver->attachments) {
	if (!is_array($_SESSION[self::SESSION_KEY]) \|\| $_SESSION[self::SESSION_KEY]['id'] != $task['id']) {
	$_SESSION[self::SESSION_KEY] = array();
	$_SESSION[self::SESSION_KEY]['id'] = $task['id'];
	$_SESSION[self::SESSION_KEY]['attachments'] = array();
	}

	foreach ((array)$message->attachments as $part) {
	$attachment = array(
	'data' => $imap->get_message_part($uid, $part->mime_id, $part),
	'size' => $part->size,
	'name' => $part->filename,
	'mimetype' => $part->mimetype,
	'group' => $task['id'],
	);

	$attachment = $this->rc->plugins->exec_hook('attachment_save', $attachment);

	if ($attachment['status'] && !$attachment['abort']) {
	$id = $attachment['id'];
	$attachment['classname'] = rcube_utils::file2class($attachment['mimetype'], $attachment['name']);

	// store new attachment in session
	unset($attachment['status'], $attachment['abort'], $attachment['data']);
	$_SESSION[self::SESSION_KEY]['attachments'][$id] = $attachment;

	$attachment['id'] = 'rcmfile' . $attachment['id']; // add prefix to consider it 'new'
	$task['attachments'][] = $attachment;
	}
	}
	}

	$this->rc->output->command('plugin.mail2taskdialog', $task);
	}
	else {
	$this->rc->output->command('display_message', $this->gettext('messageopenerror'), 'error');
	}

	$this->rc->output->send();
	}

	/**
	* Add UI element to copy task invitations or updates to the tasklist
	*/
	public function mail_messagebody_html($p)
	{
	// load iCalendar functions (if necessary)
	if (!empty($this->lib->ical_parts)) {
	$this->get_ical();
	$this->load_itip();
	}

	$html = '';
	$has_tasks = false;
	$ical_objects = $this->lib->get_mail_ical_objects();

	// show a box for every task in the file
	foreach ($ical_objects as $idx => $task) {
	if ($task['_type'] != 'task') {
	continue;
	}

	$has_tasks = true;

	// get prepared inline UI for this event object
	if ($ical_objects->method) {
	$html .= html::div('tasklist-invitebox',
	$this->itip->mail_itip_inline_ui(
	$task,
	$ical_objects->method,
	$ical_objects->mime_id . ':' . $idx,
	'tasks',
	rcube_utils::anytodatetime($ical_objects->message_date)
	)
	);
	}

	// limit listing
	if ($idx >= 3) {
	break;
	}
	}

	// prepend event boxes to message body
	if ($html) {
	$this->load_ui();
	$this->ui->init();

	$p['content'] = $html . $p['content'];

	$this->rc->output->add_label('tasklist.savingdata','tasklist.deletetaskconfirm','tasklist.declinedeleteconfirm');
	}

	// add "Save to tasks" button into attachment menu
	if ($has_tasks) {
	$this->add_button(array(
	'id' => 'attachmentsavetask',
	'name' => 'attachmentsavetask',
	'type' => 'link',
	'wrapper' => 'li',
	'command' => 'attachment-save-task',
	'class' => 'icon tasklistlink',
	'classact' => 'icon tasklistlink active',
	'innerclass' => 'icon taskadd',
	'label' => 'tasklist.savetotasklist',
	), 'attachmentmenu');
	}

	return $p;
	}

	/**
	* Load iCalendar functions
	*/
	public function get_ical()
	{
	if (!$this->ical) {
	$this->ical = libcalendaring::get_ical();
	}

	return $this->ical;
	}

	/**
	* Get properties of the tasklist this user has specified as default
	*/
	public function get_default_tasklist($writeable = false, $confidential = false)
	{
	$lists = $this->driver->get_lists();
	$list = null;

	if (!$list \|\| ($writeable && !$list['editable'])) {
	foreach ($lists as $l) {
	if ($confidential && $l['subtype'] == 'confidential') {
	$list = $l;
	break;
	}
	if ($l['default']) {
	$list = $l;
	if (!$confidential)
	break;
	}

	if (!$writeable \|\| $l['editable']) {
	$first = $l;
	}
	}
	}

	return $list ?: $first;
	}

	/**
	* Import the full payload from a mail message attachment
	*/
	public function mail_import_attachment()
	{
	$uid = rcube_utils::get_input_value('_uid', rcube_utils::INPUT_POST);
	$mbox = rcube_utils::get_input_value('_mbox', rcube_utils::INPUT_POST);
	$mime_id = rcube_utils::get_input_value('_part', rcube_utils::INPUT_POST);
	$charset = RCMAIL_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);
	$headers = $imap->get_message_headers($uid);

	if ($part->ctype_parameters['charset']) {
	$charset = $part->ctype_parameters['charset'];
	}

	if ($part) {
	$tasks = $this->get_ical()->import($part, $charset);
	}
	}

	$success = $existing = 0;

	if (!empty($tasks)) {
	// find writeable tasklist to store task
	$cal_id = !empty($_REQUEST['_list']) ? rcube_utils::get_input_value('_list', rcube_utils::INPUT_POST) : null;
	$lists = $this->driver->get_lists();

	foreach ($tasks as $task) {
	// save to tasklist
	$list = $lists[$cal_id] ?: $this->get_default_tasklist(true, $task['sensitivity'] == 'confidential');
	if ($list && $list['editable'] && $task['_type'] == 'task') {
	$task = $this->from_ical($task);
	$task['list'] = $list['id'];

	if (!$this->driver->get_task($task['uid'])) {
	$success += (bool) $this->driver->create_task($task);
	}
	else {
	$existing++;
	}
	}
	}
	}

	if ($success) {
	$this->rc->output->command('display_message', $this->gettext(array(
	'name' => 'importsuccess',
	'vars' => array('nr' => $success),
	)), 'confirmation');
	}
	else if ($existing) {
	$this->rc->output->command('display_message', $this->gettext('importwarningexists'), 'warning');
	}
	else {
	$this->rc->output->command('display_message', $this->gettext('errorimportingtask'), 'error');
	}
	}

	/**
	* Handler for POST request to import an event attached to a mail message
	*/
	public function mail_import_itip()
	{
	$uid = rcube_utils::get_input_value('_uid', rcube_utils::INPUT_POST);
	$mbox = rcube_utils::get_input_value('_mbox', rcube_utils::INPUT_POST);
	$mime_id = rcube_utils::get_input_value('_part', rcube_utils::INPUT_POST);
	$status = rcube_utils::get_input_value('_status', rcube_utils::INPUT_POST);
	$delete = intval(rcube_utils::get_input_value('_del', rcube_utils::INPUT_POST));
	$noreply = intval(rcube_utils::get_input_value('_noreply', rcube_utils::INPUT_POST)) \|\| $status == 'needs-action';

	$error_msg = $this->gettext('errorimportingtask');
	$success = false;

	// successfully parsed tasks?
	if ($task = $this->lib->mail_get_itip_object($mbox, $uid, $mime_id, 'task')) {
	$task = $this->from_ical($task);

	// find writeable list to store the task
	$list_id = !empty($_REQUEST['_folder']) ? rcube_utils::get_input_value('_folder', rcube_utils::INPUT_POST) : null;
	$lists = $this->driver->get_lists();
	$list = $lists[$list_id] ?: $this->get_default_tasklist(true, $task['sensitivity'] == 'confidential');

	$metadata = array(
	'uid' => $task['uid'],
	'changed' => is_object($task['changed']) ? $task['changed']->format('U') : 0,
	'sequence' => intval($task['sequence']),
	'fallback' => strtoupper($status),
	'method' => $task['_method'],
	'task' => 'tasks',
	);

	// update my attendee status according to submitted method
	if (!empty($status)) {
	$organizer = $task['organizer'];
	$emails = $this->lib->get_user_emails();

	foreach ($task['attendees'] as $i => $attendee) {
	if ($attendee['email'] && in_array(strtolower($attendee['email']), $emails)) {
	$metadata['attendee'] = $attendee['email'];
	$metadata['rsvp'] = $attendee['role'] != 'NON-PARTICIPANT';
	$reply_sender = $attendee['email'];

	$task['attendees'][$i]['status'] = strtoupper($status);
	if ($task['attendees'][$i]['status'] != 'NEEDS-ACTION') {
	unset($task['attendees'][$i]['rsvp']); // remove RSVP attribute
	}
	}
	}

	// add attendee with this user's default identity if not listed
	if (!$reply_sender) {
	$sender_identity = $this->rc->user->get_identity();
	$task['attendees'][] = array(
	'name' => $sender_identity['name'],
	'email' => $sender_identity['email'],
	'role' => 'OPT-PARTICIPANT',
	'status' => strtoupper($status),
	);
	$metadata['attendee'] = $sender_identity['email'];
	}
	}

	// save to tasklist
	if ($list && $list['editable']) {
	$task['list'] = $list['id'];

	// check for existing task with the same UID
	$existing = $this->driver->get_task($task['uid']);

	if ($existing) {
	// only update attendee status
	if ($task['_method'] == 'REPLY') {
	// try to identify the attendee using the email sender address
	$existing_attendee = -1;
	foreach ($existing['attendees'] as $i => $attendee) {
	if ($task['_sender'] && ($attendee['email'] == $task['_sender'] \|\| $attendee['email'] == $task['_sender_utf'])) {
	$existing_attendee = $i;
	break;
	}
	}

	$task_attendee = null;
	foreach ($task['attendees'] as $attendee) {
	if ($task['_sender'] && ($attendee['email'] == $task['_sender'] \|\| $attendee['email'] == $task['_sender_utf'])) {
	$task_attendee = $attendee;
	$metadata['fallback'] = $attendee['status'];
	$metadata['attendee'] = $attendee['email'];
	$metadata['rsvp'] = $attendee['rsvp'] \|\| $attendee['role'] != 'NON-PARTICIPANT';
	break;
	}
	}

	// found matching attendee entry in both existing and new events
	if ($existing_attendee >= 0 && $task_attendee) {
	$existing['attendees'][$existing_attendee] = $task_attendee;
	$success = $this->driver->edit_task($existing);
	}
	// update the entire attendees block
	else if (($task['sequence'] >= $existing['sequence'] \|\| $task['changed'] >= $existing['changed']) && $task_attendee) {
	$existing['attendees'][] = $task_attendee;
	$success = $this->driver->edit_task($existing);
	}
	else {
	$error_msg = $this->gettext('newerversionexists');
	}
	}
	// delete the task when declined
	else if ($status == 'declined' && $delete) {
	$deleted = $this->driver->delete_task($existing, true);
	$success = true;
	}
	// import the (newer) task
	else if ($task['sequence'] >= $existing['sequence'] \|\| $task['changed'] >= $existing['changed']) {
	$task['id'] = $existing['id'];
	$task['list'] = $existing['list'];

	// preserve my participant status for regular updates
	if (empty($status)) {
	$emails = $this->lib->get_user_emails();
	foreach ($task['attendees'] as $i => $attendee) {
	if ($attendee['email'] && in_array(strtolower($attendee['email']), $emails)) {
	foreach ($existing['attendees'] as $j => $_attendee) {
	if ($attendee['email'] == $_attendee['email']) {
	$task['attendees'][$i] = $existing['attendees'][$j];
	break;
	}
	}
	}
	}
	}

	// set status=CANCELLED on CANCEL messages
	if ($task['_method'] == 'CANCEL') {
	$task['status'] = 'CANCELLED';
	}
	// show me as free when declined (#1670)
	if ($status == 'declined' \|\| $task['status'] == 'CANCELLED') {
	$task['free_busy'] = 'free';
	}

	$success = $this->driver->edit_task($task);
	}
	else if (!empty($status)) {
	$existing['attendees'] = $task['attendees'];
	if ($status == 'declined') { // show me as free when declined (#1670)
	$existing['free_busy'] = 'free';
	}

	$success = $this->driver->edit_event($existing);
	}
	else {
	$error_msg = $this->gettext('newerversionexists');
	}
	}
	else if (!$existing && ($status != 'declined' \|\| $this->rc->config->get('kolab_invitation_tasklists'))) {
	$success = $this->driver->create_task($task);
	}
	else if ($status == 'declined') {
	$error_msg = null;
	}
	}
	else if ($status == 'declined') {
	$error_msg = null;
	}
	else {
	$error_msg = $this->gettext('nowritetasklistfound');
	}
	}

	if ($success) {
	$message = $task['_method'] == 'REPLY' ? 'attendeupdateesuccess' : ($deleted ? 'successremoval' : ($existing ? 'updatedsuccessfully' : 'importedsuccessfully'));
	$this->rc->output->command('display_message', $this->gettext(array('name' => $message, 'vars' => array('list' => $list['name']))), 'confirmation');

	$metadata['rsvp'] = intval($metadata['rsvp']);
	$metadata['after_action'] = $this->rc->config->get('calendar_itip_after_action', 0);

	$this->rc->output->command('plugin.itip_message_processed', $metadata);
	$error_msg = null;
	}
	else if ($error_msg) {
	$this->rc->output->command('display_message', $error_msg, 'error');
	}

	// send iTip reply
	if ($task['_method'] == 'REQUEST' && $organizer && !$noreply && !in_array(strtolower($organizer['email']), $emails) && !$error_msg) {
	$task['comment'] = rcube_utils::get_input_value('_comment', rcube_utils::INPUT_POST);
	$itip = $this->load_itip();
	$itip->set_sender_email($reply_sender);

	if ($itip->send_itip_message($this->to_libcal($task), 'REPLY', $organizer, 'itipsubject' . $status, 'itipmailbody' . $status))
	$this->rc->output->command('display_message', $this->gettext(array('name' => 'sentresponseto', 'vars' => array('mailto' => $organizer['name'] ?: $organizer['email']))), 'confirmation');
	else
	$this->rc->output->command('display_message', $this->gettext('itipresponseerror'), 'error');
	}

	$this->rc->output->send();
	}


	/** Task invitation plugin hooks **/

	/**
	* Handler for calendar/itip-status requests
	*/
	public function task_itip_status()
	{
	$data = rcube_utils::get_input_value('data', rcube_utils::INPUT_POST, true);

	// find local copy of the referenced task
	$existing = $this->driver->get_task($data);
	$itip = $this->load_itip();
	$response = $itip->get_itip_status($data, $existing);

	// get a list of writeable lists to save new tasks to
	if (!$existing && $response['action'] == 'rsvp' \|\| $response['action'] == 'import') {
	$lists = $this->driver->get_lists();
	$select = new html_select(array('name' => 'tasklist', 'id' => 'itip-saveto', 'is_escaped' => true));
	$num = 0;

	foreach ($lists as $list) {
	if ($list['editable']) {
	$select->add($list['name'], $list['id']);
	$num++;
	}
	}

	if ($num <= 1) {
	$select = null;
	}
	}

	if ($select) {
	$default_list = $this->get_default_tasklist(true, $data['sensitivity'] == 'confidential');
	$response['select'] = html::span('folder-select', $this->gettext('saveintasklist') . ' ' .
	$select->show($default_list['id']));
	}

	$this->rc->output->command('plugin.update_itip_object_status', $response);
	}

	/**
	* Handler for calendar/itip-remove requests
	*/
	public function task_itip_remove()
	{
	$success = false;
	$uid = rcube_utils::get_input_value('uid', rcube_utils::INPUT_POST);

	// search for event if only UID is given
	if ($task = $this->driver->get_task($uid)) {
	$success = $this->driver->delete_task($task, true);
	}

	if ($success) {
	$this->rc->output->show_message('tasklist.successremoval', 'confirmation');
	}
	else {
	$this->rc->output->show_message('tasklist.errorsaving', 'error');
	}
	}


	/***** Utility functions *****/

	/**
	* Generate a unique identifier for an event
	*/
	public function generate_uid()
	{
	return strtoupper(md5(time() . uniqid(rand())) . '-' . substr(md5($this->rc->user->get_username()), 0, 16));
	}

	/**
	* Map task properties for ical exprort using libcalendaring
	*/
	public function to_libcal($task)
	{
	$object = $task;
	$object['_type'] = 'task';
	$object['categories'] = (array)$task['tags'];

	// convert to datetime objects
	if (!empty($task['date'])) {
	$object['due'] = rcube_utils::anytodatetime($task['date'].' '.$task['time'], $this->timezone);
	if (empty($task['time']))
	$object['due']->_dateonly = true;
	unset($object['date']);
	}

	if (!empty($task['startdate'])) {
	$object['start'] = rcube_utils::anytodatetime($task['startdate'].' '.$task['starttime'], $this->timezone);
	if (empty($task['starttime']))
	$object['start']->_dateonly = true;
	unset($object['startdate']);
	}

	$object['complete'] = $task['complete'] * 100;
	if ($task['complete'] == 1.0 && empty($task['complete'])) {
	$object['status'] = 'COMPLETED';
	}

	if ($task['flagged']) {
	$object['priority'] = 1;
	}
	else if (!$task['priority']) {
	$object['priority'] = 0;
	}

	return $object;
	}

	/**
	* Convert task properties from ical parser to the internal format
	*/
	public function from_ical($vtodo)
	{
	$task = $vtodo;

	$task['tags'] = array_filter((array)$vtodo['categories']);
	$task['flagged'] = $vtodo['priority'] == 1;
	$task['complete'] = floatval($vtodo['complete'] / 100);

	// convert from DateTime to internal date format
	if (is_a($vtodo['due'], 'DateTime')) {
	$due = $this->lib->adjust_timezone($vtodo['due']);
	$task['date'] = $due->format('Y-m-d');
	if (!$vtodo['due']->_dateonly)
	$task['time'] = $due->format('H:i');
	}
	// convert from DateTime to internal date format
	if (is_a($vtodo['start'], 'DateTime')) {
	$start = $this->lib->adjust_timezone($vtodo['start']);
	$task['startdate'] = $start->format('Y-m-d');
	if (!$vtodo['start']->_dateonly)
	$task['starttime'] = $start->format('H:i');
	}
	if (is_a($vtodo['dtstamp'], 'DateTime')) {
	$task['changed'] = $vtodo['dtstamp'];
	}

	unset($task['categories'], $task['due'], $task['start'], $task['dtstamp']);

	return $task;
	}

	/**
	* Handler for user_delete plugin hook
	*/
	public function user_delete($args)
	{
	$this->load_driver();
	return $this->driver->user_delete($args);
	}


	/**
	* Magic getter for public access to protected members
	*/
	public function __get($name)
	{
	switch ($name) {
	case 'ical':
	return $this->get_ical();

	case 'itip':
	return $this->load_itip();

	case 'driver':
	$this->load_driver();
	return $this->driver;
	}

	return null;
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jul 9, 10:54 PM (1 d, 9 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1057253
Default Alt Text: (485 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions