Exemplo n.º 1
0
        //=====================================================================

        /// <summary>
        /// Initialize the dialog controls using the specified VTimeZone object
        /// </summary>
        /// <param name="tz">The time zone object from which to get the settings</param>
        public void SetValues(VTimeZone tz)
        {
            originalId = txtTimeZoneId.Text = tz.TimeZoneId.Value;
            txtTimeZoneUrl.Text = tz.TimeZoneUrl.Value;
            txtLastModified.Text = tz.LastModified.DateTimeValue.ToString("G");

            // We could bind directly to the existing collection but that would modify it.  To preserve the
            // original items, we'll pass a copy of the collection instead.
            ucRules.BindingSource.DataSource = new ObservanceRuleCollection().CloneRange(tz.ObservanceRules);
        }
Exemplo n.º 2
0
        /// <summary>
        /// Update the time zone object with the dialog control values
        /// </summary>
        /// <param name="tz">The time zone object in which the settings are updated</param>
        public void GetValues(VTimeZone tz)
        {
            tz.TimeZoneId.Value = txtTimeZoneId.Text;
            tz.TimeZoneUrl.Value = txtTimeZoneUrl.Text;
            tz.LastModified.DateTimeValue = DateTime.Now;

            // For the collection, we'll clear the existing items and copy the modified items from the browse
            // control binding source.
            tz.ObservanceRules.Clear();
            tz.ObservanceRules.CloneRange((ObservanceRuleCollection)ucRules.BindingSource.DataSource);
        }
Exemplo n.º 3
0
        //=====================================================================

        /// <summary>
        /// This is overridden to allow cloning of a PDI object
        /// </summary>
        /// <returns>A clone of the object</returns>
        public override object Clone()
        {
            VTimeZone o = new VTimeZone();
            o.Clone(this);
            return o;
        }
Exemplo n.º 4
0
 /// <summary>
 /// This is used to set the selected time zone in all date/time objects in the component without
 /// modifying the date/time values.
 /// </summary>
 /// <param name="vTimeZone">A <see cref="VTimeZone"/> object that will be used for all date/time objects
 /// in the component.</param>
 /// <remarks>This method does not affect the date/time values</remarks>
 public override void SetTimeZone(VTimeZone vTimeZone)
 {
     CalendarObject.SetPropertyTimeZone(startDate, vTimeZone);
     CalendarObject.SetPropertyTimeZone(endDate, vTimeZone);
 }
Exemplo n.º 5
0
 /// <summary>
 /// This is used to apply the selected time zone to all date/time objects in the component and convert
 /// them to the new time zone.
 /// </summary>
 /// <param name="vTimeZone">A <see cref="VTimeZone"/> object that will be used for all date/time objects
 /// in the component.</param>
 /// <remarks>When applied, all date/time values in the object will be converted to the new time zone</remarks>
 public override void ApplyTimeZone(VTimeZone vTimeZone)
 {
     CalendarObject.ApplyPropertyTimeZone(startDate, vTimeZone);
     CalendarObject.ApplyPropertyTimeZone(endDate, vTimeZone);
 }
Exemplo n.º 6
0
        /// <summary>
        /// This is implemented to handle properties related to VTimeZone items
        /// </summary>
        /// <param name="propertyName">The name of the property.</param>
        /// <param name="parameters">A string collection containing the parameters and their values.  If empty,
        /// there are no parameters.</param>
        /// <param name="propertyValue">The value of the property.</param>
        protected virtual void VTimeZoneParser(string propertyName, StringCollection parameters, string propertyValue)
        {
            int idx;

            // The last entry is always CustomProperty so scan for length minus one
            for(idx = 0; idx < ntvTimeZone.Length - 1; idx++)
                if(ntvTimeZone[idx].IsMatch(propertyName))
                    break;

            // An opening BEGIN:VTIMEZONE property must have been seen
            if(vTimeZone == null)
                throw new PDIParserException(this.LineNumber, LR.GetString("ExParseNoBeginProp", "BEGIN:VTIMEZONE",
                    propertyName));

            // Handle or create the property
            switch(ntvTimeZone[idx].EnumValue)
            {
                case PropertyType.Begin:    // Handle nested objects
                    priorState.Push(currentState);

                    // Is it a STANDARD or DAYLIGHT property?
                    if(String.Compare(propertyValue.Trim(), "STANDARD", StringComparison.OrdinalIgnoreCase) == 0)
                    {
                        obsRule = new ObservanceRule(ObservanceRuleType.Standard);
                        vTimeZone.ObservanceRules.Add(obsRule);
                        currentState = VCalendarParserState.ObservanceRule;
                    }
                    else
                        if(String.Compare(propertyValue.Trim(), "DAYLIGHT", StringComparison.OrdinalIgnoreCase) == 0)
                        {
                            obsRule = new ObservanceRule(ObservanceRuleType.Daylight);
                            vTimeZone.ObservanceRules.Add(obsRule);
                            currentState = VCalendarParserState.ObservanceRule;
                        }
                        else
                        {
                            // Unknown/custom object
                            currentState = VCalendarParserState.Custom;
                            CustomObjectParser(propertyName, parameters, propertyValue);
                        }
                    break;

                case PropertyType.End:
                    // For this, the value must be VTIMEZONE
                    if(String.Compare(propertyValue.Trim(), "VTIMEZONE", StringComparison.OrdinalIgnoreCase) != 0)
                        throw new PDIParserException(this.LineNumber, LR.GetString("ExParseUnrecognizedTagValue",
                            ntvTimeZone[idx].Name, propertyValue));

                    // Unlike other objects, we do rely on the end tag to add the time zone object to the
                    // collection as they are shared amongst all instances.
                    VCalendar.TimeZones.Merge(vTimeZone);

                    vTimeZone = null;
                    currentState = priorState.Pop();
                    break;

                case PropertyType.TimeZoneId:
                    vTimeZone.TimeZoneId.EncodedValue = propertyValue;
                    break;

                case PropertyType.TimeZoneUrl:
                    vTimeZone.TimeZoneUrl.EncodedValue = propertyValue;
                    break;

                case PropertyType.LastModified:
                    vTimeZone.LastModified.DeserializeParameters(parameters);
                    vTimeZone.LastModified.EncodedValue = propertyValue;
                    break;

                default:    // Anything else is a custom property
                    CustomProperty cust = new CustomProperty(propertyName);
                    cust.DeserializeParameters(parameters);
                    cust.EncodedValue = propertyValue;
                    vTimeZone.CustomProperties.Add(cust);
                    break;
            }
        }
Exemplo n.º 7
0
        /// <summary>
        /// This is used to set the selected time zone in all date/time objects in the component without
        /// modifying the date/time values.
        /// </summary>
        /// <param name="vTimeZone">A <see cref="VTimeZone"/> object that will be used for all date/time objects
        /// in the component.</param>
        /// <remarks>This method does not affect the date/time values</remarks>
        public override void SetTimeZone(VTimeZone vTimeZone)
        {
            CalendarObject.SetPropertyTimeZone(startDate, vTimeZone);
            CalendarObject.SetPropertyTimeZone(endDate, vTimeZone);
            CalendarObject.SetPropertyTimeZone(recurId, vTimeZone);

            if(alarms != null)
                alarms.SetTimeZone(vTimeZone);

            base.SetTimeZone(vTimeZone);
        }
Exemplo n.º 8
0
        /// <summary>
        /// This is used to apply the selected time zone to all date/time objects in the component and convert
        /// them to the new time zone.
        /// </summary>
        /// <param name="vTimeZone">A <see cref="VTimeZone"/> object that will be used for all date/time objects
        /// in the component.</param>
        /// <remarks>When applied, all date/time values in the object will be converted to the new time zone</remarks>
        public override void ApplyTimeZone(VTimeZone vTimeZone)
        {
            CalendarObject.ApplyPropertyTimeZone(startDate, vTimeZone);
            CalendarObject.ApplyPropertyTimeZone(recurId, vTimeZone);

            base.ApplyTimeZone(vTimeZone);
        }
Exemplo n.º 9
0
        /// <summary>
        /// This helper method can be used to apply a new time zone to the passed date/time property
        /// </summary>
        /// <param name="dateProp">The date/time property to check</param>
        /// <param name="vTimeZone">The new time zone component to use</param>
        /// <remarks>If the property's current time zone ID does not match the one in the new time zone, it is
        /// updated with the new ID and the date/time is adjusted to the new time zone.</remarks>
        protected static void ApplyPropertyTimeZone(BaseDateTimeProperty dateProp, VTimeZone vTimeZone)
        {
            if(dateProp != null && (vTimeZone == null || dateProp.TimeZoneId != vTimeZone.TimeZoneId.Value))
            {
                // If the time zone is null, just clear the time zone ID
                if(vTimeZone == null)
                {
                    dateProp.TimeZoneId = null;
                    return;
                }

                DateTimeInstance dti = VCalendar.TimeZoneToTimeZone(dateProp.TimeZoneDateTime, dateProp.TimeZoneId,
                    vTimeZone.TimeZoneId.Value);

                dateProp.TimeZoneDateTime = dti.StartDateTime;
                dateProp.TimeZoneId = vTimeZone.TimeZoneId.Value;
            }
        }
Exemplo n.º 10
0
 /// <summary>
 /// This is used to set the selected time zone in all date/time objects in the component without
 /// modifying the date/time values.
 /// </summary>
 /// <param name="vTimeZone">A <see cref="VTimeZone"/> object that will be used for all date/time objects
 /// in the component.</param>
 /// <remarks>This method does not affect the date/time values</remarks>
 public override void SetTimeZone(VTimeZone vTimeZone)
 {
     CalendarObject.SetPropertyTimeZone(trigger, vTimeZone);
 }
Exemplo n.º 11
0
 /// <summary>
 /// This is used to apply the selected time zone to all date/time objects in the component and convert
 /// them to the new time zone.
 /// </summary>
 /// <param name="vTimeZone">A <see cref="VTimeZone"/> object that will be used for all date/time objects
 /// in the component.</param>
 /// <remarks>When applied, all date/time values in the object will be converted to the new time zone</remarks>
 public override void ApplyTimeZone(VTimeZone vTimeZone)
 {
     CalendarObject.ApplyPropertyTimeZone(trigger, vTimeZone);
 }
Exemplo n.º 12
0
        /// <summary>
        /// This is used to set the selected time zone in all date/time objects in the component without
        /// modifying the date/time values.
        /// </summary>
        /// <param name="vTimeZone">A <see cref="VTimeZone"/> object that will be used for all date/time objects
        /// in the component.</param>
        /// <remarks>This method does not affect the date/time values</remarks>
        public override void SetTimeZone(VTimeZone vTimeZone)
        {
            if(rDates != null)
                foreach(RDateProperty rdt in rDates)
                    if(vTimeZone == null || rdt.TimeZoneId != vTimeZone.TimeZoneId.Value)
                    {
                        // If the time zone is null, just clear the time zone ID
                        if(vTimeZone == null)
                            rdt.TimeZoneId = null;
                        else
                            rdt.TimeZoneId = vTimeZone.TimeZoneId.Value;
                    }

            if(exDates != null)
                foreach(ExDateProperty edt in exDates)
                    CalendarObject.SetPropertyTimeZone(edt, vTimeZone);
        }
Exemplo n.º 13
0
        /// <summary>
        /// This is used to apply the selected time zone to all date/time objects in the component and convert
        /// them to the new time zone.
        /// </summary>
        /// <param name="vTimeZone">A <see cref="VTimeZone"/> object that will be used for all date/time objects
        /// in the component.</param>
        /// <remarks>When applied, all date/time values in the object will be converted to the new time zone</remarks>
        public override void ApplyTimeZone(VTimeZone vTimeZone)
        {
            if(rDates != null)
                foreach(RDateProperty rdt in rDates)
                    if(vTimeZone == null || rdt.TimeZoneId != vTimeZone.TimeZoneId.Value)
                    {
                        // If the time zone is null, just clear the time zone ID
                        if(vTimeZone == null)
                            rdt.TimeZoneId = null;
                        else
                        {
                            DateTimeInstance dti = VCalendar.TimeZoneToTimeZone(rdt.TimeZoneDateTime,
                                rdt.TimeZoneId, vTimeZone.TimeZoneId.Value);

                            rdt.TimeZoneDateTime = dti.StartDateTime;
                            rdt.TimeZoneId = vTimeZone.TimeZoneId.Value;
                        }
                    }

            if(exDates != null)
                foreach(ExDateProperty edt in exDates)
                    CalendarObject.ApplyPropertyTimeZone(edt, vTimeZone);
        }
Exemplo n.º 14
0
        /// <summary>
        /// This is implemented to handle properties as they are parsed from the data stream
        /// </summary>
        /// <param name="propertyName">The name of the property.</param>
        /// <param name="parameters">A string collection containing the parameters and their values.  If empty,
        /// there are no parameters.</param>
        /// <param name="propertyValue">The value of the property.</param>
        /// <remarks><para>There may be a mixture of name/value pairs or values alone in the parameters string
        /// collection.  It is up to the derived class to process the parameter list based on the specification
        /// to which it conforms.  For entries that are parameter names, the entry immediately following it in
        /// the collection is its associated parameter value.  The property name, parameter names, and their
        /// values may be in upper, lower, or mixed case.</para>
        /// 
        /// <para>The value may be an encoded string.  The properties are responsible for any decoding that may
        /// need to occur (i.e. base 64 encoded image data).</para></remarks>
        /// <exception cref="PDIParserException">This is thrown if an error is encountered while parsing the data
        /// stream.  Refer to the and inner exceptions for information on the cause of the problem.</exception>
        protected override void PropertyParser(string propertyName, StringCollection parameters, string propertyValue)
        {
            SpecificationVersions version = SpecificationVersions.None;
            string temp;
            int idx;

            // Is it parsing a sub-object?
            if(currentState != VCalendarParserState.VCalendar)
            {
                switch(currentState)
                {
                    case VCalendarParserState.VEvent:
                        VEventParser(propertyName, parameters, propertyValue);
                        break;

                    case VCalendarParserState.VToDo:
                        VToDoParser(propertyName, parameters, propertyValue);
                        break;

                    case VCalendarParserState.VJournal:
                        VJournalParser(propertyName, parameters, propertyValue);
                        break;

                    case VCalendarParserState.VAlarm:
                        VAlarmParser(propertyName, parameters, propertyValue);
                        break;

                    case VCalendarParserState.VFreeBusy:
                        VFreeBusyParser(propertyName, parameters, propertyValue);
                        break;

                    case VCalendarParserState.VTimeZone:
                        VTimeZoneParser(propertyName, parameters, propertyValue);
                        break;

                    case VCalendarParserState.ObservanceRule:
                        ObservanceRuleParser(propertyName, parameters, propertyValue);
                        break;

                    case VCalendarParserState.Custom:
                        CustomObjectParser(propertyName, parameters, propertyValue);
                        break;
                }

                return;
            }

            // The last entry is always CustomProperty so scan for length minus one
            for(idx = 0; idx < ntvCal.Length - 1; idx++)
                if(ntvCal[idx].IsMatch(propertyName))
                    break;

            // An opening BEGIN:VCALENDAR property must have been seen
            if(vCal == null && ntvCal[idx].EnumValue != PropertyType.Begin)
                throw new PDIParserException(this.LineNumber, LR.GetString("ExParseNoBeginProp", "BEGIN:VCALENDAR",
                    propertyName));

            // Handle or create the property
            switch(ntvCal[idx].EnumValue)
            {
                case PropertyType.Begin:
                    // Start a new object
                    temp = propertyValue.Trim();

                    // The last entry is always Custom so scan for length - 1
                    for(idx = 0; idx < ntvObjs.Length - 1; idx++)
                        if(ntvObjs[idx].IsMatch(temp))
                            break;

                    priorState.Push(currentState);
                    currentState = ntvObjs[idx].EnumValue;

                    switch(currentState)
                    {
                        case VCalendarParserState.VCalendar:
                            // NOTE: If serializing into an existing instance, this may not be null.  If so, it
                            // is ignored. It may also exist if two calendars appear in the same file.  In that
                            // case, they will be merged into one calendar.
                            if(vCal == null)
                                vCal = new VCalendar();
                            break;

                        case VCalendarParserState.VEvent:
                            vEvent = new VEvent();
                            vCal.Events.Add(vEvent);
                            break;

                        case VCalendarParserState.VToDo:
                            vToDo = new VToDo();
                            vCal.ToDos.Add(vToDo);
                            break;

                        case VCalendarParserState.VJournal:
                            vJournal = new VJournal();
                            vCal.Journals.Add(vJournal);
                            break;

                        case VCalendarParserState.VFreeBusy:
                            vFreeBusy = new VFreeBusy();
                            vCal.FreeBusys.Add(vFreeBusy);
                            break;

                        case VCalendarParserState.VTimeZone:
                            // NOTE: Unlike the other objects, time zone are not added to the collection until
                            // the END Tag is encountered as they are shared amongst all calendar instances.
                            vTimeZone = new VTimeZone();
                            break;

                        case VCalendarParserState.Custom:
                            CustomObjectParser(propertyName, parameters, propertyValue);
                            break;
                    }
                    break;

                case PropertyType.End:
                    // The value must be VCALENDAR
                    if(String.Compare(propertyValue.Trim(), "VCALENDAR", StringComparison.OrdinalIgnoreCase) != 0)
                        throw new PDIParserException(this.LineNumber, LR.GetString("ExParseUnrecognizedTagValue",
                            ntvCal[idx].Name, propertyValue));

                    // When done, we'll propagate the version number to all objects to make it consistent
                    vCal.PropagateVersion();
                    break;

                case PropertyType.Version:
                    // Version must be 1.0 or 2.0
                    temp = propertyValue.Trim();

                    if(temp == "1.0")
                        version = SpecificationVersions.vCalendar10;
                    else
                        if(temp == "2.0")
                            version = SpecificationVersions.iCalendar20;
                        else
                            throw new PDIParserException(this.LineNumber, LR.GetString("ExParseUnrecognizedVersion",
                                "vCalendar/iCalendar", temp));

                    vCal.Version = version;
                    break;

                case PropertyType.ProductId:
                    vCal.ProductId.EncodedValue = propertyValue;
                    break;

                case PropertyType.CalendarScale:
                    vCal.CalendarScale.DeserializeParameters(parameters);
                    vCal.CalendarScale.EncodedValue = propertyValue;
                    break;

                case PropertyType.Method:
                    vCal.Method.DeserializeParameters(parameters);
                    vCal.Method.EncodedValue = propertyValue;
                    break;

                case PropertyType.GeographicPosition:
                    vCal.VCalendarGeographicPosition.EncodedValue = propertyValue;
                    break;

                case PropertyType.TimeZone:
                    vCal.VCalendarTimeZone.DeserializeParameters(parameters);
                    vCal.VCalendarTimeZone.EncodedValue = propertyValue;
                    break;

                case PropertyType.Daylight:
                    vCal.VCalendarDaylightRule.DeserializeParameters(parameters);
                    vCal.VCalendarDaylightRule.EncodedValue = propertyValue;
                    break;

                default:    // Anything else is a custom property
                    CustomProperty c = new CustomProperty(propertyName);
                    c.DeserializeParameters(parameters);
                    c.EncodedValue = propertyValue;
                    vCal.CustomProperties.Add(c);
                    break;
            }
        }
Exemplo n.º 15
0
        //=====================================================================

        /// <summary>
        /// This is overridden to handle the additional state maintained by the calendar parser
        /// </summary>
        /// <param name="fullReset">If true, a full reset is done (i.e. this is the start of a brand new session.
        /// If false only the line state is reset (it's done parsing a property name or value).</param>
        protected override void ResetState(bool fullReset)
        {
            if(fullReset)
            {
                currentState = VCalendarParserState.VCalendar;
                vEvent = null;
                vToDo = null;
                vJournal = null;
                vAlarm = null;
                vFreeBusy = null;
                vTimeZone = null;
                obsRule = null;

                priorState.Clear();
                beginValue.Clear();
            }

            base.ResetState(fullReset);
        }
Exemplo n.º 16
0
 /// <summary>
 /// The time zone object does not have any properties that use time zone IDs
 /// </summary>
 /// <param name="vTimeZone">A <see cref="VTimeZone"/> object that will be used for all date/time objects
 /// in the component.</param>
 public override void ApplyTimeZone(VTimeZone vTimeZone)
 {
 }
Exemplo n.º 17
0
 /// <summary>
 /// The time zone object does not have any properties that use time zone IDs
 /// </summary>
 /// <param name="vTimeZone">A <see cref="VTimeZone"/> object that will be used for all date/time objects
 /// in the component.</param>
 public override void SetTimeZone(VTimeZone vTimeZone)
 {
 }
Exemplo n.º 18
0
 /// <summary>
 /// This helper method can be used to set a new time zone in the passed date/time property without
 /// modifying the date/time value.
 /// </summary>
 /// <param name="dateProp">The date/time property to check</param>
 /// <param name="vTimeZone">The new time zone component to use</param>
 /// <remarks>If the property's current time zone ID does not match the one in the new time zone, it is
 /// updated with the new ID.  The date/time value is not changed.</remarks>
 protected static void SetPropertyTimeZone(BaseDateTimeProperty dateProp, VTimeZone vTimeZone)
 {
     if(dateProp != null && (vTimeZone == null || dateProp.TimeZoneId != vTimeZone.TimeZoneId.Value))
     {
         // If the time zone is null, just clear the time zone ID
         if(vTimeZone == null)
             dateProp.TimeZoneId = null;
         else
             dateProp.TimeZoneId = vTimeZone.TimeZoneId.Value;
     }
 }
Exemplo n.º 19
0
        //=====================================================================

        /// <summary>
        /// This is used to load the VCalendar.TimeZones collection with time zone information from the registry
        /// </summary>
        public static void LoadTimeZoneInfo()
        {
            string keyName, display, standardDesc, dstDesc;
            TIMEZONE tz;

            VCalendar.TimeZones.Clear();

            // To keep things simple, we'll load the time zone data from the settings available in the registry.
            // We could take it a step further and load it from something like a copy of the Olson time zone
            // database but I haven't been that ambitious yet.
            if(Environment.OSVersion.Platform == PlatformID.Win32NT)
                keyName = @"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Time Zones";
            else
                keyName = @"SOFTWARE\Microsoft\Windows\CurrentVersion\Time Zones";

            using(var rk = Registry.LocalMachine.OpenSubKey(keyName))
            {
                foreach(string s in rk.GetSubKeyNames())
                {
                    using(var rsk = rk.OpenSubKey(s))
                    {
                        display = (string)rsk.GetValue("Display");
                        standardDesc = (string)rsk.GetValue("Std");
                        dstDesc = (string)rsk.GetValue("Dlt");
                        tz = TIMEZONE.FromRegistry(rsk.GetValue("TZI"));
                    }

                    // Create the time zone object
                    VTimeZone vtz = new VTimeZone();
                    vtz.TimeZoneId.Value = display;

                    ObservanceRule or = vtz.ObservanceRules.Add(ObservanceRuleType.Standard);

                    or.OffsetFrom.TimeSpanValue = TimeSpan.FromMinutes(tz.nBias + tz.nDaylightBias).Negate();
                    or.OffsetTo.TimeSpanValue = TimeSpan.FromMinutes(tz.nBias + tz.nStandardBias).Negate();
                    or.TimeZoneNames.Add(standardDesc);

                    // If the standard date month is zero, it doesn't use standard time.  Assume 01/01/1970 and
                    // set it up to return the offset.
                    if(tz.standardDate.wMonth == 0)
                        or.StartDateTime.DateTimeValue = new DateTime(1970, 1, 1);
                    else
                    {
                        // If year is zero, its a recurrence.  If not zero, it's a fixed date.
                        if(tz.standardDate.wYear == 0)
                        {
                            or.StartDateTime.DateTimeValue = tz.standardDate.ToDateTime(1970);

                            RRuleProperty rrule = new RRuleProperty();

                            rrule.Recurrence.RecurYearly(
                                (tz.standardDate.wDay > 4) ? DayOccurrence.Last : (DayOccurrence)tz.standardDate.wDay,
                                tz.standardDate.DayOfWeek(), tz.standardDate.wMonth, 1);

                            or.RecurrenceRules.Add(rrule);
                        }
                        else
                        {
                            or.StartDateTime.DateTimeValue = tz.standardDate.ToDateTime();
                            or.RecurDates.Add(or.StartDateTime.DateTimeValue);
                        }
                    }

                    // If the daylight month is zero, it doesn't use DST.  The standard rule will handle
                    // everything.
                    if(tz.daylightDate.wMonth != 0)
                    {
                        or = vtz.ObservanceRules.Add(ObservanceRuleType.Daylight);

                        or.OffsetFrom.TimeSpanValue = TimeSpan.FromMinutes(tz.nBias + tz.nStandardBias).Negate();
                        or.OffsetTo.TimeSpanValue = TimeSpan.FromMinutes(tz.nBias + tz.nDaylightBias).Negate();
                        or.TimeZoneNames.Add(dstDesc);

                        // If year is zero, its a recurrence.  If not zero, it's a fixed date.
                        if(tz.daylightDate.wYear == 0)
                        {
                            or.StartDateTime.DateTimeValue = tz.daylightDate.ToDateTime(1970);

                            RRuleProperty rrule = new RRuleProperty();

                            rrule.Recurrence.RecurYearly(
                                (tz.daylightDate.wDay > 4) ? DayOccurrence.Last : (DayOccurrence)tz.daylightDate.wDay,
                                tz.daylightDate.DayOfWeek(), tz.daylightDate.wMonth, 1);

                            or.RecurrenceRules.Add(rrule);
                        }
                        else
                        {
                            or.StartDateTime.DateTimeValue = tz.daylightDate.ToDateTime();
                            or.RecurDates.Add(or.StartDateTime.DateTimeValue);
                        }
                    }

                    VCalendar.TimeZones.Add(vtz);
                }
            }

            // Put the time zones in sorted order
            VCalendar.TimeZones.Sort(true);
        }
Exemplo n.º 20
0
 /// <summary>
 /// This is used to apply the selected time zone to all date/time objects in the component and convert
 /// them to the new time zone.
 /// </summary>
 /// <param name="vTimeZone">A <see cref="VTimeZone"/> object that will be used for all date/time objects
 /// in the component.</param>
 /// <remarks>When applied, all date/time values in the object will be converted to the new time zone</remarks>
 public abstract void ApplyTimeZone(VTimeZone vTimeZone);
Exemplo n.º 21
0
 /// <summary>
 /// This is used to set the selected time zone in all date/time objects in the component without
 /// modifying the date/time values.
 /// </summary>
 /// <param name="vTimeZone">A <see cref="VTimeZone"/> object that will be used for all date/time objects
 /// in the component.</param>
 /// <remarks>This method does not affect the date/time values</remarks>
 public abstract void SetTimeZone(VTimeZone vTimeZone);
Exemplo n.º 22
0
        /// <summary>
        /// This is used to set the selected time zone in all date/time objects in the component without
        /// modifying the date/time values.
        /// </summary>
        /// <param name="vTimeZone">A <see cref="VTimeZone"/> object that will be used for all date/time objects
        /// in the component.</param>
        /// <remarks>This method does not affect the date/time values</remarks>
        public override void SetTimeZone(VTimeZone vTimeZone)
        {
            if(events != null)
                events.SetTimeZone(vTimeZone);

            if(todos != null)
                todos.SetTimeZone(vTimeZone);

            if(journals != null)
                journals.SetTimeZone(vTimeZone);

            if(freebusy != null)
                freebusy.SetTimeZone(vTimeZone);
        }
Exemplo n.º 23
0
		static void Main()
		{
            Recurrence r = new Recurrence();
            int idx;

            Console.WriteLine("The first part will calculate instances using only the Recurrence class.  All " +
                "instances are expressed in local time.\nPress ENTER to continue...");
            Console.ReadLine();

            // NOTE: The examples in the spec assume the US-Eastern time zone.  Here, we're specifying the
            // date/times directly and everything is in local time.  The recurrence engine always generates the
            // date/times in local time when used by itself.  For time zone support, use the calendar objects as
            // demonstrated later on below.

            Console.WriteLine("Daily for 10 occurrences:");

            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Daily;
            r.MaximumOccurrences = 10;

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Daily until December 24, 1997:");

            // We'll re-use the same object.  Just reset it first.
            r.Reset();

            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Daily;

            // Note that in the spec examples, it looks as if the end times are wrong.  It shows the times in
            // Universal Time as it should be but if you convert the times from Universal Time to US-Eastern time
            // (-05:00), it cuts a few of the patterns off too early.  I've adjusted those where needed.
            r.RecurUntil = new DateTime(1997, 12, 24, 0, 0, 0);

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every other day - forever:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Daily;
            r.Interval = 2;

            Console.WriteLine(r.ToStringWithStartDateTime());

            // We'll limit the output of the "forever" rules by using the InstancesBetween() method to limit the
            // output to a range of dates and enumerate the returned DateTimeCollection.
            foreach(DateTime dt in r.InstancesBetween(r.StartDateTime, new DateTime(1997, 12, 5)))
                Console.WriteLine(dt);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every 10 days, 5 occurrences:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Daily;
            r.Interval = 10;
            r.MaximumOccurrences = 5;

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every day in January, for 3 years:");

            r.Reset();
            r.StartDateTime = new DateTime(1998, 1, 1, 9, 0, 0);
            r.Frequency = RecurFrequency.Yearly;
            r.RecurUntil = new DateTime(2000, 1, 31, 9, 0, 0);
            r.ByMonth.Add(1);

            // When adding days without an instance value, you can use the helper method on the collection that
            // takes an array of DayOfWeek values rather than constructing an array of DayInstance objects.
            r.ByDay.AddRange(new[] { DayOfWeek.Sunday, DayOfWeek.Monday, DayOfWeek.Tuesday, DayOfWeek.Wednesday,
                DayOfWeek.Thursday, DayOfWeek.Friday, DayOfWeek.Saturday });

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            // Like the last one but using a DAILY frequency
            Console.WriteLine("Everyday in January, for 3 years:");

            r.Reset();
            r.StartDateTime = new DateTime(1998, 1, 1, 9, 0, 0);
            r.Frequency = RecurFrequency.Daily;
            r.RecurUntil = new DateTime(2000, 1, 31, 9, 0, 0);
            r.ByMonth.Add(1);

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Weekly for 10 occurrences:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Weekly;
            r.MaximumOccurrences = 10;

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Weekly until December 24, 1997:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Weekly;
            r.RecurUntil = new DateTime(1997, 12, 24, 0, 0, 0);

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every other week - forever:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Weekly;
            r.Interval = 2;
            r.WeekStart = DayOfWeek.Sunday;

            Console.WriteLine(r.ToStringWithStartDateTime());

            // Not forever for the test
            foreach(DateTime dt in r.InstancesBetween(r.StartDateTime, new DateTime(1999, 2, 10)))
                Console.WriteLine(dt);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Weekly on Tuesday and Thursday for 5 weeks:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Weekly;
            r.RecurUntil = new DateTime(1997, 10, 07, 0, 0, 0);
            r.WeekStart = DayOfWeek.Sunday;
            r.ByDay.AddRange(new[] { DayOfWeek.Tuesday, DayOfWeek.Thursday });

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            // Like the last one but using a count
            Console.WriteLine("Weekly on Tuesday and Thursday for 5 weeks:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Weekly;
            r.MaximumOccurrences = 10;
            r.WeekStart = DayOfWeek.Sunday;
            r.ByDay.AddRange(new[] { DayOfWeek.Tuesday, DayOfWeek.Thursday });

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            // NOTE: The inclusion of DTSTART in a recurrence set is a feature of the calendar objects, NOT the
            // recurrence engine.  To include DTSTART, use a calendar object such as VEvent to generate the set
            // as demonstrated later on below.
            Console.WriteLine("Every other week on Monday, Wednesday and Friday until December 24, 1997, but " +
                "starting on Tuesday, September 2, 1997:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Weekly;
            r.Interval = 2;
            r.WeekStart = DayOfWeek.Sunday;
            r.RecurUntil = new DateTime(1997, 12, 24, 0, 0, 0);
            r.ByDay.AddRange(new[] { DayOfWeek.Monday, DayOfWeek.Wednesday, DayOfWeek.Friday });

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every other week on Tuesday and Thursday, for 8 occurrences:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Weekly;
            r.Interval = 2;
            r.WeekStart = DayOfWeek.Sunday;
            r.MaximumOccurrences = 8;
            r.ByDay.AddRange(new[] { DayOfWeek.Tuesday, DayOfWeek.Thursday });

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Monthly on the 1st Friday for ten occurrences:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 5, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.MaximumOccurrences = 10;

            // There are also helper methods to add single instances
            r.ByDay.Add(1, DayOfWeek.Friday);

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Monthly on the 1st Friday until December 24, 1997:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 5, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.RecurUntil = new DateTime(1997, 12, 24, 0, 0, 0);
            r.ByDay.Add(1, DayOfWeek.Friday);

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every other month on the 1st and last Sunday of the month for 10 occurrences:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 7, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.Interval = 2;
            r.MaximumOccurrences = 10;
            r.ByDay.AddRange(new[] { new DayInstance(1, DayOfWeek.Sunday), new DayInstance(-1, DayOfWeek.Sunday) });

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Monthly on the second to last Monday of the month for 6 months:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 22, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.MaximumOccurrences = 6;
            r.ByDay.Add(-2, DayOfWeek.Monday);

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Monthly on the third to the last day of the month, forever:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 28, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.ByMonthDay.Add(-3);

            Console.WriteLine(r.ToStringWithStartDateTime());

            // Not forever for the test
            foreach(DateTime dt in r.InstancesBetween(r.StartDateTime, new DateTime(1998, 2, 28)))
                Console.WriteLine(dt);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Monthly on the 2nd and 15th of the month for 10 occurrences:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.MaximumOccurrences = 10;
            r.ByMonthDay.AddRange(new[] { 2, 15 });

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Monthly on the first and last day of the month for 10 occurrences:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 30, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.MaximumOccurrences = 10;
            r.ByMonthDay.AddRange(new[] { 1, -1 });

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every 18 months on the 10th through 15th of the month for 10 occurrences:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 10, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.Interval = 18;
            r.MaximumOccurrences = 10;
            r.ByMonthDay.AddRange(new[] { 10, 11, 12, 13, 14, 15 });

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every Tuesday, every other month:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.Interval = 2;
            r.ByDay.Add(DayOfWeek.Tuesday);

            Console.WriteLine(r.ToStringWithStartDateTime());

            // Not forever for the test
            foreach(DateTime dt in r.InstancesBetween(r.StartDateTime, new DateTime(1998, 4, 1)))
                Console.WriteLine(dt);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Yearly in June and July for 10 occurrences:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 6, 10, 9, 0, 0);
            r.Frequency = RecurFrequency.Yearly;
            r.MaximumOccurrences = 10;
            r.ByMonth.AddRange(new[] { 6, 7 });

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every other year in January, February, and March for 10 occurrences:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 3, 10, 9, 0, 0);
            r.Frequency = RecurFrequency.Yearly;
            r.Interval = 2;
            r.MaximumOccurrences = 10;
            r.ByMonth.AddRange(new[] { 1, 2, 3 });

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every 3rd year on the 1st, 100th and 200th day for 10 occurrences:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 1, 1, 9, 0, 0);
            r.Frequency = RecurFrequency.Yearly;
            r.Interval = 3;
            r.MaximumOccurrences = 10;
            r.ByYearDay.AddRange(new[] { 1, 100, 200 });

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every 20th Monday of the year, forever:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 5, 19, 9, 0, 0);
            r.Frequency = RecurFrequency.Yearly;
            r.ByDay.Add(20, DayOfWeek.Monday);

            Console.WriteLine(r.ToStringWithStartDateTime());

            // Not forever for the test
            foreach(DateTime dt in r.InstancesBetween(r.StartDateTime, new DateTime(2004, 5, 19)))
                Console.WriteLine(dt);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Monday of week number 20 (where the default start of the week is Monday), forever:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 5, 12, 9, 0, 0);
            r.Frequency = RecurFrequency.Yearly;
            r.ByWeekNo.Add(20);
            r.ByDay.Add(DayOfWeek.Monday);

            Console.WriteLine(r.ToStringWithStartDateTime());

            // Not forever for the test
            foreach(DateTime dt in r.InstancesBetween(r.StartDateTime, new DateTime(2004, 5, 19)))
                Console.WriteLine(dt);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every Thursday in March, forever:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 3, 13, 9, 0, 0);
            r.Frequency = RecurFrequency.Yearly;
            r.ByMonth.Add(3);
            r.ByDay.Add(DayOfWeek.Thursday);

            Console.WriteLine(r.ToStringWithStartDateTime());

            // Not forever for the test
            foreach(DateTime dt in r.InstancesBetween(r.StartDateTime, new DateTime(1999, 4, 1)))
                Console.WriteLine(dt);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every Thursday, but only during June, July, and August, forever:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 6, 5, 9, 0, 0);
            r.Frequency = RecurFrequency.Yearly;
            r.ByMonth.AddRange(new[] { 6, 7, 8 });
            r.ByDay.Add(DayOfWeek.Thursday);

            Console.WriteLine(r.ToStringWithStartDateTime());

            // Not forever for the test
            foreach(DateTime dt in r.InstancesBetween(r.StartDateTime, new DateTime(1999, 9, 1)))
                Console.WriteLine(dt);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every Friday the 13th, forever:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.ByDay.Add(DayOfWeek.Friday);
            r.ByMonthDay.Add(13);

            Console.WriteLine(r.ToStringWithStartDateTime());

            // Not forever for the test
            foreach(DateTime dt in r.InstancesBetween(r.StartDateTime, new DateTime(2003, 12, 31)))
                Console.WriteLine(dt);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("The first Saturday that follows the first Sunday of the month, forever:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 13, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.ByDay.Add(DayOfWeek.Saturday);
            r.ByMonthDay.AddRange(new[] { 7, 8, 9, 10, 11, 12, 13 });

            Console.WriteLine(r.ToStringWithStartDateTime());

            // Not forever for the test
            foreach(DateTime dt in r.InstancesBetween(r.StartDateTime, new DateTime(1998, 7, 1)))
                Console.WriteLine(dt);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every four years, the first Tuesday after a Monday in November, forever " +
                "(U.S. Presidential Election day):");

            r.Reset();
            r.StartDateTime = new DateTime(1996, 11, 5, 9, 0, 0);
            r.Frequency = RecurFrequency.Yearly;
            r.Interval = 4;
            r.ByMonth.Add(11);
            r.ByDay.Add(DayOfWeek.Tuesday);
            r.ByMonthDay.AddRange(new[] { 2, 3, 4, 5, 6, 7, 8 });

            Console.WriteLine(r.ToStringWithStartDateTime());

            // Not forever for the test
            foreach(DateTime dt in r.InstancesBetween(r.StartDateTime, new DateTime(2004, 11, 3)))
                Console.WriteLine(dt);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("The 3rd instance into the month of one of Tuesday, Wednesday or Thursday, for " +
                "the next 3 months:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 4, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.MaximumOccurrences = 3;
            r.BySetPos.Add(3);
            r.ByDay.AddRange(new[] { DayOfWeek.Tuesday, DayOfWeek.Wednesday, DayOfWeek.Thursday });

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("The 2nd to last weekday of the month:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 29, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.BySetPos.Add(-2);
            r.ByDay.AddRange(new[] { DayOfWeek.Monday, DayOfWeek.Tuesday, DayOfWeek.Wednesday,
                DayOfWeek.Thursday, DayOfWeek.Friday });

            Console.WriteLine(r.ToStringWithStartDateTime());

            // Not forever for the test
            foreach(DateTime dt in r.InstancesBetween(r.StartDateTime, new DateTime(1998, 9, 29)))
                Console.WriteLine(dt);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every 3 hours from 9:00 AM to 5:00 PM on a specific day:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Hourly;
            r.Interval = 3;
            r.RecurUntil = new DateTime(1997, 9, 2, 17, 0, 0);

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every 15 minutes for 6 occurrences:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Minutely;
            r.Interval = 15;
            r.MaximumOccurrences = 6;

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every hour and a half for 4 occurrences:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Minutely;
            r.Interval = 90;
            r.MaximumOccurrences = 4;

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every 20 minutes from 9:00 AM to 4:40 PM every day:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Daily;
            r.ByHour.AddRange(new[] { 9, 10, 11, 12, 13, 14, 15, 16 });
            r.ByMinute.AddRange( new[] { 0, 20, 40 });

            Console.WriteLine(r.ToStringWithStartDateTime());

            // Not forever for the test
            foreach(DateTime dt in r.InstancesBetween(r.StartDateTime, new DateTime(1997, 9, 4)))
                Console.WriteLine(dt);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------
            
            // Like the last one but with a MINUTELY frequency
            Console.WriteLine("Every 20 minutes from 9:00 AM to 4:40 PM every day:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Minutely;
            r.Interval = 20;
            r.ByHour.AddRange(new[] { 9, 10, 11, 12, 13, 14, 15, 16 });

            Console.WriteLine(r.ToStringWithStartDateTime());

            // Not forever for the test
            foreach(DateTime dt in r.InstancesBetween(r.StartDateTime, new DateTime(1997, 9, 4)))
                Console.WriteLine(dt);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("An example where the days generated makes a difference because of WKST:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 8, 5, 9, 0, 0);
            r.Frequency = RecurFrequency.Weekly;
            r.Interval = 2;
            r.MaximumOccurrences = 4;
            r.ByDay.AddRange(new[] { DayOfWeek.Tuesday, DayOfWeek.Sunday });

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Changing only WKST from the default MO to SU yields different results:");

            r.Reset();
            r.StartDateTime = new DateTime(1997, 8, 5, 9, 0, 0);
            r.Frequency = RecurFrequency.Weekly;
            r.Interval = 2;
            r.MaximumOccurrences = 4;
            r.WeekStart = DayOfWeek.Sunday;
            r.ByDay.AddRange(new[] { DayOfWeek.Tuesday, DayOfWeek.Sunday });

            Console.WriteLine(r.ToStringWithStartDateTime());

            foreach(DateTime dt in r)
                Console.WriteLine(dt);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            // Now do the same one but use the calendar classes to demonstrate the time zone abilities
            Console.WriteLine("\n\nThe next part will calculate instances using the calendar classes with " +
                "time zone support.\nPress ENTER to continue...");
            Console.ReadLine();

            // First, set up the time zone information.  If you don't care about the time zone, you can skip this
            // stuff and everything will be calculated in local time.
            VTimeZone vtz = new VTimeZone();
            vtz.TimeZoneId.Value = "US-Eastern";

            // Set the standard time observance rule
            ObservanceRule obr = vtz.ObservanceRules.Add(ObservanceRuleType.Standard);

            obr.StartDateTime.DateTimeValue = new DateTime(1970, 10, 25, 2, 0, 0);
            obr.OffsetFrom.TimeSpanValue = TimeSpan.FromHours(-4);
            obr.OffsetTo.TimeSpanValue = TimeSpan.FromHours(-5);

            RRuleProperty rrule = new RRuleProperty();
            rrule.Recurrence.RecurYearly(DayOccurrence.Last, DaysOfWeek.Sunday, 10, 1);
            obr.RecurrenceRules.Add(rrule);

            obr.TimeZoneNames.Add("Eastern Standard Time");

            // Set the daylight saving time observance rule
            obr = vtz.ObservanceRules.Add(ObservanceRuleType.Daylight);

            obr.StartDateTime.DateTimeValue = new DateTime(1970, 4, 5, 2, 0, 0);
            obr.OffsetFrom.TimeSpanValue = TimeSpan.FromHours(-5);
            obr.OffsetTo.TimeSpanValue = TimeSpan.FromHours(-4);

            rrule = new RRuleProperty();
            rrule.Recurrence.RecurYearly(DayOccurrence.First, DaysOfWeek.Sunday, 4, 1);
            obr.RecurrenceRules.Add(rrule);

            obr.TimeZoneNames.Add("Eastern Daylight Time");

            VCalendar.TimeZones.Add(vtz);

            // Now we'll set up an event to use for the calculations.  We don't need a VCalendar object as we are
            // just generating recurring instances.
            VEvent vevent = new VEvent();

            // Add an RRULE property
            rrule = new RRuleProperty();
            vevent.RecurrenceRules.Add(rrule);

            // Get a reference to the recurrence rule property's recurrence and the event's start date property
            // for convenience.
            r = rrule.Recurrence;

            StartDateProperty startDateTime = vevent.StartDateTime;

            // Set the time zone of the event's start date to the same ID used for the time zone component above
            vevent.StartDateTime.TimeZoneId = "US-Eastern";

            //-----------------------------------------------------------------

            Console.WriteLine("Daily for 10 occurrences:");

            // The start date is set on the event.  We use the TimeZoneDateTime property to indicate that the
            // date/time is in the time zone.  Using DateTimeValue instead would convert the value from local
            // time to the time zone.
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Daily;
            r.MaximumOccurrences = 10;

            // Get the instances expressed in the time zone's time and in local time
            DateTimeInstanceCollection dtiTZ = vevent.AllInstances(false);
            DateTimeInstanceCollection dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            // We'll just display the start time from each instance.  End time and duration info is also present
            // in the returned instances.
            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Daily until December 24, 1997:");

            // We'll re-use the same recurrence object.  Just reset it first.
            r.Reset();

            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Daily;

            // Note that the recurrence rules in an event determine the end date of the event, NOT the EndDate
            // (DTEND) property of the event.  The end date property on the event simply determines the duration
            // of each instance.  Another thing to remember is that RecurUntil is specified in Universal Time
            // which ends up in local time when recurrence instances are generated.  If specify times in another
            // time zone, be sure to set the RecurUntil time as a time in that time zone.
            r.RecurUntil = new DateTime(1997, 12, 24, 5, 0, 0).ToLocalTime();

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every other day - forever:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Daily;
            r.Interval = 2;

            // We'll limit the output of the "forever" rules by using the InstancesBetween() method to limit the
            // output to a range of dates and enumerate the returned DateTimeCollection.
            dtiTZ = vevent.InstancesBetween(startDateTime.TimeZoneDateTime, new DateTime(1997, 12, 5), false);

            // For local time, the start and end date must be in local time.  To match the range in the prior
            // call, we use the DateTimeValue property of the start date property and convert a value in
            // Universal Time to local time.
            dtiLocal = vevent.InstancesBetween(startDateTime.DateTimeValue,
                new DateTime(1997, 12, 5, 5, 0, 0).ToLocalTime(), true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every 10 days, 5 occurrences:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Daily;
            r.Interval = 10;
            r.MaximumOccurrences = 5;

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Everyday in January, for 3 years:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1998, 1, 1, 9, 0, 0);
            r.Frequency = RecurFrequency.Yearly;
            r.RecurUntil = new DateTime(2000, 1, 31, 14, 0, 0).ToLocalTime();
            r.ByMonth.Add(1);

            // When adding days without an instance value, you can use the helper method on the collection that
            // takes an array of DayOfWeek values rather than constructing an array of DayInstance objects.
            r.ByDay.AddRange(new[] { DayOfWeek.Sunday, DayOfWeek.Monday, DayOfWeek.Tuesday, DayOfWeek.Wednesday,
                DayOfWeek.Thursday, DayOfWeek.Friday, DayOfWeek.Saturday });

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            // Like the last one but using a DAILY frequency
            Console.WriteLine("Everyday in January, for 3 years:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1998, 1, 1, 9, 0, 0);
            r.Frequency = RecurFrequency.Daily;
            r.RecurUntil = new DateTime(2000, 1, 31, 14, 0, 0).ToLocalTime();
            r.ByMonth.Add(1);

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Weekly for 10 occurrences:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Weekly;
            r.MaximumOccurrences = 10;

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Weekly until December 24, 1997:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Weekly;
            r.RecurUntil = new DateTime(1997, 12, 24, 5, 0, 0).ToLocalTime();

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every other week - forever:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Weekly;
            r.Interval = 2;
            r.WeekStart = DayOfWeek.Sunday;

            // Not forever for the test
            dtiTZ = vevent.InstancesBetween(startDateTime.TimeZoneDateTime, new DateTime(1999, 2, 10), false);
            dtiLocal = vevent.InstancesBetween(startDateTime.DateTimeValue,
                new DateTime(1999, 2, 10, 5, 0, 0).ToLocalTime(), true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Weekly on Tuesday and Thursday for 5 weeks:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Weekly;
            r.RecurUntil = new DateTime(1997, 10, 07, 4, 0, 0).ToLocalTime();
            r.WeekStart = DayOfWeek.Sunday;
            r.ByDay.AddRange(new [] { DayOfWeek.Tuesday, DayOfWeek.Thursday });

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------
            
            // Like the last one but using a count
            Console.WriteLine("Weekly on Tuesday and Thursday for 5 weeks:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Weekly;
            r.MaximumOccurrences = 10;
            r.WeekStart = DayOfWeek.Sunday;
            r.ByDay.AddRange(new[] { DayOfWeek.Tuesday, DayOfWeek.Thursday });

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            // The inclusion of DTSTART in a recurrence set is a feature of the calendar objects, NOT the
            // recurrence engine.  So, for this example, the start date will be included.
            Console.WriteLine("Every other week on Monday, Wednesday and Friday until December 24, 1997, but " +
                "starting on Tuesday, September 2, 1997:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Weekly;
            r.Interval = 2;
            r.WeekStart = DayOfWeek.Sunday;
            r.RecurUntil = new DateTime(1997, 12, 24, 5, 0, 0).ToLocalTime();
            r.ByDay.AddRange(new[] { DayOfWeek.Monday, DayOfWeek.Wednesday, DayOfWeek.Friday });

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every other week on Tuesday and Thursday, for 8 occurrences:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Weekly;
            r.Interval = 2;
            r.WeekStart = DayOfWeek.Sunday;
            r.MaximumOccurrences = 8;
            r.ByDay.AddRange(new[] { DayOfWeek.Tuesday, DayOfWeek.Thursday });

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName,  dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Monthly on the 1st Friday for ten occurrences:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 5, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.MaximumOccurrences = 10;

            // There are also helper methods to add single instances
            r.ByDay.Add(1, DayOfWeek.Friday);

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Monthly on the 1st Friday until December 24, 1997:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 5, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.RecurUntil = new DateTime(1997, 12, 24, 5, 0, 0).ToLocalTime();
            r.ByDay.Add(1, DayOfWeek.Friday);

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every other month on the 1st and last Sunday of the month for 10 occurrences:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 7, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.Interval = 2;
            r.MaximumOccurrences = 10;
            r.ByDay.AddRange(new[] { new DayInstance(1, DayOfWeek.Sunday), new DayInstance(-1, DayOfWeek.Sunday) });

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Monthly on the second to last Monday of the month for 6 months:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 22, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.MaximumOccurrences = 6;
            r.ByDay.Add(-2, DayOfWeek.Monday);

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Monthly on the third to the last day of the month, forever:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 28, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.ByMonthDay.Add(-3);

            // Not forever for the test
            dtiTZ = vevent.InstancesBetween(startDateTime.TimeZoneDateTime, new DateTime(1998, 2, 28), false);
            dtiLocal = vevent.InstancesBetween(startDateTime.DateTimeValue,
                new DateTime(1998, 2, 28, 5, 0, 0).ToLocalTime(), true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Monthly on the 2nd and 15th of the month for 10 occurrences:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.MaximumOccurrences = 10;
            r.ByMonthDay.AddRange(new[] { 2, 15 });

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Monthly on the first and last day of the month for 10 occurrences:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 30, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.MaximumOccurrences = 10;
            r.ByMonthDay.AddRange(new[] { 1, -1 });

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every 18 months on the 10th through 15th of the month for 10 occurrences:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 10, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.Interval = 18;
            r.MaximumOccurrences = 10;
            r.ByMonthDay.AddRange(new[] { 10, 11, 12, 13, 14, 15 });

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every Tuesday, every other month:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.Interval = 2;
            r.ByDay.Add(DayOfWeek.Tuesday);

            // Not forever for the test
            dtiTZ = vevent.InstancesBetween(startDateTime.TimeZoneDateTime, new DateTime(1998, 4, 1), false);
            dtiLocal = vevent.InstancesBetween(startDateTime.DateTimeValue,
                new DateTime(1998, 4, 1, 5, 0, 0).ToLocalTime(), true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Yearly in June and July for 10 occurrences:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 6, 10, 9, 0, 0);
            r.Frequency = RecurFrequency.Yearly;
            r.MaximumOccurrences = 10;
            r.ByMonth.AddRange(new[] { 6, 7 });

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every other year in January, February, and March for 10 occurrences:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 3, 10, 9, 0, 0);
            r.Frequency = RecurFrequency.Yearly;
            r.Interval = 2;
            r.MaximumOccurrences = 10;
            r.ByMonth.AddRange(new[] { 1, 2, 3 });

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every 3rd year on the 1st, 100th and 200th day for 10 occurrences:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 1, 1, 9, 0, 0);
            r.Frequency = RecurFrequency.Yearly;
            r.Interval = 3;
            r.MaximumOccurrences = 10;
            r.ByYearDay.AddRange(new[] { 1, 100, 200 });

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every 20th Monday of the year, forever:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 5, 19, 9, 0, 0);
            r.Frequency = RecurFrequency.Yearly;
            r.ByDay.Add(20, DayOfWeek.Monday);

            // Not forever for the test
            dtiTZ = vevent.InstancesBetween(startDateTime.TimeZoneDateTime, new DateTime(2004, 5, 19), false);
            dtiLocal = vevent.InstancesBetween(startDateTime.DateTimeValue,
                new DateTime(2004, 5, 19, 4, 0, 0).ToLocalTime(), true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Monday of week number 20 (where the default start of the week is Monday), forever:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 5, 12, 9, 0, 0);
            r.Frequency = RecurFrequency.Yearly;
            r.ByWeekNo.Add(20);
            r.ByDay.Add(DayOfWeek.Monday);

            // Not forever for the test
            dtiTZ = vevent.InstancesBetween(startDateTime.TimeZoneDateTime, new DateTime(2004, 5, 19), false);
            dtiLocal = vevent.InstancesBetween(startDateTime.DateTimeValue,
                new DateTime(2004, 5, 19, 4, 0, 0).ToLocalTime(), true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every Thursday in March, forever:");
            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 3, 13, 9, 0, 0);
            r.Frequency = RecurFrequency.Yearly;
            r.ByMonth.Add(3);
            r.ByDay.Add(DayOfWeek.Thursday);

            // Not forever for the test
            dtiTZ = vevent.InstancesBetween(startDateTime.TimeZoneDateTime, new DateTime(1999, 4, 1), false);
            dtiLocal = vevent.InstancesBetween(startDateTime.DateTimeValue,
                new DateTime(1999, 4, 1, 5, 0, 0).ToLocalTime(), true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every Thursday, but only during June, July, and August, forever:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 6, 5, 9, 0, 0);
            r.Frequency = RecurFrequency.Yearly;
            r.ByMonth.AddRange(new[] { 6, 7, 8 });
            r.ByDay.Add(DayOfWeek.Thursday);

            // Not forever for the test
            dtiTZ = vevent.InstancesBetween(startDateTime.TimeZoneDateTime, new DateTime(1999, 9, 1), false);
            dtiLocal = vevent.InstancesBetween(startDateTime.DateTimeValue,
                new DateTime(1999, 9, 1, 4, 0, 0).ToLocalTime(), true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every Friday the 13th, forever:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.ByDay.Add(DayOfWeek.Friday);
            r.ByMonthDay.Add(13);

            // This one uses an EXDATE property to remove the starting date
            ExDateProperty exdate = vevent.ExceptionDates.Add(startDateTime.TimeZoneDateTime);
            exdate.TimeZoneId = startDateTime.TimeZoneId;

            // Not forever for the test
            dtiTZ = vevent.InstancesBetween(startDateTime.TimeZoneDateTime, new DateTime(2003, 12, 31), false);
            dtiLocal = vevent.InstancesBetween(startDateTime.DateTimeValue,
                new DateTime(2003, 12, 31, 5, 0, 0).ToLocalTime(), true);

            Console.Write(startDateTime.ToString());
            Console.Write(exdate.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            // Clear the exception date
            vevent.ExceptionDates.Clear();

            //-----------------------------------------------------------------

            Console.WriteLine("The first Saturday that follows the first Sunday of the month, forever:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 13, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.ByDay.Add(DayOfWeek.Saturday);
            r.ByMonthDay.AddRange(new[] { 7, 8, 9, 10, 11, 12, 13 });

            // Not forever for the test
            dtiTZ = vevent.InstancesBetween(startDateTime.TimeZoneDateTime, new DateTime(1998, 7, 1), false);
            dtiLocal = vevent.InstancesBetween(startDateTime.DateTimeValue,
                new DateTime(1998, 7, 1, 4, 0, 0).ToLocalTime(), true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every four years, the first Tuesday after a Monday in November, forever (U.S. " +
                "Presidential Election day):");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1996, 11, 5, 9, 0, 0);
            r.Frequency = RecurFrequency.Yearly;
            r.Interval = 4;
            r.ByMonth.Add(11);
            r.ByDay.Add(DayOfWeek.Tuesday);
            r.ByMonthDay.AddRange(new[] { 2, 3, 4, 5, 6, 7, 8 });

            // Not forever for the test
            dtiTZ = vevent.InstancesBetween(startDateTime.TimeZoneDateTime, new DateTime(2004, 11, 3), false);
            dtiLocal = vevent.InstancesBetween(startDateTime.DateTimeValue,
                new DateTime(2004, 11, 3, 5, 0, 0).ToLocalTime(), true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("The 3rd instance into the month of one of Tuesday, Wednesday or Thursday, for " +
                "the next 3 months:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 4, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.MaximumOccurrences = 3;
            r.BySetPos.Add(3);
            r.ByDay.AddRange(new[] { DayOfWeek.Tuesday, DayOfWeek.Wednesday, DayOfWeek.Thursday });

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("The 2nd to last weekday of the month:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 29, 9, 0, 0);
            r.Frequency = RecurFrequency.Monthly;
            r.BySetPos.Add(-2);
            r.ByDay.AddRange(new[] { DayOfWeek.Monday, DayOfWeek.Tuesday, DayOfWeek.Wednesday,
                DayOfWeek.Thursday, DayOfWeek.Friday });

            // Not forever for the test
            dtiTZ = vevent.InstancesBetween(startDateTime.TimeZoneDateTime, new DateTime(1998, 9, 29), false);
            dtiLocal = vevent.InstancesBetween(startDateTime.DateTimeValue,
                new DateTime(1998, 9, 29, 4, 0, 0).ToLocalTime(), true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every 3 hours from 9:00 AM to 5:00 PM on a specific day:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Hourly;
            r.Interval = 3;
            r.RecurUntil = new DateTime(1997, 9, 2, 21, 0, 0).ToLocalTime();

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every 15 minutes for 6 occurrences:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Minutely;
            r.Interval = 15;
            r.MaximumOccurrences = 6;

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every hour and a half for 4 occurrences:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Minutely;
            r.Interval = 90;
            r.MaximumOccurrences = 4;

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Every 20 minutes from 9:00 AM to 4:40 PM every day:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Daily;
            r.ByHour.AddRange(new[] { 9, 10, 11, 12, 13, 14, 15, 16 });
            r.ByMinute.AddRange( new[] { 0, 20, 40 });

            // Not forever for the test
            dtiTZ = vevent.InstancesBetween(startDateTime.TimeZoneDateTime, new DateTime(1997, 9, 4), false);
            dtiLocal = vevent.InstancesBetween(startDateTime.DateTimeValue,
                new DateTime(1997, 9, 4, 4, 0, 0).ToLocalTime(), true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            // Like the last one but with a MINUTELY frequency
            Console.WriteLine("Every 20 minutes from 9:00 AM to 4:40 PM every day:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 9, 2, 9, 0, 0);
            r.Frequency = RecurFrequency.Minutely;
            r.Interval = 20;
            r.ByHour.AddRange(new[] { 9, 10, 11, 12, 13, 14, 15, 16 });

            // Not forever for the test
            dtiTZ = vevent.InstancesBetween(startDateTime.TimeZoneDateTime, new DateTime(1997, 9, 4), false);
            dtiLocal = vevent.InstancesBetween(startDateTime.DateTimeValue,
                new DateTime(1997, 9, 4, 4, 0, 0).ToLocalTime(), true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("... Forever ...\nPress ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("An example where the days generated makes a difference because of WKST:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 8, 5, 9, 0, 0);
            r.Frequency = RecurFrequency.Weekly;
            r.Interval = 2;
            r.MaximumOccurrences = 4;
            r.ByDay.AddRange(new[] { DayOfWeek.Tuesday, DayOfWeek.Sunday });

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();

            //-----------------------------------------------------------------

            Console.WriteLine("Changing only WKST from the default MO to SU yields different results:");

            r.Reset();
            startDateTime.TimeZoneDateTime = new DateTime(1997, 8, 5, 9, 0, 0);
            r.Frequency = RecurFrequency.Weekly;
            r.Interval = 2;
            r.MaximumOccurrences = 4;
            r.WeekStart = DayOfWeek.Sunday;
            r.ByDay.AddRange(new[] { DayOfWeek.Tuesday, DayOfWeek.Sunday });

            dtiTZ = vevent.AllInstances(false);
            dtiLocal = vevent.AllInstances(true);

            Console.Write(startDateTime.ToString());
            Console.Write(rrule.ToString());

            for(idx = 0; idx < dtiTZ.Count; idx++)
                Console.WriteLine("TZ: {0:G} {1}    Local: {2:G} {3}", dtiTZ[idx].StartDateTime,
                    dtiTZ[idx].AbbreviatedStartTimeZoneName, dtiLocal[idx].StartDateTime,
                    dtiLocal[idx].AbbreviatedStartTimeZoneName);

            Console.WriteLine("Press ENTER to continue...");
            Console.ReadLine();
		}
Exemplo n.º 24
0
        /// <summary>
        /// Add a new time zone component
        /// </summary>
        /// <param name="sender">The sender of the event</param>
        /// <param name="e">The event arguments</param>
        private void btnAdd_Click(object sender, EventArgs e)
        {
            using(VTimeZoneDlg dlg = new VTimeZoneDlg())
            {
                if(dlg.ShowDialog() == DialogResult.OK)
                {
                    VTimeZone tz = new VTimeZone();
                    dlg.GetValues(tz);

                    VCalendar.TimeZones.Add(tz);
                    wasModified = true;
                    LoadGridWithItems();
                }
            }
        }