зеркало из https://github.com/mozilla/gecko-dev.git
1780 строки
62 KiB
JavaScript
1780 строки
62 KiB
JavaScript
/* -*- Mode: javascript; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is OEone Calendar Code, released October 31st, 2001.
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* OEone Corporation.
|
|
* Portions created by the Initial Developer are Copyright (C) 2001
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s): Garth Smedley <garths@oeone.com>
|
|
* Mike Potter <mikep@oeone.com>
|
|
* Colin Phillips <colinp@oeone.com>
|
|
* Chris Charabaruk <coldacid@meldstar.com>
|
|
* ArentJan Banck <ajbanck@planet.nl>
|
|
* Mostafa Hosseini <mostafah@oeone.com>
|
|
* Eric Belhaire <belhaire@ief.u-psud.fr>
|
|
* Stelian Pop <stelian.pop@fr.alcove.com>
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
|
|
|
|
/***** calendar/eventDialog.js
|
|
* AUTHOR
|
|
* Garth Smedley
|
|
* REQUIRED INCLUDES
|
|
* <script type="application/x-javascript" src="chrome://calendar/content/dateUtils.js"/>
|
|
* <script type="application/x-javascript" src="chrome://calendar/content/applicationUtil.js"/>
|
|
* NOTES
|
|
* Code for the calendar's new/edit event dialog.
|
|
*
|
|
* Invoke this dialog to create a new event as follows:
|
|
|
|
var args = new Object();
|
|
args.mode = "new"; // "new" or "edit"
|
|
args.onOk = <function>; // funtion to call when OK is clicked
|
|
args.calendarEvent = calendarEvent; // newly creatd calendar event to be editted
|
|
|
|
openDialog("chrome://calendar/content/eventDialog.xul", "caEditEvent", "chrome,titlebar,modal", args );
|
|
*
|
|
* Invoke this dialog to edit an existing event as follows:
|
|
*
|
|
var args = new Object();
|
|
args.mode = "edit"; // "new" or "edit"
|
|
args.onOk = <function>; // funtion to call when OK is clicked
|
|
args.calendarEvent = calendarEvent; // javascript object containin the event to be editted
|
|
|
|
* When the user clicks OK the onOk function will be called with a calendar event object.
|
|
*
|
|
*
|
|
* IMPLEMENTATION NOTES
|
|
**********
|
|
*/
|
|
|
|
|
|
/*-----------------------------------------------------------------
|
|
* W I N D O W V A R I A B L E S
|
|
*/
|
|
|
|
var gReadOnlyMode;
|
|
var gOnOkFunction; // function to be called when user clicks OK
|
|
var gDurationMSec; // current duration, for updating end date when start date is changed
|
|
|
|
const DEFAULT_ALARM_LENGTH = 15; //default number of time units, an alarm goes off before an event
|
|
|
|
/*-----------------------------------------------------------------
|
|
* W I N D O W F U N C T I O N S
|
|
*/
|
|
|
|
/**
|
|
* Called when the dialog is loaded.
|
|
*/
|
|
function loadCalendarEventDialog()
|
|
{
|
|
const kDefaultTimezone = calendarDefaultTimezone();
|
|
|
|
// Get arguments, see description at top of file
|
|
var args = window.arguments[0];
|
|
|
|
gOnOkFunction = args.onOk;
|
|
|
|
var event = args.calendarEvent;
|
|
|
|
if (event.calendar && event.calendar.readOnly)
|
|
gReadOnlyMode = true;
|
|
|
|
// The event calendar is its current calendar, or for a new event,
|
|
// the selected calendar in the calendar list, passed in args.calendar.
|
|
var eventCalendar = event.calendar || args.calendar;
|
|
|
|
// Initialize calendar names in drop down list.
|
|
var calendarField = document.getElementById('server-field');
|
|
var calendars = getCalendarManager().getCalendars({});
|
|
for (i in calendars) {
|
|
try {
|
|
var menuitem = calendarField.appendItem(calendars[i].name,
|
|
calendars[i].uri);
|
|
menuitem.calendar = calendars[i];
|
|
// compare cal.uri because there may be multiple instances of
|
|
// calICalendar or uri for the same spec, and those instances are
|
|
// not ==.
|
|
if (eventCalendar && eventCalendar.uri.equals(calendars[i].uri))
|
|
calendarField.selectedIndex = i;
|
|
} catch(ex) {
|
|
dump("eventCalendar.uri not found...\n");
|
|
}
|
|
}
|
|
|
|
// Set up dialog as event or todo
|
|
var componentType;
|
|
if (isEvent(event)) {
|
|
processComponentType("event");
|
|
componentType = "event";
|
|
} else if (isToDo(event)) {
|
|
processComponentType("todo");
|
|
componentType = "todo";
|
|
} else {
|
|
dump("loadCalendarEventDialog: ERROR! Got a bogus event! Not event or todo!\n");
|
|
// close the dialog before we screw anything else up
|
|
return false;
|
|
}
|
|
|
|
// fill in fields from the event
|
|
switch(componentType) {
|
|
case "event":
|
|
var startDate = event.startDate.getInTimezone(kDefaultTimezone).jsDate;
|
|
setElementValue("start-datetime", startDate);
|
|
|
|
// only events have end dates. todos have due dates
|
|
var endDate = event.endDate.getInTimezone(kDefaultTimezone).jsDate;
|
|
gDurationMSec = endDate - startDate;
|
|
|
|
var displayEndDate = new Date(endDate);
|
|
if (event.startDate.isDate) {
|
|
//displayEndDate == icalEndDate - 1, in the case of allday events
|
|
displayEndDate.setDate(displayEndDate.getDate() - 1);
|
|
}
|
|
setElementValue("end-datetime", displayEndDate);
|
|
|
|
// event status fields
|
|
switch(event.status) {
|
|
case "TENTATIVE":
|
|
setElementValue("event-status-field", "TENTATIVE");
|
|
break;
|
|
case "CONFIRMED":
|
|
setElementValue("event-status-field", "CONFIRMED");
|
|
break;
|
|
case "CANCELLED":
|
|
setElementValue("event-status-field", "CANCELLED");
|
|
break;
|
|
default:
|
|
dump("loadCalendarEventDialog: ERROR! Got an invalid status: " +
|
|
event.status + "\n");
|
|
}
|
|
|
|
setElementValue("all-day-event-checkbox", event.startDate.isDate, "checked");
|
|
break;
|
|
case "todo":
|
|
var hasEntry = event.entryDate ? true : false;
|
|
var selectedDay = window.opener.gCalendarWindow.currentView.getNewEventDate();
|
|
var entryDate = (hasEntry ? event.entryDate.jsDate : selectedDay );
|
|
|
|
setElementValue("start-datetime", entryDate);
|
|
setElementValue("start-datetime", !hasEntry, "disabled");
|
|
setElementValue("start-checkbox", hasEntry, "checked");
|
|
|
|
var hasDue = event.dueDate ? true : false;
|
|
var dueDate = (hasDue? event.dueDate.jsDate : selectedDay );
|
|
|
|
setElementValue("due-datetime", dueDate);
|
|
setElementValue("due-datetime", !hasDue, "disabled");
|
|
setElementValue("due-checkbox", hasDue, "checked" );
|
|
|
|
/*integrate this into onDateTimePick()
|
|
if (hasStart && hasDue)
|
|
duration = dueDate.getTime() - startDate.getTime(); //in ms
|
|
else
|
|
duration = 0;*/
|
|
|
|
setElementValue("percent-complete-menulist", event.percentComplete);
|
|
|
|
// todo status fields
|
|
if (event.completedDate)
|
|
processToDoStatus(event.status, event.completedDate.jsDate);
|
|
else
|
|
processToDoStatus(event.status);
|
|
}
|
|
|
|
|
|
// GENERAL -----------------------------------------------------------
|
|
setElementValue("title-field", event.title );
|
|
setElementValue("description-field", event.getProperty("DESCRIPTION"));
|
|
setElementValue("location-field", event.getProperty("LOCATION"));
|
|
setElementValue("uri-field", event.getProperty("URL"));
|
|
// only enable "Go" button if there's a url
|
|
processTextboxWithButton("uri-field", "load-url-button");
|
|
|
|
|
|
// PRIVACY -----------------------------------------------------------
|
|
switch(event.privacy) {
|
|
case "PUBLIC":
|
|
case "PRIVATE":
|
|
case "CONFIDENTIAL":
|
|
setElementValue("privacy-menulist", event.privacy);
|
|
break;
|
|
case "":
|
|
setElementValue("private-menulist", "PUBLIC");
|
|
break;
|
|
default: // bogus value
|
|
dump("loadCalendarEventDialog: ERROR! Event has invalid privacy string: " + event.privacy + "\n");
|
|
break;
|
|
}
|
|
|
|
|
|
// PRIORITY ----------------------------------------------------------
|
|
var priorityInteger = parseInt( event.priority );
|
|
if( priorityInteger == 0 ) {
|
|
menuListSelectItem("priority-levels", "0"); // not defined
|
|
} else if( priorityInteger >= 1 && priorityInteger <= 4 ) {
|
|
menuListSelectItem("priority-levels", "1"); // high priority
|
|
} else if( priorityInteger == 5 ) {
|
|
menuListSelectItem("priority-levels", "5"); // medium priority
|
|
} else if( priorityInteger >= 6 && priorityInteger <= 9 ) {
|
|
menuListSelectItem("priority-levels", "9"); // low priority
|
|
} else {
|
|
dump("loadCalendarEventDialog: ERROR! Event has invalid priority: " + event.priority +"\n");
|
|
}
|
|
|
|
|
|
// ALARMS ------------------------------------------------------------
|
|
if (event.alarmTime == null) {
|
|
menuListSelectItem("alarm-type", "none");
|
|
} else {
|
|
setElementValue("alarm-length-field", event.getProperty("alarmLength"));
|
|
setElementValue("alarm-length-units", event.getProperty("alarmUnits"));
|
|
var startPickerDisabled = getElementValue("start-datetime", "disabled");
|
|
var duePickerDisabled = getElementValue("due-datetime", "disabled");
|
|
if (componentType == "event" ||
|
|
(componentType == "todo" && !(startPickerDisabled && duePickerDisabled) ) ) {
|
|
// If the event has an alarm email address, assume email alarm type
|
|
var alarmEmailAddress = event.getProperty("alarmEmailAddress");
|
|
if (alarmEmailAddress && alarmEmailAddress != "") {
|
|
menuListSelectItem("alarm-type", "email");
|
|
setElementValue("alarm-email-field", alarmEmailAddress);
|
|
} else {
|
|
menuListSelectItem("alarm-type", "popup");
|
|
/* XXX lilmatt: finish this by selection between popup and
|
|
popupAndSound by checking pref "calendar.alarms.playsound" */
|
|
}
|
|
var alarmRelated = event.getProperty("alarmRelated");
|
|
if (alarmRelated && alarmRelated != "") {
|
|
// if only one picker is enabled, check that the appropriate related
|
|
// parameter is chosen
|
|
if ( (componentType == "event") ||
|
|
(componentType == "todo" && !startPickerDisabled &&
|
|
duePickerDisabled && alarmRelated == "START") ||
|
|
(componentType == "todo" && startPickerDisabled &&
|
|
!duePickerDisabled && alarmRelated == "END") ||
|
|
(componentType == "todo" && !startPickerDisabled && !duePickerDisabled) )
|
|
{
|
|
setElementValue("alarm-trigger-relation", alarmRelated);
|
|
} else {
|
|
dump("loadCalendarEventDialog: ERROR! alarmRelated: " +
|
|
alarmRelated + " is invalid! (trying to set " +
|
|
"START/END when the necessary datepicker isn't " +
|
|
"enabled?)\n");
|
|
}
|
|
}
|
|
}
|
|
// hide/show fields and widgets for alarm type
|
|
processAlarmType();
|
|
}
|
|
|
|
|
|
// RECURRENCE --------------------------------------------------------
|
|
// Set up widgets so they're not empty. Event values will override.
|
|
setElementValue("repeat-end-date-picker", new Date() );
|
|
setElementValue("exceptions-date-picker", new Date() );
|
|
|
|
if (event.recurrenceInfo) {
|
|
// we can only display at most one rule and one set of exceptions;
|
|
// nothing else.
|
|
var theRule = null;
|
|
var theExceptions = Array();
|
|
|
|
var ritems = event.recurrenceInfo.getRecurrenceItems({});
|
|
for (i in ritems) {
|
|
if (ritems[i] instanceof calIRecurrenceRule) {
|
|
if (theRule) {
|
|
dump ("eventDialog.js: Already found a calIRecurrenceRule, we can't handle multiple ones!\n");
|
|
} else {
|
|
theRule = ritems[i].QueryInterface(calIRecurrenceRule);
|
|
if (theRule.isNegative) {
|
|
dump ("eventDialog.js: Found an EXRULE, we can't handle this!\n");
|
|
theRule = null;
|
|
}
|
|
}
|
|
} else if (ritems[i] instanceof calIRecurrenceDate) {
|
|
var exc = ritems[i].QueryInterface(calIRecurrenceDate);
|
|
if (exc.isNegative)
|
|
theExceptions.push(exc);
|
|
else
|
|
dump ("eventDialog.js: found a calIRecurrenceDate that wasn't an exception!\n");
|
|
}
|
|
}
|
|
|
|
if (theRule) {
|
|
setElementValue("repeat-checkbox", true, "checked");
|
|
setElementValue("repeat-length-field", theRule.interval);
|
|
menuListSelectItem("repeat-length-units", theRule.type);
|
|
|
|
//XXX display an error when there is no UI to display all the rules
|
|
switch(theRule.type) {
|
|
case "WEEKLY":
|
|
var recurWeekdays = theRule.getComponent("BYDAY", {});
|
|
for (i = 0; i < 7; i++ ) {
|
|
setElementValue("advanced-repeat-week-" + i, false, "checked");
|
|
setElementValue("advanced-repeat-week-" + i, false, "today" );
|
|
for (var j = 0; j < recurWeekdays.length; j++) {
|
|
//libical day #s are one more than ours
|
|
if ((i + 1) == recurWeekdays[j])
|
|
setElementValue("advanced-repeat-week-"+i, true, "checked");
|
|
}
|
|
}
|
|
|
|
//get day number for event's start date, and check and disable it
|
|
var dayNumber = getElementValue("start-datetime").getDay();
|
|
setElementValue("advanced-repeat-week-"+dayNumber, true, "checked" );
|
|
setElementValue("advanced-repeat-week-"+dayNumber, true, "disabled");
|
|
setElementValue("advanced-repeat-week-"+dayNumber, true, "today" );
|
|
break;
|
|
case "MONTHLY":
|
|
recDays = theRule.getComponent("BYDAY", {});
|
|
dump("rd: "+recDays[0]+"\n");
|
|
if (recDays.length && recDays[0] > 8) {
|
|
radioGroupSelectItem("advanced-repeat-month", "advanced-repeat-dayofweek");
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (!theRule.isFinite) {
|
|
radioGroupSelectItem("repeat-until-group", "repeat-forever-radio");
|
|
} else {
|
|
if (theRule.isByCount) {
|
|
radioGroupSelectItem("repeat-until-group", "repeat-numberoftimes-radio");
|
|
setElementValue("repeat-numberoftimes-textbox", theRule.count );
|
|
} else {
|
|
radioGroupSelectItem("repeat-until-group", "repeat-until-radio");
|
|
setElementValue("repeat-end-date-picker", theRule.endDate.jsDate);
|
|
}
|
|
}
|
|
} else {
|
|
menuListSelectItem("repeat-length-units", "DAILY");
|
|
}
|
|
updateRepeatUnitExtensions()
|
|
|
|
if (theExceptions.length > 0) {
|
|
for (i in theExceptions) {
|
|
var date = theExceptions[i].date.jsDate;
|
|
addException(date);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Only show Add/Delete Exception buttons when appropriate
|
|
updateAddExceptionButton();
|
|
updateDeleteExceptionButton();
|
|
|
|
/* Old crap:
|
|
setElementValue("advanced-repeat-dayofmonth", (gEvent.recurWeekNumber == 0 || gEvent.recurWeekNumber == undefined), "selected");
|
|
setElementValue("advanced-repeat-dayofweek", (gEvent.recurWeekNumber > 0 && gEvent.recurWeekNumber != 5), "selected");
|
|
setElementValue("advanced-repeat-dayofweek-last", (gEvent.recurWeekNumber == 5), "selected");
|
|
*/
|
|
|
|
|
|
// INVITEES ----------------------------------------------------------
|
|
var inviteEmailAddress = event.getProperty("inviteEmailAddress");
|
|
if (inviteEmailAddress != undefined && inviteEmailAddress != "") {
|
|
setElementValue("invite-checkbox", true, "checked");
|
|
setElementValue("invite-email-field", inviteEmailAddress);
|
|
} else {
|
|
setElementValue("invite-checkbox", false, "checked");
|
|
}
|
|
processInviteCheckbox();
|
|
|
|
// handle attendees
|
|
var attendeeList = event.getAttendees({});
|
|
for (var i = 0; i < attendeeList.length; i++) {
|
|
var attendee = attendeeList[i];
|
|
addAttendee(attendee.id);
|
|
}
|
|
|
|
|
|
// ATTACHMENTS -------------------------------------------------------
|
|
/* XXX this could work when attachments are supported by calItemBase
|
|
var count = event.attachments.length;
|
|
for (i = 0; i < count; i++) {
|
|
var thisAttachment = event.attachments.queryElementAt(i, Components.interfaces.calIAttachment);
|
|
addAttachment(thisAttachment);
|
|
}
|
|
*/
|
|
// Only show the Remove Attachment button if there are attachments
|
|
updateRemoveAttachmentButton();
|
|
|
|
|
|
// CATEGORIES --------------------------------------------------------
|
|
// Load categories from preferences
|
|
try {
|
|
var categoriesString = opener.GetUnicharPref(opener.gCalendarWindow.calendarPreferences.calendarPref, "categories.names", getDefaultCategories());
|
|
var categoriesList = categoriesString.split( "," );
|
|
|
|
// insert the category already in the task so it doesn't get lost
|
|
var categories = event.getProperty("CATEGORIES");
|
|
if (categories) {
|
|
if (categoriesString.indexOf(categories) == -1)
|
|
categoriesList[categoriesList.length] = categories;
|
|
}
|
|
categoriesList.sort();
|
|
|
|
var oldMenulist = document.getElementById( "categories-menulist-menupopup" );
|
|
while( oldMenulist.hasChildNodes() )
|
|
oldMenulist.removeChild( oldMenulist.lastChild );
|
|
for (i = 0; i < categoriesList.length ; i++) {
|
|
document.getElementById("categories-field").appendItem(categoriesList[i], categoriesList[i]);
|
|
}
|
|
if (categories)
|
|
menuListSelectItem("categories-field", categories);
|
|
else
|
|
document.getElementById("categories-field").selectedIndex = -1;
|
|
} catch (ex) {
|
|
dump("unable to do categories stuff in event dialog\n");
|
|
}
|
|
|
|
// update enabling and disabling
|
|
updateRepeatItemEnabled();
|
|
updateStartEndItemEnabled();
|
|
|
|
// start focus on title
|
|
var firstFocus = document.getElementById("title-field");
|
|
firstFocus.focus();
|
|
|
|
// revert cursor from "wait" set in calendar.js editEvent, editNewEvent
|
|
opener.setCursor("auto");
|
|
|
|
self.focus();
|
|
|
|
updateOKButton();
|
|
|
|
// fix a strict warning about not always returning a value
|
|
return true;
|
|
}
|
|
|
|
|
|
/*
|
|
* Called when the OK button is clicked.
|
|
*/
|
|
|
|
function onOKCommand()
|
|
{
|
|
// Get arguments, see description at top of file
|
|
var args = window.arguments[0];
|
|
var event = args.calendarEvent;
|
|
|
|
// if this event isn't mutable, we need to clone it like a sheep
|
|
var originalEvent = event;
|
|
|
|
// get values from the form and put them into the event
|
|
var componentType = getElementValue("component-type");
|
|
|
|
// calIEvent properties
|
|
if (componentType == "event") {
|
|
if (!event.isMutable) // I will cut vlad for making me do this QI
|
|
event = originalEvent.clone().QueryInterface(Components.interfaces.calIEvent);
|
|
|
|
event.startDate = jsDateToFloatingDateTime(getElementValue("start-datetime"));
|
|
var endDate = getElementValue("end-datetime");
|
|
if (getElementValue("all-day-event-checkbox", "checked") ) {
|
|
event.startDate.isDate = true;
|
|
event.endDate.isDate = true;
|
|
// displayed all day end date is inclusive date, convert to exclusive end date.
|
|
endDate.setDate(endDate.getDate() + 1);
|
|
}
|
|
event.endDate = jsDateToFloatingDateTime(endDate);
|
|
if (event.startDate.isDate) {
|
|
event.endDate.isDate = true;
|
|
}
|
|
|
|
var status = getElementValue("event-status-field");
|
|
if (status)
|
|
event.status = status;
|
|
} else if (isToDo(event)) {
|
|
componentType = "todo";
|
|
if (!event.isMutable) // I will cut vlad for making me do this QI
|
|
event = originalEvent.clone().QueryInterface(Components.interfaces.calITodo);
|
|
|
|
if ( getElementValue("start-checkbox", "checked") ) {
|
|
event.entryDate = jsDateToFloatingDateTime(getElementValue("start-datetime"));
|
|
} else {
|
|
event.entryDate = null;
|
|
}
|
|
|
|
if ( getElementValue("due-checkbox", "checked") ) {
|
|
event.dueDate = jsDateToFloatingDateTime(getElementValue("due-datetime"));
|
|
} else {
|
|
event.dueDate = null;
|
|
}
|
|
|
|
event.status = getElementValue("todo-status-field");
|
|
event.percentComplete = getElementValue("percent-complete-menulist");
|
|
if ( event.status == "COMPLETED" && event.percentComplete == 100 ) {
|
|
event.completedDate = jsDateToFloatingDateTime(getElementValue("completed-date-picker"));
|
|
} else {
|
|
event.completedDate = null;
|
|
}
|
|
} else {
|
|
dump("eventDialog.js: ERROR! onOKCommand() found neither an event nor a todo!\n");
|
|
}
|
|
|
|
// XXX should do an idiot check here to see if duration is negative
|
|
|
|
// calIItemBase properties
|
|
event.title = getElementValue("title-field");
|
|
event.priority = getElementValue("priority-levels");
|
|
|
|
// other properties
|
|
var cats = getElementValue("categories-field");
|
|
if (cats)
|
|
event.setProperty("CATEGORIES", cats);
|
|
else
|
|
event.deleteProperty("CATEGORIES");
|
|
|
|
var desc = getElementValue("description-field");
|
|
if (desc)
|
|
event.setProperty("DESCRIPTION", desc);
|
|
else
|
|
event.deleteProperty("DESCRIPTION");
|
|
|
|
var location = getElementValue("location-field");
|
|
if (location)
|
|
event.setProperty("LOCATION", location);
|
|
else
|
|
event.deleteProperty("LOCATION");
|
|
|
|
var url = getElementValue("uri-field") ;
|
|
if (url)
|
|
event.setProperty("URL", url);
|
|
else
|
|
event.deleteProperty("URL");
|
|
|
|
|
|
// PRIVACY -----------------------------------------------------------
|
|
var privacyValue = getElementValue("privacy-menulist");
|
|
switch(privacyValue) {
|
|
case "PUBLIC":
|
|
case "PRIVATE":
|
|
case "CONFIDENTIAL":
|
|
event.privacy = privacyValue;
|
|
break;
|
|
default: // bogus value
|
|
dump("onOKCommand: ERROR! Event has invalid privacy-menulist value: " +
|
|
privacyValue + "\n");
|
|
break;
|
|
}
|
|
|
|
|
|
// ALARMS ------------------------------------------------------------
|
|
var alarmType = getElementValue("alarm-type");
|
|
if (alarmType != "" && alarmType != "none") {
|
|
var alarmLength = getElementValue("alarm-length-field");
|
|
var alarmUnits = getElementValue("alarm-length-units");
|
|
var alarmRelated = getElementValue("alarm-trigger-relation");
|
|
|
|
event.setProperty("alarmLength", alarmLength);
|
|
event.setProperty("alarmUnits", alarmUnits);
|
|
event.setProperty("alarmRelated", alarmRelated);
|
|
|
|
var alarmTime = null;
|
|
|
|
if (alarmRelated == "START") {
|
|
if (event.startDate)
|
|
alarmTime = event.startDate.clone();
|
|
else if (event.entryDate)
|
|
alarmTime = event.entryDate.clone();
|
|
} else if (alarmRelated == "END") {
|
|
if (event.endDate)
|
|
alarmTime = event.endDate.clone();
|
|
else if(event.dueDate)
|
|
alarmTime = event.dueDate.clone();
|
|
}
|
|
|
|
switch (alarmUnits) {
|
|
case "minutes":
|
|
alarmTime.minute -= alarmLength;
|
|
break;
|
|
case "hours":
|
|
alarmTime.hour -= alarmLength;
|
|
break;
|
|
case "days":
|
|
alarmTime.day -= alarmLength;
|
|
break;
|
|
}
|
|
|
|
alarmTime.normalize();
|
|
|
|
event.alarmTime = alarmTime;
|
|
}
|
|
|
|
if (alarmType == "email")
|
|
event.setProperty("alarmEmailAddress", getElementValue("alarm-email-field"));
|
|
else
|
|
event.deleteProperty("alarmEmailAddress");
|
|
|
|
|
|
// RECURRENCE --------------------------------------------------------
|
|
event.recurrenceInfo = null;
|
|
|
|
if (getElementValue("repeat-checkbox", "checked")) {
|
|
var recurrenceInfo = createRecurrenceInfo();
|
|
recurrenceInfo.item = event;
|
|
|
|
var recRule = new calRecurrenceRule();
|
|
|
|
if (getElementValue("repeat-forever-radio", "selected")) {
|
|
recRule.count = -1;
|
|
} else if (getElementValue("repeat-numberoftimes-radio", "selected")) {
|
|
recRule.count = Math.max(1, getElementValue("repeat-numberoftimes-textbox"));
|
|
} else if (getElementValue("repeat-until-radio", "selected")) {
|
|
var recurEndDate = getElementValue("repeat-end-date-picker");
|
|
recRule.endDate = jsDateToFloatingDateTime(recurEndDate);
|
|
}
|
|
|
|
// don't allow for a null interval here; js
|
|
// silently converts that to 0, which confuses
|
|
// libical.
|
|
var recurInterval = getElementValue("repeat-length-field");
|
|
if (recurInterval == null)
|
|
recurInterval = 1;
|
|
recRule.interval = recurInterval;
|
|
recRule.type = getElementValue("repeat-length-units");
|
|
|
|
switch(recRule.type) {
|
|
case "WEEKLY":
|
|
var checkedState;
|
|
var byDay = new Array();
|
|
for (var i = 0; i < 7; i++) {
|
|
checkedState = getElementValue("advanced-repeat-week-" + i, "checked");
|
|
if (checkedState) {
|
|
byDay.push(i + 1);
|
|
}
|
|
}
|
|
recRule.setComponent("BYDAY", byDay.length, byDay);
|
|
break;
|
|
case "MONTHLY":
|
|
if (getElementValue("advanced-repeat-dayofweek", "selected")) {
|
|
var dow = getElementValue("start-datetime").getDay() + 1;
|
|
var weekno = getWeekNumberOfMonth();
|
|
recRule.setComponent("BYDAY", 1, [weekno * 8 + dow]);
|
|
}
|
|
break;
|
|
}
|
|
|
|
recurrenceInfo.appendRecurrenceItem(recRule);
|
|
|
|
// Exceptions
|
|
var listbox = document.getElementById("exception-dates-listbox");
|
|
|
|
var exceptionArray = new Array();
|
|
for (i = 0; i < listbox.childNodes.length; i++) {
|
|
dump ("valuestr '" + listbox.childNodes[i].value + "'\n");
|
|
var dateObj = new Date(parseInt(listbox.childNodes[i].value));
|
|
var dt = jsDateToFloatingDateTime(dateObj);
|
|
dt.isDate = true;
|
|
|
|
var dateitem = new calRecurrenceDate();
|
|
dateitem.isNegative = true;
|
|
dateitem.date = dt;
|
|
recurrenceInfo.appendRecurrenceItem(dateitem);
|
|
}
|
|
|
|
// Finally, set the recurrenceInfo
|
|
event.recurrenceInfo = recurrenceInfo;
|
|
}
|
|
|
|
|
|
// INVITEES ----------------------------------------------------------
|
|
event.removeAllAttendees();
|
|
var attendeeList = document.getElementById("bucketBody").getElementsByTagName("treecell");
|
|
for (i = 0; i < attendeeList.length; i++) {
|
|
label = attendeeList[i].getAttribute("label");
|
|
attendee = createAttendee();
|
|
attendee.id = label;
|
|
event.addAttendee(attendee);
|
|
}
|
|
|
|
if (getElementValue("invite-checkbox", "checked"))
|
|
event.setProperty("inviteEmailAddress", getElementValue("invite-email-field"));
|
|
else
|
|
event.deleteProperty("inviteEmailAddress");
|
|
|
|
|
|
// ATTACHMENTS -------------------------------------------------------
|
|
/* XXX this could will work when attachments are supported by calItemBase
|
|
var attachmentListbox = documentgetElementById("attachmentBucket");
|
|
var attachments = event.attachments.QueryInterface(Components.interfaces.nsIMutableArray);
|
|
|
|
attachments.clear();
|
|
for (i = 0; i < attachmentListbox.childNodes.length; i++) {
|
|
attachment = Components.classes["@mozilla.org/calendar/attachment;1"].createInstance(Components.interfaces.calIAttachment);
|
|
attachment.url = makeURL(attachmentListbox.childNodes[i].getAttribute("label"));
|
|
attachments.appendElement(attachment);
|
|
}
|
|
*/
|
|
|
|
|
|
var calendar = document.getElementById("server-field").selectedItem.calendar;
|
|
|
|
// :TODO: REALLY only do this if the alarm or start settings change.
|
|
// if the end time is later than the start time... alert the user using text from the dtd.
|
|
// call caller's on OK function
|
|
|
|
gOnOkFunction(event, calendar, originalEvent);
|
|
|
|
// tell standard dialog stuff to close the dialog
|
|
return true;
|
|
}
|
|
|
|
|
|
/*
|
|
* Compare dateA with dateB ignoring time of day of each date object.
|
|
* Comparison based on year, month, and day, ignoring rest.
|
|
* Returns
|
|
* -1 if dateA < dateB (ignoring time of day)
|
|
* 0 if dateA == dateB (ignoring time of day)
|
|
* +1 if dateA > dateB (ignoring time of day)
|
|
*/
|
|
function compareIgnoringTimeOfDay(dateA, dateB)
|
|
{
|
|
if (dateA.getFullYear() == dateB.getFullYear() &&
|
|
dateA.getMonth() == dateB.getMonth() &&
|
|
dateA.getDate() == dateB.getDate() ) {
|
|
return 0;
|
|
} else if (dateA < dateB) {
|
|
return -1;
|
|
} else if (dateA > dateB) {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Check that end date is not before start date, and update warning message
|
|
* Return true if problem found.
|
|
*/
|
|
function checkSetTimeDate()
|
|
{
|
|
var startDate = getElementValue("start-datetime");
|
|
var endDate = getElementValue("end-datetime");
|
|
var dateComparison = compareIgnoringTimeOfDay(endDate, startDate);
|
|
|
|
if (dateComparison < 0) {
|
|
// end date before start date
|
|
setDateError(true);
|
|
setTimeError(false);
|
|
return false;
|
|
} else if (dateComparison == 0) {
|
|
// ok even for all day events, end date will become exclusive when saved.
|
|
setDateError(false);
|
|
// start & end date same, so compare entire time (ms since 1970) if not allday.
|
|
var isAllDay = getElementValue("all-day-event-checkbox", "checked");
|
|
var isBadEndTime = (!isAllDay && (endDate.getTime() < startDate.getTime()));
|
|
setTimeError(isBadEndTime);
|
|
return !isBadEndTime;
|
|
} else {
|
|
// endDate > startDate
|
|
setDateError(false);
|
|
setTimeError(false);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Check that the recurrence end date is after the end date of the event.
|
|
* Unlike the time/date versions this one sets the error message too as it
|
|
* doesn't depend on the outcome of any of the other tests
|
|
*/
|
|
function checkSetRecur()
|
|
{
|
|
var endDate = getElementValue("end-datetime");
|
|
var recur = getElementValue("repeat-checkbox", "checked");
|
|
var recurUntil = getElementValue("repeat-until-radio", "selected");
|
|
var recurUntilDate = getElementValue("repeat-end-date-picker");
|
|
|
|
var untilDateIsBeforeEndDate =
|
|
( recur && recurUntil &&
|
|
// until date is less than end date if total milliseconds time is less
|
|
recurUntilDate.getTime() < endDate.getTime() &&
|
|
// if on same day, ignore time of day for now
|
|
// (may change in future for repeats within a day, such as hourly)
|
|
!( recurUntilDate.getFullYear() == endDate.getFullYear() &&
|
|
recurUntilDate.getMonth() == endDate.getMonth() &&
|
|
recurUntilDate.getDate() == endDate.getDate() ) );
|
|
setRecurError(untilDateIsBeforeEndDate);
|
|
|
|
var missingField = false;
|
|
|
|
// Make sure the user puts data in all the necessary fields
|
|
if (getElementValue("repeat-numberoftimes-radio", "selected") &&
|
|
!hasPositiveIntegerValue("repeat-numberoftimes-textbox")) {
|
|
setElementValue("repeat-numberoftimes-warning", false, "hidden");
|
|
missingField = true;
|
|
}
|
|
else
|
|
setElementValue("repeat-numberoftimes-warning", true, "hidden");
|
|
|
|
if (getElementValue("repeat-checkbox", "checked")) {
|
|
if (!hasPositiveIntegerValue("repeat-length-field")) {
|
|
setElementValue("repeat-interval-warning", false, "hidden");
|
|
missingField = true;
|
|
}
|
|
else
|
|
setElementValue("repeat-interval-warning", true, "hidden");
|
|
}
|
|
// If recur isn't selected, there shouldn't be warnings.
|
|
else {
|
|
missingField = false;
|
|
setElementValue("repeat-numberoftimes-warning", true, "hidden");
|
|
setElementValue("repeat-interval-warning", true, "hidden");
|
|
}
|
|
|
|
return (!untilDateIsBeforeEndDate && !missingField);
|
|
}
|
|
|
|
|
|
/*
|
|
* Called when the start or due datetime checkbox is clicked.
|
|
* Enables/disables corresponding datetime picker and alarm relation.
|
|
*/
|
|
function onDateTimeCheckbox(checkbox, pickerId)
|
|
{
|
|
setElementValue(pickerId, !checkbox.checked, "disabled");
|
|
processAlarmType();
|
|
updateOKButton();
|
|
}
|
|
|
|
|
|
function setRecurError(state)
|
|
{
|
|
setElementValue("repeat-time-warning", !state, "hidden");
|
|
}
|
|
|
|
|
|
function setDateError(state)
|
|
{
|
|
setElementValue("end-date-warning", !state, "hidden");
|
|
}
|
|
|
|
|
|
function setTimeError(state)
|
|
{
|
|
setElementValue("end-time-warning", !state, "hidden");
|
|
}
|
|
|
|
/*
|
|
* Check that start datetime <= due datetime if both exist.
|
|
* Provide separate error message for startDate > dueDate or
|
|
* startDate == dueDate && startTime > dueTime.
|
|
*/
|
|
function checkDueSetTimeDate()
|
|
{
|
|
var startCheckbox = getElementValue("start-checkbox", "checked");
|
|
var dueCheckbox = getElementValue("due-checkbox", "checked");
|
|
|
|
if (startCheckbox && dueCheckbox) {
|
|
var startDate = getElementValue("start-datetime");
|
|
var dueDate = getElementValue("due-datetime");
|
|
var dateComparison = compareIgnoringTimeOfDay(dueDate, startDate);
|
|
if ( dateComparison < 0 ) {
|
|
// due before start
|
|
setDueDateError(true);
|
|
setDueTimeError(false);
|
|
return false;
|
|
} else if ( dateComparison == 0 ) {
|
|
setDueDateError(false);
|
|
var isBadEndTime = dueDate.getTime() < startDate.getTime();
|
|
setDueTimeError(isBadEndTime);
|
|
return !isBadEndTime;
|
|
}
|
|
}
|
|
setDueDateError(false);
|
|
setDueTimeError(false);
|
|
return true;
|
|
}
|
|
|
|
|
|
function setDueDateError(state)
|
|
{
|
|
setElementValue("due-date-warning", !state, "hidden");
|
|
}
|
|
|
|
|
|
function setDueTimeError(state)
|
|
{
|
|
setElementValue("due-time-warning", !state, "hidden");
|
|
}
|
|
|
|
|
|
function setOkButton(state)
|
|
{
|
|
if (state == false)
|
|
document.getElementById("calendar-new-component-window").getButton("accept").setAttribute("disabled", true);
|
|
else
|
|
document.getElementById("calendar-new-component-window").getButton("accept").removeAttribute("disabled");
|
|
}
|
|
|
|
|
|
function updateOKButton()
|
|
{
|
|
var notReadOnly = checkReadOnlyCal();
|
|
var checkRecur = checkSetRecur();
|
|
var componentType = getElementValue("component-type");
|
|
var checkTimeDate;
|
|
if (componentType == "event")
|
|
checkTimeDate = checkSetTimeDate();
|
|
else
|
|
checkTimeDate = checkDueSetTimeDate();
|
|
setOkButton(checkRecur && checkTimeDate && notReadOnly);
|
|
//this.sizeToContent();
|
|
}
|
|
|
|
function checkReadOnlyCal() {
|
|
setElementValue("read-only-item", !gReadOnlyMode, "hidden");
|
|
if (gReadOnlyMode)
|
|
return false;
|
|
var cal = document.getElementById("server-field").selectedItem.calendar;
|
|
setElementValue("read-only-cal", !cal.readOnly, "hidden");
|
|
return !cal.readOnly;
|
|
}
|
|
|
|
function updateDuration() {
|
|
var startDate = getElementValue("start-datetime");
|
|
var endDate = new Date(getElementValue("end-datetime"));
|
|
if (getElementValue("all-day-event-checkbox", "checked")) {
|
|
// all-day display end date is inclusive end date
|
|
// but duration depends on exclusive end date
|
|
endDate.setDate(endDate.getDate() + 1);
|
|
}
|
|
gDurationMSec = endDate - startDate;
|
|
}
|
|
|
|
|
|
function onDueDateTimePick(dateTimePicker) {
|
|
// check for due < start
|
|
updateOKButton();
|
|
return;
|
|
}
|
|
|
|
function onEndDateTimePick(dateTimePicker) {
|
|
updateDuration();
|
|
// check for end < start
|
|
updateOKButton();
|
|
return;
|
|
}
|
|
|
|
function onStartDateTimePick(dateTimePicker) {
|
|
var startDate = new Date(dateTimePicker.value);
|
|
|
|
// update the end date keeping the same duration
|
|
var displayEndDate = new Date(startDate.getTime() + gDurationMSec);
|
|
if (getElementValue("all-day-event-checkbox", "checked")) {
|
|
// all-day display end date is inclusive end date
|
|
// but duration depends on exclusive end date
|
|
displayEndDate.setDate( displayEndDate.getDate() - 1 );
|
|
}
|
|
setElementValue("end-datetime", displayEndDate);
|
|
|
|
// Initialize the until-date picker for recurring events to picked day,
|
|
// if the picked date is in future and repeat is not checked.
|
|
// UNTIL dates may be last occurrence start date, inclusive
|
|
// [rfc2445sec4.3.10].
|
|
if (startDate > new Date() && !getElementValue("repeat-checkbox", "checked")) {
|
|
setElementValue("repeat-end-date-picker", startDate);
|
|
}
|
|
|
|
updateAdvancedWeekRepeat();
|
|
updateAdvancedRepeatDayOfMonth();
|
|
updateAddExceptionButton();
|
|
updateOKButton();
|
|
}
|
|
|
|
|
|
/*
|
|
* Called when the repeat checkbox is clicked.
|
|
*/
|
|
function commandRepeat()
|
|
{
|
|
updateRepeatItemEnabled();
|
|
}
|
|
|
|
|
|
/*
|
|
* Called when the until radio is clicked.
|
|
*/
|
|
function commandUntil()
|
|
{
|
|
updateUntilItemEnabled();
|
|
updateOKButton();
|
|
}
|
|
|
|
|
|
/*
|
|
* Called when the all day checkbox is clicked.
|
|
*/
|
|
function commandAllDay()
|
|
{
|
|
updateDuration(); // Same start/end means 24hrs if all-day, 0hrs if not.
|
|
updateStartEndItemEnabled();
|
|
updateOKButton();
|
|
}
|
|
|
|
|
|
/*
|
|
* Called when the invite checkbox is clicked.
|
|
*/
|
|
function processInviteCheckbox()
|
|
{
|
|
processEnableCheckbox("invite-checkbox" , "invite-email-field");
|
|
}
|
|
|
|
|
|
/*
|
|
* Enable/Disable Repeat items
|
|
*/
|
|
function updateRepeatItemEnabled()
|
|
{
|
|
var repeatDisableList = document.getElementsByAttribute("disable-controller", "repeat");
|
|
|
|
if ( getElementValue("repeat-checkbox", "checked") ) {
|
|
for( var i = 0; i < repeatDisableList.length; ++i ) {
|
|
if( repeatDisableList[i].getAttribute("today") != "true" )
|
|
repeatDisableList[i].removeAttribute("disabled");
|
|
}
|
|
} else {
|
|
for( var j = 0; j < repeatDisableList.length; ++j )
|
|
repeatDisableList[j].setAttribute("disabled", "true");
|
|
}
|
|
|
|
// udpate plural/singular
|
|
updateRepeatPlural();
|
|
updateAlarmPlural();
|
|
|
|
// update until items whenever repeat changes
|
|
updateUntilItemEnabled();
|
|
|
|
// extra interface depending on units
|
|
updateRepeatUnitExtensions();
|
|
|
|
// show/hide the exception buttons
|
|
updateAddExceptionButton();
|
|
updateDeleteExceptionButton();
|
|
}
|
|
|
|
|
|
/*
|
|
* Update plural singular menu items
|
|
*/
|
|
function updateRepeatPlural()
|
|
{
|
|
updateMenuLabels("repeat-length-field", "repeat-length-units");
|
|
}
|
|
|
|
|
|
function updateAlarmPlural()
|
|
{
|
|
updateMenuLabels("alarm-length-field", "alarm-length-units");
|
|
}
|
|
|
|
|
|
/*
|
|
* Enable/Disable Until items
|
|
*/
|
|
function updateUntilItemEnabled()
|
|
{
|
|
if (getElementValue("repeat-checkbox", "checked") &&
|
|
getElementValue("repeat-numberoftimes-radio", "selected") ) {
|
|
enableElement("repeat-numberoftimes-textbox");
|
|
} else
|
|
disableElement("repeat-numberoftimes-textbox");
|
|
|
|
if (getElementValue("repeat-checkbox", "checked") &&
|
|
getElementValue("repeat-until-radio", "selected") ) {
|
|
enableElement("repeat-end-date-picker");
|
|
} else
|
|
disableElement("repeat-end-date-picker");
|
|
}
|
|
|
|
|
|
function updateRepeatUnitExtensions()
|
|
{
|
|
var repeatMenu = document.getElementById( "repeat-length-units" );
|
|
if( repeatMenu.selectedItem ) {
|
|
switch( repeatMenu.selectedItem.value ) {
|
|
case "DAILY":
|
|
hideElement("repeat-extensions-week");
|
|
hideElement("repeat-extensions-month");
|
|
break;
|
|
case "WEEKLY":
|
|
showElement("repeat-extensions-week");
|
|
hideElement("repeat-extensions-month");
|
|
updateAdvancedWeekRepeat();
|
|
break;
|
|
case "MONTHLY":
|
|
hideElement("repeat-extensions-week");
|
|
showElement("repeat-extensions-month");
|
|
//the following line causes resize problems after turning on repeating events
|
|
updateAdvancedRepeatDayOfMonth();
|
|
break;
|
|
case "YEARLY":
|
|
hideElement("repeat-extensions-week");
|
|
hideElement("repeat-extensions-month");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Enable/Disable Start/End items
|
|
*/
|
|
function updateStartEndItemEnabled()
|
|
{
|
|
var editTimeDisabled = getElementValue("all-day-event-checkbox", "checked");
|
|
setElementValue("start-datetime", editTimeDisabled, "timepickerdisabled");
|
|
setElementValue("end-datetime", editTimeDisabled, "timepickerdisabled");
|
|
}
|
|
|
|
|
|
/*
|
|
* Handle key down in repeat field
|
|
*/
|
|
function repeatLengthKeyDown( repeatField )
|
|
{
|
|
updateRepeatPlural();
|
|
}
|
|
|
|
|
|
/*
|
|
* Handle key down in alarm field
|
|
*/
|
|
function alarmLengthKeyDown( repeatField )
|
|
{
|
|
updateAlarmPlural();
|
|
}
|
|
|
|
|
|
function repeatUnitCommand( repeatMenu )
|
|
{
|
|
updateRepeatUnitExtensions();
|
|
}
|
|
|
|
|
|
/*
|
|
* function to set the menu items text
|
|
*/
|
|
function updateAdvancedWeekRepeat()
|
|
{
|
|
//get the day number for today.
|
|
var dayNumber = getElementValue("start-datetime").getDay();
|
|
|
|
//uncheck them all if the repeat checkbox is checked
|
|
var repeatCheckBox = getElementValue("repeat-checkbox", "checked");
|
|
|
|
if(repeatCheckBox) {
|
|
//uncheck them all
|
|
for( var i = 0; i < 7; i++ ) {
|
|
setElementValue("advanced-repeat-week-"+i, false, "disabled");
|
|
setElementValue("advanced-repeat-week-"+i, false, "today");
|
|
}
|
|
}
|
|
|
|
if(!repeatCheckBox) {
|
|
for( i = 0; i < 7; i++ ) {
|
|
setElementValue("advanced-repeat-week-"+i, false, "checked");
|
|
}
|
|
}
|
|
|
|
setElementValue("advanced-repeat-week-"+dayNumber, "true", "checked" );
|
|
setElementValue("advanced-repeat-week-"+dayNumber, "true", "disabled");
|
|
setElementValue("advanced-repeat-week-"+dayNumber, "true", "today" );
|
|
}
|
|
|
|
|
|
/*
|
|
* function to set the menu items text
|
|
*/
|
|
function updateAdvancedRepeatDayOfMonth()
|
|
{
|
|
//get the day number for today.
|
|
var dayNumber = getElementValue("start-datetime").getDate();
|
|
var dayExtension = getDayExtension(dayNumber);
|
|
var weekNumber = getWeekNumberOfMonth();
|
|
var calStrings = document.getElementById("bundle_calendar");
|
|
var weekNumberText = getWeekNumberText(weekNumber);
|
|
var dayOfWeekText = getDayOfWeek(dayNumber);
|
|
var ofTheMonthText = document.getElementById("ofthemonth-text" ).getAttribute("value");
|
|
var lastText = document.getElementById("last-text" ).getAttribute("value");
|
|
var onTheText = document.getElementById("onthe-text").getAttribute("value");
|
|
var dayNumberWithOrdinal = dayNumber + dayExtension;
|
|
var repeatSentence = calStrings.getFormattedString( "weekDayMonthLabel", [onTheText, dayNumberWithOrdinal, ofTheMonthText] );
|
|
|
|
document.getElementById("advanced-repeat-dayofmonth").setAttribute("label", repeatSentence);
|
|
|
|
if( weekNumber == 4 && isLastDayOfWeekOfMonth() ) {
|
|
document.getElementById( "advanced-repeat-dayofweek" ).setAttribute( "label", calStrings.getFormattedString( "weekDayMonthLabel", [weekNumberText, dayOfWeekText, ofTheMonthText] ) );
|
|
showElement("advanced-repeat-dayofweek-last");
|
|
document.getElementById( "advanced-repeat-dayofweek-last" ).setAttribute( "label", calStrings.getFormattedString( "weekDayMonthLabel", [lastText, dayOfWeekText, ofTheMonthText] ) );
|
|
} else if( weekNumber == 4 && !isLastDayOfWeekOfMonth() ) {
|
|
document.getElementById( "advanced-repeat-dayofweek" ).setAttribute( "label", calStrings.getFormattedString( "weekDayMonthLabel", [weekNumberText, dayOfWeekText, ofTheMonthText] ) );
|
|
hideElement("advanced-repeat-dayofweek-last");
|
|
} else {
|
|
document.getElementById( "advanced-repeat-dayofweek" ).setAttribute( "label", calStrings.getFormattedString( "weekDayMonthLabel", [weekNumberText, dayOfWeekText, ofTheMonthText] ) );
|
|
hideElement("advanced-repeat-dayofweek-last");
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* function to enable or disable the add exception button
|
|
*/
|
|
|
|
function updateAddExceptionButton()
|
|
{
|
|
//get the date from the picker
|
|
var datePickerValue = getElementValue("exceptions-date-picker");
|
|
|
|
if( isAlreadyException( datePickerValue ) || !getElementValue("repeat-checkbox", "checked") )
|
|
disableElement("exception-add-button");
|
|
else
|
|
enableElement("exception-add-button");
|
|
}
|
|
|
|
|
|
function updateDeleteExceptionButton()
|
|
{
|
|
if (!getElementValue("repeat-checkbox", "checked"))
|
|
disableElement("delete-exception-button");
|
|
else
|
|
updateListboxDeleteButton("exception-dates-listbox", "delete-exception-button");
|
|
}
|
|
|
|
|
|
function removeSelectedExceptionDate()
|
|
{
|
|
var exceptionsListbox = document.getElementById("exception-dates-listbox");
|
|
var SelectedItem = exceptionsListbox.selectedItem;
|
|
|
|
if ( SelectedItem )
|
|
exceptionsListbox.removeChild( SelectedItem );
|
|
|
|
// the file list changed - see if we have to enable/disable any buttons
|
|
updateAddExceptionButton()
|
|
updateDeleteExceptionButton();
|
|
}
|
|
|
|
|
|
function addException(dateToAdd)
|
|
{
|
|
if (!dateToAdd) {
|
|
// get the date from the date and time box.
|
|
// returns a date object
|
|
dateToAdd = getElementValue("exceptions-date-picker");
|
|
}
|
|
|
|
if ( isAlreadyException( dateToAdd ) )
|
|
return;
|
|
|
|
var DateLabel = (new DateFormater()).getFormatedDate(dateToAdd);
|
|
|
|
// add a row to the listbox.
|
|
var listbox = document.getElementById("exception-dates-listbox");
|
|
// ensure user can see that add occurred (also, avoid bug 231765, bug 250123)
|
|
listbox.ensureElementIsVisible( listbox.appendItem( DateLabel, dateToAdd.getTime() ));
|
|
|
|
// the file list changed - see if we have to enable/disable any buttons
|
|
updateAddExceptionButton()
|
|
updateDeleteExceptionButton();
|
|
}
|
|
|
|
|
|
function isAlreadyException(dateObj)
|
|
{
|
|
//check to make sure that the date is not already added.
|
|
var listbox = document.getElementById( "exception-dates-listbox" );
|
|
|
|
for( var i = 0; i < listbox.childNodes.length; i++ ) {
|
|
var dateToMatch = new Date( );
|
|
|
|
dateToMatch.setTime( listbox.childNodes[i].value );
|
|
if( dateToMatch.getMonth() == dateObj.getMonth() && dateToMatch.getFullYear() == dateObj.getFullYear() && dateToMatch.getDate() == dateObj.getDate() )
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
function getDayExtension(dayNumber)
|
|
{
|
|
var dateStringBundle = srGetStrBundle("chrome://calendar/locale/dateFormat.properties");
|
|
|
|
if ( dayNumber >= 1 && dayNumber <= 31 )
|
|
return( dateStringBundle.GetStringFromName( "ordinal.suffix."+dayNumber ) );
|
|
else {
|
|
dump("ERROR: Invalid day number: " + dayNumber);
|
|
return ( false );
|
|
}
|
|
}
|
|
|
|
|
|
function getDayOfWeek()
|
|
{
|
|
//get the day number for today.
|
|
var dayNumber = getElementValue("start-datetime").getDay();
|
|
|
|
var dateStringBundle = srGetStrBundle("chrome://calendar/locale/dateFormat.properties");
|
|
|
|
//add one to the dayNumber because in the above prop. file, it starts at day1, but JS starts at 0
|
|
var oneBasedDayNumber = parseInt(dayNumber) + 1;
|
|
|
|
return(dateStringBundle.GetStringFromName("day." + oneBasedDayNumber + ".name") );
|
|
}
|
|
|
|
|
|
function getWeekNumberOfMonth()
|
|
{
|
|
//get the day number for today.
|
|
var startTime = getElementValue("start-datetime");
|
|
var oldStartTime = startTime;
|
|
var thisMonth = startTime.getMonth();
|
|
var monthToCompare = thisMonth;
|
|
var weekNumber = 0;
|
|
|
|
while(monthToCompare == thisMonth) {
|
|
startTime = new Date( startTime.getTime() - ( 1000 * 60 * 60 * 24 * 7 ) );
|
|
monthToCompare = startTime.getMonth();
|
|
weekNumber++;
|
|
}
|
|
|
|
return(weekNumber);
|
|
}
|
|
|
|
|
|
function isLastDayOfWeekOfMonth()
|
|
{
|
|
//get the day number for today.
|
|
var startTime = getElementValue("start-datetime");
|
|
var oldStartTime = startTime;
|
|
var thisMonth = startTime.getMonth();
|
|
var monthToCompare = thisMonth;
|
|
var weekNumber = 0;
|
|
|
|
while(monthToCompare == thisMonth) {
|
|
startTime = new Date( startTime.getTime() - ( 1000 * 60 * 60 * 24 * 7 ) );
|
|
monthToCompare = startTime.getMonth();
|
|
weekNumber++;
|
|
}
|
|
|
|
if (weekNumber > 3) {
|
|
var nextWeek = new Date( oldStartTime.getTime() + ( 1000 * 60 * 60 * 24 * 7 ) );
|
|
|
|
if (nextWeek.getMonth() != thisMonth) {
|
|
//its the last week of the month
|
|
return(true);
|
|
}
|
|
}
|
|
return(false);
|
|
}
|
|
|
|
|
|
function getWeekNumberText(weekNumber)
|
|
{
|
|
var dateStringBundle = srGetStrBundle("chrome://calendar/locale/dateFormat.properties");
|
|
if ( weekNumber >= 1 && weekNumber <= 4 )
|
|
return( dateStringBundle.GetStringFromName( "ordinal.name."+weekNumber) );
|
|
else if ( weekNumber == 5 )
|
|
return( dateStringBundle.GetStringFromName( "ordinal.name.last" ) );
|
|
else
|
|
return(false);
|
|
}
|
|
|
|
|
|
/* FILE ATTACHMENTS */
|
|
|
|
function removeSelectedAttachment()
|
|
{
|
|
var attachmentListbox = document.getElementById("attachmentBucket");
|
|
var SelectedItem = attachmentListbox.selectedItem;
|
|
|
|
if(SelectedItem)
|
|
attachmentListbox.removeChild(SelectedItem);
|
|
|
|
updateRemoveAttachmentButton()
|
|
}
|
|
|
|
|
|
function addAttachment(attachmentToAdd)
|
|
{
|
|
if( !attachmentToAdd || isAlreadyAttachment(attachmentToAdd) )
|
|
return;
|
|
|
|
//add a row to the listbox
|
|
document.getElementById("attachmentBucket").appendItem(attachmentToAdd.url, attachmentToAdd.url);
|
|
|
|
updateRemoveAttachmentButton();
|
|
}
|
|
|
|
|
|
function isAlreadyAttachment(attachmentToAdd)
|
|
{
|
|
//check to make sure that the file is not already attached
|
|
var listbox = document.getElementById("attachmentBucket");
|
|
|
|
for( var i = 0; i < listbox.childNodes.length; i++ ) {
|
|
if( attachmentToAdd.url == listbox.childNodex[i].url )
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
function updateRemoveAttachmentButton()
|
|
{
|
|
updateListboxDeleteButton("attachmentBucket", "attachment-delete-button");
|
|
}
|
|
|
|
|
|
/* URL */
|
|
|
|
var launch = true;
|
|
|
|
function loadURL()
|
|
{
|
|
if( launch == false ) //stops them from clicking on it twice
|
|
return;
|
|
|
|
launch = false;
|
|
//get the URL from the text box
|
|
var UrlToGoTo = getElementValue("uri-field");
|
|
|
|
//it has to be > 4, since it needs at least 1 letter, a . and a two letter domain name.
|
|
if(UrlToGoTo.length < 4)
|
|
return;
|
|
|
|
//check if it has a : in it
|
|
if(UrlToGoTo.indexOf( ":" ) == -1)
|
|
UrlToGoTo = "http://"+UrlToGoTo;
|
|
|
|
//launch the browser to that URL
|
|
launchBrowser( UrlToGoTo );
|
|
launch = true;
|
|
}
|
|
|
|
/*
|
|
* A textbox changed - see if its button needs to be enabled or disabled
|
|
*/
|
|
function processTextboxWithButton( textboxId, buttonId )
|
|
{
|
|
var theTextbox = document.getElementById( textboxId );
|
|
var theButton = document.getElementById( buttonId );
|
|
|
|
// Only change things if we have to
|
|
if ( theTextbox.textLength == 0 && !theButton.disabled ) {
|
|
disableElement( buttonId );
|
|
} else if ( theTextbox.textLength > 0 && theButton.disabled ) {
|
|
enableElement( buttonId );
|
|
}
|
|
}
|
|
|
|
|
|
function processAlarmType()
|
|
{
|
|
var alarmMenu = document.getElementById("alarm-type");
|
|
var componentType = getElementValue("component-type");
|
|
if( alarmMenu.selectedItem ) {
|
|
if( componentType == "event" ) {
|
|
switch( alarmMenu.selectedItem.value ) {
|
|
case "none":
|
|
disableElement("alarm-length-field");
|
|
disableElement("alarm-length-units");
|
|
disableElement("alarm-trigger-relation");
|
|
disableElement("before-this-event-label");
|
|
disableElement("alarm-email-field-label");
|
|
disableElement("alarm-email-field");
|
|
break;
|
|
//case "popupAndSound":
|
|
case "popup":
|
|
enableElement("alarm-length-field");
|
|
enableElement("alarm-length-units");
|
|
enableElement("alarm-trigger-relation");
|
|
enableElement("before-this-event-label");
|
|
disableElement("alarm-email-field-label");
|
|
disableElement("alarm-email-field");
|
|
break;
|
|
case "email":
|
|
enableElement("alarm-length-field");
|
|
enableElement("alarm-length-units");
|
|
enableElement("alarm-trigger-relation");
|
|
enableElement("before-this-event-label");
|
|
enableElement("alarm-email-field-label");
|
|
enableElement("alarm-email-field");
|
|
break;
|
|
}
|
|
} else if( componentType == "todo" ) {
|
|
var startChecked = getElementValue("start-checkbox", "checked");
|
|
var dueChecked = getElementValue("due-checkbox", "checked");
|
|
|
|
// disable alarms if and only if neither checked
|
|
if ( (!startChecked && !dueChecked) ) {
|
|
menuListSelectItem("alarm-type", "none");
|
|
disableElement("alarm-length-field");
|
|
disableElement("alarm-length-units");
|
|
disableElement("alarm-trigger-relation");
|
|
disableElement("before-this-todo-label");
|
|
disableElement("alarm-email-field-label");
|
|
disableElement("alarm-email-field");
|
|
disableElement("alarm-type");
|
|
} else {
|
|
enableElement("alarm-type")
|
|
switch( alarmMenu.selectedItem.value ) {
|
|
case "none":
|
|
disableElement("alarm-length-field");
|
|
disableElement("alarm-length-units");
|
|
disableElement("alarm-trigger-relation");
|
|
disableElement("before-this-todo-label");
|
|
disableElement("alarm-email-field-label");
|
|
disableElement("alarm-email-field");
|
|
break;
|
|
//case "popupAndSound":
|
|
case "popup":
|
|
enableElement("alarm-length-field");
|
|
enableElement("alarm-length-units");
|
|
enableElement("before-this-todo-label");
|
|
disableElement("alarm-email-field-label");
|
|
disableElement("alarm-email-field");
|
|
if (startChecked && !dueChecked) {
|
|
menuListSelectItem("alarm-trigger-relation", "START");
|
|
disableElement("alarm-trigger-relation");
|
|
} else if (!startChecked && dueChecked) {
|
|
menuListSelectItem("alarm-trigger-relation", "END");
|
|
disableElement("alarm-trigger-relation");
|
|
} else {
|
|
enableElement("alarm-trigger-relation");
|
|
}
|
|
break;
|
|
case "email":
|
|
enableElement("alarm-length-field");
|
|
enableElement("alarm-length-units");
|
|
enableElement("before-this-todo-label");
|
|
enableElement("alarm-email-field-label");
|
|
enableElement("alarm-email-field");
|
|
if (startChecked && !dueChecked) {
|
|
menuListSelectItem("alarm-trigger-relation", "START");
|
|
disableElement("alarm-trigger-relation");
|
|
} else if (!startChecked && dueChecked) {
|
|
menuListSelectItem("alarm-trigger-relation", "END");
|
|
disableElement("alarm-trigger-relation");
|
|
} else {
|
|
enableElement("alarm-trigger-relation");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
} else
|
|
dump("processAlarmType: ERROR! Invalid componentType passed: \n");
|
|
} else
|
|
dump("processAlarmType: ERROR! No alarmMenu.selectedItem!\n");
|
|
}
|
|
|
|
|
|
function processComponentType(componentType)
|
|
{
|
|
switch( componentType ) {
|
|
case "event":
|
|
// Hide and show the appropriate fields and widgets
|
|
changeMenuState("todo", "event");
|
|
// Set the menu properly if it isn't already
|
|
menuListSelectItem("component-type", "event");
|
|
// calling just enableElement _should_ work here, but it doesn't
|
|
setElementValue("start-datetime", false, "disabled");
|
|
enableElement("start-datetime");
|
|
enableElement("end-datetime");
|
|
// Set alarm trigger menulist text correctly (using singular/plural code)
|
|
setElementValue("alarm-trigger-text-kludge", "2"); // event text is "plural"
|
|
updateMenuLabels("alarm-trigger-text-kludge", "alarm-trigger-relation");
|
|
enableElement("alarm-type")
|
|
// Set menubar title correctly
|
|
changeTitleBar("event");
|
|
break;
|
|
case "todo":
|
|
// Hide and show the appropriate fields and widgets
|
|
changeMenuState("event", "todo");
|
|
// Set the menu properly if it isn't already
|
|
menuListSelectItem("component-type", "todo");
|
|
// Enable/disable date/time pickers as need be
|
|
onDateTimeCheckbox("start-checkbox", "start-datetime");
|
|
onDateTimeCheckbox("due-checkbox", "due-datetime");
|
|
// Set alarm trigger menulist text correctly (using singular/plural code)
|
|
setElementValue("alarm-trigger-text-kludge", "1"); // todo text is "singular"
|
|
updateMenuLabels("alarm-trigger-text-kludge", "alarm-trigger-relation");
|
|
// Set menubar title correctly
|
|
changeTitleBar("todo");
|
|
break;
|
|
//case "journal":
|
|
default:
|
|
// We were passed an invalid value:
|
|
dump("processComponentType: ERROR! Tried to select invalid component type: "+componentType+"\n");
|
|
break;
|
|
}
|
|
processAlarmType();
|
|
}
|
|
|
|
|
|
/*
|
|
* Hides/shows/enables/disables fields and widgets using "hidden-controller"
|
|
* and "disable-controller" in the .xul
|
|
*/
|
|
function changeMenuState(hiddenController, showController, disableController, enableController)
|
|
{
|
|
var hiddenList = document.getElementsByAttribute( "hidden-controller", hiddenController );
|
|
var showList = document.getElementsByAttribute( "hidden-controller", showController );
|
|
var disableList = document.getElementsByAttribute( "disable-controller", disableController );
|
|
var enableList = document.getElementsByAttribute( "disable-controller", enableController );
|
|
|
|
for( var i = 0; i < hiddenList.length; ++i ) {
|
|
hideElement( hiddenList[i].id );
|
|
}
|
|
|
|
for( i = 0; i < showList.length; ++i ) {
|
|
showElement( showList[i].id );
|
|
}
|
|
|
|
for( i = 0; i < disableList.length; ++i ) {
|
|
disableElement( disableList[i].id );
|
|
}
|
|
|
|
for( i = 0; i < enableList.length; ++i ) {
|
|
enableElement( enableList[i].id );
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Changes window title bar title ("New Event", "Edit Task", etc.)
|
|
*/
|
|
function changeTitleBar(componentType)
|
|
{
|
|
var title;
|
|
// Sanity check input
|
|
if ( componentType == "event" || componentType == "todo" ) {
|
|
var args = window.arguments[0];
|
|
|
|
// Is this a NEW event/todo, or are we EDITing an existing event/todo?
|
|
if("new" == args.mode)
|
|
title = document.getElementById("data-" + componentType + "-title-new" ).getAttribute("value");
|
|
else
|
|
title = document.getElementById("data-" + componentType + "-title-edit").getAttribute("value");
|
|
document.title = title;
|
|
} else {
|
|
dump("changeTitleBar: ERROR! Tried to change titlebar to invalid value: "+componentType+"\n");
|
|
}
|
|
}
|
|
|
|
|
|
function processToDoStatus(status, passedInCompletedDate)
|
|
{
|
|
// RFC2445 doesn't support completedDates without the todo's status
|
|
// being "COMPLETED", however twiddling the status menulist shouldn't
|
|
// nuking that information at this point (in case you change status
|
|
// back to COMPLETED). When we go to store this VTODO as .ics the
|
|
// date will get lost.
|
|
|
|
var completedDate;
|
|
if (passedInCompletedDate)
|
|
completedDate = passedInCompletedDate;
|
|
else
|
|
completedDate = null;
|
|
|
|
// remember the original values
|
|
var oldPercentComplete = getElementValue("percent-complete-menulist", "value");
|
|
var oldCompletedDate = getElementValue("completed-date-picker");
|
|
|
|
switch(status) {
|
|
case "":
|
|
case "NONE":
|
|
menuListSelectItem("todo-status-field", "NONE");
|
|
disableElement("completed-date-picker");
|
|
disableElement("percent-complete-menulist");
|
|
disableElement("percent-complete-label");
|
|
break;
|
|
case "CANCELLED":
|
|
menuListSelectItem("todo-status-field", "CANCELLED");
|
|
disableElement("completed-date-picker");
|
|
disableElement("percent-complete-menulist");
|
|
disableElement("percent-complete-label");
|
|
break;
|
|
case "COMPLETED":
|
|
menuListSelectItem("todo-status-field", "COMPLETED");
|
|
enableElement("completed-date-picker");
|
|
enableElement("percent-complete-menulist");
|
|
enableElement("percent-complete-label");
|
|
// if there isn't a completedDate, set it to now
|
|
if (!completedDate)
|
|
completedDate = new Date();
|
|
break;
|
|
case "IN-PROCESS":
|
|
menuListSelectItem("todo-status-field", "IN-PROCESS");
|
|
disableElement("completed-date-picker");
|
|
enableElement("percent-complete-menulist");
|
|
enableElement("percent-complete-label");
|
|
break;
|
|
case "NEEDS-ACTION":
|
|
menuListSelectItem("todo-status-field", "NEEDS-ACTION");
|
|
disableElement("completed-date-picker");
|
|
enableElement("percent-complete-menulist");
|
|
enableElement("percent-complete-label");
|
|
break;
|
|
}
|
|
if (status == "COMPLETED") {
|
|
setElementValue("percent-complete-menulist", "100");
|
|
setElementValue("completed-date-picker", completedDate);
|
|
} else {
|
|
setElementValue("percent-complete-menulist", oldPercentComplete);
|
|
setElementValue("completed-date-picker", oldCompletedDate);
|
|
}
|
|
}
|
|
|
|
|
|
function onInviteeAdd()
|
|
{
|
|
var email = "mailto:" + getElementValue("invite-email-field");
|
|
addAttendee(email);
|
|
}
|
|
|
|
|
|
function addAttendee(email)
|
|
{
|
|
var treeItem = document.createElement("treeitem");
|
|
var treeRow = document.createElement("treerow");
|
|
var treeCell = document.createElement("treecell");
|
|
treeCell.setAttribute("label", email);
|
|
treeItem.appendChild(treeRow);
|
|
treeRow.appendChild(treeCell);
|
|
document.getElementById("bucketBody").appendChild(treeItem);
|
|
}
|
|
|
|
|