diff --git a/plugins/libcalendaring/lib/Horde_Date.php b/plugins/libcalendaring/lib/Horde_Date.php
index 9197f846..5265acd5 100644
--- a/plugins/libcalendaring/lib/Horde_Date.php
+++ b/plugins/libcalendaring/lib/Horde_Date.php
@@ -1,1304 +1,1304 @@
 <?php
 
 /**
  * This is a concatenated copy of the following files:
  *   Horde/Date/Utils.php, Horde/Date/Recurrence.php
  * Pull the latest version of these files from the PEAR channel of the Horde
  * project at http://pear.horde.org by installing the Horde_Date package.
  */
 
 
 /**
  * Horde Date wrapper/logic class, including some calculation
  * functions.
  *
  * @category Horde
  * @package  Date
  *
  * @TODO in format():
  *   http://php.net/intldateformatter
  *
  * @TODO on timezones:
  *   http://trac.agavi.org/ticket/1008
  *   http://trac.agavi.org/changeset/3659
  *
  * @TODO on switching to PHP::DateTime:
  *   The only thing ever stored in the database *IS* Unix timestamps. Doing
  *   anything other than that is unmanageable, yet some frameworks use 'server
  *   based' times in their systems, simply because they do not bother with
  *   daylight saving and only 'serve' one timezone!
  *
  *   The second you have to manage 'real' time across timezones then daylight
  *   saving becomes essential, BUT only on the display side! Since the browser
  *   only provides a time offset, this is useless and to be honest should simply
  *   be ignored ( until it is upgraded to provide the correct information ;)
  *   ). So we need a 'display' function that takes a simple numeric epoch, and a
  *   separate timezone id into which the epoch is to be 'converted'. My W3C
  *   mapping works simply because ADOdb then converts that to it's own simple
  *   offset abbreviation - in my case GMT or BST. As long as DateTime passes the
  *   full 64 bit number the date range from 100AD is also preserved ( and
  *   further back if 2 digit years are disabled ). If I want to display the
  *   'real' timezone with this 'time' then I just add it in place of ADOdb's
  *   'timezone'. I am tempted to simply adjust the ADOdb class to take a
  *   timezone in place of the simple GMT switch it currently uses.
  *
  *   The return path is just the reverse and simply needs to take the client
  *   display offset off prior to storage of the UTC epoch. SO we use
  *   DateTimeZone to get an offset value for the clients timezone and simply add
  *   or subtract this from a timezone agnostic display on the client end when
  *   entering new times.
  *
  *
  *   It's not really feasible to store dates in specific timezone, as most
  *   national/local timezones support DST - and that is a pain to support, as
  *   eg.  sorting breaks when some timestamps get repeated. That's why it's
  *   usually better to store datetimes as either UTC datetime or plain unix
  *   timestamp. I usually go with the former - using database datetime type.
  */
 
 /**
  * @category Horde
  * @package  Date
  */
 class Horde_Date
 {
     const DATE_SUNDAY = 0;
     const DATE_MONDAY = 1;
     const DATE_TUESDAY = 2;
     const DATE_WEDNESDAY = 3;
     const DATE_THURSDAY = 4;
     const DATE_FRIDAY = 5;
     const DATE_SATURDAY = 6;
 
     const MASK_SUNDAY = 1;
     const MASK_MONDAY = 2;
     const MASK_TUESDAY = 4;
     const MASK_WEDNESDAY = 8;
     const MASK_THURSDAY = 16;
     const MASK_FRIDAY = 32;
     const MASK_SATURDAY = 64;
     const MASK_WEEKDAYS = 62;
     const MASK_WEEKEND = 65;
     const MASK_ALLDAYS = 127;
 
     const MASK_SECOND = 1;
     const MASK_MINUTE = 2;
     const MASK_HOUR = 4;
     const MASK_DAY = 8;
     const MASK_MONTH = 16;
     const MASK_YEAR = 32;
     const MASK_ALLPARTS = 63;
 
     const DATE_DEFAULT = 'Y-m-d H:i:s';
     const DATE_JSON = 'Y-m-d\TH:i:s';
 
     /**
      * Year
      *
      * @var integer
      */
     protected $_year;
 
     /**
      * Month
      *
      * @var integer
      */
     protected $_month;
 
     /**
      * Day
      *
      * @var integer
      */
     protected $_mday;
 
     /**
      * Hour
      *
      * @var integer
      */
     protected $_hour = 0;
 
     /**
      * Minute
      *
      * @var integer
      */
     protected $_min = 0;
 
     /**
      * Second
      *
      * @var integer
      */
     protected $_sec = 0;
 
     /**
      * String representation of the date's timezone.
      *
      * @var string
      */
     protected $_timezone;
 
     /**
      * Default format for __toString()
      *
      * @var string
      */
     protected $_defaultFormat = self::DATE_DEFAULT;
 
     /**
      * Default specs that are always supported.
      * @var string
      */
     protected static $_defaultSpecs = '%CdDeHImMnRStTyY';
 
     /**
      * Internally supported strftime() specifiers.
      * @var string
      */
     protected static $_supportedSpecs = '';
 
     /**
      * Map of required correction masks.
      *
      * @see __set()
      *
      * @var array
      */
     protected static $_corrections = array(
         'year'  => self::MASK_YEAR,
         'month' => self::MASK_MONTH,
         'mday'  => self::MASK_DAY,
         'hour'  => self::MASK_HOUR,
         'min'   => self::MASK_MINUTE,
         'sec'   => self::MASK_SECOND,
     );
 
     protected $_formatCache = array();
 
     /**
      * Builds a new date object. If $date contains date parts, use them to
      * initialize the object.
      *
      * Recognized formats:
      * - arrays with keys 'year', 'month', 'mday', 'day'
      *   'hour', 'min', 'minute', 'sec'
      * - objects with properties 'year', 'month', 'mday', 'hour', 'min', 'sec'
      * - yyyy-mm-dd hh:mm:ss
      * - yyyymmddhhmmss
      * - yyyymmddThhmmssZ
      * - yyyymmdd (might conflict with unix timestamps between 31 Oct 1966 and
      *   03 Mar 1973)
      * - unix timestamps
      * - anything parsed by strtotime()/DateTime.
      *
      * @throws Horde_Date_Exception
      */
     public function __construct($date = null, $timezone = null)
     {
         if (!self::$_supportedSpecs) {
             self::$_supportedSpecs = self::$_defaultSpecs;
             if (function_exists('nl_langinfo')) {
                 self::$_supportedSpecs .= 'bBpxX';
             }
         }
 
         if (func_num_args() > 2) {
             // Handle args in order: year month day hour min sec tz
             $this->_initializeFromArgs(func_get_args());
             return;
         }
 
         $this->_initializeTimezone($timezone);
 
         if (is_null($date)) {
             return;
         }
 
         if (is_string($date)) {
             $date = trim($date, '"');
         }
 
         if (is_object($date)) {
             $this->_initializeFromObject($date);
         } elseif (is_array($date)) {
             $this->_initializeFromArray($date);
         } elseif (preg_match('/^(\d{4})-?(\d{2})-?(\d{2})T? ?(\d{2}):?(\d{2}):?(\d{2})(?:\.\d+)?(Z?)$/', $date, $parts)) {
             $this->_year  = (int)$parts[1];
             $this->_month = (int)$parts[2];
             $this->_mday  = (int)$parts[3];
             $this->_hour  = (int)$parts[4];
             $this->_min   = (int)$parts[5];
             $this->_sec   = (int)$parts[6];
             if ($parts[7]) {
                 $this->_initializeTimezone('UTC');
             }
         } elseif (preg_match('/^(\d{4})-?(\d{2})-?(\d{2})$/', $date, $parts) &&
                   $parts[2] > 0 && $parts[2] <= 12 &&
                   $parts[3] > 0 && $parts[3] <= 31) {
             $this->_year  = (int)$parts[1];
             $this->_month = (int)$parts[2];
             $this->_mday  = (int)$parts[3];
             $this->_hour = $this->_min = $this->_sec = 0;
         } elseif ((string)(int)$date == $date) {
             // Try as a timestamp.
             $parts = @getdate($date);
             if ($parts) {
                 $this->_year  = $parts['year'];
                 $this->_month = $parts['mon'];
                 $this->_mday  = $parts['mday'];
                 $this->_hour  = $parts['hours'];
                 $this->_min   = $parts['minutes'];
                 $this->_sec   = $parts['seconds'];
             }
         } else {
             // Use date_create() so we can catch errors with PHP 5.2. Use
             // "new DateTime() once we require 5.3.
             $parsed = date_create($date);
             if (!$parsed) {
                 throw new Horde_Date_Exception(sprintf(Horde_Date_Translation::t("Failed to parse time string (%s)"), $date));
             }
             $parsed->setTimezone(new DateTimeZone(date_default_timezone_get()));
             $this->_year  = (int)$parsed->format('Y');
             $this->_month = (int)$parsed->format('m');
             $this->_mday  = (int)$parsed->format('d');
             $this->_hour  = (int)$parsed->format('H');
             $this->_min   = (int)$parsed->format('i');
             $this->_sec   = (int)$parsed->format('s');
             $this->_initializeTimezone(date_default_timezone_get());
         }
     }
 
     /**
      * Returns a simple string representation of the date object
      *
      * @return string  This object converted to a string.
      */
     public function __toString()
     {
         try {
             return $this->format($this->_defaultFormat);
         } catch (Exception $e) {
             return '';
         }
     }
 
     /**
      * Returns a DateTime object representing this object.
      *
      * @return DateTime
      */
     public function toDateTime()
     {
         $date = new DateTime(null, new DateTimeZone($this->_timezone));
         $date->setDate($this->_year, $this->_month, $this->_mday);
         $date->setTime($this->_hour, $this->_min, $this->_sec);
         return $date;
     }
 
     /**
      * Converts a date in the proleptic Gregorian calendar to the no of days
      * since 24th November, 4714 B.C.
      *
      * Returns the no of days since Monday, 24th November, 4714 B.C. in the
      * proleptic Gregorian calendar (which is 24th November, -4713 using
      * 'Astronomical' year numbering, and 1st January, 4713 B.C. in the
      * proleptic Julian calendar).  This is also the first day of the 'Julian
      * Period' proposed by Joseph Scaliger in 1583, and the number of days
      * since this date is known as the 'Julian Day'.  (It is not directly
      * to do with the Julian calendar, although this is where the name
      * is derived from.)
      *
      * The algorithm is valid for all years (positive and negative), and
      * also for years preceding 4714 B.C.
      *
      * Algorithm is from PEAR::Date_Calc
      *
      * @author Monte Ohrt <monte@ispi.net>
      * @author Pierre-Alain Joye <pajoye@php.net>
      * @author Daniel Convissor <danielc@php.net>
      * @author C.A. Woodcock <c01234@netcomuk.co.uk>
      *
      * @return integer  The number of days since 24th November, 4714 B.C.
      */
     public function toDays()
     {
         if (function_exists('GregorianToJD')) {
             return gregoriantojd($this->_month, $this->_mday, $this->_year);
         }
 
         $day = $this->_mday;
         $month = $this->_month;
         $year = $this->_year;
 
         if ($month > 2) {
             // March = 0, April = 1, ..., December = 9,
             // January = 10, February = 11
             $month -= 3;
         } else {
             $month += 9;
             --$year;
         }
 
         $hb_negativeyear = $year < 0;
         $century         = intval($year / 100);
         $year            = $year % 100;
 
         if ($hb_negativeyear) {
             // Subtract 1 because year 0 is a leap year;
             // And N.B. that we must treat the leap years as occurring
             // one year earlier than they do, because for the purposes
             // of calculation, the year starts on 1st March:
             //
             return intval((14609700 * $century + ($year == 0 ? 1 : 0)) / 400) +
                    intval((1461 * $year + 1) / 4) +
                    intval((153 * $month + 2) / 5) +
                    $day + 1721118;
         } else {
             return intval(146097 * $century / 4) +
                    intval(1461 * $year / 4) +
                    intval((153 * $month + 2) / 5) +
                    $day + 1721119;
         }
     }
 
     /**
      * Converts number of days since 24th November, 4714 B.C. (in the proleptic
      * Gregorian calendar, which is year -4713 using 'Astronomical' year
      * numbering) to Gregorian calendar date.
      *
      * Returned date belongs to the proleptic Gregorian calendar, using
      * 'Astronomical' year numbering.
      *
      * The algorithm is valid for all years (positive and negative), and
      * also for years preceding 4714 B.C. (i.e. for negative 'Julian Days'),
      * and so the only limitation is platform-dependent (for 32-bit systems
      * the maximum year would be something like about 1,465,190 A.D.).
      *
      * N.B. Monday, 24th November, 4714 B.C. is Julian Day '0'.
      *
      * Algorithm is from PEAR::Date_Calc
      *
      * @author Monte Ohrt <monte@ispi.net>
      * @author Pierre-Alain Joye <pajoye@php.net>
      * @author Daniel Convissor <danielc@php.net>
      * @author C.A. Woodcock <c01234@netcomuk.co.uk>
      *
      * @param int    $days   the number of days since 24th November, 4714 B.C.
      * @param string $format the string indicating how to format the output
      *
      * @return  Horde_Date  A Horde_Date object representing the date.
      */
     public static function fromDays($days)
     {
-        if (function_exists('JDToGregorian')) {
-            list($month, $day, $year) = explode('/', JDToGregorian($days));
+        if (function_exists('jdtogregorian')) {
+            list($month, $day, $year) = explode('/', jdtogregorian($days));
         } else {
             $days = intval($days);
 
             $days   -= 1721119;
             $century = floor((4 * $days - 1) / 146097);
             $days    = floor(4 * $days - 1 - 146097 * $century);
             $day     = floor($days / 4);
 
             $year = floor((4 * $day +  3) / 1461);
             $day  = floor(4 * $day +  3 - 1461 * $year);
             $day  = floor(($day +  4) / 4);
 
             $month = floor((5 * $day - 3) / 153);
             $day   = floor(5 * $day - 3 - 153 * $month);
             $day   = floor(($day +  5) /  5);
 
             $year = $century * 100 + $year;
             if ($month < 10) {
                 $month +=3;
             } else {
                 $month -=9;
                 ++$year;
             }
         }
 
         return new Horde_Date($year, $month, $day);
     }
 
     /**
      * Getter for the date and time properties.
      *
      * @param string $name  One of 'year', 'month', 'mday', 'hour', 'min' or
      *                      'sec'.
      *
      * @return integer  The property value, or null if not set.
      */
     public function __get($name)
     {
         if ($name == 'day') {
             $name = 'mday';
         }
 
         return $this->{'_' . $name};
     }
 
     /**
      * Setter for the date and time properties.
      *
      * @param string $name    One of 'year', 'month', 'mday', 'hour', 'min' or
      *                        'sec'.
      * @param integer $value  The property value.
      */
     public function __set($name, $value)
     {
         if ($name == 'timezone') {
             $this->_initializeTimezone($value);
             return;
         }
         if ($name == 'day') {
             $name = 'mday';
         }
 
         if ($name != 'year' && $name != 'month' && $name != 'mday' &&
             $name != 'hour' && $name != 'min' && $name != 'sec') {
             throw new InvalidArgumentException('Undefined property ' . $name);
         }
 
         $down = $value < $this->{'_' . $name};
         $this->{'_' . $name} = $value;
         $this->_correct(self::$_corrections[$name], $down);
         $this->_formatCache = array();
     }
 
     /**
      * Returns whether a date or time property exists.
      *
      * @param string $name  One of 'year', 'month', 'mday', 'hour', 'min' or
      *                      'sec'.
      *
      * @return boolen  True if the property exists and is set.
      */
     public function __isset($name)
     {
         if ($name == 'day') {
             $name = 'mday';
         }
         return ($name == 'year' || $name == 'month' || $name == 'mday' ||
                 $name == 'hour' || $name == 'min' || $name == 'sec') &&
             isset($this->{'_' . $name});
     }
 
     /**
      * Adds a number of seconds or units to this date, returning a new Date
      * object.
      */
     public function add($factor)
     {
         $d = clone($this);
         if (is_array($factor) || is_object($factor)) {
             foreach ($factor as $property => $value) {
                 $d->$property += $value;
             }
         } else {
             $d->sec += $factor;
         }
 
         return $d;
     }
 
     /**
      * Subtracts a number of seconds or units from this date, returning a new
      * Horde_Date object.
      */
     public function sub($factor)
     {
         if (is_array($factor)) {
             foreach ($factor as &$value) {
                 $value *= -1;
             }
         } else {
             $factor *= -1;
         }
 
         return $this->add($factor);
     }
 
     /**
      * Converts this object to a different timezone.
      *
      * @param string $timezone  The new timezone.
      *
      * @return Horde_Date  This object.
      */
     public function setTimezone($timezone)
     {
         $date = $this->toDateTime();
         $date->setTimezone(new DateTimeZone($timezone));
         $this->_timezone = $timezone;
         $this->_year     = (int)$date->format('Y');
         $this->_month    = (int)$date->format('m');
         $this->_mday     = (int)$date->format('d');
         $this->_hour     = (int)$date->format('H');
         $this->_min      = (int)$date->format('i');
         $this->_sec      = (int)$date->format('s');
         $this->_formatCache = array();
         return $this;
     }
 
     /**
      * Sets the default date format used in __toString()
      *
      * @param string $format
      */
     public function setDefaultFormat($format)
     {
         $this->_defaultFormat = $format;
     }
 
     /**
      * Returns the day of the week (0 = Sunday, 6 = Saturday) of this date.
      *
      * @return integer  The day of the week.
      */
     public function dayOfWeek()
     {
         if ($this->_month > 2) {
             $month = $this->_month - 2;
             $year = $this->_year;
         } else {
             $month = $this->_month + 10;
             $year = $this->_year - 1;
         }
 
         $day = (floor((13 * $month - 1) / 5) +
                 $this->_mday + ($year % 100) +
                 floor(($year % 100) / 4) +
                 floor(($year / 100) / 4) - 2 *
                 floor($year / 100) + 77);
 
         return (int)($day - 7 * floor($day / 7));
     }
 
     /**
      * Returns the day number of the year (1 to 365/366).
      *
      * @return integer  The day of the year.
      */
     public function dayOfYear()
     {
         return $this->format('z') + 1;
     }
 
     /**
      * Returns the week of the month.
      *
      * @return integer  The week number.
      */
     public function weekOfMonth()
     {
         return ceil($this->_mday / 7);
     }
 
     /**
      * Returns the week of the year, first Monday is first day of first week.
      *
      * @return integer  The week number.
      */
     public function weekOfYear()
     {
         return $this->format('W');
     }
 
     /**
      * Returns the number of weeks in the given year (52 or 53).
      *
      * @param integer $year  The year to count the number of weeks in.
      *
      * @return integer $numWeeks   The number of weeks in $year.
      */
     public static function weeksInYear($year)
     {
         // Find the last Thursday of the year.
         $date = new Horde_Date($year . '-12-31');
         while ($date->dayOfWeek() != self::DATE_THURSDAY) {
             --$date->mday;
         }
         return $date->weekOfYear();
     }
 
     /**
      * Sets the date of this object to the $nth weekday of $weekday.
      *
      * @param integer $weekday  The day of the week (0 = Sunday, etc).
      * @param integer $nth      The $nth $weekday to set to (defaults to 1).
      */
     public function setNthWeekday($weekday, $nth = 1)
     {
         if ($weekday < self::DATE_SUNDAY || $weekday > self::DATE_SATURDAY) {
             return;
         }
 
         if ($nth < 0) {  // last $weekday of month
             $this->_mday = $lastday = Horde_Date_Utils::daysInMonth($this->_month, $this->_year);
             $last = $this->dayOfWeek();
             $this->_mday += ($weekday - $last);
             if ($this->_mday > $lastday)
                 $this->_mday -= 7;
         }
         else {
             $this->_mday = 1;
             $first = $this->dayOfWeek();
             if ($weekday < $first) {
                 $this->_mday = 8 + $weekday - $first;
             } else {
                 $this->_mday = $weekday - $first + 1;
             }
             $diff = 7 * $nth - 7;
             $this->_mday += $diff;
             $this->_correct(self::MASK_DAY, $diff < 0);
         }
     }
 
     /**
      * Is the date currently represented by this object a valid date?
      *
      * @return boolean  Validity, counting leap years, etc.
      */
     public function isValid()
     {
         return ($this->_year >= 0 && $this->_year <= 9999);
     }
 
     /**
      * Compares this date to another date object to see which one is
      * greater (later). Assumes that the dates are in the same
      * timezone.
      *
      * @param mixed $other  The date to compare to.
      *
      * @return integer  ==  0 if they are on the same date
      *                  >=  1 if $this is greater (later)
      *                  <= -1 if $other is greater (later)
      */
     public function compareDate($other)
     {
         if (!($other instanceof Horde_Date)) {
             $other = new Horde_Date($other);
         }
 
         if ($this->_year != $other->year) {
             return $this->_year - $other->year;
         }
         if ($this->_month != $other->month) {
             return $this->_month - $other->month;
         }
 
         return $this->_mday - $other->mday;
     }
 
     /**
      * Returns whether this date is after the other.
      *
      * @param mixed $other  The date to compare to.
      *
      * @return boolean  True if this date is after the other.
      */
     public function after($other)
     {
         return $this->compareDate($other) > 0;
     }
 
     /**
      * Returns whether this date is before the other.
      *
      * @param mixed $other  The date to compare to.
      *
      * @return boolean  True if this date is before the other.
      */
     public function before($other)
     {
         return $this->compareDate($other) < 0;
     }
 
     /**
      * Returns whether this date is the same like the other.
      *
      * @param mixed $other  The date to compare to.
      *
      * @return boolean  True if this date is the same like the other.
      */
     public function equals($other)
     {
         return $this->compareDate($other) == 0;
     }
 
     /**
      * Compares this to another date object by time, to see which one
      * is greater (later). Assumes that the dates are in the same
      * timezone.
      *
      * @param mixed $other  The date to compare to.
      *
      * @return integer  ==  0 if they are at the same time
      *                  >=  1 if $this is greater (later)
      *                  <= -1 if $other is greater (later)
      */
     public function compareTime($other)
     {
         if (!($other instanceof Horde_Date)) {
             $other = new Horde_Date($other);
         }
 
         if ($this->_hour != $other->hour) {
             return $this->_hour - $other->hour;
         }
         if ($this->_min != $other->min) {
             return $this->_min - $other->min;
         }
 
         return $this->_sec - $other->sec;
     }
 
     /**
      * Compares this to another date object, including times, to see
      * which one is greater (later). Assumes that the dates are in the
      * same timezone.
      *
      * @param mixed $other  The date to compare to.
      *
      * @return integer  ==  0 if they are equal
      *                  >=  1 if $this is greater (later)
      *                  <= -1 if $other is greater (later)
      */
     public function compareDateTime($other)
     {
         if (!($other instanceof Horde_Date)) {
             $other = new Horde_Date($other);
         }
 
         if ($diff = $this->compareDate($other)) {
             return $diff;
         }
 
         return $this->compareTime($other);
     }
 
     /**
      * Returns number of days between this date and another.
      *
      * @param Horde_Date $other  The other day to diff with.
      *
      * @return integer  The absolute number of days between the two dates.
      */
     public function diff($other)
     {
         return abs($this->toDays() - $other->toDays());
     }
 
     /**
      * Returns the time offset for local time zone.
      *
      * @param boolean $colon  Place a colon between hours and minutes?
      *
      * @return string  Timezone offset as a string in the format +HH:MM.
      */
     public function tzOffset($colon = true)
     {
         return $colon ? $this->format('P') : $this->format('O');
     }
 
     /**
      * Returns the unix timestamp representation of this date.
      *
      * @return integer  A unix timestamp.
      */
     public function timestamp()
     {
         if ($this->_year >= 1970 && $this->_year < 2038) {
             return mktime($this->_hour, $this->_min, $this->_sec,
                           $this->_month, $this->_mday, $this->_year);
         }
         return $this->format('U');
     }
 
     /**
      * Returns the unix timestamp representation of this date, 12:00am.
      *
      * @return integer  A unix timestamp.
      */
     public function datestamp()
     {
         if ($this->_year >= 1970 && $this->_year < 2038) {
             return mktime(0, 0, 0, $this->_month, $this->_mday, $this->_year);
         }
         $date = new DateTime($this->format('Y-m-d'));
         return $date->format('U');
     }
 
     /**
      * Formats date and time to be passed around as a short url parameter.
      *
      * @return string  Date and time.
      */
     public function dateString()
     {
         return sprintf('%04d%02d%02d', $this->_year, $this->_month, $this->_mday);
     }
 
     /**
      * Formats date and time to the ISO format used by JSON.
      *
      * @return string  Date and time.
      */
     public function toJson()
     {
         return $this->format(self::DATE_JSON);
     }
 
     /**
      * Formats date and time to the RFC 2445 iCalendar DATE-TIME format.
      *
      * @param boolean $floating  Whether to return a floating date-time
      *                           (without time zone information).
      *
      * @return string  Date and time.
      */
     public function toiCalendar($floating = false)
     {
         if ($floating) {
             return $this->format('Ymd\THis');
         }
         $dateTime = $this->toDateTime();
         $dateTime->setTimezone(new DateTimeZone('UTC'));
         return $dateTime->format('Ymd\THis\Z');
     }
 
     /**
      * Formats time using the specifiers available in date() or in the DateTime
      * class' format() method.
      *
      * To format in languages other than English, use strftime() instead.
      *
      * @param string $format
      *
      * @return string  Formatted time.
      */
     public function format($format)
     {
         if (!isset($this->_formatCache[$format])) {
             $this->_formatCache[$format] = $this->toDateTime()->format($format);
         }
         return $this->_formatCache[$format];
     }
 
     /**
      * Formats date and time using strftime() format.
      *
      * @return string  strftime() formatted date and time.
      */
     public function strftime($format)
     {
         if (preg_match('/%[^' . self::$_supportedSpecs . ']/', $format)) {
             return strftime($format, $this->timestamp());
         } else {
             return $this->_strftime($format);
         }
     }
 
     /**
      * Formats date and time using a limited set of the strftime() format.
      *
      * @return string  strftime() formatted date and time.
      */
     protected function _strftime($format)
     {
         return preg_replace(
             array('/%b/e',
                   '/%B/e',
                   '/%C/e',
                   '/%d/e',
                   '/%D/e',
                   '/%e/e',
                   '/%H/e',
                   '/%I/e',
                   '/%m/e',
                   '/%M/e',
                   '/%n/',
                   '/%p/e',
                   '/%R/e',
                   '/%S/e',
                   '/%t/',
                   '/%T/e',
                   '/%x/e',
                   '/%X/e',
                   '/%y/e',
                   '/%Y/',
                   '/%%/'),
             array('$this->_strftime(Horde_Nls::getLangInfo(constant(\'ABMON_\' . (int)$this->_month)))',
                   '$this->_strftime(Horde_Nls::getLangInfo(constant(\'MON_\' . (int)$this->_month)))',
                   '(int)($this->_year / 100)',
                   'sprintf(\'%02d\', $this->_mday)',
                   '$this->_strftime(\'%m/%d/%y\')',
                   'sprintf(\'%2d\', $this->_mday)',
                   'sprintf(\'%02d\', $this->_hour)',
                   'sprintf(\'%02d\', $this->_hour == 0 ? 12 : ($this->_hour > 12 ? $this->_hour - 12 : $this->_hour))',
                   'sprintf(\'%02d\', $this->_month)',
                   'sprintf(\'%02d\', $this->_min)',
                   "\n",
                   '$this->_strftime(Horde_Nls::getLangInfo($this->_hour < 12 ? AM_STR : PM_STR))',
                   '$this->_strftime(\'%H:%M\')',
                   'sprintf(\'%02d\', $this->_sec)',
                   "\t",
                   '$this->_strftime(\'%H:%M:%S\')',
                   '$this->_strftime(Horde_Nls::getLangInfo(D_FMT))',
                   '$this->_strftime(Horde_Nls::getLangInfo(T_FMT))',
                   'substr(sprintf(\'%04d\', $this->_year), -2)',
                   (int)$this->_year,
                   '%'),
             $format);
     }
 
     /**
      * Corrects any over- or underflows in any of the date's members.
      *
      * @param integer $mask  We may not want to correct some overflows.
      * @param integer $down  Whether to correct the date up or down.
      */
     protected function _correct($mask = self::MASK_ALLPARTS, $down = false)
     {
         if ($mask & self::MASK_SECOND) {
             if ($this->_sec < 0 || $this->_sec > 59) {
                 $mask |= self::MASK_MINUTE;
 
                 $this->_min += (int)($this->_sec / 60);
                 $this->_sec %= 60;
                 if ($this->_sec < 0) {
                     $this->_min--;
                     $this->_sec += 60;
                 }
             }
         }
 
         if ($mask & self::MASK_MINUTE) {
             if ($this->_min < 0 || $this->_min > 59) {
                 $mask |= self::MASK_HOUR;
 
                 $this->_hour += (int)($this->_min / 60);
                 $this->_min %= 60;
                 if ($this->_min < 0) {
                     $this->_hour--;
                     $this->_min += 60;
                 }
             }
         }
 
         if ($mask & self::MASK_HOUR) {
             if ($this->_hour < 0 || $this->_hour > 23) {
                 $mask |= self::MASK_DAY;
 
                 $this->_mday += (int)($this->_hour / 24);
                 $this->_hour %= 24;
                 if ($this->_hour < 0) {
                     $this->_mday--;
                     $this->_hour += 24;
                 }
             }
         }
 
         if ($mask & self::MASK_MONTH) {
             $this->_correctMonth($down);
             /* When correcting the month, always correct the day too. Months
              * have different numbers of days. */
             $mask |= self::MASK_DAY;
         }
 
         if ($mask & self::MASK_DAY) {
             while ($this->_mday > 28 &&
                    $this->_mday > Horde_Date_Utils::daysInMonth($this->_month, $this->_year)) {
                 if ($down) {
                     $this->_mday -= Horde_Date_Utils::daysInMonth($this->_month + 1, $this->_year) - Horde_Date_Utils::daysInMonth($this->_month, $this->_year);
                 } else {
                     $this->_mday -= Horde_Date_Utils::daysInMonth($this->_month, $this->_year);
                     $this->_month++;
                 }
                 $this->_correctMonth($down);
             }
             while ($this->_mday < 1) {
                 --$this->_month;
                 $this->_correctMonth($down);
                 $this->_mday += Horde_Date_Utils::daysInMonth($this->_month, $this->_year);
             }
         }
     }
 
     /**
      * Corrects the current month.
      *
      * This cannot be done in _correct() because that would also trigger a
      * correction of the day, which would result in an infinite loop.
      *
      * @param integer $down  Whether to correct the date up or down.
      */
     protected function _correctMonth($down = false)
     {
         $this->_year += (int)($this->_month / 12);
         $this->_month %= 12;
         if ($this->_month < 1) {
             $this->_year--;
             $this->_month += 12;
         }
     }
 
     /**
      * Handles args in order: year month day hour min sec tz
      */
     protected function _initializeFromArgs($args)
     {
         $tz = (isset($args[6])) ? array_pop($args) : null;
         $this->_initializeTimezone($tz);
 
         $args = array_slice($args, 0, 6);
         $keys = array('year' => 1, 'month' => 1, 'mday' => 1, 'hour' => 0, 'min' => 0, 'sec' => 0);
         $date = array_combine(array_slice(array_keys($keys), 0, count($args)), $args);
         $date = array_merge($keys, $date);
 
         $this->_initializeFromArray($date);
     }
 
     protected function _initializeFromArray($date)
     {
         if (isset($date['year']) && is_string($date['year']) && strlen($date['year']) == 2) {
             if ($date['year'] > 70) {
                 $date['year'] += 1900;
             } else {
                 $date['year'] += 2000;
             }
         }
 
         foreach ($date as $key => $val) {
             if (in_array($key, array('year', 'month', 'mday', 'hour', 'min', 'sec'))) {
                 $this->{'_'. $key} = (int)$val;
             }
         }
 
         // If $date['day'] is present and numeric we may have been passed
         // a Horde_Form_datetime array.
         if (isset($date['day']) &&
             (string)(int)$date['day'] == $date['day']) {
             $this->_mday = (int)$date['day'];
         }
         // 'minute' key also from Horde_Form_datetime
         if (isset($date['minute']) &&
             (string)(int)$date['minute'] == $date['minute']) {
             $this->_min = (int)$date['minute'];
         }
 
         $this->_correct();
     }
 
     protected function _initializeFromObject($date)
     {
         if ($date instanceof DateTime) {
             $this->_year  = (int)$date->format('Y');
             $this->_month = (int)$date->format('m');
             $this->_mday  = (int)$date->format('d');
             $this->_hour  = (int)$date->format('H');
             $this->_min   = (int)$date->format('i');
             $this->_sec   = (int)$date->format('s');
             $this->_initializeTimezone($date->getTimezone()->getName());
         } else {
             $is_horde_date = $date instanceof Horde_Date;
             foreach (array('year', 'month', 'mday', 'hour', 'min', 'sec') as $key) {
                 if ($is_horde_date || isset($date->$key)) {
                     $this->{'_' . $key} = (int)$date->$key;
                 }
             }
             if (!$is_horde_date) {
                 $this->_correct();
             } else {
                 $this->_initializeTimezone($date->timezone);
             }
         }
     }
 
     protected function _initializeTimezone($timezone)
     {
         if (empty($timezone)) {
             $timezone = date_default_timezone_get();
         }
         $this->_timezone = $timezone;
     }
 
 }
 
 /**
  * @category Horde
  * @package  Date
  */
 
 /**
  * Horde Date wrapper/logic class, including some calculation
  * functions.
  *
  * @category Horde
  * @package  Date
  */
 class Horde_Date_Utils
 {
     /**
      * Returns whether a year is a leap year.
      *
      * @param integer $year  The year.
      *
      * @return boolean  True if the year is a leap year.
      */
     public static function isLeapYear($year)
     {
         if (strlen($year) != 4 || preg_match('/\D/', $year)) {
             return false;
         }
 
         return (($year % 4 == 0 && $year % 100 != 0) || $year % 400 == 0);
     }
 
     /**
      * Returns the date of the year that corresponds to the first day of the
      * given week.
      *
      * @param integer $week  The week of the year to find the first day of.
      * @param integer $year  The year to calculate for.
      *
      * @return Horde_Date  The date of the first day of the given week.
      */
     public static function firstDayOfWeek($week, $year)
     {
         return new Horde_Date(sprintf('%04dW%02d', $year, $week));
     }
 
     /**
      * Returns the number of days in the specified month.
      *
      * @param integer $month  The month
      * @param integer $year   The year.
      *
      * @return integer  The number of days in the month.
      */
     public static function daysInMonth($month, $year)
     {
         static $cache = array();
         if (!isset($cache[$year][$month])) {
             $date = new DateTime(sprintf('%04d-%02d-01', $year, $month));
             $cache[$year][$month] = $date->format('t');
         }
         return $cache[$year][$month];
     }
 
     /**
      * Returns a relative, natural language representation of a timestamp
      *
      * @todo Wider range of values ... maybe future time as well?
      * @todo Support minimum resolution parameter.
      *
      * @param mixed $time          The time. Any format accepted by Horde_Date.
      * @param string $date_format  Format to display date if timestamp is
      *                             more then 1 day old.
      * @param string $time_format  Format to display time if timestamp is 1
      *                             day old.
      *
      * @return string  The relative time (i.e. 2 minutes ago)
      */
     public static function relativeDateTime($time, $date_format = '%x',
                                             $time_format = '%X')
     {
         $date = new Horde_Date($time);
 
         $delta = time() - $date->timestamp();
         if ($delta < 60) {
             return sprintf(Horde_Date_Translation::ngettext("%d second ago", "%d seconds ago", $delta), $delta);
         }
 
         $delta = round($delta / 60);
         if ($delta < 60) {
             return sprintf(Horde_Date_Translation::ngettext("%d minute ago", "%d minutes ago", $delta), $delta);
         }
 
         $delta = round($delta / 60);
         if ($delta < 24) {
             return sprintf(Horde_Date_Translation::ngettext("%d hour ago", "%d hours ago", $delta), $delta);
         }
 
         if ($delta > 24 && $delta < 48) {
             $date = new Horde_Date($time);
             return sprintf(Horde_Date_Translation::t("yesterday at %s"), $date->strftime($time_format));
         }
 
         $delta = round($delta / 24);
         if ($delta < 7) {
             return sprintf(Horde_Date_Translation::t("%d days ago"), $delta);
         }
 
         if (round($delta / 7) < 5) {
             $delta = round($delta / 7);
             return sprintf(Horde_Date_Translation::ngettext("%d week ago", "%d weeks ago", $delta), $delta);
         }
 
         // Default to the user specified date format.
         return $date->strftime($date_format);
     }
 
     /**
      * Tries to convert strftime() formatters to date() formatters.
      *
      * Unsupported formatters will be removed.
      *
      * @param string $format  A strftime() formatting string.
      *
      * @return string  A date() formatting string.
      */
     public static function strftime2date($format)
     {
         $replace = array(
             '/%a/'  => 'D',
             '/%A/'  => 'l',
             '/%d/'  => 'd',
             '/%e/'  => 'j',
             '/%j/'  => 'z',
             '/%u/'  => 'N',
             '/%w/'  => 'w',
             '/%U/'  => '',
             '/%V/'  => 'W',
             '/%W/'  => '',
             '/%b/'  => 'M',
             '/%B/'  => 'F',
             '/%h/'  => 'M',
             '/%m/'  => 'm',
             '/%C/'  => '',
             '/%g/'  => '',
             '/%G/'  => 'o',
             '/%y/'  => 'y',
             '/%Y/'  => 'Y',
             '/%H/'  => 'H',
             '/%I/'  => 'h',
             '/%i/'  => 'g',
             '/%M/'  => 'i',
             '/%p/'  => 'A',
             '/%P/'  => 'a',
             '/%r/'  => 'h:i:s A',
             '/%R/'  => 'H:i',
             '/%S/'  => 's',
             '/%T/'  => 'H:i:s',
             '/%X/e' => 'Horde_Date_Utils::strftime2date(Horde_Nls::getLangInfo(T_FMT))',
             '/%z/'  => 'O',
             '/%Z/'  => '',
             '/%c/'  => '',
             '/%D/'  => 'm/d/y',
             '/%F/'  => 'Y-m-d',
             '/%s/'  => 'U',
             '/%x/e' => 'Horde_Date_Utils::strftime2date(Horde_Nls::getLangInfo(D_FMT))',
             '/%n/'  => "\n",
             '/%t/'  => "\t",
             '/%%/'  => '%'
         );
 
         return preg_replace(array_keys($replace), array_values($replace), $format);
     }
 
 }
diff --git a/plugins/libcalendaring/lib/Horde_Date_Recurrence.php b/plugins/libcalendaring/lib/Horde_Date_Recurrence.php
index 19e372c2..99a7016c 100644
--- a/plugins/libcalendaring/lib/Horde_Date_Recurrence.php
+++ b/plugins/libcalendaring/lib/Horde_Date_Recurrence.php
@@ -1,1705 +1,1743 @@
 <?php
 
 /**
- * This is a modified copy of Horde/Date/Recurrence.php
+ * This is a modified copy of Horde/Date/Recurrence.php (2015-01-05)
  * Pull the latest version of this file from the PEAR channel of the Horde
  * project at http://pear.horde.org by installing the Horde_Date package.
  */
 
-if (!class_exists('Horde_Date'))
-	require_once(dirname(__FILE__) . '/Horde_Date.php');
+if (!class_exists('Horde_Date')) {
+    require_once(__DIR__ . '/Horde_Date.php');
+}
 
 // minimal required implementation of Horde_Date_Translation to avoid a huge dependency nightmare
 class Horde_Date_Translation
 {
-	function t($arg) { return $arg; }
-	function ngettext($sing, $plur, $num) { return ($num > 1 ? $plur : $sing); }
+    function t($arg) { return $arg; }
+    function ngettext($sing, $plur, $num) { return ($num > 1 ? $plur : $sing); }
 }
 
 
 /**
  * This file contains the Horde_Date_Recurrence class and according constants.
  *
- * Copyright 2007-2012 Horde LLC (http://www.horde.org/)
+ * Copyright 2007-2015 Horde LLC (http://www.horde.org/)
  *
  * See the enclosed file COPYING for license information (LGPL). If you
  * did not receive this file, see http://www.horde.org/licenses/lgpl21.
  *
  * @category Horde
  * @package  Date
  */
 
 /**
  * The Horde_Date_Recurrence class implements algorithms for calculating
  * recurrences of events, including several recurrence types, intervals,
  * exceptions, and conversion from and to vCalendar and iCalendar recurrence
  * rules.
  *
  * All methods expecting dates as parameters accept all values that the
  * Horde_Date constructor accepts, i.e. a timestamp, another Horde_Date
  * object, an ISO time string or a hash.
  *
  * @author   Jan Schneider <jan@horde.org>
  * @category Horde
  * @package  Date
  */
 class Horde_Date_Recurrence
 {
     /** No Recurrence **/
     const RECUR_NONE = 0;
 
     /** Recurs daily. */
     const RECUR_DAILY = 1;
 
     /** Recurs weekly. */
     const RECUR_WEEKLY = 2;
 
     /** Recurs monthly on the same date. */
     const RECUR_MONTHLY_DATE = 3;
 
     /** Recurs monthly on the same week day. */
     const RECUR_MONTHLY_WEEKDAY = 4;
 
     /** Recurs yearly on the same date. */
     const RECUR_YEARLY_DATE = 5;
 
     /** Recurs yearly on the same day of the year. */
     const RECUR_YEARLY_DAY = 6;
 
     /** Recurs yearly on the same week day. */
     const RECUR_YEARLY_WEEKDAY = 7;
 
     /**
      * The start time of the event.
      *
      * @var Horde_Date
      */
     public $start;
 
     /**
      * The end date of the recurrence interval.
      *
      * @var Horde_Date
      */
     public $recurEnd = null;
 
     /**
      * The number of recurrences.
      *
      * @var integer
      */
     public $recurCount = null;
 
     /**
      * The type of recurrence this event follows. RECUR_* constant.
      *
      * @var integer
      */
     public $recurType = self::RECUR_NONE;
 
     /**
      * The length of time between recurrences. The time unit depends on the
      * recurrence type.
      *
      * @var integer
      */
     public $recurInterval = 1;
 
     /**
      * Any additional recurrence data.
      *
      * @var integer
      */
     public $recurData = null;
 
     /**
      * BYDAY recurrence number
      *
      * @var integer
      */
     public $recurNthDay = null;
 
     /**
      * BYMONTH recurrence data
      *
      * @var array
      */
     public $recurMonths = array();
 
     /**
      * RDATE recurrence values
      *
      * @var array
      */
     public $rdates = array();
 
     /**
      * All the exceptions from recurrence for this event.
      *
      * @var array
      */
     public $exceptions = array();
 
     /**
      * All the dates this recurrence has been marked as completed.
      *
      * @var array
      */
     public $completions = array();
 
     /**
      * Constructor.
      *
      * @param Horde_Date $start  Start of the recurring event.
      */
     public function __construct($start)
     {
         $this->start = new Horde_Date($start);
     }
 
     /**
      * Resets the class properties.
      */
     public function reset()
     {
         $this->recurEnd = null;
         $this->recurCount = null;
         $this->recurType = self::RECUR_NONE;
         $this->recurInterval = 1;
         $this->recurData = null;
         $this->exceptions = array();
         $this->completions = array();
     }
 
     /**
      * Checks if this event recurs on a given day of the week.
      *
      * @param integer $dayMask  A mask consisting of Horde_Date::MASK_*
      *                          constants specifying the day(s) to check.
      *
      * @return boolean  True if this event recurs on the given day(s).
      */
     public function recurOnDay($dayMask)
     {
         return ($this->recurData & $dayMask);
     }
 
     /**
      * Specifies the days this event recurs on.
      *
      * @param integer $dayMask  A mask consisting of Horde_Date::MASK_*
      *                          constants specifying the day(s) to recur on.
      */
     public function setRecurOnDay($dayMask)
     {
         $this->recurData = $dayMask;
     }
 
     /**
      *
      * @param integer $nthDay The nth weekday of month to repeat events on
      */
     public function setRecurNthWeekday($nth)
     {
         $this->recurNthDay = (int)$nth;
     }
 
     /**
      *
      * @return integer  The nth weekday of month to repeat events.
      */
     public function getRecurNthWeekday()
     {
         return isset($this->recurNthDay) ? $this->recurNthDay : ceil($this->start->mday / 7);
     }
 
     /**
      * Specifies the months for yearly (weekday) recurrence
      *
      * @param array $months  List of months (integers) this event recurs on.
      */
     function setRecurByMonth($months)
     {
         $this->recurMonths = (array)$months;
     }
 
     /**
      * Returns a list of months this yearly event recurs on
      *
      * @return array List of months (integers) this event recurs on.
      */
     function getRecurByMonth()
     {
         return $this->recurMonths;
     }
 
     /**
      * Returns the days this event recurs on.
      *
      * @return integer  A mask consisting of Horde_Date::MASK_* constants
      *                  specifying the day(s) this event recurs on.
      */
     public function getRecurOnDays()
     {
         return $this->recurData;
     }
 
     /**
      * Returns whether this event has a specific recurrence type.
      *
      * @param integer $recurrence  RECUR_* constant of the
      *                             recurrence type to check for.
      *
      * @return boolean  True if the event has the specified recurrence type.
      */
     public function hasRecurType($recurrence)
     {
         return ($recurrence == $this->recurType);
     }
 
     /**
      * Sets a recurrence type for this event.
      *
      * @param integer $recurrence  A RECUR_* constant.
      */
     public function setRecurType($recurrence)
     {
         $this->recurType = $recurrence;
     }
 
     /**
      * Returns recurrence type of this event.
      *
      * @return integer  A RECUR_* constant.
      */
     public function getRecurType()
     {
         return $this->recurType;
     }
 
     /**
      * Returns a description of this event's recurring type.
      *
      * @return string  Human readable recurring type.
      */
     public function getRecurName()
     {
         switch ($this->getRecurType()) {
-        case self::RECUR_NONE: return Horde_Date_Translation::t("No recurrence");
-        case self::RECUR_DAILY: return Horde_Date_Translation::t("Daily");
-        case self::RECUR_WEEKLY: return Horde_Date_Translation::t("Weekly");
+        case self::RECUR_NONE:
+            return Horde_Date_Translation::t("No recurrence");
+        case self::RECUR_DAILY:
+            return Horde_Date_Translation::t("Daily");
+        case self::RECUR_WEEKLY:
+            return Horde_Date_Translation::t("Weekly");
         case self::RECUR_MONTHLY_DATE:
-        case self::RECUR_MONTHLY_WEEKDAY: return Horde_Date_Translation::t("Monthly");
+        case self::RECUR_MONTHLY_WEEKDAY:
+            return Horde_Date_Translation::t("Monthly");
         case self::RECUR_YEARLY_DATE:
         case self::RECUR_YEARLY_DAY:
-        case self::RECUR_YEARLY_WEEKDAY: return Horde_Date_Translation::t("Yearly");
+        case self::RECUR_YEARLY_WEEKDAY:
+            return Horde_Date_Translation::t("Yearly");
         }
     }
 
     /**
      * Sets the length of time between recurrences of this event.
      *
      * @param integer $interval  The time between recurrences.
      */
     public function setRecurInterval($interval)
     {
         if ($interval > 0) {
             $this->recurInterval = $interval;
         }
     }
 
     /**
      * Retrieves the length of time between recurrences of this event.
      *
      * @return integer  The number of seconds between recurrences.
      */
     public function getRecurInterval()
     {
         return $this->recurInterval;
     }
 
     /**
      * Sets the number of recurrences of this event.
      *
      * @param integer $count  The number of recurrences.
      */
     public function setRecurCount($count)
     {
         if ($count > 0) {
             $this->recurCount = (int)$count;
             // Recurrence counts and end dates are mutually exclusive.
             $this->recurEnd = null;
         } else {
             $this->recurCount = null;
         }
     }
 
     /**
      * Retrieves the number of recurrences of this event.
      *
      * @return integer  The number recurrences.
      */
     public function getRecurCount()
     {
         return $this->recurCount;
     }
 
     /**
      * Returns whether this event has a recurrence with a fixed count.
      *
      * @return boolean  True if this recurrence has a fixed count.
      */
     public function hasRecurCount()
     {
         return isset($this->recurCount);
     }
 
     /**
      * Sets the start date of the recurrence interval.
      *
      * @param Horde_Date $start  The recurrence start.
      */
     public function setRecurStart($start)
     {
         $this->start = clone $start;
     }
 
     /**
      * Retrieves the start date of the recurrence interval.
      *
      * @return Horde_Date  The recurrence start.
      */
     public function getRecurStart()
     {
         return $this->start;
     }
 
     /**
      * Sets the end date of the recurrence interval.
      *
      * @param Horde_Date $end  The recurrence end.
      */
     public function setRecurEnd($end)
     {
         if (!empty($end)) {
             // Recurrence counts and end dates are mutually exclusive.
             $this->recurCount = null;
             $this->recurEnd = clone $end;
         } else {
             $this->recurEnd = $end;
         }
     }
 
     /**
      * Retrieves the end date of the recurrence interval.
      *
      * @return Horde_Date  The recurrence end.
      */
     public function getRecurEnd()
     {
         return $this->recurEnd;
     }
 
     /**
      * Returns whether this event has a recurrence end.
      *
      * @return boolean  True if this recurrence ends.
      */
     public function hasRecurEnd()
     {
         return isset($this->recurEnd) && isset($this->recurEnd->year) &&
             $this->recurEnd->year != 9999;
     }
 
     /**
      * Finds the next recurrence of this event that's after $afterDate.
      *
      * @param Horde_Date|string $after  Return events after this date.
      *
      * @return Horde_Date|boolean  The date of the next recurrence or false
      *                             if the event does not recur after
      *                             $afterDate.
      */
     public function nextRecurrence($after)
     {
         if (!($after instanceof Horde_Date)) {
             $after = new Horde_Date($after);
         } else {
             $after = clone($after);
         }
 
         // Make sure $after and $this->start are in the same TZ
         $after->setTimezone($this->start->timezone);
         if ($this->start->compareDateTime($after) >= 0) {
             return clone $this->start;
         }
 
         if ($this->recurInterval == 0 && empty($this->rdates)) {
             return false;
         }
 
         switch ($this->getRecurType()) {
         case self::RECUR_DAILY:
             $diff = $this->start->diff($after);
             $recur = ceil($diff / $this->recurInterval);
             if ($this->recurCount && $recur >= $this->recurCount) {
                 return false;
             }
 
             $recur *= $this->recurInterval;
             $next = $this->start->add(array('day' => $recur));
             if ((!$this->hasRecurEnd() ||
                  $next->compareDateTime($this->recurEnd) <= 0) &&
                 $next->compareDateTime($after) >= 0) {
                 return $next;
             }
+
             break;
 
         case self::RECUR_WEEKLY:
             if (empty($this->recurData)) {
                 return false;
             }
 
             $start_week = Horde_Date_Utils::firstDayOfWeek($this->start->format('W'),
                                                            $this->start->year);
             $start_week->timezone = $this->start->timezone;
             $start_week->hour = $this->start->hour;
             $start_week->min  = $this->start->min;
             $start_week->sec  = $this->start->sec;
 
             // Make sure we are not at the ISO-8601 first week of year while
             // still in month 12...OR in the ISO-8601 last week of year while
             // in month 1 and adjust the year accordingly.
             $week = $after->format('W');
             if ($week == 1 && $after->month == 12) {
                 $theYear = $after->year + 1;
             } elseif ($week >= 52 && $after->month == 1) {
                 $theYear = $after->year - 1;
             } else {
                 $theYear = $after->year;
             }
 
             $after_week = Horde_Date_Utils::firstDayOfWeek($week, $theYear);
             $after_week->timezone = $this->start->timezone;
             $after_week_end = clone $after_week;
-            $after_week_end->mday += 7;
 
             $diff = $start_week->diff($after_week);
             $interval = $this->recurInterval * 7;
             $repeats = floor($diff / $interval);
             if ($diff % $interval < 7) {
                 $recur = $diff;
             } else {
                 /**
                  * If the after_week is not in the first week interval the
                  * search needs to skip ahead a complete interval. The way it is
                  * calculated here means that an event that occurs every second
                  * week on Monday and Wednesday with the event actually starting
                  * on Tuesday or Wednesday will only have one incidence in the
                  * first week.
                  */
                 $recur = $interval * ($repeats + 1);
             }
 
             if ($this->hasRecurCount()) {
                 $recurrences = 0;
                 /**
                  * Correct the number of recurrences by the number of events
                  * that lay between the start of the start week and the
                  * recurrence start.
                  */
                 $next = clone $start_week;
                 while ($next->compareDateTime($this->start) < 0) {
                     if ($this->recurOnDay((int)pow(2, $next->dayOfWeek()))) {
                         $recurrences--;
                     }
                     ++$next->mday;
                 }
                 if ($repeats > 0) {
                     $weekdays = $this->recurData;
                     $total_recurrences_per_week = 0;
                     while ($weekdays > 0) {
                         if ($weekdays % 2) {
                             $total_recurrences_per_week++;
                         }
                         $weekdays = ($weekdays - ($weekdays % 2)) / 2;
                     }
                     $recurrences += $total_recurrences_per_week * $repeats;
                 }
             }
 
             $next = clone $start_week;
             $next->mday += $recur;
             while ($next->compareDateTime($after) < 0 &&
                    $next->compareDateTime($after_week_end) < 0) {
                 if ($this->hasRecurCount()
                     && $next->compareDateTime($after) < 0
                     && $this->recurOnDay((int)pow(2, $next->dayOfWeek()))) {
                     $recurrences++;
                 }
                 ++$next->mday;
             }
             if ($this->hasRecurCount() &&
                 $recurrences >= $this->recurCount) {
                 return false;
             }
             if (!$this->hasRecurEnd() ||
                 $next->compareDateTime($this->recurEnd) <= 0) {
                 if ($next->compareDateTime($after_week_end) >= 0) {
                     return $this->nextRecurrence($after_week_end);
                 }
                 while (!$this->recurOnDay((int)pow(2, $next->dayOfWeek())) &&
                        $next->compareDateTime($after_week_end) < 0) {
                     ++$next->mday;
                 }
                 if (!$this->hasRecurEnd() ||
                     $next->compareDateTime($this->recurEnd) <= 0) {
                     if ($next->compareDateTime($after_week_end) >= 0) {
                         return $this->nextRecurrence($after_week_end);
                     } else {
                         return $next;
                     }
                 }
             }
             break;
 
         case self::RECUR_MONTHLY_DATE:
             $start = clone $this->start;
             if ($after->compareDateTime($start) < 0) {
                 $after = clone $start;
             } else {
                 $after = clone $after;
             }
 
             // If we're starting past this month's recurrence of the event,
             // look in the next month on the day the event recurs.
             if ($after->mday > $start->mday) {
                 ++$after->month;
                 $after->mday = $start->mday;
             }
 
             // Adjust $start to be the first match.
             $offset = ($after->month - $start->month) + ($after->year - $start->year) * 12;
             $offset = floor(($offset + $this->recurInterval - 1) / $this->recurInterval) * $this->recurInterval;
 
             if ($this->recurCount &&
                 ($offset / $this->recurInterval) >= $this->recurCount) {
                 return false;
             }
             $start->month += $offset;
             $count = $offset / $this->recurInterval;
 
             do {
                 if ($this->recurCount &&
                     $count++ >= $this->recurCount) {
                     return false;
                 }
 
                 // Bail if we've gone past the end of recurrence.
                 if ($this->hasRecurEnd() &&
                     $this->recurEnd->compareDateTime($start) < 0) {
                     return false;
                 }
                 if ($start->isValid()) {
                     return $start;
                 }
 
                 // If the interval is 12, and the date isn't valid, then we
                 // need to see if February 29th is an option. If not, then the
                 // event will _never_ recur, and we need to stop checking to
                 // avoid an infinite loop.
                 if ($this->recurInterval == 12 && ($start->month != 2 || $start->mday > 29)) {
                     return false;
                 }
 
                 // Add the recurrence interval.
                 $start->month += $this->recurInterval;
             } while (true);
 
             break;
 
         case self::RECUR_MONTHLY_WEEKDAY:
             // Start with the start date of the event.
             $estart = clone $this->start;
 
             // What day of the week, and week of the month, do we recur on?
             if (isset($this->recurNthDay)) {
                 $nth = $this->recurNthDay;
                 $weekday = log($this->recurData, 2);
             } else {
                 $nth = ceil($this->start->mday / 7);
                 $weekday = $estart->dayOfWeek();
             }
 
             // Adjust $estart to be the first candidate.
             $offset = ($after->month - $estart->month) + ($after->year - $estart->year) * 12;
             $offset = floor(($offset + $this->recurInterval - 1) / $this->recurInterval) * $this->recurInterval;
 
             // Adjust our working date until it's after $after.
             $estart->month += $offset - $this->recurInterval;
 
             $count = $offset / $this->recurInterval;
             do {
                 if ($this->recurCount &&
                     $count++ >= $this->recurCount) {
                     return false;
                 }
 
                 $estart->month += $this->recurInterval;
 
                 $next = clone $estart;
                 $next->setNthWeekday($weekday, $nth);
 
+                if ($next->month != $estart->month) {
+                    // We're already in the next month.
+                    continue;
+                }
                 if ($next->compareDateTime($after) < 0) {
                     // We haven't made it past $after yet, try again.
                     continue;
                 }
                 if ($this->hasRecurEnd() &&
                     $next->compareDateTime($this->recurEnd) > 0) {
                     // We've gone past the end of recurrence; we can give up
                     // now.
                     return false;
                 }
 
                 // We have a candidate to return.
                 break;
             } while (true);
 
             return $next;
 
         case self::RECUR_YEARLY_DATE:
             // Start with the start date of the event.
             $estart = clone $this->start;
             $after = clone $after;
 
             if ($after->month > $estart->month ||
                 ($after->month == $estart->month && $after->mday > $estart->mday)) {
                 ++$after->year;
                 $after->month = $estart->month;
                 $after->mday = $estart->mday;
             }
 
             // Seperate case here for February 29th
             if ($estart->month == 2 && $estart->mday == 29) {
                 while (!Horde_Date_Utils::isLeapYear($after->year)) {
                     ++$after->year;
                 }
             }
 
             // Adjust $estart to be the first candidate.
             $offset = $after->year - $estart->year;
             if ($offset > 0) {
                 $offset = floor(($offset + $this->recurInterval - 1) / $this->recurInterval) * $this->recurInterval;
                 $estart->year += $offset;
             }
 
             // We've gone past the end of recurrence; give up.
             if ($this->recurCount &&
                 $offset >= $this->recurCount) {
                 return false;
             }
             if ($this->hasRecurEnd() &&
                 $this->recurEnd->compareDateTime($estart) < 0) {
                 return false;
             }
 
             return $estart;
 
         case self::RECUR_YEARLY_DAY:
             // Check count first.
             $dayofyear = $this->start->dayOfYear();
             $count = ($after->year - $this->start->year) / $this->recurInterval + 1;
             if ($this->recurCount &&
                 ($count > $this->recurCount ||
                  ($count == $this->recurCount &&
                   $after->dayOfYear() > $dayofyear))) {
                 return false;
             }
 
             // Start with a rough interval.
             $estart = clone $this->start;
             $estart->year += floor($count - 1) * $this->recurInterval;
 
             // Now add the difference to the required day of year.
             $estart->mday += $dayofyear - $estart->dayOfYear();
 
             // Add an interval if the estimation was wrong.
             if ($estart->compareDate($after) < 0) {
                 $estart->year += $this->recurInterval;
                 $estart->mday += $dayofyear - $estart->dayOfYear();
             }
 
             // We've gone past the end of recurrence; give up.
             if ($this->hasRecurEnd() &&
                 $this->recurEnd->compareDateTime($estart) < 0) {
                 return false;
             }
 
             return $estart;
 
         case self::RECUR_YEARLY_WEEKDAY:
             // Start with the start date of the event.
             $estart = clone $this->start;
 
             // What day of the week, and week of the month, do we recur on?
             if (isset($this->recurNthDay)) {
                 $nth = $this->recurNthDay;
                 $weekday = log($this->recurData, 2);
             } else {
                 $nth = ceil($this->start->mday / 7);
                 $weekday = $estart->dayOfWeek();
             }
 
             // Adjust $estart to be the first candidate.
             $offset = floor(($after->year - $estart->year + $this->recurInterval - 1) / $this->recurInterval) * $this->recurInterval;
 
             // Adjust our working date until it's after $after.
             $estart->year += $offset - $this->recurInterval;
 
             $count = $offset / $this->recurInterval;
             do {
                 if ($this->recurCount &&
                     $count++ >= $this->recurCount) {
                     return false;
                 }
 
                 $estart->year += $this->recurInterval;
 
                 $next = clone $estart;
                 $next->setNthWeekday($weekday, $nth);
 
                 if ($next->compareDateTime($after) < 0) {
                     // We haven't made it past $after yet, try again.
                     continue;
                 }
                 if ($this->hasRecurEnd() &&
                     $next->compareDateTime($this->recurEnd) > 0) {
                     // We've gone past the end of recurrence; we can give up
                     // now.
                     return false;
                 }
 
                 // We have a candidate to return.
                 break;
             } while (true);
 
             return $next;
         }
 
         // fall-back to RDATE properties
         if (!empty($this->rdates)) {
             $next = clone $this->start;
             foreach ($this->rdates as $rdate) {
                 $next->year  = $rdate->year;
                 $next->month = $rdate->month;
                 $next->mday  = $rdate->mday;
                 if ($next->compareDateTime($after) >= 0) {
                     return $next;
                 }
             }
         }
 
         // We didn't find anything, the recurType was bad, or something else
         // went wrong - return false.
         return false;
     }
 
     /**
      * Returns whether this event has any date that matches the recurrence
      * rules and is not an exception.
      *
      * @return boolean  True if an active recurrence exists.
      */
     public function hasActiveRecurrence()
     {
         if (!$this->hasRecurEnd()) {
             return true;
         }
 
         $next = $this->nextRecurrence(new Horde_Date($this->start));
         while (is_object($next)) {
             if (!$this->hasException($next->year, $next->month, $next->mday) &&
                 !$this->hasCompletion($next->year, $next->month, $next->mday)) {
                 return true;
             }
 
             $next = $this->nextRecurrence($next->add(array('day' => 1)));
         }
 
         return false;
     }
 
     /**
      * Returns the next active recurrence.
      *
      * @param Horde_Date $afterDate  Return events after this date.
      *
      * @return Horde_Date|boolean The date of the next active
      *                             recurrence or false if the event
      *                             has no active recurrence after
      *                             $afterDate.
      */
     public function nextActiveRecurrence($afterDate)
     {
         $next = $this->nextRecurrence($afterDate);
         while (is_object($next)) {
             if (!$this->hasException($next->year, $next->month, $next->mday) &&
                 !$this->hasCompletion($next->year, $next->month, $next->mday)) {
                 return $next;
             }
             $next->mday++;
             $next = $this->nextRecurrence($next);
         }
 
         return false;
     }
 
     /**
      * Adds an absolute recurrence date.
      *
      * @param integer $year   The year of the instance.
      * @param integer $month  The month of the instance.
      * @param integer $mday   The day of the month of the instance.
      */
     public function addRDate($year, $month, $mday)
     {
         $this->rdates[] = new Horde_Date($year, $month, $mday);
     }
 
     /**
      * Adds an exception to a recurring event.
      *
      * @param integer $year   The year of the execption.
      * @param integer $month  The month of the execption.
      * @param integer $mday   The day of the month of the exception.
      */
     public function addException($year, $month, $mday)
     {
-        $this->exceptions[] = sprintf('%04d%02d%02d', $year, $month, $mday);
+        $key = sprintf('%04d%02d%02d', $year, $month, $mday);
+        if (array_search($key, $this->exceptions) === false) {
+            $this->exceptions[] = sprintf('%04d%02d%02d', $year, $month, $mday);
+        }
     }
 
     /**
      * Deletes an exception from a recurring event.
      *
      * @param integer $year   The year of the execption.
      * @param integer $month  The month of the execption.
      * @param integer $mday   The day of the month of the exception.
      */
     public function deleteException($year, $month, $mday)
     {
         $key = array_search(sprintf('%04d%02d%02d', $year, $month, $mday), $this->exceptions);
         if ($key !== false) {
             unset($this->exceptions[$key]);
         }
     }
 
     /**
      * Checks if an exception exists for a given reccurence of an event.
      *
      * @param integer $year   The year of the reucrance.
      * @param integer $month  The month of the reucrance.
      * @param integer $mday   The day of the month of the reucrance.
      *
      * @return boolean  True if an exception exists for the given date.
      */
     public function hasException($year, $month, $mday)
     {
         return in_array(sprintf('%04d%02d%02d', $year, $month, $mday),
                         $this->getExceptions());
     }
 
     /**
      * Retrieves all the exceptions for this event.
      *
      * @return array  Array containing the dates of all the exceptions in
      *                YYYYMMDD form.
      */
     public function getExceptions()
     {
         return $this->exceptions;
     }
 
     /**
      * Adds a completion to a recurring event.
      *
      * @param integer $year   The year of the execption.
      * @param integer $month  The month of the execption.
      * @param integer $mday   The day of the month of the completion.
      */
     public function addCompletion($year, $month, $mday)
     {
         $this->completions[] = sprintf('%04d%02d%02d', $year, $month, $mday);
     }
 
     /**
      * Deletes a completion from a recurring event.
      *
      * @param integer $year   The year of the execption.
      * @param integer $month  The month of the execption.
      * @param integer $mday   The day of the month of the completion.
      */
     public function deleteCompletion($year, $month, $mday)
     {
         $key = array_search(sprintf('%04d%02d%02d', $year, $month, $mday), $this->completions);
         if ($key !== false) {
             unset($this->completions[$key]);
         }
     }
 
     /**
      * Checks if a completion exists for a given reccurence of an event.
      *
      * @param integer $year   The year of the reucrance.
      * @param integer $month  The month of the recurrance.
      * @param integer $mday   The day of the month of the recurrance.
      *
      * @return boolean  True if a completion exists for the given date.
      */
     public function hasCompletion($year, $month, $mday)
     {
         return in_array(sprintf('%04d%02d%02d', $year, $month, $mday),
                         $this->getCompletions());
     }
 
     /**
      * Retrieves all the completions for this event.
      *
      * @return array  Array containing the dates of all the completions in
      *                YYYYMMDD form.
      */
     public function getCompletions()
     {
         return $this->completions;
     }
 
     /**
      * Parses a vCalendar 1.0 recurrence rule.
      *
      * @link http://www.imc.org/pdi/vcal-10.txt
      * @link http://www.shuchow.com/vCalAddendum.html
      *
      * @param string $rrule  A vCalendar 1.0 conform RRULE value.
      */
     public function fromRRule10($rrule)
     {
         $this->reset();
 
         if (!$rrule) {
             return;
         }
 
         if (!preg_match('/([A-Z]+)(\d+)?(.*)/', $rrule, $matches)) {
             // No recurrence data - event does not recur.
             $this->setRecurType(self::RECUR_NONE);
         }
 
         // Always default the recurInterval to 1.
         $this->setRecurInterval(!empty($matches[2]) ? $matches[2] : 1);
 
         $remainder = trim($matches[3]);
 
         switch ($matches[1]) {
         case 'D':
             $this->setRecurType(self::RECUR_DAILY);
             break;
 
         case 'W':
             $this->setRecurType(self::RECUR_WEEKLY);
             if (!empty($remainder)) {
                 $mask = 0;
                 while (preg_match('/^ ?[A-Z]{2} ?/', $remainder, $matches)) {
                     $day = trim($matches[0]);
                     $remainder = substr($remainder, strlen($matches[0]));
                     $mask |= $maskdays[$day];
                 }
                 $this->setRecurOnDay($mask);
             } else {
                 // Recur on the day of the week of the original recurrence.
                 $maskdays = array(
                     Horde_Date::DATE_SUNDAY => Horde_Date::MASK_SUNDAY,
                     Horde_Date::DATE_MONDAY => Horde_Date::MASK_MONDAY,
                     Horde_Date::DATE_TUESDAY => Horde_Date::MASK_TUESDAY,
                     Horde_Date::DATE_WEDNESDAY => Horde_Date::MASK_WEDNESDAY,
                     Horde_Date::DATE_THURSDAY => Horde_Date::MASK_THURSDAY,
                     Horde_Date::DATE_FRIDAY => Horde_Date::MASK_FRIDAY,
                     Horde_Date::DATE_SATURDAY => Horde_Date::MASK_SATURDAY,
                 );
                 $this->setRecurOnDay($maskdays[$this->start->dayOfWeek()]);
             }
             break;
 
         case 'MP':
             $this->setRecurType(self::RECUR_MONTHLY_WEEKDAY);
             break;
 
         case 'MD':
             $this->setRecurType(self::RECUR_MONTHLY_DATE);
             break;
 
         case 'YM':
             $this->setRecurType(self::RECUR_YEARLY_DATE);
             break;
 
         case 'YD':
             $this->setRecurType(self::RECUR_YEARLY_DAY);
             break;
         }
 
         // We don't support modifiers at the moment, strip them.
         while ($remainder && !preg_match('/^(#\d+|\d{8})($| |T\d{6})/', $remainder)) {
                $remainder = substr($remainder, 1);
         }
         if (!empty($remainder)) {
             if (strpos($remainder, '#') === 0) {
                 $this->setRecurCount(substr($remainder, 1));
             } else {
-                list($year, $month, $mday) = sscanf($remainder, '%04d%02d%02d');
+                list($year, $month, $mday, $hour, $min, $sec, $tz) =
+                    sscanf($remainder, '%04d%02d%02dT%02d%02d%02d%s');
                 $this->setRecurEnd(new Horde_Date(array('year' => $year,
                                                         'month' => $month,
                                                         'mday' => $mday,
-                                                        'hour' => 23,
-                                                        'min' => 59,
-                                                        'sec' => 59)));
+                                                        'hour' => $hour,
+                                                        'min' => $min,
+                                                        'sec' => $sec),
+                                                  $tz == 'Z' ? 'UTC' : $this->start->timezone));
             }
         }
     }
 
     /**
      * Creates a vCalendar 1.0 recurrence rule.
      *
      * @link http://www.imc.org/pdi/vcal-10.txt
      * @link http://www.shuchow.com/vCalAddendum.html
      *
      * @param Horde_Icalendar $calendar  A Horde_Icalendar object instance.
      *
      * @return string  A vCalendar 1.0 conform RRULE value.
      */
     public function toRRule10($calendar)
     {
         switch ($this->recurType) {
         case self::RECUR_NONE:
             return '';
 
         case self::RECUR_DAILY:
             $rrule = 'D' . $this->recurInterval;
             break;
 
         case self::RECUR_WEEKLY:
             $rrule = 'W' . $this->recurInterval;
             $vcaldays = array('SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA');
 
             for ($i = 0; $i <= 7; ++$i) {
                 if ($this->recurOnDay(pow(2, $i))) {
                     $rrule .= ' ' . $vcaldays[$i];
                 }
             }
             break;
 
         case self::RECUR_MONTHLY_DATE:
             $rrule = 'MD' . $this->recurInterval . ' ' . trim($this->start->mday);
             break;
 
         case self::RECUR_MONTHLY_WEEKDAY:
             $nth_weekday = (int)($this->start->mday / 7);
             if (($this->start->mday % 7) > 0) {
                 $nth_weekday++;
             }
 
             $vcaldays = array('SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA');
             $rrule = 'MP' . $this->recurInterval . ' ' . $nth_weekday . '+ ' . $vcaldays[$this->start->dayOfWeek()];
 
             break;
 
         case self::RECUR_YEARLY_DATE:
             $rrule = 'YM' . $this->recurInterval . ' ' . trim($this->start->month);
             break;
 
         case self::RECUR_YEARLY_DAY:
             $rrule = 'YD' . $this->recurInterval . ' ' . $this->start->dayOfYear();
             break;
 
         default:
             return '';
         }
 
         if ($this->hasRecurEnd()) {
             $recurEnd = clone $this->recurEnd;
             return $rrule . ' ' . $calendar->_exportDateTime($recurEnd);
         }
 
         return $rrule . ' #' . (int)$this->getRecurCount();
     }
 
     /**
      * Parses an iCalendar 2.0 recurrence rule.
      *
      * @link http://rfc.net/rfc2445.html#s4.3.10
      * @link http://rfc.net/rfc2445.html#s4.8.5
      * @link http://www.shuchow.com/vCalAddendum.html
      *
      * @param string $rrule  An iCalendar 2.0 conform RRULE value.
      */
     public function fromRRule20($rrule)
     {
         $this->reset();
 
         // Parse the recurrence rule into keys and values.
         $rdata = array();
         $parts = explode(';', $rrule);
         foreach ($parts as $part) {
             list($key, $value) = explode('=', $part, 2);
             $rdata[strtoupper($key)] = $value;
         }
 
         if (isset($rdata['FREQ'])) {
             // Always default the recurInterval to 1.
             $this->setRecurInterval(isset($rdata['INTERVAL']) ? $rdata['INTERVAL'] : 1);
 
             $maskdays = array(
                 'SU' => Horde_Date::MASK_SUNDAY,
                 'MO' => Horde_Date::MASK_MONDAY,
                 'TU' => Horde_Date::MASK_TUESDAY,
                 'WE' => Horde_Date::MASK_WEDNESDAY,
                 'TH' => Horde_Date::MASK_THURSDAY,
                 'FR' => Horde_Date::MASK_FRIDAY,
                 'SA' => Horde_Date::MASK_SATURDAY,
             );
 
             switch (strtoupper($rdata['FREQ'])) {
             case 'DAILY':
                 $this->setRecurType(self::RECUR_DAILY);
                 break;
 
             case 'WEEKLY':
                 $this->setRecurType(self::RECUR_WEEKLY);
                 if (isset($rdata['BYDAY'])) {
                     $days = explode(',', $rdata['BYDAY']);
                     $mask = 0;
                     foreach ($days as $day) {
                         $mask |= $maskdays[$day];
                     }
                     $this->setRecurOnDay($mask);
                 } else {
                     // Recur on the day of the week of the original
                     // recurrence.
                     $maskdays = array(
                         Horde_Date::DATE_SUNDAY => Horde_Date::MASK_SUNDAY,
                         Horde_Date::DATE_MONDAY => Horde_Date::MASK_MONDAY,
                         Horde_Date::DATE_TUESDAY => Horde_Date::MASK_TUESDAY,
                         Horde_Date::DATE_WEDNESDAY => Horde_Date::MASK_WEDNESDAY,
                         Horde_Date::DATE_THURSDAY => Horde_Date::MASK_THURSDAY,
                         Horde_Date::DATE_FRIDAY => Horde_Date::MASK_FRIDAY,
                         Horde_Date::DATE_SATURDAY => Horde_Date::MASK_SATURDAY);
                     $this->setRecurOnDay($maskdays[$this->start->dayOfWeek()]);
                 }
                 break;
 
             case 'MONTHLY':
                 if (isset($rdata['BYDAY'])) {
                     $this->setRecurType(self::RECUR_MONTHLY_WEEKDAY);
                     if (preg_match('/(-?[1-4])([A-Z]+)/', $rdata['BYDAY'], $m)) {
                         $this->setRecurOnDay($maskdays[$m[2]]);
                         $this->setRecurNthWeekday($m[1]);
                     }
                 } else {
                     $this->setRecurType(self::RECUR_MONTHLY_DATE);
                 }
                 break;
 
             case 'YEARLY':
                 if (isset($rdata['BYYEARDAY'])) {
                     $this->setRecurType(self::RECUR_YEARLY_DAY);
                 } elseif (isset($rdata['BYDAY'])) {
                     $this->setRecurType(self::RECUR_YEARLY_WEEKDAY);
                     if (preg_match('/(-?[1-4])([A-Z]+)/', $rdata['BYDAY'], $m)) {
                         $this->setRecurOnDay($maskdays[$m[2]]);
                         $this->setRecurNthWeekday($m[1]);
                     }
                     if ($rdata['BYMONTH']) {
                         $months = explode(',', $rdata['BYMONTH']);
                         $this->setRecurByMonth($months);
                     }
                 } else {
                     $this->setRecurType(self::RECUR_YEARLY_DATE);
                 }
                 break;
             }
 
+            // MUST take into account the time portion if it is present.
+            // See Bug: 12869 and Bug: 2813
             if (isset($rdata['UNTIL'])) {
-                list($year, $month, $mday) = sscanf($rdata['UNTIL'],
-                                                    '%04d%02d%02d');
-                $this->setRecurEnd(new Horde_Date(array('year' => $year,
-                                                        'month' => $month,
-                                                        'mday' => $mday,
-                                                        'hour' => 23,
-                                                        'min' => 59,
-                                                        'sec' => 59)));
+                if (preg_match('/^(\d{4})-?(\d{2})-?(\d{2})T? ?(\d{2}):?(\d{2}):?(\d{2})(?:\.\d+)?(Z?)$/', $rdata['UNTIL'], $parts)) {
+                    $until = new Horde_Date($rdata['UNTIL'], 'UTC');
+                    $until->setTimezone($this->start->timezone);
+                } else {
+                    list($year, $month, $mday) = sscanf($rdata['UNTIL'],
+                                                        '%04d%02d%02d');
+                    $until = new Horde_Date(
+                        array('year' => $year,
+                              'month' => $month,
+                              'mday' => $mday + 1),
+                        $this->start->timezone
+                    );
+                }
+                $this->setRecurEnd($until);
             }
             if (isset($rdata['COUNT'])) {
                 $this->setRecurCount($rdata['COUNT']);
             }
         } else {
             // No recurrence data - event does not recur.
             $this->setRecurType(self::RECUR_NONE);
         }
     }
 
     /**
      * Creates an iCalendar 2.0 recurrence rule.
      *
      * @link http://rfc.net/rfc2445.html#s4.3.10
      * @link http://rfc.net/rfc2445.html#s4.8.5
      * @link http://www.shuchow.com/vCalAddendum.html
      *
      * @param Horde_Icalendar $calendar  A Horde_Icalendar object instance.
      *
      * @return string  An iCalendar 2.0 conform RRULE value.
      */
     public function toRRule20($calendar)
     {
         switch ($this->recurType) {
         case self::RECUR_NONE:
             return '';
 
         case self::RECUR_DAILY:
             $rrule = 'FREQ=DAILY;INTERVAL='  . $this->recurInterval;
             break;
 
         case self::RECUR_WEEKLY:
-            $rrule = 'FREQ=WEEKLY;INTERVAL=' . $this->recurInterval . ';BYDAY=';
+            $rrule = 'FREQ=WEEKLY;INTERVAL=' . $this->recurInterval;
             $vcaldays = array('SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA');
 
             for ($i = $flag = 0; $i <= 7; ++$i) {
                 if ($this->recurOnDay(pow(2, $i))) {
-                    if ($flag) {
+                    if ($flag == 0) {
+                        $rrule .= ';BYDAY=';
+                        $flag = 1;
+                    } else {
                         $rrule .= ',';
                     }
                     $rrule .= $vcaldays[$i];
-                    $flag = true;
                 }
             }
             break;
 
         case self::RECUR_MONTHLY_DATE:
             $rrule = 'FREQ=MONTHLY;INTERVAL=' . $this->recurInterval;
             break;
 
         case self::RECUR_MONTHLY_WEEKDAY:
             if (isset($this->recurNthDay)) {
                 $nth_weekday = $this->recurNthDay;
                 $day_of_week = log($this->recurData, 2);
             } else {
                 $day_of_week = $this->start->dayOfWeek();
                 $nth_weekday = (int)($this->start->mday / 7);
                 if (($this->start->mday % 7) > 0) {
                     $nth_weekday++;
                 }
             }
             $vcaldays = array('SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA');
             $rrule = 'FREQ=MONTHLY;INTERVAL=' . $this->recurInterval
                 . ';BYDAY=' . $nth_weekday . $vcaldays[$day_of_week];
             break;
 
         case self::RECUR_YEARLY_DATE:
             $rrule = 'FREQ=YEARLY;INTERVAL=' . $this->recurInterval;
             break;
 
         case self::RECUR_YEARLY_DAY:
             $rrule = 'FREQ=YEARLY;INTERVAL=' . $this->recurInterval
                 . ';BYYEARDAY=' . $this->start->dayOfYear();
             break;
 
         case self::RECUR_YEARLY_WEEKDAY:
             if (isset($this->recurNthDay)) {
                 $nth_weekday = $this->recurNthDay;
                 $day_of_week = log($this->recurData, 2);
             } else {
                 $day_of_week = $this->start->dayOfWeek();
                 $nth_weekday = (int)($this->start->mday / 7);
                 if (($this->start->mday % 7) > 0) {
                     $nth_weekday++;
                 }
              }
             $months = !empty($this->recurMonths) ? join(',', $this->recurMonths) : $this->start->month;
             $vcaldays = array('SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA');
             $rrule = 'FREQ=YEARLY;INTERVAL=' . $this->recurInterval
                 . ';BYDAY='
                 . $nth_weekday
                 . $vcaldays[$day_of_week]
                 . ';BYMONTH=' . $this->start->month;
             break;
         }
 
         if ($this->hasRecurEnd()) {
             $recurEnd = clone $this->recurEnd;
             $rrule .= ';UNTIL=' . $calendar->_exportDateTime($recurEnd);
         }
         if ($count = $this->getRecurCount()) {
             $rrule .= ';COUNT=' . $count;
         }
         return $rrule;
     }
 
     /**
-     * Parses the recurrence data from a hash.
+     * Parses the recurrence data from a Kolab hash.
      *
      * @param array $hash  The hash to convert.
      *
      * @return boolean  True if the hash seemed valid, false otherwise.
      */
-    public function fromHash($hash)
+    public function fromKolab($hash)
     {
         $this->reset();
 
         if (!isset($hash['interval']) || !isset($hash['cycle'])) {
             $this->setRecurType(self::RECUR_NONE);
             return false;
         }
 
         $this->setRecurInterval((int)$hash['interval']);
 
         $month2number = array(
             'january'   => 1,
             'february'  => 2,
             'march'     => 3,
             'april'     => 4,
             'may'       => 5,
             'june'      => 6,
             'july'      => 7,
             'august'    => 8,
             'september' => 9,
             'october'   => 10,
             'november'  => 11,
             'december'  => 12,
         );
 
         $parse_day = false;
         $set_daymask = false;
         $update_month = false;
         $update_daynumber = false;
         $update_weekday = false;
         $nth_weekday = -1;
 
         switch ($hash['cycle']) {
         case 'daily':
             $this->setRecurType(self::RECUR_DAILY);
             break;
 
         case 'weekly':
             $this->setRecurType(self::RECUR_WEEKLY);
             $parse_day = true;
             $set_daymask = true;
             break;
 
         case 'monthly':
             if (!isset($hash['daynumber'])) {
                 $this->setRecurType(self::RECUR_NONE);
                 return false;
             }
 
             switch ($hash['type']) {
             case 'daynumber':
                 $this->setRecurType(self::RECUR_MONTHLY_DATE);
                 $update_daynumber = true;
                 break;
 
             case 'weekday':
                 $this->setRecurType(self::RECUR_MONTHLY_WEEKDAY);
                 $this->setRecurNthWeekday($hash['daynumber']);
                 $parse_day = true;
                 $set_daymask = true;
                 break;
             }
             break;
 
         case 'yearly':
             if (!isset($hash['type'])) {
                 $this->setRecurType(self::RECUR_NONE);
                 return false;
             }
 
             switch ($hash['type']) {
             case 'monthday':
                 $this->setRecurType(self::RECUR_YEARLY_DATE);
                 $update_month = true;
                 $update_daynumber = true;
                 break;
 
             case 'yearday':
-                if (!isset($hash['month'])) {
+                if (!isset($hash['daynumber'])) {
                     $this->setRecurType(self::RECUR_NONE);
                     return false;
                 }
 
                 $this->setRecurType(self::RECUR_YEARLY_DAY);
                 // Start counting days in January.
                 $hash['month'] = 'january';
                 $update_month = true;
                 $update_daynumber = true;
                 break;
 
             case 'weekday':
                 if (!isset($hash['daynumber'])) {
                     $this->setRecurType(self::RECUR_NONE);
                     return false;
                 }
 
                 $this->setRecurType(self::RECUR_YEARLY_WEEKDAY);
                 $this->setRecurNthWeekday($hash['daynumber']);
                 $parse_day = true;
                 $set_daymask = true;
 
                 if ($hash['month'] && isset($month2number[$hash['month']])) {
                     $this->setRecurByMonth($month2number[$hash['month']]);
                 }
                 break;
             }
         }
 
         if (isset($hash['range-type']) && isset($hash['range'])) {
             switch ($hash['range-type']) {
             case 'number':
                 $this->setRecurCount((int)$hash['range']);
                 break;
 
             case 'date':
                 $recur_end = new Horde_Date($hash['range']);
                 $recur_end->hour = 23;
                 $recur_end->min = 59;
                 $recur_end->sec = 59;
                 $this->setRecurEnd($recur_end);
                 break;
             }
         }
 
         // Need to parse <day>?
         $last_found_day = -1;
         if ($parse_day) {
             if (!isset($hash['day'])) {
                 $this->setRecurType(self::RECUR_NONE);
                 return false;
             }
 
             $mask = 0;
             $bits = array(
                 'monday' => Horde_Date::MASK_MONDAY,
                 'tuesday' => Horde_Date::MASK_TUESDAY,
                 'wednesday' => Horde_Date::MASK_WEDNESDAY,
                 'thursday' => Horde_Date::MASK_THURSDAY,
                 'friday' => Horde_Date::MASK_FRIDAY,
                 'saturday' => Horde_Date::MASK_SATURDAY,
                 'sunday' => Horde_Date::MASK_SUNDAY,
             );
             $days = array(
                 'monday' => Horde_Date::DATE_MONDAY,
                 'tuesday' => Horde_Date::DATE_TUESDAY,
                 'wednesday' => Horde_Date::DATE_WEDNESDAY,
                 'thursday' => Horde_Date::DATE_THURSDAY,
                 'friday' => Horde_Date::DATE_FRIDAY,
                 'saturday' => Horde_Date::DATE_SATURDAY,
                 'sunday' => Horde_Date::DATE_SUNDAY,
             );
 
             foreach ($hash['day'] as $day) {
                 // Validity check.
                 if (empty($day) || !isset($bits[$day])) {
                     continue;
                 }
 
                 $mask |= $bits[$day];
                 $last_found_day = $days[$day];
             }
 
             if ($set_daymask) {
                 $this->setRecurOnDay($mask);
             }
         }
 
         if ($update_month || $update_daynumber || $update_weekday) {
             if ($update_month) {
                 if (isset($month2number[$hash['month']])) {
                     $this->start->month = $month2number[$hash['month']];
                 }
             }
 
             if ($update_daynumber) {
                 if (!isset($hash['daynumber'])) {
                     $this->setRecurType(self::RECUR_NONE);
                     return false;
                 }
 
                 $this->start->mday = $hash['daynumber'];
             }
 
             if ($update_weekday) {
                 $this->setNthWeekday($nth_weekday);
             }
         }
 
         // Exceptions.
-        if (isset($hash['exceptions'])) {
-            $this->exceptions = $hash['exceptions'];
+        if (isset($hash['exclusion'])) {
+            foreach ($hash['exclusion'] as $exception) {
+                if ($exception instanceof DateTime) {
+                    $this->exceptions[] = $exception->format('Ymd');
+                }
+            }
         }
 
-        if (isset($hash['completions'])) {
-            $this->completions = $hash['completions'];
+        if (isset($hash['complete'])) {
+            foreach ($hash['complete'] as $completion) {
+                if ($exception instanceof DateTime) {
+                    $this->completions[] = $completion->format('Ymd');
+                }
+            }
         }
 
         return true;
     }
 
     /**
-     * Export this object into a hash.
+     * Export this object into a Kolab hash.
      *
      * @return array  The recurrence hash.
      */
-    public function toHash()
+    public function toKolab()
     {
         if ($this->getRecurType() == self::RECUR_NONE) {
             return array();
         }
 
         $day2number = array(
             0 => 'sunday',
             1 => 'monday',
             2 => 'tuesday',
             3 => 'wednesday',
             4 => 'thursday',
             5 => 'friday',
             6 => 'saturday'
         );
         $month2number = array(
             1 => 'january',
             2 => 'february',
             3 => 'march',
             4 => 'april',
             5 => 'may',
             6 => 'june',
             7 => 'july',
             8 => 'august',
             9 => 'september',
             10 => 'october',
             11 => 'november',
             12 => 'december'
         );
 
         $hash = array('interval' => $this->getRecurInterval());
         $start = $this->getRecurStart();
 
         switch ($this->getRecurType()) {
         case self::RECUR_DAILY:
             $hash['cycle'] = 'daily';
             break;
 
         case self::RECUR_WEEKLY:
             $hash['cycle'] = 'weekly';
             $bits = array(
                 'monday' => Horde_Date::MASK_MONDAY,
                 'tuesday' => Horde_Date::MASK_TUESDAY,
                 'wednesday' => Horde_Date::MASK_WEDNESDAY,
                 'thursday' => Horde_Date::MASK_THURSDAY,
                 'friday' => Horde_Date::MASK_FRIDAY,
                 'saturday' => Horde_Date::MASK_SATURDAY,
                 'sunday' => Horde_Date::MASK_SUNDAY,
             );
             $days = array();
             foreach ($bits as $name => $bit) {
                 if ($this->recurOnDay($bit)) {
                     $days[] = $name;
                 }
             }
             $hash['day'] = $days;
             break;
 
         case self::RECUR_MONTHLY_DATE:
             $hash['cycle'] = 'monthly';
             $hash['type'] = 'daynumber';
             $hash['daynumber'] = $start->mday;
             break;
 
         case self::RECUR_MONTHLY_WEEKDAY:
             $hash['cycle'] = 'monthly';
             $hash['type'] = 'weekday';
             $hash['daynumber'] = $start->weekOfMonth();
             $hash['day'] = array ($day2number[$start->dayOfWeek()]);
             break;
 
         case self::RECUR_YEARLY_DATE:
             $hash['cycle'] = 'yearly';
             $hash['type'] = 'monthday';
             $hash['daynumber'] = $start->mday;
             $hash['month'] = $month2number[$start->month];
             break;
 
         case self::RECUR_YEARLY_DAY:
             $hash['cycle'] = 'yearly';
             $hash['type'] = 'yearday';
             $hash['daynumber'] = $start->dayOfYear();
             break;
 
         case self::RECUR_YEARLY_WEEKDAY:
             $hash['cycle'] = 'yearly';
             $hash['type'] = 'weekday';
             $hash['daynumber'] = $start->weekOfMonth();
             $hash['day'] = array ($day2number[$start->dayOfWeek()]);
             $hash['month'] = $month2number[$start->month];
         }
 
         if ($this->hasRecurCount()) {
             $hash['range-type'] = 'number';
             $hash['range'] = $this->getRecurCount();
         } elseif ($this->hasRecurEnd()) {
             $date = $this->getRecurEnd();
             $hash['range-type'] = 'date';
-            $hash['range'] = $date->datestamp();
+            $hash['range'] = $date->toDateTime();
         } else {
             $hash['range-type'] = 'none';
             $hash['range'] = '';
         }
 
         // Recurrence exceptions
-        $hash['exceptions'] = $this->exceptions;
-        $hash['completions'] = $this->completions;
+        $hash['exclusion'] = $hash['complete'] = array();
+        foreach ($this->exceptions as $exception) {
+            $hash['exclusion'][] = new DateTime($exception);
+        }
+        foreach ($this->completions as $completionexception) {
+            $hash['complete'][] = new DateTime($completionexception);
+        }
 
         return $hash;
     }
 
     /**
      * Returns a simple object suitable for json transport representing this
      * object.
      *
      * Possible properties are:
      * - t: type
      * - i: interval
      * - e: end date
      * - c: count
      * - d: data
      * - co: completions
      * - ex: exceptions
      *
      * @return object  A simple object.
      */
     public function toJson()
     {
         $json = new stdClass;
         $json->t = $this->recurType;
         $json->i = $this->recurInterval;
         if ($this->hasRecurEnd()) {
             $json->e = $this->recurEnd->toJson();
         }
         if ($this->recurCount) {
             $json->c = $this->recurCount;
         }
         if ($this->recurData) {
             $json->d = $this->recurData;
         }
         if ($this->completions) {
             $json->co = $this->completions;
         }
         if ($this->exceptions) {
             $json->ex = $this->exceptions;
         }
         return $json;
     }
 
 }