No OneTemporary
Actions

Size

73 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/plugins/calendar/drivers/kolab/kolab_driver.php b/plugins/calendar/drivers/kolab/kolab_driver.php
	index eea5b32b..b48a9581 100644
	--- a/plugins/calendar/drivers/kolab/kolab_driver.php
	+++ b/plugins/calendar/drivers/kolab/kolab_driver.php
	@@ -1,1228 +1,1229 @@
	<?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, 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/>.
	*/

	require_once(dirname(__FILE__) . '/kolab_calendar.php');

	class kolab_driver extends calendar_driver
	{
	// features this backend supports
	public $alarms = true;
	public $attendees = true;
	public $freebusy = true;
	public $attachments = true;
	public $undelete = true;
	+ public $alarm_types = array('DISPLAY','EMAIL');
	public $categoriesimmutable = true;

	private $rc;
	private $cal;
	private $calendars;
	private $has_writeable = false;

	/**
	* Default constructor
	*/
	public function __construct($cal)
	{
	$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'));
	}


	/**
	* 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
	$folders = kolab_storage::get_folders('event');
	$this->calendars = array();

	if (PEAR::isError($folders)) {
	raise_error(array(
	'code' => 600, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Failed to list calendar folders from Kolab server:" . $folders->getMessage()),
	true, false);
	}
	else {
	// convert to UTF8 and sort
	$names = array();
	foreach ($folders as $folder)
	$names[$folder->name] = rcube_charset::convert($folder->name, 'UTF7-IMAP');

	asort($names, SORT_LOCALE_STRING);

	foreach ($names as $utf7name => $name) {
	$calendar = new kolab_calendar($utf7name, $this->cal);
	$this->calendars[$calendar->id] = $calendar;
	if (!$calendar->readonly)
	$this->has_writeable = true;
	}
	}

	return $this->calendars;
	}


	/**
	* Get a list of available calendars from this source
	*/
	public function list_calendars()
	{
	// attempt to create a default calendar for this user
	if (!$this->has_writeable) {
	if ($this->create_calendar(array('name' => 'Calendar', 'color' => 'cc0000'))) {
	unset($this->calendars);
	$this->_read_calendars();
	}
	}

	$calendars = $names = array();

	foreach ($this->calendars as $id => $cal) {
	if ($cal->ready) {
	$name = $origname = $cal->get_name();

	// find folder prefix to truncate (the same code as in kolab_addressbook plugin)
	for ($i = count($names)-1; $i >= 0; $i--) {
	if (strpos($name, $names[$i].' » ') === 0) {
	$length = strlen($names[$i].' » ');
	$prefix = substr($name, 0, $length);
	$count = count(explode(' » ', $prefix));
	$name = str_repeat('  ', $count-1) . '» ' . substr($name, $length);
	break;
	}
	}

	$names[] = $origname;

	$calendars[$cal->id] = array(
	'id' => $cal->id,
	'name' => $name,
	'editname' => $cal->get_foldername(),
	'color' => $cal->get_color(),
	'readonly' => $cal->readonly,
	'showalarms' => $cal->alarms,
	'class_name' => $cal->get_namespace(),
	'active' => $cal->storage->is_subscribed(kolab_storage::SERVERSIDE_SUBSCRIPTION),
	);
	}
	}

	return $calendars;
	}


	/**
	* 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)
	{
	$folder = $this->folder_update($prop);

	if ($folder === false) {
	return false;
	}

	// subscribe to new calendar by default
	$storage = $this->rc->get_storage();
	$storage->subscribe($folder);

	// 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->calendars[$prop['id']])) {
	$oldfolder = $cal->get_realname();
	$newfolder = $this->folder_update($prop);

	if ($newfolder === false) {
	return false;
	}

	// create ID
	$id = kolab_storage::folder_id($newfolder);

	// fallback to local prefs
	$prefs['kolab_calendars'] = $this->rc->config->get('kolab_calendars', array());
	unset($prefs['kolab_calendars'][$prop['id']]);

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

	return false;
	}


	/**
	* Set active/subscribed state of a calendar
	*
	* @see calendar_driver::subscribe_calendar()
	*/
	public function subscribe_calendar($prop)
	{
	if ($prop['id'] && ($cal = $this->calendars[$prop['id']])) {
	$storage = $this->rc->get_storage();
	if ($prop['active'])
	return $storage->subscribe($cal->get_realname());
	else
	return $storage->unsubscribe($cal->get_realname());
	}

	return false;
	}


	/**
	* Rename or Create a new IMAP folder
	*
	* @param array Hash array with calendar properties
	*
	* @return mixed New folder name or False on failure
	*/
	private function folder_update(&$prop)
	{
	$folder = rcube_charset::convert($prop['name'], RCMAIL_CHARSET, 'UTF7-IMAP');
	$oldfolder = $prop['oldname']; // UTF7
	$parent = $prop['parent']; // UTF7
	$storage = $this->rc->get_storage();
	$delimiter = $storage->get_hierarchy_delimiter();

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

	if (!empty($options) && ($options['norename'] \|\| $options['protected'])) {
	}
	// sanity checks (from steps/settings/save_folder.inc)
	else if (!strlen($folder)) {
	$this->last_error = 'Invalid folder name';
	return false;
	}
	else if (strlen($folder) > 128) {
	$this->last_error = 'Folder name too long';
	return false;
	}
	else {
	// these characters are problematic e.g. when used in LIST/LSUB
	foreach (array($delimiter, '%', '*') as $char) {
	if (strpos($folder, $delimiter) !== false) {
	$this->last_error = 'Invalid folder name';
	return false;
	}
	}
	}

	if (!empty($options) && ($options['protected'] \|\| $options['norename'])) {
	$folder = $oldfolder;
	}
	else if (strlen($parent)) {
	$folder = $parent . $delimiter . $folder;
	}
	else {
	// add namespace prefix (when needed)
	$folder = $storage->mod_folder($folder, 'in');
	}

	// Check access rights to the parent folder
	if (strlen($parent) && (!strlen($oldfolder) \|\| $oldfolder != $folder)) {
	$parent_opts = $storage->folder_info($parent);
	if ($parent_opts['namespace'] != 'personal'
	&& (empty($parent_opts['rights']) \|\| !preg_match('/[ck]/', implode($parent_opts)))
	) {
	$this->last_error = 'No permission to create folder';
	return false;
	}
	}

	// update the folder name
	if (strlen($oldfolder)) {
	if ($oldfolder != $folder) {
	if (!($result = kolab_storage::folder_rename($oldfolder, $folder)))
	$this->last_error = kolab_storage::$last_error;
	}
	else
	$result = true;
	}
	// create new folder
	else {
	if (!($result = kolab_storage::folder_create($folder, 'event', false)))
	$this->last_error = kolab_storage::$last_error;
	}

	// save color in METADATA
	// TODO: also save 'showalarams' and other properties here

	if ($result && $prop['color']) {
	if (!($meta_saved = $storage->set_metadata(array(kolab_calendar::COLOR_KEY_SHARED => $prop['color'])))) // try in shared namespace
	$meta_saved = $storage->set_metadata(array(kolab_calendar::COLOR_KEY_PRIVATE => $prop['color'])); // try in private namespace
	if ($meta_saved)
	unset($prop['color']); // unsetting will prevent fallback to local user prefs
	}

	return $result ? $folder : false;
	}


	/**
	* Delete the given calendar with all its contents
	*
	* @see calendar_driver::remove_calendar()
	*/
	public function remove_calendar($prop)
	{
	if ($prop['id'] && ($cal = $this->calendars[$prop['id']])) {
	$folder = $cal->get_realname();
	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;
	}


	/**
	* 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 = null)
	{
	if (is_array($event)) {
	$id = $event['id'] ? $event['id'] : $event['uid'];
	$cal = $event['calendar'];
	}
	else {
	$id = $event;
	}

	if ($cal && ($storage = $this->calendars[$cal])) {
	return $storage->get_event($id);
	}
	// iterate over all calendar folders and search for the event ID
	else if (!$cal) {
	foreach ($this->calendars as $storage) {
	if ($writeable && $storage->readonly)
	continue;
	if ($result = $storage->get_event($id)) {
	return $result;
	}
	}
	}

	return false;
	}

	/**
	* Add a single event to the database
	*
	* @see calendar_driver::new_event()
	*/
	public function new_event($event)
	{
	$cid = $event['calendar'] ? $event['calendar'] : reset(array_keys($this->calendars));
	if ($storage = $this->calendars[$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']);
	}
	}

	$GLOBALS['conf']['kolab']['no_triggering'] = true;
	$success = $storage->insert_event($event);

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

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

	/**
	* 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->calendars[$event['calendar']]) && ($ev = $storage->get_event($event['id'])))
	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->calendars[$event['calendar']]) && ($ev = $storage->get_event($event['id'])))
	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'];

	if (($storage = $this->calendars[$event['calendar']]) && ($event = $storage->get_event($event['id']))) {
	$event['_savemode'] = $_savemode;
	$savemode = 'all';
	$master = $event;

	$this->rc->session->remove('calendar_restore_event_data');
	$GLOBALS['conf']['kolab']['no_triggering'] = true;

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

	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'], $event['end'] + 86400 * 370, $event['id'].'-1'));
	$master['start'] = $recurring['start'];
	$master['end'] = $recurring['end'];
	if ($master['recurrence']['COUNT'])
	$master['recurrence']['COUNT']--;
	}
	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'] = $event['start'] - 86400;
	unset($master['recurrence']['COUNT']);
	$success = $storage->update_event($master);
	break;
	}

	default: // 'all' is default
	$success = $storage->delete_event($master, $force);
	break;
	}
	}

	if ($success)
	$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->calendars[$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->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->calendars[$event['calendar']]))
	return false;

	// move event to another folder/calendar
	if ($event['_fromcalendar'] && $event['_fromcalendar'] != $event['calendar']) {
	if (!($fromcalendar = $this->calendars[$event['_fromcalendar']]))
	return false;

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

	$fromcalendar = $storage;
	$storage->storage->synchronize();
	}
	}
	else
	$fromcalendar = $storage;

	$success = false;
	$savemode = 'all';
	$attachments = array();
	$old = $master = $fromcalendar->get_event($event['id']);

	// 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) {
	unset($old['attachments'][$idx]);
	}
	}
	}
	}
	}

	// 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;
	// 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
	$attachments[] = array(
	'name' => $attachment['name'],
	'type' => $attachment['mimetype'],
	'content' => $attachment['data'] ? $attachment['data'] : file_get_contents($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'];

	$GLOBALS['conf']['kolab']['no_triggering'] = true;

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

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

	case 'current':
	// add exception to master event
	$master['recurrence']['EXDATE'][] = $old['start'];
	$storage->update_event($master);

	// insert new event for this occurence
	$event += $old;
	$event['recurrence'] = array();
	$event['uid'] = $this->cal->generate_uid();
	$success = $storage->insert_event($event);
	break;

	case 'future':
	if ($master['id'] != $event['id']) {
	// set until-date on master event
	$master['recurrence']['UNTIL'] = $old['start'] - 86400;
	unset($master['recurrence']['COUNT']);
	$storage->update_event($master);

	// save this instance as new recurring event
	$event += $old;
	$event['uid'] = $this->cal->generate_uid();

	// if recurrence COUNT, update value to the correct number of future occurences
	if ($event['recurrence']['COUNT']) {
	$event['recurrence']['COUNT'] -= $old['_instance'];
	}

	// remove fixed weekday, will be re-set to the new weekday in kolab_calendar::insert_event()
	if (strlen($event['recurrence']['BYDAY']) == 2)
	unset($event['recurrence']['BYDAY']);
	if ($master['recurrence']['BYMONTH'] == gmdate('n', $master['start']))
	unset($event['recurrence']['BYMONTH']);

	$success = $storage->insert_event($event);
	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 = date('Y-m-d', $old['start']);
	$old_start_time = date('H:i', $old['start']);
	$old_duration = $old['end'] - $old['start'];

	$new_start_date = date('Y-m-d', $event['start']);
	$new_start_time = date('H:i', $event['start']);
	$new_duration = $event['end'] - $event['start'];

	$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'] + ($event['start'] - $old['start']);
	$event['end'] = $event['start'] + $new_duration;

	// 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'] == gmdate('n', $old['start']))
	unset($event['recurrence']['BYMONTH']);
	}
	}

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

	if ($success)
	$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 Strip virtual events (optional)
	* @return array A list of event records
	*/
	public function load_events($start, $end, $search = null, $calendars = null, $virtual = 1)
	{
	if ($calendars && is_string($calendars))
	$calendars = explode(',', $calendars);

	$events = $categories = array();
	foreach ($this->calendars as $cid => $calendar) {
	if ($calendars && !in_array($cid, $calendars))
	continue;

	$events = array_merge($events, $this->calendars[$cid]->list_events($start, $end, $search, $virtual));
	$categories += $this->calendars[$cid]->categories;
	}

	// add new categories to user prefs
	$old_categories = $this->rc->config->get('calendar_categories', array());
	if ($newcats = array_diff(array_map('strtolower', array_keys($categories)), array_map('strtolower', array_keys($old_categories)))) {
	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->session->get_keep_alive());
	$last -= $last % $interval;

	// only check for alerts once in 5 minutes
	if ($last == $slot)
	return false;

	if ($calendars && is_string($calendars))
	$calendars = explode(',', $calendars);

	$time = $slot + $interval;

	$events = array();
	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) as $e) {
	// add to list if alarm is set
	if ($e['_alarm'] && ($notifyat = $e['start'] - $e['_alarm'] * 60) <= $time) {
	$id = $e['id'];
	$events[$id] = $e;
	$events[$id]['notifyat'] = $notifyat;
	}
	}
	}

	// get alarm information stored in local database
	if (!empty($events)) {
	$event_ids = array_map(array($this->rc->db, 'quote'), array_keys($events));
	$result = $this->rc->db->query(sprintf(
	"SELECT * FROM kolab_alarms
	WHERE event_id IN (%s)",
	join(',', $event_ids),
	$this->rc->db->now()
	));

	while ($result && ($e = $this->rc->db->fetch_assoc($result))) {
	$dbdata[$e['event_id']] = $e;
	}
	}

	$alarms = array();
	foreach ($events as $id => $e) {
	// skip dismissed
	if ($dbdata[$id]['dismissed'])
	continue;

	// snooze function may have shifted alarm time
	$notifyat = $dbdata[$id]['notifyat'] ? strtotime($dbdata[$id]['notifyat']) : $e['notifyat'];
	if ($notifyat <= $time)
	$alarms[] = $e;
	}

	return $alarms;
	}

	/**
	* Feedback after showing/sending an alarm notification
	*
	* @see calendar_driver::dismiss_alarm()
	*/
	public function dismiss_alarm($event_id, $snooze = 0)
	{
	// 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(
	"REPLACE INTO kolab_alarms
	(event_id, dismissed, notifyat)
	VALUES(?, ?, ?)",
	$event_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->calendars[$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->calendars[$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
	*/
	public function get_attachment_body($id, $event)
	{
	if (!($storage = $this->calendars[$event['calendar']]))
	return false;

	return $storage->get_attachment_body($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', array());
	}

	/**
	* Fetch free/busy information from a person within the given range
	*/
	public function get_freebusy_list($email, $start, $end)
	{
	require_once('Horde/iCalendar.php');

	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
	$fbdata = @file_get_contents(kolab_storage::get_freebusy_url($email));

	// 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) {
	$fbcal = new Horde_iCalendar;
	$fbcal->parsevCalendar($fbdata);
	if ($fb = $fbcal->findComponent('vfreebusy')) {
	$result = array();
	$params = $fb->getExtraParams();
	foreach ($fb->getBusyPeriods() as $from => $to) {
	if ($to == null) // no information, assume free
	break;
	$type = $params[$from]['FBTYPE'];
	$result[] = array($from, $to, isset($fbtypemap[$type]) ? $fbtypemap[$type] : calendar::FREEBUSY_BUSY);
	}

	// set period from $start till the begin of the free-busy information as 'unknown'
	if (($fbstart = $fb->getStart()) && $start < $fbstart) {
	array_unshift($result, array($start, $fbstart, calendar::FREEBUSY_UNKNOWN));
	}
	// pad period till $end with status 'unknown'
	if (($fbend = $fb->getEnd()) && $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);
	if (!($cal = $this->calendars[$cal]))
	return false;

	// trigger updates on folder
	$trigger = $cal->storage->trigger();
	if (is_object($trigger) && is_a($trigger, 'PEAR_Error')) {
	raise_error(array(
	'code' => 900, 'type' => 'php',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Failed triggering folder. Error was " . $trigger->getMessage()),
	true, false);
	}

	exit;
	}

	/**
	* 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)
	{
	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'] = Q(str_replace($delimiter, ' » ', 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'), $folder);
	$form['props']['fieldsets']['location']['content']['path'] = array(
	'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) {
	$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;
	}


	/**
	* 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);
	if ($calid && ($cal = $this->calendars[$calid])) {
	$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);

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


	/**
	* Return a (limited) list of color values to be used for calendar and category coloring
	*
	* @return mixed List for colors as hex values or false if no presets should be shown
	*/
	public function get_color_values()
	{
	// selection from http://msdn.microsoft.com/en-us/library/aa358802%28v=VS.85%29.aspx
	return array('000000','006400','2F4F4F','800000','808000','008000',
	'008080','000080','800080','4B0082','191970','8B0000','008B8B',
	'00008B','8B008B','556B2F','8B4513','228B22','6B8E23','2E8B57',
	'B8860B','483D8B','A0522D','0000CD','A52A2A','00CED1','696969',
	'20B2AA','9400D3','B22222','C71585','3CB371','D2691E','DC143C',
	'DAA520','00FA9A','4682B4','7CFC00','9932CC','FF0000','FF4500',
	'FF8C00','FFA500','FFD700','FFFF00','9ACD32','32CD32','00FF00',
	'00FF7F','00FFFF','5F9EA0','00BFFF','0000FF','FF00FF','808080',
	'708090','CD853F','8A2BE2','778899','FF1493','48D1CC','1E90FF',
	'40E0D0','4169E1','6A5ACD','BDB76B','BA55D3','CD5C5C','ADFF2F',
	'66CDAA','FF6347','8FBC8B','DA70D6','BC8F8F','9370DB','DB7093',
	'FF7F50','6495ED','A9A9A9','F4A460','7B68EE','D2B48C','E9967A',
	'DEB887','FF69B4','FA8072','F08080','EE82EE','87CEEB','FFA07A',
	'F0E68C','DDA0DD','90EE90','7FFFD4','C0C0C0','87CEFA','B0C4DE',
	'98FB98','ADD8E6','B0E0E6','D8BFD8','EEE8AA','AFEEEE','D3D3D3',
	'FFDEAD');
	}

	}
	diff --git a/plugins/calendar/lib/calendar_ui.php b/plugins/calendar/lib/calendar_ui.php
	index 35a5c9ce..c740e4aa 100644
	--- a/plugins/calendar/lib/calendar_ui.php
	+++ b/plugins/calendar/lib/calendar_ui.php
	@@ -1,820 +1,813 @@
	<?php
	/**
	* User Interface class for the Calendar plugin
	*
	* @version @package_version@
	* @author Lazlo Westerhof <hello@lazlo.me>
	* @author Thomas Bruederli <bruederli@kolabsys.com>
	*
	* Copyright (C) 2010, Lazlo Westerhof <hello@lazlo.me>
	* 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 calendar_ui
	{
	private $rc;
	private $cal;
	private $ready = false;
	public $screen;

	function __construct($cal)
	{
	$this->cal = $cal;
	$this->rc = $cal->rc;
	$this->screen = $this->rc->task == 'calendar' ? ($this->rc->action ? $this->rc->action: 'calendar') : 'other';
	}

	/**
	* Calendar UI initialization and requests handlers
	*/
	public function init()
	{
	if ($this->ready) // already done
	return;

	// add taskbar button
	$this->cal->add_button(array(
	'command' => 'calendar',
	'class' => 'button-calendar',
	'classsel' => 'button-calendar button-selected',
	'innerclass' => 'button-inner',
	'label' => 'calendar.calendar',
	), 'taskbar');

	// load basic client script (which - unfortunately - requires fullcalendar)
	$this->cal->include_script('lib/js/fullcalendar.js');
	$this->cal->include_script('calendar_base.js');

	$skin = $this->rc->config->get('skin');
	$this->cal->include_stylesheet('skins/' . $skin . '/calendar.css');

	$this->ready = true;
	}

	/**
	* Register handler methods for the template engine
	*/
	public function init_templates()
	{
	$this->cal->register_handler('plugin.calendar_css', array($this, 'calendar_css'));
	$this->cal->register_handler('plugin.calendar_list', array($this, 'calendar_list'));
	$this->cal->register_handler('plugin.calendar_select', array($this, 'calendar_select'));
	$this->cal->register_handler('plugin.category_select', array($this, 'category_select'));
	$this->cal->register_handler('plugin.freebusy_select', array($this, 'freebusy_select'));
	$this->cal->register_handler('plugin.priority_select', array($this, 'priority_select'));
	$this->cal->register_handler('plugin.sensitivity_select', array($this, 'sensitivity_select'));
	$this->cal->register_handler('plugin.alarm_select', array($this, 'alarm_select'));
	$this->cal->register_handler('plugin.snooze_select', array($this, 'snooze_select'));
	$this->cal->register_handler('plugin.recurrence_form', array($this, 'recurrence_form'));
	$this->cal->register_handler('plugin.attachments_form', array($this, 'attachments_form'));
	$this->cal->register_handler('plugin.attachments_list', array($this, 'attachments_list'));
	$this->cal->register_handler('plugin.attendees_list', array($this, 'attendees_list'));
	$this->cal->register_handler('plugin.attendees_form', array($this, 'attendees_form'));
	$this->cal->register_handler('plugin.attendees_freebusy_table', array($this, 'attendees_freebusy_table'));
	$this->cal->register_handler('plugin.edit_attendees_notify', array($this, 'edit_attendees_notify'));
	$this->cal->register_handler('plugin.edit_recurring_warning', array($this, 'recurring_event_warning'));
	$this->cal->register_handler('plugin.event_rsvp_buttons', array($this, 'event_rsvp_buttons'));
	$this->cal->register_handler('plugin.angenda_options', array($this, 'angenda_options'));
	$this->cal->register_handler('plugin.events_import_form', array($this, 'events_import_form'));
	$this->cal->register_handler('plugin.searchform', array($this->rc->output, 'search_form')); // use generic method from rcube_template
	}

	/**
	* Adds CSS stylesheets to the page header
	*/
	public function addCSS()
	{
	$skin = $this->rc->config->get('skin');
	$this->cal->include_stylesheet('skins/' . $skin . '/fullcalendar.css');
	$this->cal->include_stylesheet('skins/' . $skin . '/jquery.miniColors.css');
	}

	/**
	* Adds JS files to the page header
	*/
	public function addJS()
	{
	$this->cal->include_script('calendar_ui.js');
	$this->cal->include_script('lib/js/jquery.miniColors.min.js');
	}

	/**
	*
	*/
	function calendar_css($attrib = array())
	{
	$mode = $this->rc->config->get('calendar_event_coloring', $this->cal->defaults['calendar_event_coloring']);
	$categories = $this->cal->driver->list_categories();
	$css = "\n";

	foreach ((array)$categories as $class => $color) {
	if (empty($color))
	continue;

	$class = 'cat-' . asciiwords(strtolower($class), true);
	$css .= ".$class { color: #$color }\n";
	if ($mode > 0) {
	if ($mode == 2) {
	$css .= ".fc-event-$class .fc-event-bg {";
	$css .= " opacity: 0.9;";
	$css .= " filter: alpha(opacity=90);";
	}
	else {
	$css .= ".fc-event-$class.fc-event-skin, ";
	$css .= ".fc-event-$class .fc-event-skin, ";
	$css .= ".fc-event-$class .fc-event-inner {";
	}
	$css .= " background-color: #" . $color . ";";
	if ($mode % 2)
	$css .= " border-color: #$color;";
	$css .= "}\n";
	}
	}

	$calendars = $this->cal->driver->list_calendars();
	foreach ((array)$calendars as $id => $prop) {
	if (!$prop['color'])
	continue;
	$color = $prop['color'];
	$class = 'cal-' . asciiwords($id, true);
	$css .= "li.$class, #eventshow .$class { color: #$color }\n";
	if ($mode != 1) {
	if ($mode == 3) {
	$css .= ".fc-event-$class .fc-event-bg {";
	$css .= " opacity: 0.9;";
	$css .= " filter: alpha(opacity=90);";
	}
	else {
	$css .= ".fc-event-$class, ";
	$css .= ".fc-event-$class .fc-event-inner {";
	}
	if (!$attrib['printmode'])
	$css .= " background-color: #$color;";
	if ($mode % 2 == 0)
	$css .= " border-color: #$color;";
	$css .= "}\n";
	}
	$css .= ".$class .handle { background-color: #$color; }";
	}

	return html::tag('style', array('type' => 'text/css'), $css);
	}

	/**
	*
	*/
	function calendar_list($attrib = array())
	{
	$calendars = $this->cal->driver->list_calendars();

	$li = '';
	foreach ((array)$calendars as $id => $prop) {
	if ($attrib['activeonly'] && !$prop['active'])
	continue;

	unset($prop['user_id']);
	$prop['alarms'] = $this->cal->driver->alarms;
	$prop['attendees'] = $this->cal->driver->attendees;
	$prop['freebusy'] = $this->cal->driver->freebusy;
	$prop['attachments'] = $this->cal->driver->attachments;
	$prop['undelete'] = $this->cal->driver->undelete;
	$prop['feedurl'] = $this->cal->get_url(array('_cal' => $this->cal->ical_feed_hash($id) . '.ics', 'action' => 'feed'));
	$jsenv[$id] = $prop;

	$html_id = html_identifier($id);
	$class = 'cal-' . asciiwords($id, true);

	if ($prop['readonly'])
	$class .= ' readonly';
	if ($prop['class_name'])
	$class .= ' '.$prop['class_name'];

	$li .= html::tag('li', array('id' => 'rcmlical' . $html_id, 'class' => $class),
	html::tag('input', array('type' => 'checkbox', 'name' => '_cal[]', 'value' => $id, 'checked' => $prop['active']), '') .
	html::span('handle', ' ') .
	html::span('calname', Q($prop['name'])));
	}

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

	return html::tag('ul', $attrib, $li, html::$common_attrib);
	}

	/**
	*
	*/
	function angenda_options($attrib = array())
	{
	$attrib += array('id' => 'agendaoptions');
	$attrib['style'] .= 'display:none';

	$select_range = new html_select(array('name' => 'listrange', 'id' => 'agenda-listrange'));
	$select_range->add(1 . ' ' . preg_replace('/$.+$/', '', $this->cal->gettext('days')), $days);
	foreach (array(2,5,7,14,30,60,90) as $days)
	$select_range->add($days . ' ' . preg_replace('/$\|$/', '', $this->cal->gettext('days')), $days);

	$html .= html::label('agenda-listrange', $this->cal->gettext('listrange'));
	$html .= $select_range->show($this->rc->config->get('calendar_agenda_range', $this->cal->defaults['calendar_agenda_range']));

	$select_sections = new html_select(array('name' => 'listsections', 'id' => 'agenda-listsections'));
	$select_sections->add('---', '');
	foreach (array('day' => 'days', 'week' => 'weeks', 'month' => 'months', 'smart' => 'smartsections') as $val => $label)
	$select_sections->add(preg_replace('/$\|$/', '', ucfirst($this->cal->gettext($label))), $val);

	$html .= html::span('spacer', '&nbsp');
	$html .= html::label('agenda-listsections', $this->cal->gettext('listsections'));
	$html .= $select_sections->show($this->rc->config->get('calendar_agenda_sections', $this->cal->defaults['calendar_agenda_sections']));

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

	/**
	* Render a HTML select box for calendar selection
	*/
	function calendar_select($attrib = array())
	{
	$attrib['name'] = 'calendar';
	$select = new html_select($attrib);
	foreach ((array)$this->cal->driver->list_calendars() as $id => $prop) {
	if (!$prop['readonly'])
	$select->add($prop['name'], $id);
	}

	return $select->show(null);
	}

	/**
	* Render a HTML select box to select an event category
	*/
	function category_select($attrib = array())
	{
	$attrib['name'] = 'categories';
	$select = new html_select($attrib);
	$select->add('---', '');
	foreach ((array)$this->cal->driver->list_categories() as $cat => $color) {
	$select->add($cat, $cat);
	}

	return $select->show(null);
	}

	/**
	* Render a HTML select box for free/busy/out-of-office property
	*/
	function freebusy_select($attrib = array())
	{
	$attrib['name'] = 'freebusy';
	$select = new html_select($attrib);
	$select->add($this->cal->gettext('free'), 'free');
	$select->add($this->cal->gettext('busy'), 'busy');
	$select->add($this->cal->gettext('outofoffice'), 'outofoffice');
	$select->add($this->cal->gettext('tentative'), 'tentative');
	return $select->show(null);
	}

	/**
	* Render a HTML select for event priorities
	*/
	function priority_select($attrib = array())
	{
	$attrib['name'] = 'priority';
	$select = new html_select($attrib);
	$select->add('---', '0');
	$select->add('1 '.$this->cal->gettext('highest'), '1');
	$select->add('2 '.$this->cal->gettext('high'), '2');
	$select->add('3 ', '3');
	$select->add('4 ', '4');
	$select->add('5 '.$this->cal->gettext('normal'), '5');
	$select->add('6 ', '6');
	$select->add('7 ', '7');
	$select->add('8 '.$this->cal->gettext('low'), '8');
	$select->add('9 '.$this->cal->gettext('lowest'), '9');
	return $select->show(null);
	}

	/**
	* Render HTML input for sensitivity selection
	*/
	function sensitivity_select($attrib = array())
	{
	$attrib['name'] = 'sensitivity';
	$select = new html_select($attrib);
	$select->add($this->cal->gettext('public'), '0');
	$select->add($this->cal->gettext('private'), '1');
	$select->add($this->cal->gettext('confidential'), '2');
	return $select->show(null);
	}

	/**
	* Render HTML form for alarm configuration
	*/
	function alarm_select($attrib = array())
	{
	unset($attrib['name']);
	$select_type = new html_select(array('name' => 'alarmtype[]', 'class' => 'edit-alarm-type'));
	$select_type->add($this->cal->gettext('none'), '');
	foreach ($this->cal->driver->alarm_types as $type)
	$select_type->add($this->cal->gettext(strtolower("alarm{$type}option")), $type);

	$input_value = new html_inputfield(array('name' => 'alarmvalue[]', 'class' => 'edit-alarm-value', 'size' => 3));
	$input_date = new html_inputfield(array('name' => 'alarmdate[]', 'class' => 'edit-alarm-date', 'size' => 10));
	$input_time = new html_inputfield(array('name' => 'alarmtime[]', 'class' => 'edit-alarm-time', 'size' => 6));

	$select_offset = new html_select(array('name' => 'alarmoffset[]', 'class' => 'edit-alarm-offset'));
	foreach (array('-M','-H','-D','+M','+H','+D','@') as $trigger)
	$select_offset->add($this->cal->gettext('trigger' . $trigger), $trigger);

	// pre-set with default values from user settings
	$preset = calendar::parse_alaram_value($this->rc->config->get('calendar_default_alarm_offset', '-15M'));
	$hidden = array('style' => 'display:none');
	$html = html::span('edit-alarm-set',
	$select_type->show($this->rc->config->get('calendar_default_alarm_type', '')) . ' ' .
	html::span(array('class' => 'edit-alarm-values', 'style' => 'display:none'),
	$input_value->show($preset[0]) . ' ' .
	$select_offset->show($preset[1]) . ' ' .
	$input_date->show('', $hidden) . ' ' .
	$input_time->show('', $hidden)
	)
	);

	// TODO: support adding more alarms
	#$html .= html::a(array('href' => '#', 'id' => 'edit-alam-add', 'title' => $this->cal->gettext('addalarm')),
	# $attrib['addicon'] ? html::img(array('src' => $attrib['addicon'], 'alt' => 'add')) : '(+)');

	return $html;
	}

	function snooze_select($attrib = array())
	{
	$steps = array(
	5 => 'repeatinmin',
	10 => 'repeatinmin',
	15 => 'repeatinmin',
	20 => 'repeatinmin',
	30 => 'repeatinmin',
	60 => 'repeatinhr',
	120 => 'repeatinhrs',
	1440 => 'repeattomorrow',
	10080 => 'repeatinweek',
	);

	$items = array();
	foreach ($steps as $n => $label) {
	$items[] = html::tag('li', null, html::a(array('href' => "#" . ($n * 60), 'class' => 'active'),
	$this->cal->gettext(array('name' => $label, 'vars' => array('min' => $n % 60, 'hrs' => intval($n / 60))))));
	}

	return html::tag('ul', $attrib, join("\n", $items), html::$common_attrib);
	}

	/**
	*
	*/
	function edit_attendees_notify($attrib = array())
	{
	$checkbox = new html_checkbox(array('name' => '_notify', 'id' => 'edit-attendees-donotify', 'value' => 1));
	return html::div($attrib, html::label(null, $checkbox->show(1) . ' ' . $this->cal->gettext('sendnotifications')));
	}

	/**
	* Generate the form for recurrence settings
	*/
	function recurring_event_warning($attrib = array())
	{
	$attrib['id'] = 'edit-recurring-warning';

	$radio = new html_radiobutton(array('name' => '_savemode', 'class' => 'edit-recurring-savemode'));
	$form = html::label(null, $radio->show('', array('value' => 'current')) . $this->cal->gettext('currentevent')) . ' ' .
	html::label(null, $radio->show('', array('value' => 'future')) . $this->cal->gettext('futurevents')) . ' ' .
	html::label(null, $radio->show('all', array('value' => 'all')) . $this->cal->gettext('allevents')) . ' ' .
	html::label(null, $radio->show('', array('value' => 'new')) . $this->cal->gettext('saveasnew'));

	return html::div($attrib, html::div('message', html::span('ui-icon ui-icon-alert', '') . $this->cal->gettext('changerecurringeventwarning')) . html::div('savemode', $form));
	}

	/**
	* Generate the form for recurrence settings
	*/
	function recurrence_form($attrib = array())
	{
	switch ($attrib['part']) {
	// frequency selector
	case 'frequency':
	$select = new html_select(array('name' => 'frequency', 'id' => 'edit-recurrence-frequency'));
	$select->add($this->cal->gettext('never'), '');
	$select->add($this->cal->gettext('daily'), 'DAILY');
	$select->add($this->cal->gettext('weekly'), 'WEEKLY');
	$select->add($this->cal->gettext('monthly'), 'MONTHLY');
	$select->add($this->cal->gettext('yearly'), 'YEARLY');
	$html = html::label('edit-frequency', $this->cal->gettext('frequency')) . $select->show('');
	break;

	// daily recurrence
	case 'daily':
	$select = $this->interval_selector(array('name' => 'interval', 'class' => 'edit-recurrence-interval', 'id' => 'edit-recurrence-interval-daily'));
	$html = html::div($attrib, html::label(null, $this->cal->gettext('every')) . $select->show(1) . html::span('label-after', $this->cal->gettext('days')));
	break;

	// weekly recurrence form
	case 'weekly':
	$select = $this->interval_selector(array('name' => 'interval', 'class' => 'edit-recurrence-interval', 'id' => 'edit-recurrence-interval-weekly'));
	$html = html::div($attrib, html::label(null, $this->cal->gettext('every')) . $select->show(1) . html::span('label-after', $this->cal->gettext('weeks')));
	// weekday selection
	$daymap = array('sun','mon','tue','wed','thu','fri','sat');
	$checkbox = new html_checkbox(array('name' => 'byday', 'class' => 'edit-recurrence-weekly-byday'));
	$first = $this->rc->config->get('calendar_first_day', 1);
	for ($weekdays = '', $j = $first; $j <= $first+6; $j++) {
	$d = $j % 7;
	$weekdays .= html::label(array('class' => 'weekday'), $checkbox->show('', array('value' => strtoupper(substr($daymap[$d], 0, 2)))) . $this->cal->gettext($daymap[$d])) . ' ';
	}
	$html .= html::div($attrib, html::label(null, $this->cal->gettext('bydays')) . $weekdays);
	break;

	// monthly recurrence form
	case 'monthly':
	$select = $this->interval_selector(array('name' => 'interval', 'class' => 'edit-recurrence-interval', 'id' => 'edit-recurrence-interval-monthly'));
	$html = html::div($attrib, html::label(null, $this->cal->gettext('every')) . $select->show(1) . html::span('label-after', $this->cal->gettext('months')));

	-/* multiple month selection is not supported by Kolab
	- $checkbox = new html_radiobutton(array('name' => 'bymonthday', 'class' => 'edit-recurrence-monthly-bymonthday'));
	+ $checkbox = new html_checkbox(array('name' => 'bymonthday', 'class' => 'edit-recurrence-monthly-bymonthday'));
	for ($monthdays = '', $d = 1; $d <= 31; $d++) {
	$monthdays .= html::label(array('class' => 'monthday'), $checkbox->show('', array('value' => $d)) . $d);
	$monthdays .= $d % 7 ? ' ' : html::br();
	}
	-*/
	+
	// rule selectors
	$radio = new html_radiobutton(array('name' => 'repeatmode', 'class' => 'edit-recurrence-monthly-mode'));
	$table = new html_table(array('cols' => 2, 'border' => 0, 'cellpadding' => 0, 'class' => 'formtable'));
	- $table->add('label', html::label(null, $radio->show('BYMONTHDAY', array('value' => 'BYMONTHDAY')) . ' ' . $this->cal->gettext('onsamedate'))); // $this->cal->gettext('each')
	+ $table->add('label', html::label(null, $radio->show('BYMONTHDAY', array('value' => 'BYMONTHDAY')) . ' ' . $this->cal->gettext('each')));
	$table->add(null, $monthdays);
	$table->add('label', html::label(null, $radio->show('', array('value' => 'BYDAY')) . ' ' . $this->cal->gettext('onevery')));
	$table->add(null, $this->rrule_selectors($attrib['part']));

	$html .= html::div($attrib, $table->show());

	break;

	// annually recurrence form
	case 'yearly':
	$select = $this->interval_selector(array('name' => 'interval', 'class' => 'edit-recurrence-interval', 'id' => 'edit-recurrence-interval-yearly'));
	$html = html::div($attrib, html::label(null, $this->cal->gettext('every')) . $select->show(1) . html::span('label-after', $this->cal->gettext('years')));
	// month selector
	$monthmap = array('','jan','feb','mar','apr','may','jun','jul','aug','sep','oct','nov','dec');
	- $boxtype = is_a($this->cal->driver, 'kolab_driver') ? 'radio' : 'checkbox';
	- $checkbox = new html_inputfield(array('type' => $boxtype, 'name' => 'bymonth', 'class' => 'edit-recurrence-yearly-bymonth'));
	+ $checkbox = new html_checkbox(array('name' => 'bymonth', 'class' => 'edit-recurrence-yearly-bymonth'));
	for ($months = '', $m = 1; $m <= 12; $m++) {
	$months .= html::label(array('class' => 'month'), $checkbox->show(null, array('value' => $m)) . $this->cal->gettext($monthmap[$m]));
	$months .= $m % 4 ? ' ' : html::br();
	}
	$html .= html::div($attrib + array('id' => 'edit-recurrence-yearly-bymonthblock'), $months);

	// day rule selection
	$html .= html::div($attrib, html::label(null, $this->cal->gettext('onevery')) . $this->rrule_selectors($attrib['part'], '---'));
	break;

	// end of recurrence form
	case 'until':
	$radio = new html_radiobutton(array('name' => 'repeat', 'class' => 'edit-recurrence-until'));
	$select = $this->interval_selector(array('name' => 'times', 'id' => 'edit-recurrence-repeat-times'));
	$input = new html_inputfield(array('name' => 'untildate', 'id' => 'edit-recurrence-enddate', 'size' => "10"));

	$table = new html_table(array('cols' => 2, 'border' => 0, 'cellpadding' => 0, 'class' => 'formtable'));

	$table->add('label', ucfirst($this->cal->gettext('recurrencend')));
	$table->add(null, html::label(null, $radio->show('', array('value' => '', 'id' => 'edit-recurrence-repeat-forever')) . ' ' .
	$this->cal->gettext('forever')));

	$table->add('label', '');
	$table->add(null, $radio->show('', array('value' => 'count', 'id' => 'edit-recurrence-repeat-count')) . ' ' .
	$this->cal->gettext(array(
	'name' => 'forntimes',
	'vars' => array('nr' => $select->show(1)))
	));

	$table->add('label', '');
	$table->add(null, $radio->show('', array('value' => 'until', 'id' => 'edit-recurrence-repeat-until')) . ' ' .
	$this->cal->gettext('untildate') . ' ' . $input->show(''));
	$html = $table->show();
	break;
	}

	return $html;
	}

	/**
	* Input field for interval selection
	*/
	private function interval_selector($attrib)
	{
	$select = new html_select($attrib);
	$select->add(range(1,30), range(1,30));
	return $select;
	}

	/**
	* Drop-down menus for recurrence rules like "each last sunday of"
	*/
	private function rrule_selectors($part, $noselect = null)
	{
	// rule selectors
	$select_prefix = new html_select(array('name' => 'bydayprefix', 'id' => "edit-recurrence-$part-prefix"));
	if ($noselect) $select_prefix->add($noselect, '');
	$select_prefix->add(array(
	$this->cal->gettext('first'),
	$this->cal->gettext('second'),
	$this->cal->gettext('third'),
	- $this->cal->gettext('fourth')
	+ $this->cal->gettext('fourth'),
	+ $this->cal->gettext('last')
	),
	- array(1, 2, 3, 4));
	-
	- // Kolab doesn't support 'last' but others do.
	- if (!is_a($this->cal->driver, 'kolab_driver'))
	- $select_prefix->add($this->cal->gettext('last'), -1);
	+ array(1, 2, 3, 4, -1));

	$select_wday = new html_select(array('name' => 'byday', 'id' => "edit-recurrence-$part-byday"));
	if ($noselect) $select_wday->add($noselect, '');

	$daymap = array('sunday','monday','tuesday','wednesday','thursday','friday','saturday');
	$first = $this->rc->config->get('calendar_first_day', 1);
	for ($j = $first; $j <= $first+6; $j++) {
	$d = $j % 7;
	$select_wday->add($this->cal->gettext($daymap[$d]), strtoupper(substr($daymap[$d], 0, 2)));
	}
	- if ($part == 'monthly')
	- $select_wday->add($this->cal->gettext('dayofmonth'), '');

	return $select_prefix->show() . ' ' . $select_wday->show();
	}

	/**
	* Form for uploading and importing events
	*/
	function events_import_form($attrib = array())
	{
	if (!$attrib['id'])
	$attrib['id'] = 'rcmImportForm';

	// Get max filesize, enable upload progress bar
	$max_filesize = rcube_upload_init();

	$button = new html_inputfield(array('type' => 'button'));
	$input = new html_inputfield(array(
	'type' => 'file', 'name' => '_data', 'size' => $attrib['uploadfieldsize']));

	$select = new html_select(array('name' => '_range', 'id' => 'event-import-range'));
	$select->add(array(
	$this->cal->gettext('onemonthback'),
	$this->cal->gettext(array('name' => 'nmonthsback', 'vars' => array('nr'=>2))),
	$this->cal->gettext(array('name' => 'nmonthsback', 'vars' => array('nr'=>6))),
	$this->cal->gettext(array('name' => 'nmonthsback', 'vars' => array('nr'=>12))),
	$this->cal->gettext('all'),
	),
	array('1','2','6','12',0));

	$html .= html::div('form-section',
	html::div(null, $input->show()) .
	html::div('hint', rcube_label(array('name' => 'maxuploadsize', 'vars' => array('size' => $max_filesize))))
	);

	$html .= html::div('form-section',
	html::label('event-import-calendar', $this->cal->gettext('calendar')) .
	$this->calendar_select(array('name' => 'calendar', 'id' => 'event-import-calendar'))
	);

	$html .= html::div('form-section',
	html::label('event-import-range', $this->cal->gettext('importrange')) .
	$select->show(1)
	);

	$this->rc->output->add_gui_object('importform', $attrib['id']);
	$this->rc->output->add_label('import');

	return html::tag('form', array('action' => $this->rc->url(array('task' => 'calendar', 'action' => 'import_events')),
	'method' => "post", 'enctype' => 'multipart/form-data', 'id' => $attrib['id']),
	$html
	);
	}

	/**
	* Generate the form for event attachments upload
	*/
	function attachments_form($attrib = array())
	{
	// add ID if not given
	if (!$attrib['id'])
	$attrib['id'] = 'rcmUploadForm';

	// Get max filesize, enable upload progress bar
	$max_filesize = rcube_upload_init();

	$button = new html_inputfield(array('type' => 'button'));
	$input = new html_inputfield(array(
	'type' => 'file', 'name' => '_attachments[]',
	'multiple' => 'multiple', 'size' => $attrib['attachmentfieldsize']));

	return html::div($attrib,
	html::div(null, $input->show()) .
	html::div('buttons', $button->show(rcube_label('upload'), array('class' => 'button mainaction',
	'onclick' => JS_OBJECT_NAME . ".upload_file(this.form)"))) .
	html::div('hint', rcube_label(array('name' => 'maxuploadsize', 'vars' => array('size' => $max_filesize))))
	);
	}

	/**
	* Generate HTML element for attachments list
	*/
	function attachments_list($attrib = array())
	{
	if (!$attrib['id'])
	$attrib['id'] = 'rcmAttachmentList';

	$skin_path = $this->rc->config->get('skin_path');
	if ($attrib['deleteicon']) {
	$_SESSION['calendar_deleteicon'] = $skin_path . $attrib['deleteicon'];
	$this->rc->output->set_env('deleteicon', $skin_path . $attrib['deleteicon']);
	}
	if ($attrib['cancelicon'])
	$this->rc->output->set_env('cancelicon', $skin_path . $attrib['cancelicon']);
	if ($attrib['loadingicon'])
	$this->rc->output->set_env('loadingicon', $skin_path . $attrib['loadingicon']);

	$this->rc->output->add_gui_object('attachmentlist', $attrib['id']);

	return html::tag('ul', $attrib, '', html::$common_attrib);
	}

	function attachment_controls($attrib = array())
	{
	$table = new html_table(array('cols' => 3));

	if (!empty($this->cal->attachment['name'])) {
	$table->add('title', Q(rcube_label('filename')));
	$table->add(null, Q($this->cal->attachment['name']));
	$table->add(null, '[' . html::a('?'.str_replace('_frame=', '_download=', $_SERVER['QUERY_STRING']), Q(rcube_label('download'))) . ']');
	}

	if (!empty($this->cal->attachment['size'])) {
	$table->add('title', Q(rcube_label('filesize')));
	$table->add(null, Q(show_bytes($this->cal->attachment['size'])));
	}

	return $table->show($attrib);
	}

	/**
	* Handler for calendar form template.
	* The form content could be overriden by the driver
	*/
	function calendar_editform($action, $calendar = array())
	{
	// compose default calendar form fields
	$input_name = new html_inputfield(array('name' => 'name', 'id' => 'calendar-name', 'size' => 20));
	$input_color = new html_inputfield(array('name' => 'color', 'id' => 'calendar-color', 'size' => 6));

	$formfields = array(
	'name' => array(
	'label' => $this->cal->gettext('name'),
	'value' => $input_name->show($name),
	'id' => 'calendar-name',
	),
	'color' => array(
	'label' => $this->cal->gettext('color'),
	'value' => $input_color->show($calendar['color']),
	'id' => 'calendar-color',
	),
	);

	if ($this->cal->driver->alarms) {
	$checkbox = new html_checkbox(array('name' => 'showalarms', 'id' => 'calendar-showalarms', 'value' => 1));
	$formfields['showalarms'] = array(
	'label' => $this->cal->gettext('showalarms'),
	'value' => $checkbox->show($calendar['showalarms']?1:0),
	'id' => 'calendar-showalarms',
	);
	}

	// allow driver to extend or replace the form content
	return html::tag('form', array('action' => "#", 'method' => "get", 'id' => 'calendarpropform'),
	$this->cal->driver->calendar_form($action, $calendar, $formfields)
	);
	}

	/**
	*
	*/
	function attendees_list($attrib = array())
	{
	$table = new html_table(array('cols' => 5, 'border' => 0, 'cellpadding' => 0, 'class' => 'rectable'));
	$table->add_header('role', $this->cal->gettext('role'));
	$table->add_header('name', $this->cal->gettext('attendee'));
	$table->add_header('availability', $this->cal->gettext('availability'));
	$table->add_header('confirmstate', $this->cal->gettext('confirmstate'));
	$table->add_header('options', '');

	return $table->show($attrib);
	}

	/**
	*
	*/
	function attendees_form($attrib = array())
	{
	$input = new html_inputfield(array('name' => 'participant', 'id' => 'edit-attendee-name', 'size' => 30));
	$checkbox = new html_checkbox(array('name' => 'invite', 'id' => 'edit-attendees-invite', 'value' => 1));

	return html::div($attrib,
	html::div(null, $input->show() . " " .
	html::tag('input', array('type' => 'button', 'class' => 'button', 'id' => 'edit-attendee-add', 'value' => $this->cal->gettext('addattendee'))) . " " .
	html::tag('input', array('type' => 'button', 'class' => 'button', 'id' => 'edit-attendee-schedule', 'value' => $this->cal->gettext('scheduletime').'...'))) .
	html::p('attendees-invitebox', html::label(null, $checkbox->show(1) . $this->cal->gettext('sendinvitations')))
	);
	}

	/**
	*
	*/
	function attendees_freebusy_table($attrib = array())
	{
	$table = new html_table(array('cols' => 2, 'border' => 0, 'cellspacing' => 0));
	$table->add('attendees',
	html::tag('h3', 'boxtitle', $this->cal->gettext('tabattendees')) .
	html::div('timesheader', ' ') .
	html::div(array('id' => 'schedule-attendees-list', 'class' => 'attendees-list'), '')
	);
	$table->add('times',
	html::div('scroll',
	html::tag('table', array('id' => 'schedule-freebusy-times', 'border' => 0, 'cellspacing' => 0), html::tag('thead') . html::tag('tbody')) .
	html::div(array('id' => 'schedule-event-time', 'style' => 'display:none'), ' ')
	)
	);

	return $table->show($attrib);
	}

	/**
	* Render event details in a table
	*/
	function event_details_table($event, $title)
	{
	$table = new html_table(array('cols' => 2, 'border' => 0, 'class' => 'calendar-eventdetails'));
	$table->add('ititle', $title);
	$table->add('title', Q($event['title']));
	$table->add('label', $this->cal->gettext('date'));
	$table->add('location', Q($this->cal->event_date_text($event)));
	if ($event['location']) {
	$table->add('label', $this->cal->gettext('location'));
	$table->add('location', Q($event['location']));
	}

	return $table->show();
	}

	/**
	*
	*/
	function event_invitebox($attrib = array())
	{
	if ($this->cal->event) {
	return html::div($attrib,
	$this->event_details_table($this->cal->event, $this->cal->gettext('itipinvitation')) .
	$this->cal->invitestatus
	);
	}

	return '';
	}

	function event_rsvp_buttons($attrib = array())
	{
	$attrib += array('type' => 'button');
	foreach (array('accepted','tentative','declined') as $method) {
	$buttons .= html::tag('input', array(
	'type' => $attrib['type'],
	'name' => $attrib['iname'],
	'class' => 'button',
	'rel' => $method,
	'value' => $this->cal->gettext('itip' . $method),
	));
	}

	return html::div($attrib,
	html::div('label', $this->cal->gettext('acceptinvitation')) .
	html::div('rsvp-buttons', $buttons));
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Aug 18, 12:11 AM (1 d, 20 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1258461
Default Alt Text: (73 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions