diff options
Diffstat (limited to 'comm/calendar/base/public')
40 files changed, 4296 insertions, 0 deletions
diff --git a/comm/calendar/base/public/calIAlarm.idl b/comm/calendar/base/public/calIAlarm.idl new file mode 100644 index 0000000000..4fe5f9c945 --- /dev/null +++ b/comm/calendar/base/public/calIAlarm.idl @@ -0,0 +1,157 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface nsIVariant; + +interface calIAttachment; +interface calIAttendee; +interface calIDateTime; +interface calIDuration; +interface calIItemBase; +interface calIIcalComponent; + +[scriptable, uuid(b8db7c7f-c168-4e11-becb-f26c1c4f5f8f)] +interface calIAlarm : nsISupports +{ + /** + * Returns true if this alarm is able to be modified + */ + readonly attribute boolean isMutable; + + /** + * Makes this alarm immutable. + */ + void makeImmutable(); + + /** + * Make a copy of this alarm. The returned alarm will be mutable. + */ + calIAlarm clone(); + + /** + * How this alarm is shown. Special values as described in rfc2445 are + * AUDIO, DISPLAY, EMAIL + * In addition, custom actions may be defined as an X-Prop, i.e + * X-SMS. + * + * Note that aside from setting this action, the frontend must be able to + * handle the specified action. Unknown actions WILL NOT be notified for. + */ + attribute AUTF8String action; + + /** + * The offset between the item's date and the alarm time. + * This will be null for absolute alarms. + */ + attribute calIDuration offset; + + /** + * The absolute date and time the alarm should fire. + * This will be null for relative alarms. + */ + attribute calIDateTime alarmDate; + + /** + * One of the ALARM_RELATED constants below. + */ + attribute unsigned long related; + + /** + * The alarm is absolute and is therefore not related to either. + */ + const unsigned long ALARM_RELATED_ABSOLUTE = 0; + + /** + * The alarm's offset should be based off of the startDate or + * entryDate (for events and tasks, respectively) + */ + const unsigned long ALARM_RELATED_START = 1; + + /** + * the alarm's offset should be based off of the endDate or + * dueDate (for events and tasks, respectively) + */ + const unsigned long ALARM_RELATED_END = 2; + + /** + * Times the alarm should be repeated. This value is the number of + * ADDITIONAL alarms, aside from the actual alarm. + * + * For the alarm to be valid, if repeat is specified, the repeatOffset + * attribute MUST also be specified. + */ + attribute unsigned long repeat; + + /** + * The duration between the alarm and each subsequent repeat + * + * For the alarm to be valid, if repeatOffset is specified, the repeat + * attribute MUST also be specified. + */ + attribute calIDuration repeatOffset; + + /** + * If repeat is specified, this helper returns the first DATETIME the alarm + * should be repeated on. + * This will be null for relative alarms. + */ + readonly attribute calIDateTime repeatDate; + + /** + * The description of the alarm. Not valid for AUDIO alarms. + */ + attribute AUTF8String description; + + /** + * The summary of the alarm. Not valid for AUDIO and DISPLAY alarms. + */ + attribute AUTF8String summary; + + /** + * Manage Attendee for this alarm. Not valid for AUDIO and DISPLAY alarms. + */ + void addAttendee(in calIAttendee aAttendee); + void deleteAttendee(in calIAttendee aAttendee); + void clearAttendees(); + Array<calIAttendee> getAttendees(); + + /** + * Manage Attachments for this alarm. + * For EMAIL alarms, more than one attachment can be specified. + * For AUDIO alarms, one Attachment can be specified. + * For DISPLAY alarms, attachments are invalid. + */ + void addAttachment(in calIAttachment aAttachment); + void deleteAttachment(in calIAttachment aAttachment); + void clearAttachments(); + Array<calIAttachment> getAttachments(); + + /** + * The human readable representation of this alarm. Uses locale strings. + * + * @param aItem The item to base the string on. Defaults to an event. + */ + AUTF8String toString([optional] in calIItemBase aItem); + + /** + * The ical representation of this VALARM + */ + attribute AUTF8String icalString; + + /** + * The ical component of this VALARM + */ + attribute calIIcalComponent icalComponent; + + // Property bag + boolean hasProperty(in AUTF8String name); + nsIVariant getProperty(in AUTF8String name); + void setProperty(in AUTF8String name, in nsIVariant value); + void deleteProperty(in AUTF8String name); + + // Each inner array has two elements: a string and a nsIVariant. + readonly attribute Array<Array<jsval> > properties; +}; diff --git a/comm/calendar/base/public/calIAlarmService.idl b/comm/calendar/base/public/calIAlarmService.idl new file mode 100644 index 0000000000..4af77628db --- /dev/null +++ b/comm/calendar/base/public/calIAlarmService.idl @@ -0,0 +1,116 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface calIItemBase; +interface calICalendar; +interface calIDuration; +interface calITimezone; +interface calIAlarm; +interface calIOperation; + +[scriptable,uuid(dc96dd04-d2dd-448e-b307-8c8ff39c72af)] +interface calIAlarmServiceObserver : nsISupports +{ + /** + * Gets called when an alarm has fired. Depending on type of alarm, an + * observer could bring up a dialog or play a sound. + */ + void onAlarm(in calIItemBase item, in calIAlarm alarm); + + /** + * Gets called when an notification has fired. The notification is only + * controlled by prefs, and is independent from the alarm/reminder. + */ + void onNotification(in calIItemBase item); + + /** + * Called if alarm(s) of a specific item are to be removed from + * the alarm window. + * + * @param aItem corresponding item, maybe master item of recurring + * series (then all alarms belonging to this item are to + * be removed) + */ + void onRemoveAlarmsByItem(in calIItemBase item); + + /** + * Called if all alarms of a specific calendar are to be removed. + */ + void onRemoveAlarmsByCalendar(in calICalendar calendar); + + /** + * Called when all alarms of a specific calendar are loaded. + */ + void onAlarmsLoaded(in calICalendar calendar); +}; + +[scriptable,uuid(42cfa9ce-49d6-11e5-b88c-5b90eedc1c47)] +interface calIAlarmService : nsISupports +{ + /** + * Upper limit for the snooze period for an alarm. To avoid performance issues, don't change this + * to a value larger then 1 at least until bug 861594 or a similar concept is implemented. + */ + const unsigned long MAX_SNOOZE_MONTHS = 1; + + /** + * This is the timezone that all-day events will be converted to in order to + * determine when their alarms should fire. + */ + attribute calITimezone timezone; + + /** + * Will return true while the alarm service is in the process of loading alarms + */ + attribute boolean isLoading; + + /** + * Cause the alarm service to start up, create a list of upcoming + * alarms in all registered calendars, add observers to watch for + * calendar registration and unregistration, and setup a timer to + * maintain that list and fire alarms. + * + * @note Will throw NS_ERROR_NOT_INITIALIZED if you have not previously set + * the timezone attribute. + */ + void startup(); + + /** + * Shuts down the alarm service, canceling all timers and removing all + * alarms. + */ + void shutdown(); + + /* add and remove observers that will be notified when an + alarm has gone off. It is up to the application to display + the alarm. + */ + void addObserver(in calIAlarmServiceObserver observer); + void removeObserver(in calIAlarmServiceObserver observer); + + /** + * Call to reschedule an alarm to be notified at a later point. The alarm will + * instead fire at "now + duration" This will cause an event to be scheduled + * even if it was not previously scheduled. + * + * @param item The item the alarm belongs to. + * @param alarm The alarm to snooze. + * @param duration The duration in minutes to snooze for. + * @return The operation that modifies the item to snooze the + * alarm. + */ + calIOperation snoozeAlarm(in calIItemBase item, in calIAlarm alarm, in calIDuration duration); + + /** + * Dismisses the given alarm for the passed occurrence. + * + * @param item The item the alarm belongs to. + * @param alarm The alarm to dismiss. + * @return The operation that modifies the item to dismiss the + * alarm. + */ + calIOperation dismissAlarm(in calIItemBase item, in calIAlarm alarm); +}; diff --git a/comm/calendar/base/public/calIAttachment.idl b/comm/calendar/base/public/calIAttachment.idl new file mode 100644 index 0000000000..7ca054d5a2 --- /dev/null +++ b/comm/calendar/base/public/calIAttachment.idl @@ -0,0 +1,57 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface nsIURI; +interface calIIcalProperty; +interface calIItemBase; + +[scriptable,uuid(7a17d45d-1c0e-4877-baa3-0eb67e770498)] +interface calIAttachment : nsISupports +{ + /** + * The hash id is used to identify this attachment and compare it to others. + */ + readonly attribute AUTF8String hashId; + + /** + * An nsIURI object that points to the file (local or remote) + */ + attribute nsIURI uri; + + /** + * Raw attachment data, in case its not an uri + */ + attribute AUTF8String rawData; + + /** + * The type of file that this attachment refers to + */ + attribute AString formatType; + + /** + * The encoding the (local) file should be encoded with. + */ + attribute AUTF8String encoding; + + /** + * The calIIcalProperty corresponding to this object. Can be used for + * serializing/unserializing from ics files. + */ + attribute calIIcalProperty icalProperty; + attribute AUTF8String icalString; + + /** + * For accessing additional parameters, such as x-params. + */ + AUTF8String getParameter(in AString name); + void setParameter(in AString name, in AUTF8String value); + void deleteParameter(in AString name); + + /** + * Clone this calIAttachment instance into a new object. + */ + calIAttachment clone(); +}; diff --git a/comm/calendar/base/public/calIAttendee.idl b/comm/calendar/base/public/calIAttendee.idl new file mode 100644 index 0000000000..ccbda1827e --- /dev/null +++ b/comm/calendar/base/public/calIAttendee.idl @@ -0,0 +1,80 @@ +/* -*- Mode: idl; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface calIIcalProperty; + +[scriptable,uuid(73a074ad-8812-4055-af75-14b509b8c5fe)] +interface calIAttendee : nsISupports +{ + readonly attribute boolean isMutable; + + // makes this item immutable + void makeImmutable(); + + // clone always returns a mutable event + calIAttendee clone(); + + attribute AUTF8String id; + attribute AUTF8String commonName; + attribute AUTF8String rsvp; + + /** + * If true, indicates that this is not a standard attendee, but rather this + * icalProperty corresponds to the organizer of the event (rfc2445 Sec 4.8.4.3) + */ + attribute boolean isOrganizer; + + /** + * CHAIR + * REQ-PARTICIPANT + * OPT-PARTICIPANT + * NON-PARTICIPANT + */ + attribute AUTF8String role; + + /** + * NEEDS-ACTION + * ACCEPTED + * DECLINED + * TENTATIVE + * DELEGATED + * COMPLETED + * IN-PROCESS + */ + attribute AUTF8String participationStatus; + + /** + * INDIVIDUAL + * GROUP + * RESOURCE + * ROOM + * UNKNOWN + */ + attribute AUTF8String userType; + + // Each inner array has two elements: a string and a nsIVariant. + readonly attribute Array<Array<jsval> > properties; + + // If you use the has/get/set/deleteProperty + // methods, property names are case-insensitive. + // + // For purposes of ICS serialization, all property names in + // the hashbag are in uppercase. + AUTF8String getProperty(in AString name); + void setProperty(in AString name, in AUTF8String value); + void deleteProperty(in AString name); + + attribute calIIcalProperty icalProperty; + attribute AUTF8String icalString; + + /** + * The display name of the attendee. If the attendee has a common name, this + * is used. Otherwise, the attendee id is displayed (often an email), with the + * mailto: prefix dropped. + */ + AUTF8String toString(); +}; diff --git a/comm/calendar/base/public/calICalendar.idl b/comm/calendar/base/public/calICalendar.idl new file mode 100644 index 0000000000..8366dbaf38 --- /dev/null +++ b/comm/calendar/base/public/calICalendar.idl @@ -0,0 +1,605 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +// decls for stuff from other files +interface nsIURI; +interface calIItemBase; +interface nsIVariant; + +// forward decls for this file +interface calICalendarACLManager; +interface calICalendarACLEntry; +interface calIObserver; +interface calIOperationListener; +interface calIRange; +interface calISchedulingSupport; +interface calIDateTime; +interface calIOperation; +interface calIStatusObserver; +interface nsIDOMChromeWindow; + + +[scriptable, uuid(b18782c0-6557-4e8e-931d-4bf052f0a31e)] +interface calICalendar : nsISupports +{ + /** + * Unique ID of this calendar. Only the calendar manager is allowed to set + * this attribute. For everybody else, it should be considered to be + * read-only. + * The id is null for unregistered calendars. + */ + attribute AUTF8String id; + + /** + * Name of the calendar + * Notes: Can only be set after the calendar is registered with the calendar manager. + */ + attribute AUTF8String name; + + /** + * Type of the calendar + * 'memory', 'storage', 'caldav', etc + */ + readonly attribute AUTF8String type; + + /** + * If this calendar is provided by an extension, this attribute should return + * the extension's id, otherwise null. + */ + readonly attribute AString providerID; + + /** + * Returns the acl manager for the calendar, based on the "aclManagerClass" + * property. If this property is not defined, the default manager is used + */ + readonly attribute calICalendarACLManager aclManager; + + /** + * Returns the acl entry associated to the calendar. + */ + readonly attribute calICalendarACLEntry aclEntry; + + /** + * Multiple calendar instances may be composited, logically acting as a + * single calendar, e.g. for caching puorposing. + * This attribute determines the topmost calendar that returned items should + * belong to. If the current instance is the topmost calendar, then it should + * be returned directly. + * + * @see calIItemBase::calendar + */ + attribute calICalendar superCalendar; + + /** + * Setting this URI causes the calendar to be (re)loaded. + * This is not an unique identifier! It is also not unchangeable. Don't + * use it to identify a calendar, use the id attribute for that purpose. + */ + attribute nsIURI uri; + + /** + * Is this calendar read-only? Used by the UI to decide whether or not + * widgetry should allow editing. + */ + attribute boolean readOnly; + + /** + * Whether or not it makes sense to call refresh() on this calendar. + */ + readonly attribute boolean canRefresh; + + /** + * Setting this attribute to true will prevent the calendar to make calendar properties + * persistent, which is useful if you would like to set properties on unregistered + * calendar instances. + */ + attribute boolean transientProperties; + + /** + * Gets a calendar property. + * The call returns null in case the property is not known; + * callers should use a sensible default in that case. + * + * It's up to the provider where to store properties, + * e.g. on the server or in local prefs. + * + * Currently known properties are: + * [boolean] disabled + * [boolean] auto-enabled If true, the calendar will be enabled on next startup. + * [boolean] force-disabled If true, the calendar cannot be enabled (transient). + * [boolean] calendar-main-in-composite + * [string] name + * [boolean] readOnly + * [boolean] requiresNetwork If false, the calendar does not require + * network access at all. This is mainy used + * as a UI hint. + * [boolean] suppressAlarms If true, alarms of this calendar are not minded. + * [boolean] cache.supported If true, the calendar should to be cached, + * e.g. this generally applies to network calendars; + * default is true (if not present). + * [boolean] cache.enabled If true, the calendar is cached; default is false. + * [boolean] cache.always If true, the cache will always be enabled + * and the user cannot turn it off. For + * backward compatibility, return true for + * cache.enabled too. + * + * [nsresult] currentStatus The current error status of the calendar (transient). + * + * [calIItipTransport] itip.transport If the provider implements a custom calIItipTransport (transient) + * If null, then Email Scheduling will effectively be + * disabled. This means for example, the calendar will + * not show up in the list of calendars to store an + * invitation in. + * [boolean] itip.disableRevisionChecks If true, the iTIP handling code disables revision checks + * against SEQUENCE and DTSTAMP, and will never reject an + * iTIP message as outdated + * [nsIMsgIdentity] imip.identity If provided, this is the email identity used for + * scheduling purposes + * [boolean] imip.identity.disabled If true, this calendar doesn't support switching imip + * identities. This for example means that the + * dropdown of identities will not be shown in the + * calendar properties dialog. (transient) + * scheduling purposes + * [nsIMsgAccount] imip.account If provided, this is the email account used for + * scheduling purposes + * [string] imip.identity.key If provided, this is the email internal identity key used to + * get the above + * + * [string] organizerId If provided, this is the preset organizer id on creating + * scheduling appointments (transient) + * [string] organizerCN If provided, this is the preset organizer common name on creating + * scheduling appointments (transient) + * + * The following calendar capabilities can be used to inform the UI or backend + * that certain features are not supported. If not otherwise mentioned, not + * specifying these capabilities assumes a default value of true + * capabilities.alarms.popup.supported Supports popup alarms + * capabilities.alarms.oninviations.supported Supports alarms on inviations. + * capabilities.alarms.maxCount Maximum number of alarms supported per event + * capabilities.attachments.supported Supports attachments + * capabilities.categories.maxCount Maximum number of supported categories. + * -1 means infinite, 0 means disabled. + * capabilities.privacy.supported Supports a privacy state + * capabilities.priority.supported Supports the priority field + * capabilities.events.supported Supports tasks + * capabilities.tasks.supported Supports events + * capabilities.timezones.floating.supported Supports local time + * capabilities.timezones.UTC.supported Supports UTC/GMT timezone + * capabilities.autoschedule.supported Supports caldav schedule properties in + * icalendar (SCHEDULE-AGENT, SCHEDULE-STATUS...) + * + * The following capabilities are used to restrict the values for specific + * fields. An array should be specified with the values, the default + * values are specified here. Extensions using this need to take care of + * adding any UI elements needed in an overlay. To make sure the correct + * elements are shown, those elements should additionally specify an attribute + * "provider", with the type of the provider. + * + * capabilities.privacy.values = ["PUBLIC", "CONFIDENTIAL", "PRIVATE"]; + * + * The following special capability disables rewriting the WWW-Authenticate + * header on HTTP requests to include the calendar name. The default value + * is false, i.e rewriting is NOT disabled. + * + * capabilities.realmrewrite.disabled = false + * + * The following capability describes if the calendar can be permanently + * deleted, or just unsubscribed. If this property is not specified, then + * only unsubscribing is allowed. If an empty array is specified, neither + * deleting nor unsubscribing is presented in the UI. + * + * capabilities.removeModes = ["delete", "unsubscribe"] + * + * @param aName property name + * @return value (string, integer and boolean values are supported), + * else null + */ + nsIVariant getProperty(in AUTF8String aName); + + /** + * Sets a calendar property. + * This will (only) cause a notification onPropertyChanged() in case + * the value has changed. + * + * It's up to the provider where to store properties, + * e.g. on the server or in local prefs. + * + * @param aName property name + * @param aValue value + * (string, integer and boolean values are supported) + */ + void setProperty(in AUTF8String aName, in nsIVariant aValue); + + /** + * Deletes a calendar property. + * + * It's up to the provider where to store properties, + * e.g. on the server or in local prefs. + * + * @param aName property name + */ + void deleteProperty(in AUTF8String aName); + + /** + * In combination with the other parameters to getItems(), these + * constants provide for a very basic filtering mechanisms for use + * in getting and observing items. At some point fairly soon, we're + * going to need to generalize this mechanism significantly (so we + * can allow boolean logic, categories, etc.). + * + * When adding item filters (bits which, when not set to 1, reduce the + * scope of the results), use bit positions <= 15, so that + * ITEM_FILTER_ALL_ITEMS remains compatible for components that have the + * constant compiled in. + * + * XXX the naming here is questionable; adding a filter (setting a bit, in + * this case) usually _reduces_ the set of items that pass the set of + * filters, rather than adding to it. + */ + const unsigned long ITEM_FILTER_COMPLETED_YES = 1 << 0; + const unsigned long ITEM_FILTER_COMPLETED_NO = 1 << 1; + const unsigned long ITEM_FILTER_COMPLETED_ALL = (ITEM_FILTER_COMPLETED_YES | + ITEM_FILTER_COMPLETED_NO); + + const unsigned long ITEM_FILTER_TYPE_TODO = 1 << 2; + const unsigned long ITEM_FILTER_TYPE_EVENT = 1 << 3; + const unsigned long ITEM_FILTER_TYPE_JOURNAL = 1 << 4; + const unsigned long ITEM_FILTER_TYPE_ALL = (ITEM_FILTER_TYPE_TODO | + ITEM_FILTER_TYPE_EVENT | + ITEM_FILTER_TYPE_JOURNAL); + + const unsigned long ITEM_FILTER_ALL_ITEMS = 0xFFFF; + + /** + * If set, return calIItemBase occurrences for all the appropriate instances, + * as determined by an item's recurrenceInfo. All of these occurrences will + * have their parentItem set to the recurrence parent. If not set, will + * return only calIItemBase parent items. + */ + const unsigned long ITEM_FILTER_CLASS_OCCURRENCES = 1 << 16; + + /** + * Scope: Attendee + * Filter items that correspond to an invitation from another + * user and the current user has not replied to it yet. + */ + const unsigned long ITEM_FILTER_REQUEST_NEEDS_ACTION = 1 << 17; + + /** + * Flags for items that have been created, modified or deleted while + * offline. + * ITEM_FILTER_OFFLINE_DELETED is a particular case in that elements *must* + * be excluded from searches when not specified in the filter mask. + */ + const unsigned long ITEM_FILTER_OFFLINE_CREATED = 1 << 29; + const unsigned long ITEM_FILTER_OFFLINE_MODIFIED = 1 << 30; + const unsigned long ITEM_FILTER_OFFLINE_DELETED = 1 << 31; + + void addObserver( in calIObserver observer ); + void removeObserver( in calIObserver observer ); + + /** + * supportsScheduling indicates whether the calendar implements the + * calISchedulingSupport interface. + */ + readonly attribute boolean supportsScheduling; + + /** + * getSchedulingSupport provides a calISchedulingSupport implementation for + * calendars that support it. + */ + calISchedulingSupport getSchedulingSupport(); + + /** + * addItem adds the given calIItemBase to the calendar. + * + * @param aItem item to add + * @return optional operation handle to track the operation + * + * - If aItem already has an ID, that ID is used when adding. + * - If aItem is mutable and has no ID, the calendar is expected + * to generate an ID for the item. + * - If aItem is immutable and has no ID, an error is thrown. + * + * The result of the operation is the calIItemBase corresponding to the + * immutable version of the newly added item. + * + * If an item with a given ID already exists in the calendar, the Promise is + * rejected with a NS_ERROR_XXXXX error. + * + * @return {Promise<calIItemBase>} + */ + Promise addItem(in calIItemBase aItem); + + /** + * adoptItem adds the given calIItemBase to the calendar, but doesn't + * clone it. It adopts the item as-is. This is generally for use in + * performance-critical situations where there is no danger of the caller + * using the item after making the call. + * + * @see addItem + * + * @return {Promise<calIItemBase>} + */ + Promise adoptItem(in calIItemBase aItem); + + /** + * modifyItem takes a modified item and modifies the + * calendar's internal version of the item to match. The item is expected to + * be mutable and have an ID that already exists in the calendar. If it does + * not, the Promise is rejected with NS_ERROR_XXXXX. + * + * If the generation of the given aNewItem does not match the generation + * of the internal item (indicating that someone else modified the + * item), the Promise is rejected with NS_ERROR_XXXXX. + * + * If you would like to disable revision checks, pass null as aOldItem. This + * will overwrite the item on the server. + * + * @param aNewItem new version to replace the old one + * @param aOldItem caller's view of the item to be changed, as it is now + * @return {Promise<calIItemBase>} the newly-updated immutable version of + * the modified item. + * + */ + Promise modifyItem(in calIItemBase aNewItem, in calIItemBase aOldItem); + + /** + * Deletes an item. The item is expected to have an ID that already exists in + * the calendar. + * + * @param aItem item to delete + * @return {Promise<void>} optional operation handle to track the operation + */ + Promise deleteItem(in calIItemBase aItem); + + /** + * Get a single event. The event will be typed as one of the subclasses + * of calIItemBase (whichever concrete type is most appropriate). + * + * @param aId UID of the event + * @return {Promise<calIItemBase|null>} A Promise that is resolved with the item if found. + */ + Promise getItem(in string aId); + + /** + * XXX As mentioned above, this method isn't suitably general. It's just + * placeholder until it gets supplanted by something more SQL or RDF-like. + * + * Ordering: This method is currently guaranteed to return lists ordered + * as follows to make for the least amount of pain when + * migrating existing frontend code: + * + * The events are sorted based on the order of their next occurrence + * if they recur in the future or their last occurrence in the past + * otherwise. Here's a presentation of the sort criteria using the + * time axis: + * + * -----(Last occurrence of Event1)---(Last occurrence of Event2)----(Now)----(Next occurrence of Event3)----> + * + * (Note that Event1 and Event2 will not recur in the future.) + * + * We should probably be able get rid of this ordering constraint + * at some point in the future. + * + * Note that the range is intended to act as a mask on the + * occurrences, not just the initial recurring items. So if a + * getItems() call without ITEM_FILTER_CLASS_occurrenceS is made, all + * events and todos which have occurrences inside the range should + * be returned, even if some of those events or todos themselves + * live outside the range. + * + * @param aItemFilter ITEM_FILTER flags, or-ed together + * @param aCount Maximum number of items to return, or 0 for + * an unbounded query. + * @param aRangeStart Items starting at this time or after should be + * returned. If invalid, assume "since the beginning + * of time". + * @param aRangeEndEx Items starting before (not including) aRangeEndEx should be + * returned. If null, assume "until the end of time". + * @return {ReadableStream<calIItemBase>} + */ + jsval getItems(in unsigned long aItemFilter, + in unsigned long aCount, + in calIDateTime aRangeStart, + in calIDateTime aRangeEndEx); + + /** + * Similar to getItems() but returns all results in a single array. + * @param aItemFilter ITEM_FILTER flags, or-ed together + * @param aCount Maximum number of items to return, or 0 for + * an unbounded query. + * @param aRangeStart Items starting at this time or after should be + * returned. If invalid, assume "since the beginning + * of time". + * @param aRangeEndEx Items starting before (not including) aRangeEndEx should be + * returned. If null, assume "until the end of time". + * @return {Promise<calIItemBase[]>} + */ + Promise getItemsAsArray(in unsigned long aItemFilter, + in unsigned long aCount, + in calIDateTime aRangeStart, + in calIDateTime aRangeEndEx); + + /** + * Refresh the datasource, and call the observers for any changes found. + * If the provider doesn't know the details of the changes it must call + * onLoad on its observers. + * + * @return optional operation handle to track the operation + */ + calIOperation refresh(); + + /** + * Turn on batch mode. Observers will get a notification of this. + * They will still get notified for every individual change, but they are + * free to ignore those notifications. + * Use this when a lot of changes are about to happen, and it would be + * useless to refresh the display (or the backend store) for every change. + * Caller must make sure to also call endBatchMode. Make sure all errors + * are caught! + */ + void startBatch(); + + /** + * Turn off batch mode. + */ + void endBatch(); +}; + +/** + * Used to allow multiple calendars (eg work and home) to be easily queried + * and displayed as a single unit. All calendars are referenced by ID, i.e. + * calendars need to have an ID when being added. + */ +[scriptable, uuid(6748fa00-79b5-4728-84f3-20dd47e0b031)] +interface calICompositeCalendar : calICalendar +{ + /** + * Adds a calendar to the composite, if not already part of it. + * + * @param aCalendar the calendar to be added + */ + void addCalendar(in calICalendar aCalendar); + + /** + * Remove a calendar from the composite + * + * @param aCalendar the calendar to be removed + */ + void removeCalendar(in calICalendar aCalendar); + + /** + * If a calendar for the given ID exists in the CompositeCalendar, + * return it; otherwise return null. + * + * @param aId id of calendar + * @return calendar, or null if none + */ + calICalendar getCalendarById(in AUTF8String aId); + + /* return a list of all calendars currently registered */ + Array<calICalendar> getCalendars(); + + /** + * In order for addItem() to be called on this object, it is first necessary + * to set this attribute to specify which underlying calendar the item is + * to be added to. + */ + attribute calICalendar defaultCalendar; + + /** + * If set, the composite will initialize itself from calICalendarManager + * prefs keyed off of the provided prefPrefix, and update those prefs to + * track changes in calendar membership and default calendar. + */ + attribute ACString prefPrefix; + + /** + * If returns true there is a process running that needs to displayed + * by the statusObserver + */ + readonly attribute boolean statusDisplayed; + + /** + * Sets a statusobserver for status notifications like startMeteors() and StopMeteors(). + */ + void setStatusObserver(in calIStatusObserver aStatusObserver, in nsIDOMChromeWindow aWindow); +}; + +/** + * Make a more general nsIObserverService2 and friends to support + * nsISupports data and use that instead? + * + * NOTE: When adding methods here, please also add them in calUtils.jsm's + * createAdapter() method. + */ +[scriptable, uuid(2953c9b2-2c73-11d9-80b6-00045ace3b8d)] +interface calIObserver : nsISupports +{ + void onStartBatch(in calICalendar aCalendar); + void onEndBatch(in calICalendar aCalendar); + void onLoad( in calICalendar aCalendar ); + void onAddItem( in calIItemBase aItem ); + void onModifyItem( in calIItemBase aNewItem, in calIItemBase aOldItem ); + void onDeleteItem( in calIItemBase aDeletedItem ); + void onError( in calICalendar aCalendar, in nsresult aErrNo, in AUTF8String aMessage ); + + /// Called after a property is changed. + void onPropertyChanged(in calICalendar aCalendar, + in AUTF8String aName, + in nsIVariant aValue, + in nsIVariant aOldValue); + + /// Called before the property is deleted. + void onPropertyDeleting(in calICalendar aCalendar, + in AUTF8String aName); +}; + +/** + * calICompositeObserver interface adds things to observe changes to + * a calICompositeCalendar + */ +[scriptable, uuid(a3584c92-b8eb-4aa8-a638-e46a2e11d6a9)] +interface calICompositeObserver : calIObserver +{ + void onCalendarAdded( in calICalendar aCalendar ); + void onCalendarRemoved( in calICalendar aCalendar ); + void onDefaultCalendarChanged( in calICalendar aNewDefaultCalendar ); +}; + +/** + * Async operations are called back via this interface. If you know that your + * object is not going to get called back for either of these methods, having + * them return NS_ERROR_NOT_IMPLEMENTED is reasonable. + * + * NOTE: When adding methods here, please also add them in calUtils.jsm's + * createAdapter() method. + */ +[scriptable, uuid(ed3d87d8-2c77-11d9-8f5f-00045ace3b8d)] +interface calIOperationListener : nsISupports +{ + /** + * For add, modify, and delete. + * + * @param aCalendar the calICalendar on which the operation took place + * @param aStatus status code summarizing what happened + * @param aOperationType type of operation that was completed + * @param aId UUID of element that was changed + * @param aDetail not yet fully specified. If aStatus is an error + * result, this will probably be an extended error + * string (eg one returned by a server). + */ + void onOperationComplete(in calICalendar aCalendar, + in nsresult aStatus, + in unsigned long aOperationType, + in string aId, + in nsIVariant aDetail); + const unsigned long ADD = 1; + const unsigned long MODIFY = 2; + const unsigned long DELETE = 3; + const unsigned long GET = 4; + + /** + * For getItem and getItems. + * + * @param aStatus status code summarizing what happened. + * @param aItemType type of interface returned in the array (@see + * calICalendar::GetItems). + * @param aDetail not yet fully specified. If aStatus is an error + * result, this will probably be an extended error + * string (eg one returned by a server). + * @param aItems array of immutable items + * + * Multiple onGetResults might be called + */ + void onGetResult(in calICalendar aCalendar, + in nsresult aStatus, + in nsIIDRef aItemType, + in nsIVariant aDetail, + [iid_is(aItemType)] in Array<nsQIResult> aItems); +}; diff --git a/comm/calendar/base/public/calICalendarACLManager.idl b/comm/calendar/base/public/calICalendarACLManager.idl new file mode 100644 index 0000000000..21499fa93e --- /dev/null +++ b/comm/calendar/base/public/calICalendarACLManager.idl @@ -0,0 +1,86 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface nsIMsgIdentity; +interface nsIURI; + +interface calICalendar; +interface calIItemBase; +interface calIOperationListener; + +interface calIItemACLEntry; + +/** + */ +[scriptable, uuid(a64bd8a0-e9f0-4f64-928a-1c98861e4703)] +interface calICalendarACLManager : nsISupports +{ + /* Gets the calICalendarACLEntry of the current user for the specified + calendar. */ + void getCalendarEntry(in calICalendar aCalendar, + in calIOperationListener aListener); + + /* Gets the calIItemACLEntry of the current user for the specified + calendar item. Depending on the implementation, each item can have + different permissions based on specific attributes. + (TODO: should be made asynchronous one day) */ + calIItemACLEntry getItemEntry(in calIItemBase aItem); +}; + +[scriptable, uuid(f3da7954-52a4-45a9-bd7d-96c518133d0c)] +interface calICalendarACLEntry : nsISupports +{ + /* The calICalendarACLManager instance that generated this entry. */ + readonly attribute calICalendarACLManager aclManager; + + /* Whether the underlying calendar does have access control. */ + readonly attribute boolean hasAccessControl; + + /* Whether the user accessing the calendar is its owner. */ + readonly attribute boolean userIsOwner; + + /* Whether the user accessing the calendar can add items to it. */ + readonly attribute boolean userCanAddItems; + + /* Whether the user accessing the calendar can remove items from it. */ + readonly attribute boolean userCanDeleteItems; + + /* Returns the list of user ids matching the user accessing the + calendar. */ + Array<AString> getUserAddresses(); + + /* Returns the list of instantiated identities for the user accessing the + calendar. */ + Array<nsIMsgIdentity> getUserIdentities(); + /* Returns the list of instantiated identities for the user representing + the calendar owner. */ + Array<nsIMsgIdentity> getOwnerIdentities(); + + /* Helper method that forces a cleanup of any cache and a reload of the + current entry. + (TODO: should be made asynchronous one day) */ + void refresh(); +}; + +[scriptable, uuid(4d0b7ced-8c57-4efa-87e7-8dd5b7481312)] +interface calIItemACLEntry : nsISupports +{ + /* The parent calICalendarACLEntry instance. */ + readonly attribute calICalendarACLEntry calendarEntry; + + /* Whether the active user can fully modify the item. */ + readonly attribute boolean userCanModify; + + /* Whether the active user can respond to this item, if it is an invitation. */ + readonly attribute boolean userCanRespond; + + /* Whether the active user can view all the item properties. */ + readonly attribute boolean userCanViewAll; + + /* Whether the active user can only see when this item occurs without + knowing any details. */ + readonly attribute boolean userCanViewDateAndTime; +}; diff --git a/comm/calendar/base/public/calICalendarManager.idl b/comm/calendar/base/public/calICalendarManager.idl new file mode 100644 index 0000000000..6eff2075a3 --- /dev/null +++ b/comm/calendar/base/public/calICalendarManager.idl @@ -0,0 +1,139 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface calICalendar; +interface calIObserver; +interface nsIURI; +interface nsIVariant; + +interface calICalendarManagerObserver; + +[scriptable, uuid(fd8a2565-cb0f-4ecc-945d-760d75ab16d8)] +interface calICalendarManager : nsISupports +{ + /** + * Gives the number of registered calendars that require network access. + */ + readonly attribute uint32_t networkCalendarCount; + + /*** + * Gives the number of registered readonly calendars. + */ + readonly attribute uint32_t readOnlyCalendarCount; + + /** + * Gives the number of registered calendars + */ + readonly attribute uint32_t calendarCount; + + /** + * Register a calendar provider with the given JavaScript implementation. The implementation must + * implement calICalendar, and can optionally implement a number of other related interfaces. + * Please see the documentation for calICalendar for more details. + * + * @param {string} aType The calendar type string, see calICalendar::type. + * @param {Object} aImplementation The class that implements calICalendar. + */ + void registerCalendarProvider(in AUTF8String aType, in jsval aImplementation); + + /** + * Unregister a calendar provider by type. Already registered calendars will be replaced by a + * dummy calendar that is force-disabled. + * + * @param {string} aType The calendar type string, see calICalendar::type. + * @param {boolean} aTemporary If true, cached calendars will not be cleared. + */ + void unregisterCalendarProvider(in AUTF8String aType, [optional] in boolean aTemporary); + + /** + * Checks if a calendar provider has been dynamically registered with the given type. This does + * not check for the built-in XPCOM providers. + * + * @param {string} aType The calendar type string, see calICalendar::type. + */ + boolean hasCalendarProvider(in AUTF8String aType); + + /* + * create a new calendar + * aType is the type ("caldav", "storage", etc) + */ + calICalendar createCalendar(in AUTF8String aType, in nsIURI aURL); + + /* register a newly created calendar with the calendar service */ + void registerCalendar(in calICalendar aCalendar); + + /* unregister a calendar */ + void unregisterCalendar(in calICalendar aCalendar); + + /** Remove the calendar following the calendar's capabilities.removeModes. */ + const unsigned short REMOVE_AUTO = 0; + + /** Just unsubscribe from the calendar, do not delete it. */ + const unsigned short REMOVE_NO_DELETE = 1; + + /** Passing this flag will cause the call to fail if the calendar is registered */ + const unsigned short REMOVE_NO_UNREGISTER = 2; + + /** + * Unregister and delete the calendar from the calendar manager. By default + * the calendar will be removed based on the capabilities.removeModes + * property of the calendar. + * + * WARNING: If the calendar supports deletion, the calendar will be + * permanently deleted. You can prevent this with the REMOVE_NO_DELETE flag. + * + * @param aCalendar The calendar to remove. + * @param aMode A combination of the above mode flags. + */ + void removeCalendar(in calICalendar aCalendar, [optional] in uint8_t aMode); + + /* get a calendar by its id */ + calICalendar getCalendarById(in AUTF8String aId); + + /* return a list of all calendars currently registered */ + Array<calICalendar> getCalendars(); + + /** Add an observer for the calendar manager, i.e when calendars are registered */ + void addObserver(in calICalendarManagerObserver aObserver); + /** Remove an observer for the calendar manager */ + void removeObserver(in calICalendarManagerObserver aObserver); + + /** Add an observer to handle changes to all calendars (even disabled or unchecked ones) */ + void addCalendarObserver(in calIObserver aObserver); + /** Remove an observer to handle changes to all calendars */ + void removeCalendarObserver(in calIObserver aObserver); + + /* XXX private, don't use: + will vanish as soon as providers will directly read/write from moz prefs + */ + nsIVariant getCalendarPref_(in calICalendar aCalendar, + in AUTF8String aName); + void setCalendarPref_(in calICalendar aCalendar, + in nsIVariant aName, + in nsIVariant aValue); + void deleteCalendarPref_(in calICalendar aCalendar, + in AUTF8String aName); + +}; + +/** + * Observer to handle actions done by the calendar manager + * + * NOTE: When adding methods here, please also add them in calUtils.jsm's + * createAdapter() method. + */ +[scriptable, uuid(383f36f1-e669-4ca4-be7f-06b43910f44a)] +interface calICalendarManagerObserver : nsISupports +{ + /** Called after the calendar is registered */ + void onCalendarRegistered(in calICalendar aCalendar); + + /** Called before the unregister actually takes place */ + void onCalendarUnregistering(in calICalendar aCalendar); + + /** Called before the delete actually takes place */ + void onCalendarDeleting(in calICalendar aCalendar); +}; diff --git a/comm/calendar/base/public/calICalendarProvider.idl b/comm/calendar/base/public/calICalendarProvider.idl new file mode 100644 index 0000000000..e6adf7a060 --- /dev/null +++ b/comm/calendar/base/public/calICalendarProvider.idl @@ -0,0 +1,89 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface nsIURI; +interface calICalendar; +interface nsIVariant; +interface calIProviderListener; + +/** + * High-level interface to allow providers to be pluggable. + */ +[scriptable, uuid(30e22db4-9f13-11d9-80d6-000b7d081f44)] +interface calICalendarProvider : nsISupports +{ + /** + * The type of provider, this may be used as a key to uniquely identify a + * provider and should match the type= part of the contract id of both the + * provider and the matching calICalendar implementation. + */ + readonly attribute AUTF8String type; + + /** + * The way to refer to this provider in UI for the end-user + * (eg "Shared ICS File"). + */ + readonly attribute AUTF8String displayName; + + /** + * The way to refer to this provider in the UI when needing to display a short + * label to describe the type (eg "CalDAV", "ICS", etc.). This is different + * from the type attribute as it's not meant to be used as unique identifier + * but only as a shorter non-localized label. + */ + readonly attribute AUTF8String shortName; + + /** + * Delete a calendar. Deletes the actual underlying calendar, which + * could be (for example) a file or a calendar on a server + * + * @param aCalendar the calendar to delete + * @param aListener where to call the results back to + */ + void deleteCalendar(in calICalendar aCalendar, + in calIProviderListener aListener); + + /** + * Detect calendars using the given parameters (location, username, etc.). + * + * @param username The username to use. + * @param password The password to use. + * @param location The location to use. It could be a hostname, a + * specific URL, the origin URL, etc. + * @param savePassword Whether to save the password or not. + * @param extraProperties Any additional properties needed. + * @return Promise resolved with an array of found calendars. + * (Array<calICalendar>). If no calendars were + * found, resolved with an empty array. If an + * error occurs, rejected with the error. + */ + Promise detectCalendars(in AUTF8String username, in AUTF8String password, + in AUTF8String location, in boolean savePassword, + [optional] in jsval extraProperties); +}; + +[scriptable, uuid(0eebe99e-a22d-11d9-87a6-000b7d081f44)] +interface calIProviderListener : nsISupports +{ + /** + * @param aStatus status code summarizing what happened + * @param aDetail not yet fully specified. If aStatus is an error + * result, this will probably be an extended error + * string (eg one returned by a server). + */ + void onCreateCalendar(in calICalendar aCalendar, in nsresult aStatus, + in nsIVariant aDetail); + + /** + * @param aStatus status code summarizing what happened + * @param aDetail not yet fully specified. If aStatus is an error + * result, this will probably be an extended error + * string (eg one returned by a server). + */ + void onDeleteCalendar(in calICalendar aCalendar, in nsresult aStatus, + in nsIVariant aDetail); +}; diff --git a/comm/calendar/base/public/calICalendarView.idl b/comm/calendar/base/public/calICalendarView.idl new file mode 100644 index 0000000000..d9024d21e9 --- /dev/null +++ b/comm/calendar/base/public/calICalendarView.idl @@ -0,0 +1,216 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + + +#include "nsISupports.idl" + +interface calICalendar; +interface calIDateTime; +interface calICalendarViewController; +interface calIItemBase; + +/** + * An interface for view widgets containing calendaring data. + * + * @note Code that implements this interface is intended to be pure + * widgetry and thus not have any preference dependencies. + */ + +[scriptable, uuid(0e392744-4b2e-4b64-8862-2fb707d900a7)] +interface calICalendarView : nsISupports +{ + + /** + * Oftentimes other elements in the DOM in which a calIDecoratedView is + * used want to be aware of whether or not the view is selected. An element + * whose ID is observerID can be included in that DOM, and will be set to be + * enabled or disabled depending on whether the view is selected. + */ + readonly attribute AUTF8String observerID; + + /** + * the controller for this view + */ + attribute calICalendarViewController controller; + + /** + * If true, the view supports workdays only + */ + readonly attribute boolean supportsWorkdaysOnly; + + /** + * If this is set to 'true', the view should not display days specified to be + * non-workdays. The implementor is responsible for obtaining what those + * days are on its own. + */ + attribute boolean workdaysOnly; + + /** + * Whether or not tasks are to be displayed in the calICalendarView + */ + attribute boolean tasksInView; + + /** + * If true, the view is rotatable + */ + readonly attribute boolean supportsRotation; + + /** + * If set, the view will be rotated (i.e time on top, date at left) + */ + attribute boolean rotated; + + /** + * If true, the view is zoomable + */ + readonly attribute boolean supportsZoom; + + /** + * Zoom view in one level. Defaults to one level. + */ + void zoomIn([optional] in uint32_t level); + + /** + * Zoom view out one level. Defaults to one level. + */ + void zoomOut([optional] in uint32_t level); + + /** + * Reset view zoom. + */ + void zoomReset(); + + /** + * Whether or not completed tasks are shown in the calICalendarView + */ + attribute boolean showCompleted; + + /** + * Ensure that the given date is visible; the view is free + * to show more dates than the given date (e.g. week view + * would show the entire week). + */ + void showDate(in calIDateTime aDate); + + /** + * Set a date range for the view to display, from aStartDate + * to aEndDate, inclusive. + * + * Some views may decide to utilize the time portion of these + * calIDateTimes; pass in calIDateTimes that are dates if you + * want to make sure this doesn't happen. + */ + void setDateRange(in calIDateTime aStartDate, in calIDateTime aEndDate); + + /** + * The start date of the view's display. If the view is displaying + * disjoint dates, this will be the earliest date that's displayed. + */ + readonly attribute calIDateTime startDate; + + /** + * The end date of the view's display. If the view is displaying + * disjoint dates, this will be the latest date that's displayed. + * + * Note that this won't be equivalent to the aEndDate passed to + * setDateRange, because that date isn't actually displayed! + */ + readonly attribute calIDateTime endDate; + + /** + * The first day shown in the embedded view + */ + readonly attribute calIDateTime startDay; + + /** + * The last day shown in the embedded view + */ + readonly attribute calIDateTime endDay; + + /** + * True if this view supports disjoint dates + */ + readonly attribute boolean supportsDisjointDates; + + /** + * True if this view currently has a disjoint date set. + */ + readonly attribute boolean hasDisjointDates; + + /** + * Returns the list of dates being shown by this calendar. + * If a date range is set, it will expand out the date range by + * day and return the full set. + */ + Array<calIDateTime> getDateList(); + + /** + * Get the items currently selected in this view. + * + * @return the array of items currently selected in this. + */ + Array<calIItemBase> getSelectedItems(); + + /** + * Select an array of items in the view. Items outside the view's current + * display range will be ignored. + * + * @param aCount the number of items to select + * @param aItems an array of items to select + * @param aSuppressEvent if true, the 'itemselect' event will not be fired. + */ + void setSelectedItems(in Array<calIItemBase> aItems, [optional] in boolean aSuppressEvent); + + /** + * Make as many of the selected items as possible are visible in the view. + */ + void centerSelectedItems(); + + /** + * Get or set the selected day. + */ + attribute calIDateTime selectedDay; + + /** + * Get or set the timezone that the view's elements should be displayed in. + * Setting this does not refresh the view. + */ + attribute AUTF8String timezone; + + /** + * Ensures that the given date is visible, and that the view is centered + * around this date. aDate becomes the selectedDay of the view. Calling + * this function with the current selectedDay effectively refreshes the view + * + * @param aDate the date that must be shown in the view and becomes + * the selected day + */ + void goToDay(in calIDateTime aDate); + + /** + * Moves the view a specific number of pages. Negative numbers correspond to + * moving the view backwards. Note that it is up to the view to determine + * how the selected day ought to move as well. + * + * @param aNumber the number of pages to move the view + */ + void moveView(in long aNumber); + + /** + * gets the description of the range displayed by the view + */ + AString getRangeDescription(); + + /** + * The type of the view e.g "day", "week", "multiweek" or "month" that refers + * to the displayed time period. + */ + readonly attribute string type; + /** + * removes the dropshadows that are inserted into childelements during a + * drag and drop session + */ + + void removeDropShadows(); +}; diff --git a/comm/calendar/base/public/calICalendarViewController.idl b/comm/calendar/base/public/calICalendarViewController.idl new file mode 100644 index 0000000000..823a72fe34 --- /dev/null +++ b/comm/calendar/base/public/calICalendarViewController.idl @@ -0,0 +1,75 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + + +#include "nsISupports.idl" + +interface calICalendar; +interface calIDateTime; +interface calIEvent; +interface calIItemBase; + +[scriptable, uuid(40430501-a666-4c24-b234-eeac5ccb70f6)] +interface calICalendarViewController : nsISupports +{ + /** + * Create an event, with an optional start time and optional end + * time in the given Calendar. The Calendar will be the + * displayCalendar set on the View which invokes this method + * on the controller, or null, if the views wish to delegate the + * choice of the calendar to the controller. + * + * If neither aStartTime or aEndTime are given, the user wants to + * create a generic event with no information prefilled. + * + * If aStartTime is given and is a date, the user wants to + * create an all day event, optionally a multi-all-day event if + * aEndTime is given (and is also a date). + * + * If aStartTime is given and is a time, but no aEndTime is + * given, the user wants to create an event starting at + * aStartTime and of the default duration. The controller has the + * option of creating this event automatically or via the dialog. + * + * If both aStartTime and aEndTime are given as times, then + * the user wants to create an event going from aStartTime + * to aEndTime. + */ + void createNewEvent (in calICalendar aCalendar, + in calIDateTime aStartTime, + in calIDateTime aEndTime); + + /** + * View an occurrence of an event. This opens the event in a read-only + * summary dialog. + */ + void viewOccurrence(in calIItemBase aOccurrence); + + /** + * Modify aOccurrence. If aNewStartTime and aNewEndTime are given, + * update the event to those times. If aNewTitle is given, modify the title + * of the item. If no parameters are given, ask the user to modify. + */ + void modifyOccurrence (in calIItemBase aOccurrence, + in calIDateTime aNewStartTime, + in calIDateTime aNewEndTime, + in AString aNewTitle); + /** + * Delete all events in the given array. If more than one event is passed, + * this will prompt whether to delete just this occurrence or all occurrences. + * All passed events will be handled in one transaction, i.e undoing this will + * make all events reappear. + * + * @param aCount The number of events in the array + * @param aOccurrences An array of Items/Occurrences to delete + * @param aUseParentItems If set, each occurrence will have its parent item + * deleted. + * @param aDoNotConfirm If set, the events will be deleted without + * confirmation. + */ + void deleteOccurrences (in Array<calIItemBase> aOccurrences, + in boolean aUseParentItems, + in boolean aDoNotConfirm); +}; diff --git a/comm/calendar/base/public/calIChangeLog.idl b/comm/calendar/base/public/calIChangeLog.idl new file mode 100644 index 0000000000..e49e42f61d --- /dev/null +++ b/comm/calendar/base/public/calIChangeLog.idl @@ -0,0 +1,151 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "calICalendar.idl" + +interface calIGenericOperationListener; +interface calIOperation; + +/** + * Interface for managing offline flags in offline storage + * (calStorageCalendar), in particular from calICachedCalendar. + */ +[scriptable, uuid(36dc2c93-5851-40d2-9ba9-b1f6e682c75c)] +interface calIOfflineStorage : calICalendar { + /** + * Mark the item of which the id is passed as parameter as new. + * + * @param aItem the item to add + * + * @return {Promise<void>} + */ + Promise addOfflineItem(in calIItemBase aItem); + + /** + * Mark the item of which the id is passed as parameter as modified. + * + * @param aItem the item to modify + * + * @return {Promise<void>} + */ + Promise modifyOfflineItem(in calIItemBase aItem); + + /** + * Mark the item of which the id is passed as parameter as deleted. + * + * @param aItem the item to delete + * @return {Promise<void>} + */ + Promise deleteOfflineItem(in calIItemBase aItem); + + /** + * Retrieves the offline flag for the given item. + * + * @param aItem the item to reset + * @return {Promise<number>} + */ + Promise getItemOfflineFlag(in calIItemBase aItem); + + /** + * Remove any offline flag from the item record. + * + * @param aItem the item to reset + * @return {Promise<void>} + */ + Promise resetItemOfflineFlag(in calIItemBase aItem); +}; + +/** + * Interface for synchronously working providers on storing items, + * e.g. storage, memory. All modifying commands return after the + * modification has been performed. + * + * @note + * This interface is used in conjunction with changelog-based synchronization + * and additionally offers storing meta-data for items for this purpose. + * The meta data is stored as long as the corresponding items persist in + * the calendar and automatically cleanup up once the item is deleted from + * the calendar, but is not altered when an item is modified (modifyItem). + * Meta data can be fetched/stored per (master) item, i.e. if you need to + * store meta data for individual overridden items, you need to store it + * along with the master item's meta data. + * Finally, keep in mind that the meta data is "calendar local" and not + * automatically transferred when storing the item on another calISyncWriteCalendar. + */ +[scriptable, uuid(651e137b-2f3a-4595-af89-da51b6a37f85)] +interface calISyncWriteCalendar : calICalendar { + /** + * Adds or replaces meta data of an item. + * + * @param id an item id + * @param value an arbitrary string + */ + void setMetaData(in AUTF8String id, + in AUTF8String value); + + /** + * Deletes meta data of an item. + * + * @param id an item id + */ + void deleteMetaData(in AUTF8String id); + + /** + * Gets meta data of an item or null if there's none or the item id is invalid. + * + * @param id an item id + */ + AUTF8String getMetaData(in AUTF8String id); + + /** + * Gets all meta data IDs. + */ + Array<AString> getAllMetaDataIds(); + + /** + * Gets all meta data values. + */ + Array<AString> getAllMetaDataValues(); +}; + +/** + * Calendar implementing this interface have improved means of replaying their + * changelog data. This could for example mean, that the provider can retrieve + * changes between now and the last sync. + * + * Not implementing this interface is perfectly valid for calendars, that need + * to do a full sync each time anyway (i.e ics) + */ +[scriptable, uuid(0bf4c6a2-b4c7-4cae-993a-4408d8bded3e)] +interface calIChangeLog : nsISupports { + + // To denote no offline flag, use null + const long OFFLINE_FLAG_CREATED_RECORD = 1; + const long OFFLINE_FLAG_MODIFIED_RECORD = 2; + const long OFFLINE_FLAG_DELETED_RECORD = 4; + + /** + * Enable the changelog calendar to retrieve offline data right after instantiation. + */ + attribute calISyncWriteCalendar offlineStorage; + + /** + * Resets the changelog. This is used if the cache should be refreshed. + */ + void resetLog(); + + /** + * Instructs the calendar to replay remote changes into the above offlineStorage + * calendar. The calendar itself is responsible for storing anything needed + * to keep track of what items need updating. + * + * TODO: We might reconsider to replay on calICalendar, + * but this complicates implementing this interface + * enormously for providers. + * + * @param aDestination The calendar to sync changes into + * @param aListener The listener to notify when the operation completes. + */ + calIOperation replayChangesOn(in calIGenericOperationListener aListener); +}; diff --git a/comm/calendar/base/public/calIDateTime.idl b/comm/calendar/base/public/calIDateTime.idl new file mode 100644 index 0000000000..e4da295843 --- /dev/null +++ b/comm/calendar/base/public/calIDateTime.idl @@ -0,0 +1,228 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface calIDuration; +interface calITimezone; + +[scriptable, uuid(fe3e9a58-2938-4b2c-9085-4989d5f7244f)] +interface calIDateTime : nsISupports +{ + /** + * isMutable is true if this instance is modifiable. + * If isMutable is false, any attempts to modify + * the object will throw NS_ERROR_OBJECT_IS_IMMUTABLE. + */ + readonly attribute boolean isMutable; + + /** + * Make this calIDateTime instance immutable. + */ + void makeImmutable(); + + /** + * Clone this calIDateTime instance into a new + * mutable object. + */ + calIDateTime clone(); + + /** + * valid is true if this object contains a valid + * time/date. + */ + // true if this thing is set/valid + readonly attribute boolean isValid; + + /** + * nativeTime contains this instance's PRTime value relative + * to the UTC epoch, regardless of the timezone that's set + * on this instance. If nativeTime is set, the given UTC PRTime + * value is exploded into year/month/etc, forcing the timezone + * setting to UTC. + * + * @warning: When the timezone is set to 'floating', this will return + * the nativeTime as-if the timezone was UTC. Take this into account + * when comparing values. + * + * @note on objects that are pinned to a timezone and have isDate set, + * nativeTime will be 00:00:00 in the timezone of that date, not 00:00:00 in + * UTC. + */ + attribute PRTime nativeTime; + + /** + * Full 4-digit year value (e.g. "1989", "2004") + */ + attribute short year; + + /** + * Month, 0-11, 0 = January + */ + attribute short month; + + /** + * Day of month, 1-[28,29,30,31] + */ + attribute short day; + + /** + * Hour, 0-23 + */ + attribute short hour; + + /** + * Minute, 0-59 + */ + attribute short minute; + + /** + * Second, 0-59 + */ + attribute short second; + + /** + * Gets or sets the timezone of this calIDateTime instance. + * Setting the timezone does not change the actual date/time components; + * to convert between timezones, use getInTimezone(). + * + * @throws NS_ERROR_INVALID_ARG if null is passed in. + */ + attribute calITimezone timezone; + + /** + * Resets the datetime object. + * + * @param year full 4-digit year value (e.g. "1989", "2004") + * @param month month, 0-11, 0 = January + * @param day day of month, 1-[28,29,31] + * @param hour hour, 0-23 + * @param minute minute, 0-59 + * @param second second, 0-59 + * @param timezone timezone + * + * The passed datetime will be normalized, e.g. a minute value of 60 will + * increase the hour. + * + * @throws NS_ERROR_INVALID_ARG if no timezone is passed in. + */ + void resetTo(in short year, + in short month, + in short day, + in short hour, + in short minute, + in short second, + in calITimezone timezone); + + /** + * The offset of the timezone this datetime is in, relative to UTC, in + * seconds. A positive number means that the timezone is ahead of UTC. + */ + readonly attribute long timezoneOffset; + + /** + * isDate indicates that this calIDateTime instance represents a date + * (a whole day), and not a specific time on that day. If isDate is set, + * accessing the hour/minute/second fields will return 0, and and setting + * them is an illegal operation. + */ + attribute boolean isDate; + + /* + * computed values + */ + + /** + * Day of the week. 0-6, with Sunday = 0. + */ + readonly attribute short weekday; + + /** + * Day of the year, 1-[365,366]. + */ + readonly attribute short yearday; + + /* + * Methods + */ + + /** + * Resets this instance to Jan 1, 1970 00:00:00 UTC. + */ + void reset(); + + /** + * Return a string representation of this instance. + */ + AUTF8String toString(); + + /** + * Returns a string representation of this instance suitable for JSON. + */ + AUTF8String toJSON(); + + /** + * Return a new calIDateTime instance that's the result of + * converting this one into the given timezone. Valid values + * for aTimezone are the same as the timezone field. If + * the "floating" timezone is given, then this object + * is just cloned, and the timezone is set to floating. + */ + calIDateTime getInTimezone(in calITimezone aTimezone); + + // add the given calIDateTime, treating it as a duration, to + // this item. + // XXX will change + void addDuration (in calIDuration aDuration); + + // Subtract two dates and return a duration + // returns duration of this - aOtherDate + // if aOtherDate is > this the duration will be negative + calIDuration subtractDate (in calIDateTime aOtherDate); + + /** + * Compare this calIDateTime instance to aOther. Returns -1, 0, 1 to + * indicate if this < aOther, this == aOther, or this > aOther, + * respectively. + * + * This comparison is timezone-aware; the given values are converted + * to a common timezone before comparing. If either this or aOther is + * floating, both objects are treated as floating for the comparison. + * + * If either this or aOther has isDate set, then only the date portion is + * compared. + * + * @exception calIErrors.INVALID_TIMEZONE bad timezone on this object + * (not the argument object) + */ + long compare (in calIDateTime aOther); + + // + // Some helper getters for calculating useful ranges + // + + /** + * Returns SUNDAY of the given datetime object's week. + */ + readonly attribute calIDateTime startOfWeek; + + /** + * Returns SATURDAY of the datetime object's week. + */ + readonly attribute calIDateTime endOfWeek; + + // the start/end of the current object's month + readonly attribute calIDateTime startOfMonth; + readonly attribute calIDateTime endOfMonth; + + // the start/end of the current object's year + readonly attribute calIDateTime startOfYear; + readonly attribute calIDateTime endOfYear; + + /** + * This object as either an iCalendar DATE or DATETIME string, as + * appropriate and sets the timezone to either UTC or floating. + */ + attribute ACString icalString; +}; diff --git a/comm/calendar/base/public/calIDeletedItems.idl b/comm/calendar/base/public/calIDeletedItems.idl new file mode 100644 index 0000000000..8045fa24b5 --- /dev/null +++ b/comm/calendar/base/public/calIDeletedItems.idl @@ -0,0 +1,26 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface calIDateTime; + +[scriptable, uuid(2414729b-37dc-456e-ba72-f9c33891e6ee)] +interface calIDeletedItems : nsISupports +{ + /** + * Clean the database of all deleted items older than an internal threshold. + */ + void flush(); + + /** + * Gets the time the item with given id was deleted at. If passed, the + * search will be restricted to a certain calendar + * + * @param aId The ID of the item to search for. + * @param aCalId The calendar id to restrict the search to. + * @return The date/time the item was deleted, or null if not found. + */ + calIDateTime getDeletedDate(in AUTF8String aId, [optional] in AUTF8String aCalId); +}; diff --git a/comm/calendar/base/public/calIDuration.idl b/comm/calendar/base/public/calIDuration.idl new file mode 100644 index 0000000000..a6bb00ed79 --- /dev/null +++ b/comm/calendar/base/public/calIDuration.idl @@ -0,0 +1,104 @@ +/* -*- Mode: idl; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +[scriptable, uuid(78537f21-fd5c-4e02-ab26-8ff6a3d946cb)] +interface calIDuration : nsISupports +{ + /** + * isMutable is true if this instance is modifiable. + * If isMutable is false, any attempts to modify + * the object will throw CAL_ERROR_ITEM_IS_MUTABLE. + */ + readonly attribute boolean isMutable; + + /** + * Make this calIDuration instance immutable. + */ + void makeImmutable(); + + /** + * Clone this calIDuration instance into a new + * mutable object. + */ + calIDuration clone(); + + /** + * Is Negative + */ + attribute boolean isNegative; + + /** + * Weeks + */ + attribute short weeks; + + /** + * Days + */ + attribute short days; + + /** + * Hours + */ + attribute short hours; + + /** + * Minutes + */ + attribute short minutes; + + /** + * Seconds + */ + attribute short seconds; + + /** + * total duration in seconds + */ + attribute long inSeconds; + + /* + * Methods + */ + + /** + * Add a duration + */ + void addDuration(in calIDuration aDuration); + + /** + * Compare with another duration + * + * @param aOther to be compared with this object + * + * @return -1, 0, 1 if this < aOther, this == aOther, or this > aOther, + * respectively. + */ + long compare(in calIDuration aOther); + + /** + * Reset this duration to 0 + */ + void reset(); + + /** + * Normalize the duration + */ + void normalize(); + + /** + * Return a string representation of this instance. + */ + AUTF8String toString(); + + attribute jsval icalDuration; + + /** + * This object as an iCalendar DURATION string + */ + attribute ACString icalString; +}; diff --git a/comm/calendar/base/public/calIErrors.idl b/comm/calendar/base/public/calIErrors.idl new file mode 100644 index 0000000000..51571822e0 --- /dev/null +++ b/comm/calendar/base/public/calIErrors.idl @@ -0,0 +1,117 @@ +/* -*- Mode: IDL; tab-width: 50; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +[scriptable, uuid(404c7d78-bec7-474c-aa2a-82c0d0563bb6)] +interface calIErrors : nsISupports +{ + /** + * The first two constants are copied from nsError.h, but named slightly + * differently, because if they're named the same, the names collide and + * the compiler can't deal. + */ + const unsigned long CAL_ERROR_MODULE_CALENDAR = 5; + const unsigned long CAL_ERROR_MODULE_BASE_OFFSET = 0x45; + + /** + * The beginning of this set of error codes, also copied from the macros + * in nsError.h. + */ + const unsigned long ERROR_BASE = (1<<31) | + (CAL_ERROR_MODULE_CALENDAR + CAL_ERROR_MODULE_BASE_OFFSET) << 16; + + /* Onto the actual errors! */ + + /** + * An invalid or nonexistent timezone was encountered. + */ + const unsigned long INVALID_TIMEZONE = ERROR_BASE + 1; + + /** + * Attempted to modify a readOnly calendar. + */ + const unsigned long CAL_IS_READONLY = ERROR_BASE + 2; + + /** + * Error while decoding an (ics) file from utf8 + */ + const unsigned long CAL_UTF8_DECODING_FAILED = ERROR_BASE + 3; + + /** + * Tried to add an item to a calendar in which an item with the + * same ID already existed + */ + const unsigned long DUPLICATE_ID = ERROR_BASE + 4; + + /** + * Operation has been cancelled. + */ + const unsigned long OPERATION_CANCELLED = ERROR_BASE + 5; + + /** + * Creation of calendar object failed + */ + const unsigned long PROVIDER_CREATION_FAILED = ERROR_BASE + 6; + + /** + * Profile data has newer schema than we know in this calendar version. + */ + const unsigned long STORAGE_UNKNOWN_SCHEMA_ERROR = ERROR_BASE + 7; + + /** + * Profile data may refer to newer timezones than we know. + */ + const unsigned long STORAGE_UNKNOWN_TIMEZONES_ERROR = ERROR_BASE + 8; + + /** + * The calendar could not be accessed for reading. + */ + const unsigned long READ_FAILED = ERROR_BASE + 9; + + /** + * The calendar could not be accessed for modification. + */ + const unsigned long MODIFICATION_FAILED = ERROR_BASE + 10; + + /* ICS specific errors */ + const unsigned long ICS_ERROR_BASE = ERROR_BASE + 0x100; + + /** + * ICS errors, copied from icalerror.h. + * The numbers (minus ICS_ERROR_BASE) should match with the enum + * values from icalerror.h + */ + const unsigned long ICS_NO_ERROR = ICS_ERROR_BASE + 0; + const unsigned long ICS_BADARG = ICS_ERROR_BASE + 1; + const unsigned long ICS_NEWFAILED = ICS_ERROR_BASE + 2; + const unsigned long ICS_ALLOCATION = ICS_ERROR_BASE + 3; + const unsigned long ICS_MALFORMEDDATA = ICS_ERROR_BASE + 4; + const unsigned long ICS_PARSE = ICS_ERROR_BASE + 5; + const unsigned long ICS_INTERNAL = ICS_ERROR_BASE + 6; + const unsigned long ICS_FILE = ICS_ERROR_BASE + 7; + const unsigned long ICS_USAGE = ICS_ERROR_BASE + 8; + const unsigned long ICS_UNIMPLEMENTED = ICS_ERROR_BASE + 9; + const unsigned long ICS_UNKNOWN = ICS_ERROR_BASE + 10; + + /** + * Range for former WCAP provider. This could be re-used now in theory, but + * you might as well just add to the end. + * Range previously claimed is [ERROR_BASE + 0x200, ERROR_BASE + 0x300) + */ + const unsigned long EX_WCAP_ERROR_BASE = ERROR_BASE + 0x200; + + /** + * (Cal)DAV specific errors + * Range is [ERROR_BASE + 0x301, ERROR_BASE + 0x399] + */ + const unsigned long DAV_ERROR_BASE = ERROR_BASE + 0x301; + const unsigned long DAV_NOT_DAV = DAV_ERROR_BASE + 0; + const unsigned long DAV_DAV_NOT_CALDAV = DAV_ERROR_BASE + 1; + const unsigned long DAV_NO_PROPS = DAV_ERROR_BASE + 2; + const unsigned long DAV_PUT_ERROR = DAV_ERROR_BASE + 3; + const unsigned long DAV_REMOVE_ERROR = DAV_ERROR_BASE + 4; + const unsigned long DAV_REPORT_ERROR = DAV_ERROR_BASE + 5; +}; diff --git a/comm/calendar/base/public/calIEvent.idl b/comm/calendar/base/public/calIEvent.idl new file mode 100644 index 0000000000..218163ec30 --- /dev/null +++ b/comm/calendar/base/public/calIEvent.idl @@ -0,0 +1,42 @@ +/* -*- Mode: idl; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "calIItemBase.idl" + +interface calIDuration; + +// +// calIEvent +// +// An interface for an event (analogous to a VEVENT) +// + +[scriptable, uuid(5ab15c1c-e295-4d8e-a9a9-ba5bc848b59a)] +interface calIEvent : calIItemBase +{ + // these attributes are marked readonly, as the calIDates are owned + // by the event; however, the actual calIDate objects are not read + // only and are intended to be manipulated to adjust dates. + + /** + * The (inclusive) start of the event. + */ + attribute calIDateTime startDate; + + /** + * The (non-inclusive) end of the event. + * Note that for all-day events, non-inclusive means that this will be set + * to the day after the last day of the event. + * If startDate.isDate is set, endDate.isDate must also be set. + */ + attribute calIDateTime endDate; + + /** + * The duration of the event. + * equal to endDate - startDate + */ + readonly attribute calIDuration duration; + +}; diff --git a/comm/calendar/base/public/calIFreeBusyProvider.idl b/comm/calendar/base/public/calIFreeBusyProvider.idl new file mode 100644 index 0000000000..5215f54998 --- /dev/null +++ b/comm/calendar/base/public/calIFreeBusyProvider.idl @@ -0,0 +1,109 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface calIDateTime; +interface calIPeriod; +interface calIOperation; +interface calIGenericOperationListener; + +[scriptable, uuid(EB24424C-DD22-4306-9379-FA098C61F5AF)] +interface calIFreeBusyProvider : nsISupports +{ + /** + * Gets free/busy intervals. + * Results are notified to the passed listener interface. + * + * @param aCalId calid or MAILTO:rfc822addr + * @param aRangeStart start time of free-busy search + * @param aRangeEnd end time of free-busy search + * @param aBusyTypes what free-busy intervals should be returned + * @param aListener called with an array of calIFreeBusyInterval objects + * @return optional operation handle to track the operation + */ + calIOperation getFreeBusyIntervals(in AUTF8String aCalId, + in calIDateTime aRangeStart, + in calIDateTime aRangeEnd, + in unsigned long aBusyTypes, + in calIGenericOperationListener aListener); +}; + +/** + * This interface reflects a free or busy interval in time. + * Referring to RFC 2445, section 4.2.9, for the different types. + */ +[scriptable, uuid(CCBEAF5E-DB87-4bc9-8BB7-24754B76BCB5)] +interface calIFreeBusyInterval : nsISupports +{ + /** + * The calId this free-busy period belongs to. + */ + readonly attribute AUTF8String calId; + + /** + * The free-busy time interval. + */ + readonly attribute calIPeriod interval; + + /** + * The value UNKNOWN indicates that the free-busy information for the time interval is + * not known. + */ + const unsigned long UNKNOWN = 0; + + /** + * The value FREE indicates that the time interval is free for scheduling. + */ + const unsigned long FREE = 1; + + /** + * The value BUSY indicates that the time interval is busy because one + * or more events have been scheduled for that interval. + */ + const unsigned long BUSY = 1 << 1; + + /** + * The value BUSY_UNAVAILABLE indicates that the time interval is busy + * and that the interval can not be scheduled. + */ + const unsigned long BUSY_UNAVAILABLE = 1 << 2; + + /** + * The value BUSY_TENTATIVE indicates that the time interval is busy because + * one or more events have been tentatively scheduled for that interval. + */ + const unsigned long BUSY_TENTATIVE = 1 << 3; + + /** + * All BUSY* states. + */ + const unsigned long BUSY_ALL = (BUSY | + BUSY_UNAVAILABLE | + BUSY_TENTATIVE); + + /** + * One of the above types. + */ + readonly attribute unsigned long freeBusyType; +}; + +/** + * This service acts as a central access point for free-busy lookup. + * A free-busy request will be multiplexed to all added free-busy providers. + * Adding a free-busy provider is transient. + */ +[scriptable, uuid(BE1796CF-CB53-482e-8942-D6CAA0A11BAA)] +interface calIFreeBusyService : calIFreeBusyProvider +{ + /** + * Adds a new free-busy provider. + */ + void addProvider(in calIFreeBusyProvider aProvider); + + /** + * Removes a free-busy provider. + */ + void removeProvider(in calIFreeBusyProvider aProvider); +}; diff --git a/comm/calendar/base/public/calIICSService.idl b/comm/calendar/base/public/calIICSService.idl new file mode 100644 index 0000000000..46d5f90320 --- /dev/null +++ b/comm/calendar/base/public/calIICSService.idl @@ -0,0 +1,242 @@ +/* -*- Mode: idl; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +// XXX use strings for kind values instead of enumerated constants? + + +#include "nsISupports.idl" + +interface calIItemBase; +interface calIDateTime; +interface calIDuration; +interface calITimezone; + +interface calIIcalProperty; +interface nsIInputStream; + +/** + * General notes: + * + * As with libical, use of getNextFoo(footype) is only valid if there have been + * no intervening getNextFoo(otherfootype)s, or removeFoo()s, or addFoo()s. In + * general, you want to do as little manipulation of your FooContainers as + * possible while iterating over them. + */ +[scriptable,uuid(59132cf2-e48c-4807-ab53-779f414a7fbc)] +interface calIIcalComponent : nsISupports +{ + /** + * The parent ical property + */ + readonly attribute calIIcalComponent parent; + + /** + * Access to the inner ical.js objects. Only use these if you know what you + * are doing. + */ + attribute jsval icalComponent; + attribute jsval icalTimezone; + + /** + * This is the value that an integer-valued getter will provide if + * there is no such property on the wrapped ical structure. + */ + const int32_t INVALID_VALUE = -1; + + /** + * @param kind ANY, XROOT, VCALENDAR, VEVENT, etc. + */ + calIIcalComponent getFirstSubcomponent(in AUTF8String componentType); + calIIcalComponent getNextSubcomponent(in AUTF8String componentType); + + readonly attribute AUTF8String componentType; + + attribute AUTF8String uid; + attribute AUTF8String prodid; + attribute AUTF8String version; + + /** + * PUBLISH, REQUEST, REPLY, etc. + */ + attribute AUTF8String method; + + /** + * TENTATIVE, CONFIRMED, CANCELLED, etc. + */ + attribute AUTF8String status; + + attribute AUTF8String summary; + attribute AUTF8String description; + attribute AUTF8String location; + attribute AUTF8String categories; + attribute AUTF8String URL; + + attribute int32_t priority; + + attribute calIDateTime startTime; + attribute calIDateTime endTime; + readonly attribute calIDuration duration; + attribute calIDateTime dueTime; + attribute calIDateTime stampTime; + + attribute calIDateTime createdTime; + attribute calIDateTime completedTime; + attribute calIDateTime lastModified; + + /** + * The recurrence ID, a.k.a. DTSTART-of-calculated-occurrence, + * or null if this isn't an occurrence. + */ + attribute calIDateTime recurrenceId; + + AUTF8String serializeToICS(); + + /** + * Return a string representation of this instance. + */ + AUTF8String toString(); + + /** + * Serializes this component (and subcomponents) directly to an + * input stream. Typically used for performance to avoid + * unnecessary conversions and XPConnect traversals. + * + * @result an input stream which can be read to get the serialized + * version of this component, encoded in UTF-8. Implements + * nsISeekableStream so that it can be used with + * nsIUploadChannel. + */ + nsIInputStream serializeToICSStream(); + + void addSubcomponent(in calIIcalComponent comp); +// If you add then remove a property/component, the referenced +// timezones won't get purged out. There's currently no client code. +// void removeSubcomponent(in calIIcalComponent comp); + + /** + * @param kind ANY, ATTENDEE, X-WHATEVER, etc. + */ + calIIcalProperty getFirstProperty(in AUTF8String kind); + calIIcalProperty getNextProperty(in AUTF8String kind); + void addProperty(in calIIcalProperty prop); +// If you add then remove a property/component, the referenced +// timezones won't get purged out. There's currently no client code. +// void removeProperty(in calIIcalProperty prop); + + /** + * Timezones need special handling, as they must be + * emitted as children of VCALENDAR, but can be referenced by + * any sub component. + * Adding a second timezone (of the same TZID) will remove the + * first one. + */ + void addTimezoneReference(in calITimezone aTimezone); + + /** + * Returns an array of VTIMEZONE components. + * These are the timezones that are in use by this + * component and its children. + */ + Array<calITimezone> getReferencedTimezones(); + + /** + * Clones the component. The cloned component is decoupled from any parent. + * @return cloned component + */ + calIIcalComponent clone(); +}; + +[scriptable,uuid(5b13a69c-53d3-44a0-9203-f89f7e5e1604)] +interface calIIcalProperty : nsISupports +{ + /** + * The whole property as an ical string. + * @exception Any error will be thrown as an calIError::ICS_ error. + */ + readonly attribute AUTF8String icalString; + + /** + * Access to the inner ical.js objects. Only use these if you know what you + * are doing. + */ + attribute jsval icalProperty; + + /** + * The parent component containing this property + */ + readonly attribute calIIcalComponent parent; + + /** + * Return a string representation of this instance. + */ + AUTF8String toString(); + + /** + * The value of the property as string. + * The exception for properties of TEXT or X- type, those will be unescaped + * when getting, and also expects an unescaped string when setting. + * Datetime, numeric and other non-text types are represented as ical string + */ + attribute AUTF8String value; + + /** + * The value of the property in (escaped) ical format. + */ + attribute AUTF8String valueAsIcalString; + + /** + * The value of the property as date/datetime value, keeping + * track of the used timezone referenced in the owning component. + */ + attribute calIDateTime valueAsDatetime; + + // XXX attribute AUTF8String stringValueWithParams; ? + readonly attribute AUTF8String propertyName; + + AUTF8String getParameter(in AUTF8String paramname); + void setParameter(in AUTF8String paramname, in AUTF8String paramval); + + AUTF8String getFirstParameterName(); + AUTF8String getNextParameterName(); + + void removeParameter(in AUTF8String paramname); + void clearXParameters(); +}; + +[scriptable,uuid(eda9565f-f9bb-4846-b134-1e0653b2e767)] +interface calIIcsComponentParsingListener : nsISupports +{ + /** + * Called when the parsing has completed. + * + * @param rc The result code of parsing + * @param rootComp The root ical component that was parsed + */ + void onParsingComplete(in nsresult rc, in calIIcalComponent rootComp); +}; + +[scriptable,uuid(31e7636b-5a64-4d15-bc60-67b67cd85176)] +interface calIICSService : nsISupports +{ + /** + * Parse an ICS string into components. + * + * @param serialized an ICS string + */ + calIIcalComponent parseICS(in AUTF8String serialized); + + /** + * Asynchronously parse an ICS string into components. + * + * @param serialized an ICS string + * @param listener The listener that notifies the root component + */ + void parseICSAsync(in AUTF8String serialized, + in calIIcsComponentParsingListener listener); + + calIIcalComponent createIcalComponent(in AUTF8String kind); + calIIcalProperty createIcalProperty(in AUTF8String kind); + calIIcalProperty createIcalPropertyFromString(in AUTF8String str); +}; diff --git a/comm/calendar/base/public/calIIcsParser.idl b/comm/calendar/base/public/calIIcsParser.idl new file mode 100644 index 0000000000..9d27edfa4b --- /dev/null +++ b/comm/calendar/base/public/calIIcsParser.idl @@ -0,0 +1,81 @@ +/* -*- Mode: idl; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface calIIcalProperty; +interface calIIcalComponent; +interface calIItemBase; +interface nsIInputStream; +interface calIIcsParser; + +/** + * Listener being called once asynchronous parsing is done. + */ +[scriptable, uuid(d22527da-b0e2-41b7-b6f4-ee9c243cd285)] +interface calIIcsParsingListener : nsISupports +{ + void onParsingComplete(in nsresult rc, in calIIcsParser parser); +}; + +/** + * An interface for parsing an ics string or stream into its items. + * Note that this is not a service. A new instance must be created for every new + * string or stream to be parsed. + */ +[scriptable, uuid(83e9befe-5e9e-49de-8bc2-d882f464f7e7)] +interface calIIcsParser : nsISupports +{ + /** + * Parse an ics string into its items, and store top-level properties and + * components that are not interpreted. + * + * @param aICSString + * The ICS string to parse + * @param optional aAsyncParsing + * If non-null, parsing will be performed on a worker thread, + * and the passed listener is called when it's done + */ + void parseString(in AString aICSString, + [optional] in calIIcsParsingListener aAsyncParsing); + + /** + * Parse an input stream. + * + * @see parseString + * @param aICSString + * The stream to parse + * @param optional aAsyncParsing + * If non-null, parsing will be performed on a worker thread, + * and the passed listener is called when it's done + */ + void parseFromStream(in nsIInputStream aStream, + [optional] in calIIcsParsingListener aAsyncParsing); + + /** + * Get the items that were in the string or stream. In case an item represents a + * recurring series, the (unexpanded) parent item is returned only. + * Please keep in mind that any parentless items (see below) are not contained + * in the returned set of items. + */ + Array<calIItemBase> getItems(); + + /** + * Get the parentless items that may have occurred, i.e. overridden items of a + * recurring series (having a RECURRENCE-ID) missing their parent item in the + * parsed content. + */ + Array<calIItemBase> getParentlessItems(); + + /** + * Get the top-level properties that were not interpreted as anything special + */ + Array<calIIcalProperty> getProperties(); + + /** + * Get the top-level components that were not interpreted as anything special + */ + Array<calIIcalComponent> getComponents(); +}; diff --git a/comm/calendar/base/public/calIIcsSerializer.idl b/comm/calendar/base/public/calIIcsSerializer.idl new file mode 100644 index 0000000000..2d81c8387c --- /dev/null +++ b/comm/calendar/base/public/calIIcsSerializer.idl @@ -0,0 +1,73 @@ +/* -*- Mode: idl; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface calIIcalProperty; +interface calIIcalComponent; +interface calIItemBase; +interface nsIOutputStream; +interface nsIInputStream; + +/** + * An interface for serializing calendar items into an ICS string. + * Note that this is not a service. A new instance must be created for every new + * set of items to be serialized. + */ +[scriptable, uuid(4dcf6b4e-7322-4a61-a191-8d8cc1aea42e)] +interface calIIcsSerializer : nsISupports +{ + /** + * Add some items to the items that are to be serialized. Can be called + * multiple times, and appends to the set on every call. + * + * @param aItems + * The items to be added + */ + void addItems(in Array<calIItemBase> aItems); + + /** + * Add a property to the top-level properties to be added on serializing. Can + * be called multiple times, and appends to the set on every call. + * + * @param aProperty + * The property to be added + */ + void addProperty(in calIIcalProperty aProperty); + + /** + * Add a component to the top-level components to be added on serializing. Can + * be called multiple times, and appends to the set on every call. + * + * @param aComponent + * The component to be added + */ + void addComponent(in calIIcalComponent aComponent); + + /** + * Serialize the added items, properties and components into an ICS string + * + * @returns + * A string containing the serialized items, properties and components. + */ + AString serializeToString(); + + /** + * Serialize the added items, properties and components into an ICS stream + * + * @returns + * A stream containing the serialized items, properties and components. + */ + nsIInputStream serializeToInputStream(); + + /** + * Serialize the added items, properties and components into an ICS stream + * + * @param aStream + * A stream into which the serialized items, properties and components + * will be written. + */ + void serializeToStream(in nsIOutputStream aStream); +}; diff --git a/comm/calendar/base/public/calIImportExport.idl b/comm/calendar/base/public/calIImportExport.idl new file mode 100644 index 0000000000..1f16d351e3 --- /dev/null +++ b/comm/calendar/base/public/calIImportExport.idl @@ -0,0 +1,56 @@ +/* -*- Mode: IDL; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + + +#include "nsISupports.idl" + +interface calIItemBase; +interface nsIInputStream; +interface nsIOutputStream; + +[scriptable, uuid(efef8333-e995-4f45-bdf7-bfcabbd9793e)] +interface calIFileType : nsISupports +{ + /** + * The default extension that should be associated + * with files of this type. + */ + readonly attribute AString defaultExtension; + + /** + * The extension filter to use in the filepicker's filter list. + * Separate multiple extensions with semicolon and space. + * For example "*.html; *.htm". + */ + readonly attribute AString extensionFilter; + + /** + * The description to show to the user in the filter list. + */ + readonly attribute AString description; +}; + +[scriptable, uuid(dbe262ca-d6c6-4691-8d46-e7f6bbe632ec)] +interface calIImporter : nsISupports +{ + Array<calIFileType> getFileTypes(); + + Array<calIItemBase> importFromStream(in nsIInputStream aStream); +}; + +[scriptable, uuid(18c75bb3-6309-4c33-903f-6055fec39d07)] +interface calIExporter : nsISupports +{ + Array<calIFileType> getFileTypes(); + + /** + * Export the items into the stream + * + * @param aStream the stream to put the data into + * @param aItems an array of items to be exported + * @param aTitle a title the exporter can choose to use + */ + void exportToStream(in nsIOutputStream aStream, in Array<calIItemBase> aItems, in AString aTitle); +}; diff --git a/comm/calendar/base/public/calIItemBase.idl b/comm/calendar/base/public/calIItemBase.idl new file mode 100644 index 0000000000..f87935b297 --- /dev/null +++ b/comm/calendar/base/public/calIItemBase.idl @@ -0,0 +1,372 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface nsIVariant; + +interface calIItemACLEntry; +interface calIAlarm; +interface calIAttachment; +interface calIAttendee; +interface calICalendar; +interface calIDateTime; +interface calIDuration; +interface calIIcalComponent; +interface calIRecurrenceInfo; +interface calIRelation; + +// +// calIItemBase +// +// Base for Events, Todos, Journals, etc. +// + +[scriptable, uuid(9c988b8d-af45-4046-b05e-34417bba9058)] +interface calIItemBase : nsISupports +{ + // returns true if this thing is able to be modified; + // if the item is not mutable, attempts to modify + // any data will throw CAL_ERROR_ITEM_IS_IMMUTABLE + readonly attribute boolean isMutable; + + // makes this item immutable + void makeImmutable(); + + // clone always returns a mutable event + calIItemBase clone(); + + /** + * Returns true if this item is an instance of calIEvent. + */ + boolean isEvent(); + + /** + * Returns true if this item is an instance of calITodo. + */ + boolean isTodo(); + + /** + * Hash Id that incorporates the item's UID, RECURRENCE-ID and calendar.id + * to be used for lookup of items that come from different calendars. + * Setting either id, recurrenceId or the calendar attribute leads to + * a recomputation of hashId. + * + * @attention Individual implementors of calIItemBase must stick to the + * same algorithm that base/src/calItemBase.js uses. + */ + readonly attribute AUTF8String hashId; + + /** + * Checks whether the argument object refers the same calendar item as + * this one, by testing both the id and recurrenceId property. This + * + * @arg aItem the item to compare against this one + * + * @return true if both ids match, false otherwise + */ + boolean hasSameIds(in calIItemBase aItem); + + /** + * Returns the acl entry associated to the item. + */ + readonly attribute calIItemACLEntry aclEntry; + + // + // the generation number of this item + // + attribute uint32_t generation; + + // the time when this item was created + readonly attribute calIDateTime creationDate; + + // last time any attribute was modified on this item, in UTC + readonly attribute calIDateTime lastModifiedTime; + + // last time a "significant change" was made to this item + readonly attribute calIDateTime stampTime; + + // the calICalendar to which this event belongs + attribute calICalendar calendar; + + // the ID of this event + attribute AUTF8String id; + + // event title + attribute AUTF8String title; + + /** + * The event's description in plain text. + * + * Setting this will reset descriptionHTML. + */ + attribute AUTF8String descriptionText; + + /** + * The event's description, as HTML. + * + * The text content MUST match descriptionText but the HTML can contain + * formatting, links etc. + * + * Getter: If HTML was not set, the plain text will be upconverted to HTML. + * + * Setter: Setting HTML data will set descriptionText to the + * downconverted pretty-printed plain text. + */ + attribute AUTF8String descriptionHTML; + + // event priority + attribute short priority; + attribute AUTF8String privacy; + + // status of the event + attribute AUTF8String status; + + // ical interop; writing this means parsing + // the ical string into this event + attribute AUTF8String icalString; + + // an icalComponent for this item, suitable for serialization. + // the icalComponent returned is not live: changes in it or this + // item will not be reflected in the other. + attribute calIIcalComponent icalComponent; + + // + // alarms + // + + /** + * Get all alarms assigned to this item + * + * @param aAlarms The array of calIAlarms + */ + Array<calIAlarm> getAlarms(); + + /** + * Add an alarm to the item + * + * @param aAlarm The calIAlarm to add + */ + void addAlarm(in calIAlarm aAlarm); + + /** + * Delete an alarm from the item + * + * @param aAlarm The calIAlarm to delete + */ + void deleteAlarm(in calIAlarm aAlarm); + + /** + * Clear all alarms from the item + */ + void clearAlarms(); + + // The last time this alarm was fired and acknowledged by the user; coerced to UTC. + attribute calIDateTime alarmLastAck; + + // + // recurrence + // + attribute calIRecurrenceInfo recurrenceInfo; + readonly attribute calIDateTime recurrenceStartDate; + + // + // All event properties are stored in a property bag; + // some number of these are "promoted" to top-level + // accessor attributes. For example, "SUMMARY" is + // promoted to the top-level "title" attribute. + // + // If you use the has/get/set/deleteProperty + // methods, property names are case-insensitive. + // + // For purposes of ICS serialization, all property names in + // the hashbag are in uppercase. + // + // The isPropertyPromoted() attribute can will indicate + // if a particular property is promoted or not, for + // serialization purposes. + // + + // Note that if this item is a proxy, then any requests for + // non-existent properties will be forward to the parent item. + + // some other properties that may exist: + // + // 'description' - description (string) + // 'location' - location (string) + // 'categories' - categories (string) + // 'syncId' - sync id (string) + // 'inviteEmailAddress' - string + // alarmLength/alarmUnits/alarmEmailAddress/lastAlarmAck + // recurInterval/recurCount/recurWeekdays/recurWeeknumber + + // these forward to an internal property bag; implemented here, so we can + // do access control on set/delete to have control over mutability. + // Each inner array has two elements: a string and a nsIVariant. + readonly attribute Array<Array<jsval> > properties; + boolean hasProperty(in AString name); + + /** + * Gets a particular property. + * Objects passed back are still owned by the item, e.g. if callers need to + * store or modify a calIDateTime they must clone it. + */ + nsIVariant getProperty(in AString name); + + /** + * Sets a particular property. + * Ownership of objects gets passed to the item, e.g. callers must not + * modify a calIDateTime after it's been passed to an item. + * + * @warning this reflects the current implementation + * xxx todo: rethink whether it's more sensible to store + * clones in calItemBase. + */ + void setProperty(in AString name, in nsIVariant value); + + // will not throw an error if you delete a property that doesn't exist + void deleteProperty(in AString name); + + // returns true if the given property is promoted to some + // top-level attribute (e.g. id or title) + boolean isPropertyPromoted(in AString name); + + /** + * Returns a particular parameter value for a property, or null if the + * parameter does not exist. If the property does not exist, throws. + * + * @param aPropertyName the name of the property + * @param aParameterName the name of the parameter on the property + */ + AString getPropertyParameter(in AString aPropertyName, + in AString aParameterName); + + /** + * Checks if the given property has the given parameter. + * + * @param aPropertyName The name of the property. + * @param aParameterName The name of the parameter on the property. + * @return True, if the parameter exists on the property + */ + boolean hasPropertyParameter(in AString aPropertyName, + in AString aParameterName); + + /** + * Sets a particular parameter value for a property, or unsets if null is + * passed. If the property does not exist, throws. + * + * @param aPropertyName The name of the property + * @param aParameterName The name of the parameter on the property + * @param aParameterValue The value of the parameter to set + */ + void setPropertyParameter(in AString aPropertyName, + in AString aParameterName, + in AUTF8String aParameterValue); + + /** + * Returns the names of all the parameters set on the given property. + * + * @param aPropertyName {AString} The name of the property. + * @return {Array<AString} The parameter names. + */ + Array<AString> getParameterNames(in AString aPropertyName); + + /** + * The organizer (originator) of the item. We will likely not + * honour or preserve all fields in the calIAttendee passed around here. + * A base class like calIPerson might be more appropriate here, if we ever + * grow one. + */ + attribute calIAttendee organizer; + + // + // Attendees + // + + // The array returned here is not live; it will not reflect calls to + // removeAttendee/addAttendee that follow the call to getAttendees. + Array<calIAttendee> getAttendees(); + + /** + * getAttendeeById's matching is done in a case-insensitive manner to handle + * places where "MAILTO:" or similar properties are capitalized arbitrarily + * by different calendar clients. + */ + calIAttendee getAttendeeById(in AUTF8String id); + void addAttendee(in calIAttendee attendee); + void removeAttendee(in calIAttendee attendee); + void removeAllAttendees(); + + // + // Attachments + // + Array<calIAttachment> getAttachments(); + void addAttachment(in calIAttachment attachment); + void removeAttachment(in calIAttachment attachment); + void removeAllAttachments(); + + // + // Categories + // + + /** + * Gets the array of categories this item belongs to. + */ + Array<AString> getCategories(); + + /** + * Sets the array of categories this item belongs to. + */ + void setCategories(in Array<AString> aCategories); + + // + // Relations + // + + /** + * This gives back every relation where the item is neither the owner of the + * relation nor the referred relation + */ + Array<calIRelation> getRelations(); + + /** + * Adds a relation to the item + */ + void addRelation(in calIRelation relation); + + /** + * Removes the relation for this item and the referred item + */ + void removeRelation(in calIRelation relation); + + /** + * Removes every relation for this item (in this items and also where it is referred + */ + void removeAllRelations(); + + // Occurrence querying + // + + /** + * Return a list of occurrences of this item between the given dates. The items + * returned are the same type as this one, as proxies. + */ + Array<calIItemBase> getOccurrencesBetween(in calIDateTime aStartDate, in calIDateTime aEndDate); + + /** + * If this item is a proxy or overridden item, parentItem will point upwards + * to our parent. Otherwise, it will point to this. + * parentItem can thus always be used for modifyItem() calls + * to providers. + */ + attribute calIItemBase parentItem; + + /** + * The recurrence ID, a.k.a. DTSTART-of-calculated-occurrence, + * or null if this isn't an occurrence. + * Be conservative about setting this. It isn't marked as such, but + * consider it as readonly. + */ + attribute calIDateTime recurrenceId; +}; diff --git a/comm/calendar/base/public/calIItipItem.idl b/comm/calendar/base/public/calIItipItem.idl new file mode 100644 index 0000000000..acb6683f1f --- /dev/null +++ b/comm/calendar/base/public/calIItipItem.idl @@ -0,0 +1,112 @@ +/* -*- Mode: idl; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface calIItemBase; +interface calICalendar; + +/** + * calIItipItem is an interface used to carry information between the mime + * parser, the imip-bar UI, and the iTIP processor. It encapsulates a list of + * calIItemBase objects and provides specialized iTIP methods for those items. + */ +[scriptable, uuid(7539c158-c30d-41d0-90e9-41d315ac3eb1)] +interface calIItipItem : nsISupports +{ + /** + * Initializes the item with an ics string + * @param - in parameter - AString of ical Data + */ + void init(in AUTF8String icalData); + + /** + * Creates a new calItipItem with the same attributes as the one that + * clone() is called upon. + */ + calIItipItem clone(); + + /** + * Attribute: isSend - set to TRUE when sending this item to initiate an + * iMIP communication. This will be used by the iTIP processor to route + * the item directly to the email subsystem so that communication can be + * initiated. For example, if you are Sending a REQUEST, you would set + * this flag, and send the iTIP Item into the iTIP processor, which would + * handle everything else. + */ + attribute boolean isSend; + + /** + * Attribute: sender - set to the email address of the sender if part of an + * iMIP communication. + */ + attribute AUTF8String sender; + + /** + * Attribute: receivedMethod - method the iTIP item had upon receipt + */ + attribute AUTF8String receivedMethod; + + /** + * Attribute: responseMethod - method that the protocol handler (or the + * user) decides to use to respond to the iTIP item (could be COUNTER, + * REPLY, DECLINECOUNTER, etc) + */ + attribute AUTF8String responseMethod; + + /** + * Attribute: autoResponse Set to one of the three constants below + */ + attribute unsigned long autoResponse; + + /** + * Used to tell the iTIP processor to use an automatic response when + * handling this iTIP item + */ + const unsigned long AUTO = 0; + + /** + * Used to tell the iTIP processor to allow the user to edit the response + */ + const unsigned long USER = 1; + + /** + * Used to tell the iTIP processor not to respond at all. + */ + const unsigned long NONE = 2; + + /** + * Attribute: targetCalendar - the calendar that this thing should be + * stored in, if it should be stored onto a calendar. + */ + attribute calICalendar targetCalendar; + + /** + * The identity this item was received on. Helps to determine which + * attendee to manipulate. This should be the full email address of the + * attendee that is considered to be the local user. + */ + attribute AUTF8String identity; + + /** + * localStatus: The response that the user has made to the invitation in + * this ItipItem. + */ + attribute AUTF8String localStatus; + + /** + * Get the list of items that are encapsulated in this calIItipItem + * @returns An array of calIItemBase items that are inside this + * calIItipItem + */ + Array<calIItemBase> getItemList(); + + /** + * Modifies the state of the given attendee in the item's ics + * @param attendeeId - AString containing attendee address + * @param status - AString containing the new attendee status + */ + void setAttendeeStatus(in AString attendeeId, in AString status); +}; diff --git a/comm/calendar/base/public/calIItipTransport.idl b/comm/calendar/base/public/calIItipTransport.idl new file mode 100644 index 0000000000..72f6b7b63d --- /dev/null +++ b/comm/calendar/base/public/calIItipTransport.idl @@ -0,0 +1,48 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface calIItipItem; +interface calIAttendee; +interface calIDateTime; + +/** + * calIItipTransport is a generic transport interface that is implemented + * by transports (eg: email, XMPP, etc.) wishing to send calIItipItems + */ +[scriptable, uuid(caedabb9-d886-4814-ada5-a5636d2fb939)] +interface calIItipTransport : nsISupports +{ + /** + * Scheme to be used to prefix attendees. For example, the Email transport + * should return "mailto". + */ + readonly attribute AUTF8String scheme; + + /** + * Sending identity. This can be set to change the "sender" identity from + * defaultIdentity above. + */ + attribute AUTF8String senderAddress; + + /** + * Type of the transport: email, xmpp, etc. + */ + readonly attribute AUTF8String type; + + /** + * Sends a calIItipItem to the recipients using the specified title and + * alternative representation. If a calIItipItem is attached, then an ICS + * representation of those objects are generated and attached to the email. + * If the calIItipItem is null, then the item(s) is sent without any + * text/calendar mime part. + * @param recipientArray array of recipients + * @param calIItipItem set of calIItems encapsulated as calIItipItems + * @param sender the attendee the calIItipItem is coming from. + */ + boolean sendItems(in Array<calIAttendee> recipientArray, + in calIItipItem item, + in calIAttendee sender); +}; diff --git a/comm/calendar/base/public/calIOperation.idl b/comm/calendar/base/public/calIOperation.idl new file mode 100644 index 0000000000..92f3e8bb8d --- /dev/null +++ b/comm/calendar/base/public/calIOperation.idl @@ -0,0 +1,46 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsIVariant.idl" + +[scriptable, uuid(B96C2997-7AAA-4619-AD48-B7EBD9236C93)] +interface calIOperation : nsISupports +{ + /** + * Id for easy management of pending requests. + */ + readonly attribute AUTF8String id; + + /** + * Determines whether the request is pending, i.e. has not been completed. + */ + readonly attribute boolean isPending; + + /** + * Status of the request, e.g. NS_OK while pending or after successful + * completion, or NS_ERROR_FAILED when failed. + */ + readonly attribute nsIVariant status; + + /** + * Cancels a pending request and changes status. + * @param aStatus operation status to be set; + * defaults to calIErrors.OPERATION_CANCELLED if null + */ + void cancel([optional] in nsIVariant aStatus); +}; + +[scriptable, uuid(1FA39726-63D2-440c-A464-296D2822B9DA)] +interface calIGenericOperationListener : nsISupports +{ + /** + * Generic callback receiving result. + * Results may appear in multiple calls, i.e. callees have to collect + * until isPending is false. + * + * @param aOperation operation object + * @param aResult result or null in case of an error + */ + void onResult(in calIOperation aOperation, in nsIVariant aResult); +}; diff --git a/comm/calendar/base/public/calIPeriod.idl b/comm/calendar/base/public/calIPeriod.idl new file mode 100644 index 0000000000..d11f0ebdb3 --- /dev/null +++ b/comm/calendar/base/public/calIPeriod.idl @@ -0,0 +1,58 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface calIDateTime; +interface calIDuration; + +[scriptable,uuid(ace2a74c-bd08-476f-be8b-6565abc50339)] +interface calIPeriod : nsISupports +{ + attribute jsval icalPeriod; + + /** + * isMutable is true if this instance is modifiable. + * If isMutable is false, any attempts to modify + * the object will throw NS_ERROR_OBJECT_IS_IMMUTABLE. + */ + readonly attribute boolean isMutable; + + /** + * Make this calIPeriod instance immutable. + */ + void makeImmutable(); + + /** + * Clone this calIPeriod instance into a new + * mutable object. + */ + calIPeriod clone(); + + /** + * The start datetime of this period + */ + attribute calIDateTime start; + + /** + * The end datetime of this period + */ + attribute calIDateTime end; + + /** + * The duration, equal to end-start + */ + readonly attribute calIDuration duration; + + + /** + * Return a string representation of this instance. + */ + AUTF8String toString(); + + /** + * This object as an iCalendar DURATION string + */ + attribute ACString icalString; +}; diff --git a/comm/calendar/base/public/calIRecurrenceDate.idl b/comm/calendar/base/public/calIRecurrenceDate.idl new file mode 100644 index 0000000000..33f1d4b482 --- /dev/null +++ b/comm/calendar/base/public/calIRecurrenceDate.idl @@ -0,0 +1,24 @@ +/* -*- Mode: idl; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +#include "calIRecurrenceItem.idl" + +interface calIItemBase; +interface calIDateTime; + +interface calIIcalProperty; + +// an interface implementing a RDATE or EXDATE + +[scriptable, uuid(c5b331d4-b470-475b-9497-db9e2731e559)] +interface calIRecurrenceDate : calIRecurrenceItem +{ + // + // recurrence date set + // + attribute calIDateTime date; +}; diff --git a/comm/calendar/base/public/calIRecurrenceInfo.idl b/comm/calendar/base/public/calIRecurrenceInfo.idl new file mode 100644 index 0000000000..0e21298c47 --- /dev/null +++ b/comm/calendar/base/public/calIRecurrenceInfo.idl @@ -0,0 +1,184 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface calIItemBase; +interface calIDateTime; + +interface calIRecurrenceItem; + +interface calIIcalProperty; + +[scriptable, uuid(8ca5db89-2583-4f0c-b845-4a6d2f229efd)] +interface calIRecurrenceInfo : nsISupports +{ + // returns true if this thing is able to be modified; + // if the item is not mutable, attempts to modify + // any data will throw CAL_ERROR_ITEM_IS_IMMUTABLE + readonly attribute boolean isMutable; + + // makes this item immutable + void makeImmutable(); + + // clone always returns a mutable event + calIRecurrenceInfo clone(); + + // initialize this with the item for which this recurrence + // applies, so that the start date can be tracked + attribute calIItemBase item; + + /** + * The start date of an item is directly referenced by parts of calIRecurrenceInfo, + * thus changing the former without adjusting the latter would break the internal structure. + * This method provides the necessary functionality. There's no need to call it manually + * after writing to the start date of an item, since it's called automatically in the + * appropriate setter of an item. + */ + void onStartDateChange(in calIDateTime aNewStartTime, in calIDateTime aOldStartTime); + + /** + * If the base item's UID changes, this implicitly has to change all overridden items' UID, too. + * + * @param id new UID + */ + void onIdChange(in AUTF8String aNewId); + + /** + * The end point of the last occurrence, to avoid calculating occurrences for + * items that have finished recurring. If the object is mutable, or the + * recurrence is not finite, this value is the maximum possible PRTime. + */ + readonly attribute PRTime recurrenceEndDate; + + Array<calIRecurrenceItem> getRecurrenceItems(); + /** + * Set of recurrence items; the order of these matters. + */ + void setRecurrenceItems(in Array<calIRecurrenceItem> aItems); + + unsigned long countRecurrenceItems(); + void clearRecurrenceItems(); + void appendRecurrenceItem(in calIRecurrenceItem aItem); + + calIRecurrenceItem getRecurrenceItemAt(in unsigned long aIndex); + void deleteRecurrenceItemAt(in unsigned long aIndex); + void deleteRecurrenceItem(in calIRecurrenceItem aItem); + // inserts the item at the given index, pushing the item that was previously there forward + void insertRecurrenceItemAt(in calIRecurrenceItem aItem, in unsigned long aIndex); + + /** + * isFinite is true if the recurrence items specify a finite number + * of occurrences. This is useful for UI and for possibly other users. + */ + readonly attribute boolean isFinite; + + /** + * This is a shortcut to appending or removing a single negative date + * assertion. aRecurrenceId needs to be a normal recurrence id, it may not be + * RDATE. + */ + void removeOccurrenceAt(in calIDateTime aRecurrenceId); + void restoreOccurrenceAt(in calIDateTime aRecurrenceId); + + /* + * exceptions + */ + + /** + * Modify an a particular occurrence with the given exception proxy + * item. If the recurrenceId isn't an already existing exception item, + * a new exception is added. Otherwise, the existing exception + * is modified. + * + * The item's parentItem must be equal to this RecurrenceInfo's + * item. <-- XXX check this, compare by calendar/id only + * + * @param anItem exceptional/overridden item + * @param aTakeOverOwnership whether the recurrence info object can take over + * the item or needs to clone it + */ + void modifyException(in calIItemBase anItem, in boolean aTakeOverOwnership); + + /** + * Return an existing exception item for the given recurrence ID. + * If an exception does not exist, null is returned. + */ + calIItemBase getExceptionFor(in calIDateTime aRecurrenceId); + + /** + * Removes an exception item for the given recurrence ID, if + * any exist. + */ + void removeExceptionFor(in calIDateTime aRecurrenceId); + + /** + * Returns a list of all recurrence ids that have exceptions. + */ + Array<calIDateTime> getExceptionIds(); + + /* + * Recurrence calculation + */ + + /* + * Get the occurrence at the given recurrence ID; if there is no + * exception, then create a new proxy object with the normal occurrence. + * Otherwise, return the exception. + * + * @param aRecurrenceId The recurrence ID to get the occurrence for. + * @return The occurrence or exception corresponding to the id + */ + calIItemBase getOccurrenceFor(in calIDateTime aRecurrenceId); + + /** + * Return the chronologically next occurrence after aTime. This takes + * exceptions and EXDATE/RDATEs into account. + * + * @param aTime The (exclusive) date to start searching. + * @return The next occurrence, or null if there is none. + */ + calIItemBase getNextOccurrence(in calIDateTime aTime); + + /** + * Return the chronologically previous occurrence after aTime. This takes + * exceptions and EXDATE/RDATEs into account. + * + * @param aTime The (exclusive) date to start searching. + * @return The previous occurrence, or null if there is none. + */ + calIItemBase getPreviousOccurrence(in calIDateTime aTime); + + /** + * Return an array of calIDateTime representing all start times of this event + * between start (inclusive) and end (non-inclusive). Exceptions are taken + * into account. + * + * @param aRangeStart The (inclusive) date to start searching. + * @param aRangeEnd The (exclusive) date to end searching. + * @param aMaxCount The maximum number of dates to return + * + * @param aCount The number of dates returned. + * @return The array of dates. + */ + Array<calIDateTime> getOccurrenceDates(in calIDateTime aRangeStart, + in calIDateTime aRangeEnd, + in unsigned long aMaxCount); + + /** + * Return an array of calIItemBase representing all occurrences of this event + * between start (inclusive) and end (non-inclusive). Exceptions are taken + * into account. + * + * @param aRangeStart The (inclusive) date to start searching. + * @param aRangeEnd The (exclusive) date to end searching. + * @param aMaxCount The maximum number of occurrences to return + * + * @param aCount The number of occurrences returned. + * @return The array of occurrences. + */ + Array<calIItemBase> getOccurrences(in calIDateTime aRangeStart, + in calIDateTime aRangeEnd, + in unsigned long aMaxCount); +}; diff --git a/comm/calendar/base/public/calIRecurrenceItem.idl b/comm/calendar/base/public/calIRecurrenceItem.idl new file mode 100644 index 0000000000..9e2b83dadb --- /dev/null +++ b/comm/calendar/base/public/calIRecurrenceItem.idl @@ -0,0 +1,60 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface calIItemBase; +interface calIDateTime; + +interface calIIcalProperty; + +[scriptable, uuid(918a243b-d887-41b0-8b4b-9cd56a9dd55f)] +interface calIRecurrenceItem : nsISupports +{ + // returns true if this thing is able to be modified; + // if the item is not mutable, attempts to modify + // any data will throw CAL_ERROR_ITEM_IS_IMMUTABLE + readonly attribute boolean isMutable; + + // makes this item immutable + void makeImmutable(); + + // clone always returns a mutable event + calIRecurrenceItem clone(); + + // defaults to false; if true, this item is to be interpreted + // as a negative rule (e.g. exceptions instead of rdates) + attribute boolean isNegative; + + // returns whether this item has a finite number of dates + // or not (e.g. a rule with no end date) + readonly attribute boolean isFinite; + + /** + * Search for the next occurrence after aTime and return its recurrence id. + * aRecurrenceId must be the recurrence id of an occurrence to search after. + * If this item has an unsupported FREQ value ("SECONDLY" or "MINUTELY"), null + * is returned. + * + * @require (aTime >= aRecurrenceId) + * @param aRecurrenceId The recurrence id to start searching at. + * @param aTime The earliest time to find the occurrence after. + */ + calIDateTime getNextOccurrence(in calIDateTime aRecurrenceId, + in calIDateTime aTime); + + /** + * Return an array of calIDateTime of the start of all occurrences of + * this event starting at aStartTime, between rangeStart and an + * optional rangeEnd. If this item has an unsupported FREQ value ("SECONDLY" + * or "MINUTELY"), an empty array is returned. + */ + Array<calIDateTime> getOccurrences(in calIDateTime aStartTime, + in calIDateTime aRangeStart, + in calIDateTime aRangeEnd, + in unsigned long aMaxCount); + + attribute calIIcalProperty icalProperty; + attribute AUTF8String icalString; +}; diff --git a/comm/calendar/base/public/calIRecurrenceRule.idl b/comm/calendar/base/public/calIRecurrenceRule.idl new file mode 100644 index 0000000000..8694036a8c --- /dev/null +++ b/comm/calendar/base/public/calIRecurrenceRule.idl @@ -0,0 +1,53 @@ +/* -*- Mode: idl; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +#include "calIRecurrenceItem.idl" + +interface calIItemBase; +interface calIDateTime; + +// an interface implementing a RRULE + +[scriptable, uuid(e965a91a-49fa-41b5-b668-1a824a73bdbf)] +interface calIRecurrenceRule : calIRecurrenceItem +{ + // + // rule-based recurrence + // + + // null/"", "SECONDLY", "MINUTELY", "HOURLY", "DAILY", "WEEKLY", + // "MONTHLY", "YEARLY" + attribute AUTF8String type; + + // repeat every N of type + attribute long interval; + + // These two are mutually exclusive; whichever is set + // invalidates the other. It's only valid to read the one + // that was set; the other will throw NS_ERROR_FAILURE. Use + // isByCount to figure out whether count or untilDate is valid. + // Setting count to -1 or untilDate to null indicates infinite + // recurrence. + attribute long count; + attribute calIDateTime untilDate; + + // if this isn't infinite recurrence, this flag indicates whether + // it was set by count or not + readonly attribute boolean isByCount; + + // The week start for this rule, used for certain calculations. This is a + // value from 0=Sunday to 6=Saturday. + attribute short weekStart; + + // the components defining the recurrence + // "BYSECOND", "BYMINUTE", "BYHOUR", "BYDAY", + // "BYMONTHDAY", "BYYEARDAY", "BYWEEKNO", "BYMONTH", + // "BYSETPOS" + Array<short> getComponent (in AUTF8String aComponentType); + void setComponent (in AUTF8String aComponentType, in Array<short> aValues); + +}; diff --git a/comm/calendar/base/public/calIRelation.idl b/comm/calendar/base/public/calIRelation.idl new file mode 100644 index 0000000000..ee73dc9aaa --- /dev/null +++ b/comm/calendar/base/public/calIRelation.idl @@ -0,0 +1,45 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface calIIcalProperty; +interface calIItemBase; + +[scriptable,uuid(77f0820a-2b49-4c8e-86bf-2b6bda46e391)] +interface calIRelation : nsISupports +{ + /** + * The type of the relation between the items: + * PARENT + * CHILD + * SIBLING + */ + attribute AUTF8String relType; + + /** + * The id of the related item + **/ + + attribute AUTF8String relId; + + /** + * The calIIcalProperty corresponding to this object. Can be used for + * serializing/unserializing from ics files. + */ + attribute calIIcalProperty icalProperty; + attribute AUTF8String icalString; + + /** + * For accessing additional parameters, such as x-params. + */ + AUTF8String getParameter(in AString name); + void setParameter(in AString name, in AUTF8String value); + void deleteParameter(in AString name); + + /** + * Clone this calIRelation instance into a new object. + */ + calIRelation clone(); +}; diff --git a/comm/calendar/base/public/calISchedulingSupport.idl b/comm/calendar/base/public/calISchedulingSupport.idl new file mode 100644 index 0000000000..123ca35192 --- /dev/null +++ b/comm/calendar/base/public/calISchedulingSupport.idl @@ -0,0 +1,47 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" +interface calIItemBase; +interface calIAttendee; + +/** + * Accesses scheduling specific information of calendar items. + * Implementation by providers is optional. + */ +[scriptable, uuid(9221e243-c97e-4c5f-9e00-5d7d3521bb44)] +interface calISchedulingSupport : nsISupports +{ + /** + * Tests whether the passed item corresponds to an invitation, e.g. + * the CUA or server has placed it in the calendar. + * + * @param aItem Item to be tested. + * @return Whether the passed item corresponds to an invitation. + */ + boolean isInvitation(in calIItemBase aItem); + + /** + * Gets the invited attendee if the passed item corresponds to + * an invitation. UI code will use that attendee to modify e.g. PARTSTAT. + * If isInvitation returns true, getInvitedAttendee must return + * an attendee. If isInvitation is false, getInvitedAttendee may return + * an attendee in case the organizer (and owner of the calendar) has + * invited himself. + * + * @param aItem Invitation item. + * @return Attendee object, or null. + */ + calIAttendee getInvitedAttendee(in calIItemBase aItem); + + /** + * Checks whether the provider keeps track of sending out the proper + * iTIP/iMIP message for a particular item. + * + * @param aMethod a iTIP method + * @param aItem an item that has been modified/deleted etc. + * @return true, if the provider keeps track of sending out passed message + */ + boolean canNotify(in AUTF8String aMethod, in calIItemBase aItem); +}; diff --git a/comm/calendar/base/public/calIStartupService.idl b/comm/calendar/base/public/calIStartupService.idl new file mode 100644 index 0000000000..c387bf5a4b --- /dev/null +++ b/comm/calendar/base/public/calIStartupService.idl @@ -0,0 +1,30 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" +#include "calIOperation.idl" + +/** + * Interface that can be used on services that need to be started up and shut + * down. The service needs to be registered within calStartupService.js, so this + * is only useful from within calendar code. If you want calendar code to be + * fully initialized, listen to "calendar-startup-done" via nsIObserverService. + */ +[scriptable, uuid(99d52094-37f9-4c81-9c55-32fbeb6a79cf)] +interface calIStartupService: nsISupports +{ + /** + * Function called when the service should be started + * + * @param completeListener The listener to call on startup completion. + */ + void startup(in calIGenericOperationListener completeListener); + + /** + * Function called when the service should be shut down. + * + * @param completeListener The listener to call on shutdown completion. + */ + void shutdown(in calIGenericOperationListener completeListener); +}; diff --git a/comm/calendar/base/public/calIStatusObserver.idl b/comm/calendar/base/public/calIStatusObserver.idl new file mode 100644 index 0000000000..2dc48e14c4 --- /dev/null +++ b/comm/calendar/base/public/calIStatusObserver.idl @@ -0,0 +1,60 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" +interface calICalendar; +interface nsIDOMChromeWindow; + +[scriptable, uuid(60160f68-4514-41b4-a19d-2f2cf0143426)] +interface calIStatusObserver : nsISupports +{ + + void initialize(in nsIDOMChromeWindow aWindow); + + /** + * Starts the display of an operation to check a series of calendars + * This operation may either be determined or undetermined + * @param aProgressMode An integer value that can accept DETERMINED_PROGRESS, + * UNDETERMINED_PROGRESS or NO_PROGRESS + * @param aCalendarsCount If the first parameter is DETERMINED_PROGRESS + * aCalendarCount is the number of Calendars + * which completion is to be displayed + */ + void startMeteors(in unsigned long aProgressMode, in unsigned long aCalendarCount); + + /** + * stops the display of an progressed operation + */ + void stopMeteors(); + + /** + * increments the display value denoting that a calendar has been processed + */ + void calendarCompleted(in calICalendar aCalendar); + + /** + * @return An integer value denoting whether a progress is running or not; + * if it returns DETERMINED_PROGRESS a determined progress + is running; + * if it returns UNDETERMINED_PROGRESS an undetermined progress + is running; + * if it returns NO_PROGRESS no Progress is running. + */ + readonly attribute unsigned long spinning; + + /** + * A constant that denotes that no operation is running + */ + const unsigned long NO_PROGRESS = 0; + + /** + * A constant that refers to whether an operation is determined + */ + const unsigned long DETERMINED_PROGRESS = 1; + + /** + * A constant that refers to whether an operation is undetermined + */ + const unsigned long UNDETERMINED_PROGRESS = 2; +}; diff --git a/comm/calendar/base/public/calITimezone.idl b/comm/calendar/base/public/calITimezone.idl new file mode 100644 index 0000000000..a6d6135abd --- /dev/null +++ b/comm/calendar/base/public/calITimezone.idl @@ -0,0 +1,43 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface calIIcalComponent; + +[scriptable, uuid(d79161e7-0db9-427d-a0c3-27e0db3b030f)] +interface calITimezone : nsISupports +{ + /** + * VTIMEZONE ical component, null if floating or UTC. + */ + readonly attribute calIIcalComponent icalComponent; + + /** + * The TZID of this timezone. + */ + readonly attribute AUTF8String tzid; + + /** + * Whether this timezone is the "floating" timezone. + */ + readonly attribute boolean isFloating; + + /** + * Whether this is the "UTC" timezone. + */ + readonly attribute boolean isUTC; + + /** + * Localized name of the timezone; falls back to TZID if unknown. + */ + readonly attribute AString displayName; + + /** + * For debugging purposes. + * + * @return "UTC", "floating" or component's ical representation + */ + AUTF8String toString(); +}; diff --git a/comm/calendar/base/public/calITimezoneDatabase.idl b/comm/calendar/base/public/calITimezoneDatabase.idl new file mode 100644 index 0000000000..6c9d0c0505 --- /dev/null +++ b/comm/calendar/base/public/calITimezoneDatabase.idl @@ -0,0 +1,37 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +/** + * Provides access to raw iCalendar timezone definitions. Intended for providing + * a backing database for a calITimezoneService; most consumers will want to use + * calITimezoneService instead. + */ +[scriptable, uuid(dcace7e1-9600-47ba-a27e-b3bc8222192a)] +interface calITimezoneDatabase : nsISupports +{ + /** + * The version of the IANA Time Zone Database provided. + */ + readonly attribute AUTF8String version; + + /** + * Get all supported canonical timezone IDs. This does not include link + * timezone IDs and should only be used to provide users with a list of + * timezones they may select, not to restrict supported timezone values. + * + * @return a list of supported canonical timezone IDs + */ + Array<AUTF8String> getCanonicalTimezoneIds(); + + /** + * Get an iCalendar timezone definition by timezone ID. + * + * @param tzid timezone ID for which to return definition + * @return a string containing an ical VTIMEZONE definition, or + * the empty string if the timezone ID is not recognized + */ + AUTF8String getTimezoneDefinition(in AUTF8String tzid); +}; diff --git a/comm/calendar/base/public/calITimezoneService.idl b/comm/calendar/base/public/calITimezoneService.idl new file mode 100644 index 0000000000..6c7ef24112 --- /dev/null +++ b/comm/calendar/base/public/calITimezoneService.idl @@ -0,0 +1,50 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface calITimezone; + +/** + * Provides access to timezone definitions from the IANA Time Zone Database. + */ +[scriptable, uuid(ab1bfe6a-ee95-4038-b594-34aeeda9911a)] +interface calITimezoneService : nsISupports +{ + /** + * All canonical timezone IDs provided by the current IANA Time Zone + * Database; intended to provide a list of selectable timezones, not to + * restrict the list of valid timezones. + */ + readonly attribute Array<AUTF8String> timezoneIds; + + /** + * The version of the IANA Time Zone Database provided. + */ + readonly attribute AUTF8String version; + + /** + * Get a timezone definition by timezone ID. + * + * @param tzid timezone ID for which to return definition + * @return a timezone object, or null if ID is not recognized + */ + calITimezone getTimezone(in AUTF8String tzid); + + /** + * The definition for the "floating" timezone, in which times are relative + * to local time. + */ + readonly attribute calITimezone floating; + + /** + * The timezone definition for Coordinated Universal Time. + */ + readonly attribute calITimezone UTC; + + /** + * Returns the current default timezone for calendars/events. + */ + readonly attribute calITimezone defaultTimezone; +}; diff --git a/comm/calendar/base/public/calITodo.idl b/comm/calendar/base/public/calITodo.idl new file mode 100644 index 0000000000..1ed322829d --- /dev/null +++ b/comm/calendar/base/public/calITodo.idl @@ -0,0 +1,72 @@ +/* -*- Mode: idl; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "calIItemBase.idl" + +// +// calITodo +// +// An interface for a todo item (analogous to a VTODO) +// + +[scriptable, uuid(0a93fdad-8a5c-44e9-8f90-16a6df819e03)] +interface calITodo : calIItemBase +{ + const long CAL_TODO_STATUS_NEEDSACTION = 4; + const long CAL_TODO_STATUS_COMPLETED = 5; + const long CAL_TODO_STATUS_INPROCESS = 6; + + // as per the rather broken RFC2445, + + // entryDate maps to DTSTART, which is the day + // this todo shows up on, if set. (optional). + // + // dueDate maps to DUE, which is the day + // this todo is due, if set. (optional). + // + // If neither DUE nor DTSTART are set, then + // the todo appears "today" until it is completed. + // + // The completeDate is the date the todo was completed, + // or null if it hasn't been completed yet. + + attribute calIDateTime entryDate; + attribute calIDateTime dueDate; + attribute calIDateTime completedDate; + attribute short percentComplete; + + // A todo isCompleted if any of the following is true: + // - percentComplete is 100, or + // - completedDate is non-null, or + // - status is COMPLETED. + // Setting isCompleted to true will + // - set percentComplete to 100, and + // - set completedDate to the current time, if it is not already set, and + // - set status to COMPLETED. + // Setting isCompleted to false will remove percentComplete, completedDate, + // and status properties. (This returns the todo to its state at creation, + // in terms of completion-relevant properties.) + // + // If you would like to take advantage of the full, confusing disaster that + // is the RFC2445 VTODO status state space, you can feel free to set the + // fields individually, instead of setting isCompleted directly. (And then + // hope that whatever else you're talking to has the same set of rules for + // determining if something is completed or not.) + // + // Setting percentComplete, completedDate, or status individually does not + // affect any of the others at present. (E.g., setting the percentComplete + // from 100 to 50 doesn't clear completedDate, or change status to + // IN-PROCESS.) It's not clear that we want any more magic than a simple + // property to control "all complete" vs "not complete in any way". + attribute boolean isCompleted; + + /** + * The duration of the todo, which is either set or defined as + * dueDate - entryDate. + * Please note that null is returned if there is no duration set and entry + * Date or dueDate don't exist. + */ + attribute calIDuration duration; +}; diff --git a/comm/calendar/base/public/calIWeekInfoService.idl b/comm/calendar/base/public/calIWeekInfoService.idl new file mode 100644 index 0000000000..c688579418 --- /dev/null +++ b/comm/calendar/base/public/calIWeekInfoService.idl @@ -0,0 +1,50 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsISupports.idl" + +interface calIDateTime; + +/** + * This interface will calculate a week title from a given datetime. This + * will depends on the users preferences. + * Extensions might override the default implementation, in order to + * generate week titles aimed at special cases (like weeknumbers for a + * schoolyear) + */ +[scriptable, uuid(650fd33b-ebf4-46fa-b9ca-dd80b2451498)] +interface calIWeekInfoService: nsISupports +{ + /** + * Return the week title. It's meant to be displayed. + * (Usually, will return a weeknumber, but might return a string like Q1W4) + * + * @param dateTime + * The dateTime to get the weektitle for + * @returns + * A string, representing the week title. Will usually be the + * week number. Every week (7 days) should get a different string, + * but the switch from one week to the next isn't necessarily + * on sunday. + */ + AString getWeekTitle(in calIDateTime dateTime); + + /** + * Gets the first day of a week of a passed day under consideration + * of the preference setting "calendar.week.start" + * + * @param aDate The dateTime to get get the start of the week for + * @return A dateTime-object denoting the first day of the week + */ + calIDateTime getStartOfWeek(in calIDateTime dateTime); + + /** + * Gets the last day of a week of a passed day under consideration + * of the preference setting "calendar.week.start" + * + * @param aDate The dateTime to get get the last day of the week for + * @return A dateTime-object denoting the last day of the week + */ + calIDateTime getEndOfWeek(in calIDateTime dateTime); +}; diff --git a/comm/calendar/base/public/moz.build b/comm/calendar/base/public/moz.build new file mode 100644 index 0000000000..8879b4e63b --- /dev/null +++ b/comm/calendar/base/public/moz.build @@ -0,0 +1,56 @@ +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +XPIDL_SOURCES += [ + "calIAlarm.idl", + "calIAlarmService.idl", + "calIAttachment.idl", + "calIAttendee.idl", + "calICalendar.idl", + "calICalendarACLManager.idl", + "calICalendarManager.idl", + "calICalendarProvider.idl", + "calICalendarView.idl", + "calICalendarViewController.idl", + "calIChangeLog.idl", + "calIDateTime.idl", + "calIDeletedItems.idl", + "calIDuration.idl", + "calIErrors.idl", + "calIEvent.idl", + "calIFreeBusyProvider.idl", + "calIIcsParser.idl", + "calIIcsSerializer.idl", + "calIICSService.idl", + "calIImportExport.idl", + "calIItemBase.idl", + "calIItipItem.idl", + "calIItipTransport.idl", + "calIOperation.idl", + "calIPeriod.idl", + "calIRecurrenceDate.idl", + "calIRecurrenceInfo.idl", + "calIRecurrenceItem.idl", + "calIRecurrenceRule.idl", + "calIRelation.idl", + "calISchedulingSupport.idl", + "calIStartupService.idl", + "calIStatusObserver.idl", + "calITimezone.idl", + "calITimezoneDatabase.idl", + "calITimezoneService.idl", + "calITodo.idl", + "calIWeekInfoService.idl", +] + +XPIDL_MODULE = "calbase" + +EXPORTS += [] + +with Files("**"): + BUG_COMPONENT = ("Calendar", "Internal Components") + +with Files("calIAlarm*"): + BUG_COMPONENT = ("Calendar", "Alarms") |