зеркало из https://github.com/mozilla/gecko-dev.git
1451 строка
50 KiB
XML
1451 строка
50 KiB
XML
<?xml version="1.0"?>
|
|
|
|
<!--
|
|
- ***** 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 calendar views.
|
|
-
|
|
- The Initial Developer of the Original Code is
|
|
- Oracle Corporation
|
|
- Portions created by the Initial Developer are Copyright (C) 2005
|
|
- the Initial Developer. All Rights Reserved.
|
|
-
|
|
- Contributor(s):
|
|
- Vladimir Vukicevic <vladimir@pobox.com>
|
|
- Stefan Sitter <ssitter@googlemail.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 *****
|
|
-->
|
|
|
|
<!-- Note that this file depends on helper functions in calendarUtils.js-->
|
|
|
|
<bindings id="calendar-month-view-bindings"
|
|
xmlns="http://www.mozilla.org/xbl"
|
|
xmlns:html="http://www.w3.org/1999/xhtml"
|
|
xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
|
|
xmlns:xbl="http://www.mozilla.org/xbl">
|
|
|
|
<binding id="calendar-month-day-box-item" extends="chrome://calendar/content/calendar-view-core.xml#calendar-editable-item">
|
|
<content>
|
|
<xul:hbox flex="1" class="calendar-item">
|
|
<xul:label anonid="item-label" class="calendar-month-day-box-item-label" xbl:inherits="context"/>
|
|
<xul:vbox class="calendar-event-box-container" xbl:inherits="context" flex="1" align="left">
|
|
<xul:label anonid="event-name" style="margin: 0px;" flex="1" crop="end"/>
|
|
<xul:textbox class="plain" style="background: transparent !important"
|
|
anonid="event-name-textbox" crop="end" hidden="true" wrap="true"/>
|
|
<xul:spacer flex="1"/>
|
|
</xul:vbox>
|
|
</xul:hbox>
|
|
</content>
|
|
|
|
<implementation>
|
|
<property name="occurrence">
|
|
<getter><![CDATA[
|
|
return this.mOccurrence;
|
|
]]></getter>
|
|
<setter><![CDATA[
|
|
this.mOccurrence = val;
|
|
|
|
var str = null;
|
|
// if val is an event and not an all day event, show start time in title
|
|
if (val instanceof Components.interfaces.calIEvent && !val.startDate.isDate) {
|
|
var df = Components.classes["@mozilla.org/calendar/datetime-formatter;1"]
|
|
.getService(Components.interfaces.calIDateTimeFormatter);
|
|
str = df.formatTime(val.startDate.getInTimezone(this.calendarView.mTimezone));
|
|
} else if (val instanceof Components.interfaces.calITodo) {
|
|
// yeah, this should really be a little picture instead of a "*"
|
|
str = "* ";
|
|
} else {
|
|
str = " ";
|
|
}
|
|
|
|
var label = document.getAnonymousElementByAttribute(this, "anonid", "item-label");
|
|
label.value = str;
|
|
|
|
this.setEditableLabel();
|
|
this.setCSSClasses();
|
|
]]></setter>
|
|
</property>
|
|
<property name="parentBox"
|
|
onget="return this.mParentBox;"
|
|
onset="this.mParentBox = val;"/>
|
|
</implementation>
|
|
|
|
<handlers>
|
|
<handler event="draggesture"><![CDATA[
|
|
var dragService = Components.classes["@mozilla.org/widget/dragservice;1"]
|
|
.getService(Components.interfaces.nsIDragService);
|
|
var transfer = Components.classes["@mozilla.org/widget/transferable;1"]
|
|
.createInstance(Components.interfaces.nsITransferable);
|
|
|
|
var item = this.occurrence;
|
|
transfer.addDataFlavor("text/calendar");
|
|
|
|
var flavourProvider = {
|
|
QueryInterface: function(aIID) {
|
|
if (aIID.equals(Components.interfaces.nsIFlavorDataProvider) ||
|
|
aIID.equals(Components.interfaces.nsISupports)) {
|
|
return this;
|
|
}
|
|
throw Components.results.NS_NOINTERFACE;
|
|
},
|
|
item: item,
|
|
|
|
getFlavorData: function(aInTransferable, aInFlavor, aOutData, aOutDataLen) {
|
|
if ((aInFlavor == "application/vnd.x-moz-cal-event") ||
|
|
(aInFlavor == "application/vnd.x-moz-cal-task")) {
|
|
aOutData.value = this.item;
|
|
aOutDataLen.value = 1;
|
|
return Components.results.NS_OK;
|
|
} else {
|
|
alert("error:"+aInFlavor);
|
|
}
|
|
}
|
|
};
|
|
|
|
if (item instanceof Components.interfaces.calIEvent) {
|
|
transfer.addDataFlavor("application/vnd.x-moz-cal-event");
|
|
transfer.setTransferData("application/vnd.x-moz-cal-event", flavourProvider, 0);
|
|
} else if (item instanceof Components.interfaces.calITodo) {
|
|
transfer.addDataFlavor("application/vnd.x-moz-cal-task");
|
|
transfer.setTransferData("application/vnd.x-moz-cal-task", flavourProvider, 0);
|
|
}
|
|
|
|
// Also set some normal data-types, in case we drag into another app
|
|
var supportsString = Components.classes["@mozilla.org/supports-string;1"]
|
|
.createInstance(Components.interfaces.nsISupportsString);
|
|
supportsString.data = item.icalComponent.serializeToICS();
|
|
transfer.setTransferData("text/calendar", supportsString, supportsString.data.length*2);
|
|
transfer.setTransferData("text/unicode", supportsString, supportsString.data.length*2);
|
|
|
|
var action = dragService.DRAGDROP_ACTION_MOVE;
|
|
var supArray = Components.classes["@mozilla.org/supports-array;1"]
|
|
.createInstance(Components.interfaces.nsISupportsArray);
|
|
supArray.AppendElement(transfer);
|
|
|
|
// OK, now that the data is all set up, start playing with the shadows
|
|
this.parentBox.monthView.doDeleteItem(item);
|
|
|
|
// Figure out how many shadows we're going to need, and how they should
|
|
// be oriented from the mouse's position
|
|
var boxes = this.parentBox.monthView.findBoxesForItem(item);
|
|
this.parentBox.monthView.mShadowLength = boxes.length;
|
|
for (var i in boxes) {
|
|
if (boxes[i].box == this.parentBox) {
|
|
this.parentBox.monthView.mShadowIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
this.parentBox.addDropShadows();
|
|
|
|
dragService.invokeDragSession(this, supArray, null, action);
|
|
]]></handler>
|
|
</handlers>
|
|
</binding>
|
|
|
|
<binding id="calendar-month-day-box">
|
|
<content>
|
|
<xul:vbox flex="1">
|
|
<xul:label anonid="day-label" crop="end" class="calendar-month-day-box-date-label"/>
|
|
<xul:vbox anonid="day-items"/>
|
|
</xul:vbox>
|
|
</content>
|
|
|
|
<implementation>
|
|
<field name="mDate">null</field>
|
|
<!-- mItemData will always be kept sorted in display order -->
|
|
<field name="mItemData">[]</field>
|
|
<field name="mMonthView">null</field>
|
|
<field name="mShowMonthLabel">false</field>
|
|
|
|
<property name="date">
|
|
<getter>return this.mDate;</getter>
|
|
<setter>this.setDate(val); return val;</setter>
|
|
</property>
|
|
|
|
<property name="monthView">
|
|
<getter><![CDATA[
|
|
return this.mMonthView;
|
|
]]></getter>
|
|
<setter><![CDATA[
|
|
this.mMonthView = val;
|
|
return val;
|
|
]]></setter>
|
|
</property>
|
|
|
|
<property name="selected">
|
|
<getter><![CDATA[
|
|
var sel = this.getAttribute("selected");
|
|
if (sel && sel == "true") {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
]]></getter>
|
|
<setter><![CDATA[
|
|
if (val)
|
|
this.setAttribute("selected", "true");
|
|
else
|
|
this.removeAttribute("selected");
|
|
]]></setter>
|
|
</property>
|
|
|
|
<property name="dayitems">
|
|
<getter>return document.getAnonymousElementByAttribute(this, "anonid", "day-items");</getter>
|
|
</property>
|
|
|
|
<property name="showMonthLabel">
|
|
<getter><![CDATA[
|
|
return this.mShowMonthLabel;
|
|
]]></getter>
|
|
<setter><![CDATA[
|
|
if (this.mShowMonthLabel == val) {
|
|
return val;
|
|
}
|
|
this.mShowMonthLabel = val;
|
|
|
|
if (!this.mDate) {
|
|
return val;
|
|
}
|
|
var daylabel = document.getAnonymousElementByAttribute(this, "anonid", "day-label");
|
|
|
|
if (val) {
|
|
var monthName = calGetString("dateFormat", "month." + (this.mDate.month+1) + ".Mmm");
|
|
daylabel.setAttribute("value", this.mDate.day + " " + monthName);
|
|
} else {
|
|
daylabel.setAttribute("value", aDate.day);
|
|
}
|
|
return val;
|
|
]]></setter>
|
|
</property>
|
|
|
|
<method name="setDate">
|
|
<parameter name="aDate"/>
|
|
<body><![CDATA[
|
|
if (!aDate)
|
|
throw Components.results.NS_ERROR_NULL_POINTER;
|
|
|
|
// Remove all the old events
|
|
this.mItemData = new Array();
|
|
while(this.dayitems.hasChildNodes()) {
|
|
this.dayitems.removeChild(this.dayitems.lastChild);
|
|
}
|
|
|
|
if (this.mDate && this.mDate.compare(aDate) == 0)
|
|
return;
|
|
|
|
this.mDate = aDate;
|
|
var daylabel = document.getAnonymousElementByAttribute(this, "anonid", "day-label");
|
|
|
|
if (this.mShowMonthLabel)
|
|
{
|
|
var monthName = calGetString("dateFormat", "month." + (aDate.month+1) + ".Mmm");
|
|
daylabel.setAttribute("value", aDate.day + " " + monthName);
|
|
} else {
|
|
daylabel.setAttribute("value", aDate.day);
|
|
}
|
|
]]></body>
|
|
</method>
|
|
|
|
<method name="addItem">
|
|
<parameter name="aItem"/>
|
|
<body><![CDATA[
|
|
for each (ed in this.mItemData) {
|
|
if (aItem.hasSameIds(ed.item))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
// insert the new item block, and then relayout
|
|
this.mItemData.push({ item: aItem });
|
|
|
|
this.relayout();
|
|
]]></body>
|
|
</method>
|
|
|
|
<method name="selectItem">
|
|
<parameter name="aItem"/>
|
|
<body><![CDATA[
|
|
for each (var itd in this.mItemData) {
|
|
if (itd.item.id == aItem.id) {
|
|
itd.box.selected = true;
|
|
}
|
|
}
|
|
]]></body>
|
|
</method>
|
|
|
|
<method name="unselectItem">
|
|
<parameter name="aItem"/>
|
|
<body><![CDATA[
|
|
for each (var itd in this.mItemData) {
|
|
if (itd.item.id == aItem.id) {
|
|
itd.box.selected = false;
|
|
}
|
|
}
|
|
]]></body>
|
|
</method>
|
|
|
|
<method name="deleteItem">
|
|
<parameter name="aItem"/>
|
|
<body><![CDATA[
|
|
var deleted = [];
|
|
|
|
var origLen = this.mItemData.length;
|
|
this.mItemData = this.mItemData.filter(
|
|
function(itd) {
|
|
if (aItem.hasSameIds(itd.item))
|
|
{
|
|
deleted.push(itd);
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
|
|
if (deleted.length > 0) {
|
|
for each (itd in deleted) {
|
|
if (itd.box)
|
|
this.dayitems.removeChild(itd.box);
|
|
}
|
|
// no need to relayout; all we did was delete
|
|
//this.relayout();
|
|
}
|
|
]]></body>
|
|
</method>
|
|
|
|
<method name="relayout">
|
|
<body><![CDATA[
|
|
function createXULElement(el) {
|
|
return document.createElementNS("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul", el);
|
|
}
|
|
|
|
|
|
this.mItemData.sort(
|
|
function (a, b) {
|
|
var aIsEvent = (a.item instanceof Components.interfaces.calIEvent);
|
|
var aIsTodo = (a.item instanceof Components.interfaces.calITodo);
|
|
|
|
var bIsEvent = (b.item instanceof Components.interfaces.calIEvent);
|
|
var bIsTodo = (b.item instanceof Components.interfaces.calITodo);
|
|
|
|
if ((!aIsEvent && !aIsTodo) || (!bIsEvent && !bIsTodo)) {
|
|
// XXX ????
|
|
dump ("Don't know how to sort these two events: " + a.item + " " + b.item + "\n");
|
|
return 0;
|
|
}
|
|
|
|
// sort todos before events
|
|
if (aIsTodo && bIsEvent) return -1;
|
|
if (aIsEvent && bIsTodo) return 1;
|
|
|
|
// XXX how do I sort todos?
|
|
if (aIsTodo && bIsTodo) {
|
|
return 0;
|
|
}
|
|
|
|
if (aIsEvent && bIsEvent) {
|
|
var cmp;
|
|
|
|
cmp = a.item.startDate.compare(b.item.startDate);
|
|
if (cmp != 0)
|
|
return cmp;
|
|
|
|
cmp = a.item.endDate.compare(b.item.endDate);
|
|
if (cmp != 0)
|
|
return cmp;
|
|
|
|
if (a.item.title < b.item.title)
|
|
return -1;
|
|
if (a.item.title > b.item.title)
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
});
|
|
|
|
for (var i = 0; i < this.mItemData.length; i++) {
|
|
var itd = this.mItemData[i];
|
|
|
|
if (!itd.box) {
|
|
// find what element to insert before
|
|
var before = null;
|
|
for (var j = i+1; !before && this.mItemData[j]; j++)
|
|
before = this.mItemData[j].box;
|
|
|
|
var box = createXULElement("calendar-month-day-box-item");
|
|
box.setAttribute("context", this.getAttribute("item-context") || this.getAttribute("context"));
|
|
box.setAttribute("class", "calendar-item");
|
|
box.setAttribute("item-calendar", itd.item.calendar.uri.spec);
|
|
box.setAttribute("tooltip", "itemTooltip");
|
|
|
|
var categoriesSelectorList = "";
|
|
if (itd.item.getProperty("CATEGORIES") != null) {
|
|
var categoriesList = itd.item.getProperty("CATEGORIES").split(",");
|
|
for (var i = 0; i < categoriesList.length; i++ ) {
|
|
// Remove illegal chars.
|
|
categoriesList[i] = categoriesList[i].replace(' ','_');
|
|
categoriesList[i] = categoriesList[i].toLowerCase();
|
|
}
|
|
categoriesSelectorList = categoriesList.join(" ");
|
|
}
|
|
box.setAttribute("item-category", categoriesSelectorList);
|
|
|
|
this.dayitems.insertBefore(box, before);
|
|
|
|
box.calendarView = this.monthView;
|
|
box.item = itd.item;
|
|
box.occurrence = itd.item;
|
|
box.parentBox = this;
|
|
itd.box = box;
|
|
}
|
|
}
|
|
]]></body>
|
|
</method>
|
|
|
|
<!-- While you might expect 'dragexit' to be fired when we drag outside
|
|
- the node in question, this isn't actually the case. So, we need
|
|
- to keep track of these shadows on the month-view itself, so they can
|
|
- be properly removed.
|
|
-->
|
|
<method name="addDropShadows">
|
|
<body><![CDATA[
|
|
// Only allow one set of drop-boxes
|
|
if (this.monthView.mDropShadows) {
|
|
return;
|
|
}
|
|
|
|
this.monthView.mDropShadows = [];
|
|
var shadowStart = this.mDate.clone();
|
|
shadowStart.day -= this.monthView.mShadowIndex;
|
|
shadowStart.normalize();
|
|
for (var i = 0; i < this.monthView.mShadowLength; i++) {
|
|
var dropbox = document.createElementNS("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul", "box");
|
|
dropbox.setAttribute("dropbox", "true");
|
|
dropbox.setAttribute("flex", "1");
|
|
|
|
var box = this.monthView.findBoxForDate(shadowStart);
|
|
if (!box) {
|
|
// Dragging to the end of a view
|
|
shadowStart.day += 1;
|
|
shadowStart.normalize();
|
|
continue;
|
|
}
|
|
box.box.dayitems.insertBefore(dropbox, box.box.dayitems.firstChild);
|
|
this.monthView.mDropShadows.push(dropbox);
|
|
|
|
shadowStart.day += 1;
|
|
shadowStart.normalize();
|
|
}
|
|
]]></body>
|
|
</method>
|
|
<method name="removeDropShadows">
|
|
<body><![CDATA[
|
|
if (!this.monthView.mDropShadows) {
|
|
return;
|
|
}
|
|
|
|
for each (shadow in this.monthView.mDropShadows) {
|
|
shadow.parentNode.removeChild(shadow);
|
|
}
|
|
|
|
this.monthView.mDropShadows = null;
|
|
]]></body>
|
|
</method>
|
|
</implementation>
|
|
|
|
<handlers>
|
|
<handler event="mousedown"><![CDATA[
|
|
event.stopPropagation();
|
|
|
|
if (this.mDate)
|
|
this.monthView.selectedDay = this.mDate;
|
|
]]></handler>
|
|
<handler event="dblclick"><![CDATA[
|
|
event.stopPropagation();
|
|
this.monthView.controller.createNewEvent();
|
|
]]></handler>
|
|
<handler event="dragenter"><![CDATA[
|
|
var dragService = Components.classes["@mozilla.org/widget/dragservice;1"]
|
|
.getService(Components.interfaces.nsIDragService);
|
|
var session = dragService.getCurrentSession();
|
|
session.canDrop = true;
|
|
this.removeDropShadows();
|
|
this.addDropShadows();
|
|
]]></handler>
|
|
|
|
<handler event="dragover"><![CDATA[
|
|
var dragService = Components.classes["@mozilla.org/widget/dragservice;1"]
|
|
.getService(Components.interfaces.nsIDragService);
|
|
var session = dragService.getCurrentSession();
|
|
session.canDrop = true;
|
|
]]></handler>
|
|
<handler event="dragexit"><![CDATA[
|
|
if (event.originalTarget != this) {
|
|
return;
|
|
}
|
|
this.removeDropShadows();
|
|
var dragService = Components.classes["@mozilla.org/widget/dragservice;1"]
|
|
.getService(Components.interfaces.nsIDragService);
|
|
var session = dragService.getCurrentSession();
|
|
session.canDrop = false;
|
|
]]></handler>
|
|
|
|
<handler event="dragdrop"><![CDATA[
|
|
var dragService = Components.classes["@mozilla.org/widget/dragservice;1"]
|
|
.getService(Components.interfaces.nsIDragService);
|
|
var session = dragService.getCurrentSession();
|
|
|
|
var transfer = Components.classes["@mozilla.org/widget/transferable;1"]
|
|
.createInstance(Components.interfaces.nsITransferable);
|
|
transfer.addDataFlavor("application/x-moz-cal-event");
|
|
session.getData(transfer, 0);
|
|
var flavor = {};
|
|
var data = {};
|
|
|
|
// nsITransferable sucks when it comes to trying to add extra flavors.
|
|
// This will throw NS_ERROR_FAILURE, so as a workaround, we use the
|
|
// sourceNode property and get the event that way
|
|
//transfer.getAnyTransferData(flavor, data, {});
|
|
|
|
var newStart;
|
|
var newEnd;
|
|
|
|
var boxDate = this.mDate;
|
|
var offset = this.monthView.mShadowIndex;
|
|
|
|
function adjustDate(date) {
|
|
var newDate = date.clone();
|
|
newDate.day = boxDate.day - offset;
|
|
newDate.month = boxDate.month;
|
|
newDate.year = boxDate.year;
|
|
return newDate;
|
|
}
|
|
|
|
if (!session.sourceNode || !session.sourceNode.occurrence) {
|
|
return;
|
|
}
|
|
|
|
event.stopPropagation();
|
|
var item = session.sourceNode.occurrence;
|
|
if (item instanceof Components.interfaces.calIEvent) {
|
|
var duration = item.duration;
|
|
newStart = adjustDate(item.startDate);
|
|
newEnd = newStart.clone();
|
|
newEnd.addDuration(duration);
|
|
} else if (item instanceof Components.interfaces.calITodo) {
|
|
if (item.entryDate && item.dueDate) {
|
|
var duration = item.duration;
|
|
newStart = adjustDate(item.entryDate);
|
|
newEnd = newStart.clone();
|
|
newEnd.addDuration(duration);
|
|
} else if (item.entryDate) {
|
|
newStart = adjustDate(item.entryDate);
|
|
} else { // only due date
|
|
newEnd = adjustDate(item.dueDate);
|
|
}
|
|
}
|
|
|
|
this.removeDropShadows();
|
|
this.monthView.controller.modifyOccurrence(item, newStart, newEnd);
|
|
]]></handler>
|
|
</handlers>
|
|
</binding>
|
|
|
|
<binding id="calendar-month-view-column-header">
|
|
<content>
|
|
<xul:hbox flex="1">
|
|
<xul:spacer flex="1"/>
|
|
<xul:label anonid="label" crop="right" class="calendar-month-view-column-header-label" />
|
|
<xul:spacer flex="1"/>
|
|
</xul:hbox>
|
|
</content>
|
|
|
|
<implementation>
|
|
<field name="mIndex">-1</field>
|
|
|
|
<constructor><![CDATA[
|
|
if (this.mIndex == -1) {
|
|
var attrIndex = this.getAttribute("index");
|
|
if (attrIndex)
|
|
this.index = parseInt(attrIndex);
|
|
}
|
|
]]></constructor>
|
|
|
|
<property name="index">
|
|
<getter>return this.mIndex;</getter>
|
|
<setter><![CDATA[
|
|
this.mIndex = val % 7;
|
|
|
|
var label = document.getAnonymousElementByAttribute(this, "anonid", "label");
|
|
var dayName = calGetString("dateFormat", "day." + (this.mIndex+1) + ".name");
|
|
label.setAttribute("value", dayName);
|
|
|
|
return this.mIndex;
|
|
]]></setter>
|
|
</property>
|
|
</implementation>
|
|
</binding>
|
|
|
|
<binding id="calendar-month-view">
|
|
<content>
|
|
<xul:vbox flex="1">
|
|
<xul:hbox anonid="headerbox" equalsize="always"/>
|
|
|
|
<xul:grid anonid="monthgrid" flex="1">
|
|
<xul:columns anonid="monthgridcolumns" equalsize="always">
|
|
<xul:column flex="1" class="calendar-month-view-grid-column"/>
|
|
<xul:column flex="1" class="calendar-month-view-grid-column"/>
|
|
<xul:column flex="1" class="calendar-month-view-grid-column"/>
|
|
<xul:column flex="1" class="calendar-month-view-grid-column"/>
|
|
<xul:column flex="1" class="calendar-month-view-grid-column"/>
|
|
<xul:column flex="1" class="calendar-month-view-grid-column"/>
|
|
<xul:column flex="1" class="calendar-month-view-grid-column"/>
|
|
</xul:columns>
|
|
|
|
<xul:rows anonid="monthgridrows" equalsize="always">
|
|
<xul:row flex="1" class="calendar-month-view-grid-row">
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
</xul:row>
|
|
<xul:row flex="1" class="calendar-month-view-grid-row">
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
</xul:row>
|
|
<xul:row flex="1" class="calendar-month-view-grid-row">
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
</xul:row>
|
|
<xul:row flex="1" class="calendar-month-view-grid-row">
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
</xul:row>
|
|
<xul:row flex="1" class="calendar-month-view-grid-row">
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
</xul:row>
|
|
<xul:row flex="1" class="calendar-month-view-grid-row">
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
<xul:calendar-month-day-box/>
|
|
</xul:row>
|
|
</xul:rows>
|
|
</xul:grid>
|
|
</xul:vbox>
|
|
</content>
|
|
|
|
<implementation implements="calICalendarView">
|
|
|
|
<!-- constructor -->
|
|
<constructor><![CDATA[
|
|
function createXULElement(el) {
|
|
return document.createElementNS("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul", el);
|
|
}
|
|
|
|
var headerbox = document.getAnonymousElementByAttribute(this, "anonid", "headerbox")
|
|
for (var i = 0; i < 7; i++) {
|
|
var hdr = createXULElement("calendar-month-view-column-header");
|
|
hdr.setAttribute("flex", "1");
|
|
headerbox.appendChild(hdr);
|
|
hdr.index = i;
|
|
}
|
|
]]></constructor>
|
|
|
|
<!-- fields -->
|
|
|
|
<field name="mCalendar">null</field>
|
|
<field name="mController">null</field>
|
|
<field name="mStartDate">null</field>
|
|
<field name="mEndDate">null</field>
|
|
<field name="mDateBoxes">null</field>
|
|
<field name="mTimezone">"floating"</field>
|
|
|
|
<field name="mSelectedItem">null</field>
|
|
<field name="mSelectedDayBox">null</field>
|
|
|
|
<field name="mShowDaysOutsideMonth">true</field>
|
|
<field name="mTasksInView">true</field>
|
|
<field name="mShowFullMonth">true</field>
|
|
<field name="mWeekStartOffset">0</field>
|
|
<field name="mDaysOffArray">[0,6]</field>
|
|
<field name="mDisplayDaysOff">true</field>
|
|
<field name="mDropShadows">null</field>
|
|
<field name="mShadowIndex">0</field>
|
|
|
|
<field name="mSelectionObserver"><![CDATA[
|
|
({ calView: this,
|
|
onSelectionChanged: function selectionObserverCallback(itemSelectionArray) {
|
|
// The selection manager is smart enough to call this only when
|
|
// the selection really did change, so don't bother checking
|
|
if (this.calView.mSelectedItem) {
|
|
var oldboxes = this.calView.findBoxesForItem(this.calView.mSelectedItem);
|
|
for each (oldbox in oldboxes) {
|
|
oldbox.box.unselectItem(this.calView.mSelectedItem);
|
|
}
|
|
}
|
|
this.calView.mSelectedItem = itemSelectionArray[0];
|
|
|
|
var newboxes = this.calView.findBoxesForItem(this.calView.mSelectedItem);
|
|
for each (newbox in newboxes) {
|
|
newbox.box.selectItem(this.calView.mSelectedItem);
|
|
}
|
|
}
|
|
})
|
|
]]></field>
|
|
|
|
<!-- other methods -->
|
|
<method name="setAttribute">
|
|
<parameter name="aAttr"/>
|
|
<parameter name="aVal"/>
|
|
<body><![CDATA[
|
|
var needsrelayout = false;
|
|
if (aAttr == "context" || aAttr == "item-context")
|
|
needsrelayout = true;
|
|
|
|
var ret = XULElement.prototype.setAttribute.call (this, aAttr, aVal);
|
|
|
|
if (needsrelayout)
|
|
this.relayout();
|
|
|
|
return ret;
|
|
]]></body>
|
|
</method>
|
|
|
|
<!-- calICalendarView -->
|
|
|
|
<property name="supportsDisjointDates" readonly="true"
|
|
onget="return false;"/>
|
|
<property name="hasDisjointDates" readonly="true"
|
|
onget="return false;"/>
|
|
|
|
<property name="displayCalendar">
|
|
<getter><![CDATA[
|
|
return this.mCalendar;
|
|
]]></getter>
|
|
<setter><![CDATA[
|
|
if (this.mCalendar != val) {
|
|
this.mCalendar = val;
|
|
this.mCalendar.addObserver(this.mObserver);
|
|
this.refresh();
|
|
}
|
|
return val;
|
|
]]></setter>
|
|
</property>
|
|
|
|
<property name="weekStartOffset">
|
|
<getter><![CDATA[
|
|
return this.mWeekStartOffset;
|
|
]]></getter>
|
|
<setter><![CDATA[
|
|
this.mWeekStartOffset = val;
|
|
]]></setter>
|
|
</property>
|
|
|
|
<property name="displayDaysOff">
|
|
<getter><![CDATA[
|
|
return this.mDisplayDaysOff;
|
|
]]></getter>
|
|
<setter><![CDATA[
|
|
this.mDisplayDaysOff = val;
|
|
return val;
|
|
]]></setter>
|
|
</property>
|
|
|
|
<property name="daysOffArray">
|
|
<getter><![CDATA[
|
|
return this.mDaysOffArray;
|
|
]]></getter>
|
|
<setter><![CDATA[
|
|
this.mDaysOffArray = val;
|
|
return val;
|
|
]]></setter>
|
|
</property>
|
|
|
|
<property name="controller"
|
|
onget="return this.mController;"
|
|
onset="return this.mController = val;"/>
|
|
|
|
<property name="startDate" readonly="true"
|
|
onget="return this.mStartDate"/>
|
|
|
|
<property name="endDate" readonly="true">
|
|
<getter><![CDATA[
|
|
return this.mEndDate;
|
|
]]></getter>
|
|
</property>
|
|
|
|
<!-- the end date that should be used for getItems and similar queries -->
|
|
<property name="queryEndDate" readonly="true">
|
|
<getter><![CDATA[
|
|
var end = this.endDate;
|
|
if (!end)
|
|
return null;
|
|
|
|
end = end.clone();
|
|
end.day += 1;
|
|
end.isDate = true;
|
|
end.normalize();
|
|
|
|
return end;
|
|
]]></getter>
|
|
</property>
|
|
|
|
<property name="tasksInView">
|
|
<getter><![CDATA[
|
|
return this.mTasksInView;
|
|
]]></getter>
|
|
<setter><![CDATA[
|
|
this.mTasksInView = val;
|
|
]]></setter>
|
|
</property>
|
|
|
|
<property name="showFullMonth">
|
|
<getter><![CDATA[
|
|
return this.mShowFullMonth;
|
|
]]></getter>
|
|
<setter><![CDATA[
|
|
this.mShowFullMonth = val;
|
|
]]></setter>
|
|
</property>
|
|
|
|
<property name="selectedItem">
|
|
<getter><![CDATA[
|
|
return this.mSelectedItem;
|
|
]]></getter>
|
|
<setter><![CDATA[
|
|
if (this.mSelectedItem) {
|
|
var oldboxes = this.findBoxesForItem(this.mSelectedItem);
|
|
for each (oldbox in oldboxes) {
|
|
oldbox.box.unselectItem(this.mSelectedItem);
|
|
}
|
|
}
|
|
|
|
this.mSelectedItem = val;
|
|
|
|
if (this.mSelectedItem) {
|
|
var newboxes = this.findBoxesForItem(this.mSelectedItem);
|
|
for each (newbox in newboxes) {
|
|
newbox.box.selectItem(this.mSelectedItem);
|
|
}
|
|
if (this.mController.selectionManager)
|
|
this.mController.selectionManager.replaceSelection(this.mSelectedItem);
|
|
}
|
|
]]></setter>
|
|
</property>
|
|
|
|
<property name="selectedDay">
|
|
<getter><![CDATA[
|
|
if (this.mSelectedDayBox)
|
|
return this.mSelectedDayBox.date.clone();
|
|
|
|
return null;
|
|
]]></getter>
|
|
<setter><![CDATA[
|
|
if (this.mSelectedDayBox)
|
|
this.mSelectedDayBox.box.selected = false;
|
|
|
|
var realVal = val;
|
|
if (!realVal.isDate) {
|
|
realVal = val.clone();
|
|
realVal.isDate = true;
|
|
}
|
|
var box = this.findBoxForDate(realVal);
|
|
if (box) {
|
|
box.box.selected = true;
|
|
this.mSelectedDayBox = box;
|
|
}
|
|
this.fireEvent("dayselect", realVal);
|
|
return val;
|
|
]]></setter>
|
|
</property>
|
|
|
|
<property name="timezone">
|
|
<getter><![CDATA[
|
|
return this.mTimezone;
|
|
]]></getter>
|
|
<setter><![CDATA[
|
|
this.mTimezone = val;
|
|
return val;
|
|
]]></setter>
|
|
</property>
|
|
|
|
<method name="fireEvent">
|
|
<parameter name="aEventName"/>
|
|
<parameter name="aEventDetail"/>
|
|
<body><![CDATA[
|
|
var event = document.createEvent('Events');
|
|
event.initEvent(aEventName, true, false);
|
|
event.detail = aEventDetail;
|
|
this.dispatchEvent(event);
|
|
]]></body>
|
|
</method>
|
|
|
|
<method name="showDate">
|
|
<parameter name="aDate"/>
|
|
<body><![CDATA[
|
|
aDate = aDate.getInTimezone(this.mTimezone);
|
|
|
|
// We might need to do some adjusting here to make sure we still
|
|
// display whole month even with alternative week-start days
|
|
var startDate = aDate.startOfMonth;
|
|
var endDate = aDate.endOfMonth;
|
|
if (startDate.weekday < this.mWeekStartOffset) {
|
|
// Go back one week to make sure we display this day
|
|
startDate.day -= 7;
|
|
}
|
|
|
|
if (endDate.weekday < this.mWeekStartOffset) {
|
|
// Go back one week so we don't display any extra days
|
|
endDate.day -= 7;
|
|
}
|
|
|
|
this.setDateRange(startDate, endDate);
|
|
this.selectedDay = aDate;
|
|
]]></body>
|
|
</method>
|
|
|
|
<method name="setDateRange">
|
|
<parameter name="aStartDate"/>
|
|
<parameter name="aEndDate"/>
|
|
<body><![CDATA[
|
|
if (this.mTimezone != aStartDate.timezone) {
|
|
aStartDate = aStartDate.getInTimezone(this.mTimezone);
|
|
aEndDate = aEndDate.getInTimezone(this.mTimezone);
|
|
}
|
|
|
|
this.mStartDate = aStartDate.startOfWeek;
|
|
this.mEndDate = aEndDate.endOfWeek;
|
|
|
|
this.mStartDate.day += this.mWeekStartOffset;
|
|
this.mEndDate.day += this.mWeekStartOffset;
|
|
this.mStartDate.normalize();
|
|
this.mEndDate.normalize();
|
|
|
|
this.refresh();
|
|
]]></body>
|
|
</method>
|
|
|
|
<method name="setDateList">
|
|
<parameter name="aCount"/>
|
|
<parameter name="aDates"/>
|
|
<body><![CDATA[
|
|
throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
|
|
]]></body>
|
|
</method>
|
|
|
|
<method name="getDateList">
|
|
<parameter name="aCount"/>
|
|
<body><![CDATA[
|
|
if (!this.mStartDate || !this.mEndDate) {
|
|
aCount.value = 0;
|
|
return [];
|
|
}
|
|
|
|
var results = [];
|
|
var curDate = this.mStartDate.clone();
|
|
curDate.isDate = true;
|
|
curDate.normalize();
|
|
|
|
while (curDate.compare(this.mEndDate) <= 0) {
|
|
results.push(curDate.clone());
|
|
curDate.day += 1;
|
|
curDate.normalize();
|
|
}
|
|
aCount.value = results.length;
|
|
return results;
|
|
]]></body>
|
|
</method>
|
|
|
|
<!-- public properties and methods -->
|
|
|
|
<!-- whether to show days outside of the current month -->
|
|
<property name="showDaysOutsideMonth">
|
|
<getter><![CDATA[
|
|
return this.mShowDaysOutsideMonth;
|
|
]]></getter>
|
|
<setter><![CDATA[
|
|
if (this.mShowDaysOutsideMonth != val) {
|
|
this.mShowDaysOutsideMonth = val;
|
|
this.refresh();
|
|
}
|
|
return val;
|
|
]]></setter>
|
|
</property>
|
|
|
|
<!-- private properties and methods -->
|
|
|
|
<property name="monthgrid" readonly="true"
|
|
onget="return document.getAnonymousElementByAttribute(this, 'anonid', 'monthgrid');"/>
|
|
|
|
<property name="monthgridrows" readonly="true"
|
|
onget="return document.getAnonymousElementByAttribute(this, 'anonid', 'monthgridrows');"/>
|
|
|
|
<method name="refresh">
|
|
<body><![CDATA[
|
|
if (!this.startDate || !this.endDate)
|
|
return;
|
|
|
|
this.relayout();
|
|
|
|
if (!this.mCalendar)
|
|
return;
|
|
|
|
var filter = this.mCalendar.ITEM_FILTER_COMPLETED_ALL |
|
|
this.mCalendar.ITEM_FILTER_CLASS_OCCURRENCES;
|
|
|
|
if (this.mTasksInView)
|
|
filter |= this.mCalendar.ITEM_FILTER_TYPE_ALL;
|
|
else
|
|
filter |= this.mCalendar.ITEM_FILTER_TYPE_EVENT;
|
|
|
|
this.mCalendar.getItems(filter,
|
|
0,
|
|
this.startDate,
|
|
this.queryEndDate,
|
|
this.mOperationListener);
|
|
]]></body>
|
|
</method>
|
|
|
|
<method name="relayout">
|
|
<body><![CDATA[
|
|
function createXULElement(el) {
|
|
return document.createElementNS("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul", el);
|
|
}
|
|
|
|
// Adjust headers based on the starting day of the week, if necessary
|
|
var headerbox = document.getAnonymousElementByAttribute(this, "anonid", "headerbox");
|
|
|
|
if (headerbox.firstChild.index != this.mWeekStartOffset) {
|
|
var i = 0;
|
|
for each(header in headerbox.childNodes) {
|
|
header.index = (i + this.mWeekStartOffset) % 7;
|
|
i++;
|
|
}
|
|
}
|
|
|
|
if (this.mSelectedItem) {
|
|
this.selectedItem = null;
|
|
}
|
|
|
|
// Clear out the old selection, since it won't be valid after relayout
|
|
if (this.mSelectedDayBox) {
|
|
this.mSelectedDayBox.box.selected = false;
|
|
}
|
|
|
|
if (!this.mStartDate || !this.mEndDate)
|
|
throw NS_ERROR_FAILURE;
|
|
|
|
// Days that are not in the main month on display are displayed with
|
|
// a gray background. Unless the month actually starts on a Sunday,
|
|
// this means that mStartDate.month is 1 month less than the main month
|
|
var mainMonth = this.mStartDate.month;
|
|
if (this.mStartDate.day != 1) {
|
|
mainMonth++;
|
|
mainMonth = mainMonth % 12;
|
|
}
|
|
|
|
var dateBoxes = [];
|
|
|
|
// clear out the old today
|
|
var oldToday = document.getAnonymousElementByAttribute(this, "today", "true");
|
|
if (oldToday) {
|
|
oldToday.removeAttribute("today");
|
|
}
|
|
|
|
// This gets set to true, telling us to collapse the rest of the rows
|
|
var finished = false;
|
|
var dateList = this.getDateList({})
|
|
|
|
var rows = this.monthgridrows.childNodes;
|
|
|
|
// Iterate through each monthgridrow and set up the day-boxes that
|
|
// are its child nodes. Remember, childNodes is not a normal array,
|
|
// so don't use the in operator if you don't want extra properties
|
|
// coming out.
|
|
for (var i = 0; i < rows.length; i++) {
|
|
var row = rows[i];
|
|
// If we've already assigned all of the day-boxes that we need, just
|
|
// collapse the rest of the rows, otherwise expand them if needed.
|
|
if (finished) {
|
|
row.setAttribute("collapsed", true);
|
|
continue;
|
|
} else {
|
|
row.removeAttribute("collapsed");
|
|
}
|
|
for (var j = 0; j < row.childNodes.length; j++) {
|
|
var daybox = row.childNodes[j];
|
|
var date = dateList[dateBoxes.length];
|
|
|
|
daybox.setAttribute("context", this.getAttribute("context"));
|
|
daybox.setAttribute("item-context", this.getAttribute("item-context") || this.getAttribute("context"));
|
|
|
|
// Set the box-class depending on if this box displays a day in
|
|
// the month being currently shown or not.
|
|
var boxClass;
|
|
if (this.showFullMonth) {
|
|
boxClass = "calendar-month-day-box-" +
|
|
(mainMonth == date.month ? "current-month" : "other-month");
|
|
} else {
|
|
boxClass = "calendar-month-day-box-current-month";
|
|
}
|
|
|
|
function matchesDayOff(dayOffNum) { return dayOffNum == date.weekday; }
|
|
if (this.mDaysOffArray.some(matchesDayOff)) {
|
|
boxClass = "calendar-month-day-box-day-off " + boxClass;
|
|
}
|
|
|
|
daybox.setAttribute("class", boxClass);
|
|
|
|
daybox.setDate(date);
|
|
if (date.day == 1 || date.day == date.endOfMonth.day) {
|
|
daybox.showMonthLabel = true;
|
|
}
|
|
daybox.monthView = this;
|
|
|
|
// add the box and its data to our stored array
|
|
var boxdata = {
|
|
date: date,
|
|
row: row,
|
|
box: daybox
|
|
};
|
|
|
|
dateBoxes.push(boxdata);
|
|
|
|
// If we've now assigned all of our dates, set this to true so we
|
|
// know we can just collapse the rest of the rows.
|
|
if (dateBoxes.length == dateList.length) {
|
|
finished = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If we're not showing a full month, then add a few extra labels to
|
|
// help the user orient themselves in the view.
|
|
if (!this.mShowFullMonth) {
|
|
dateBoxes[0].box.showMonthLabel = true;
|
|
dateBoxes[dateBoxes.length-1].box.showMonthLabel = true;
|
|
}
|
|
|
|
// Store these, so that we can access them later
|
|
this.mDateBoxes = dateBoxes;
|
|
this.hideDaysOff();
|
|
|
|
// Highlight today, if it's in the range of the view
|
|
var today = this.today();
|
|
if (today.compare(dateList[0]) != -1 &&
|
|
today.compare(dateList[dateList.length-1]) != 1) {
|
|
this.findBoxForDate(today).box.setAttribute("today", "true");
|
|
}
|
|
]]></body>
|
|
</method>
|
|
|
|
<method name="hideDaysOff">
|
|
<body><![CDATA[
|
|
var columns = document.getAnonymousElementByAttribute(this, "anonid", "monthgridcolumns").childNodes;
|
|
var headerkids = document.getAnonymousElementByAttribute(this, "anonid", "headerbox").childNodes;
|
|
for (var i in columns) {
|
|
var dayForColumn = (Number(i) + this.mWeekStartOffset) % 7;
|
|
var dayOff = (this.mDaysOffArray.indexOf(dayForColumn) != -1);
|
|
columns[i].collapsed = dayOff && !this.mDisplayDaysOff;
|
|
headerkids[i].collapsed = dayOff && !this.mDisplayDaysOff;
|
|
}
|
|
]]></body>
|
|
</method>
|
|
|
|
<method name="findBoxForDate">
|
|
<parameter name="aDate"/>
|
|
<body><![CDATA[
|
|
for each (box in this.mDateBoxes) {
|
|
if (box.date.compare(aDate) == 0)
|
|
return box;
|
|
}
|
|
return null;
|
|
]]></body>
|
|
</method>
|
|
<method name="findBoxesForItem">
|
|
<parameter name="aItem"/>
|
|
<body><![CDATA[
|
|
var targetDate = null;
|
|
var finishDate = null;
|
|
var boxes = new Array();
|
|
|
|
// All our boxes are in default tz, so we need these times in them too.
|
|
if (aItem instanceof Components.interfaces.calIEvent) {
|
|
targetDate = aItem.startDate.getInTimezone(this.mTimezone);
|
|
finishDate = aItem.endDate.getInTimezone(this.mTimezone);
|
|
} else if (aItem instanceof Components.interfaces.calITodo) {
|
|
if (aItem.entryDate) {
|
|
targetDate = aItem.entryDate.getInTimezone(this.mTimezone);
|
|
if (aItem.dueDate) {
|
|
finishDate = aItem.dueDate.getInTimezone(this.mTimezone);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!targetDate)
|
|
return boxes;
|
|
|
|
if (!finishDate) {
|
|
var maybeBox = this.findBoxForDate(targetDate);
|
|
if (maybeBox) {
|
|
boxes.push(maybeBox);
|
|
}
|
|
return boxes;
|
|
}
|
|
|
|
if (!targetDate.isDate) {
|
|
// Reset the time to 00:00, so that we really get all the boxes
|
|
targetDate.hour = 0;
|
|
targetDate.minute = 0;
|
|
targetDate.second = 0;
|
|
}
|
|
|
|
if (targetDate.compare(finishDate) == 0) {
|
|
// Zero length events are silly, but we have to handle them
|
|
var box = this.findBoxForDate(targetDate);
|
|
if (box) {
|
|
boxes.push(box);
|
|
}
|
|
}
|
|
|
|
while (targetDate.compare(finishDate) == -1) {
|
|
var box = this.findBoxForDate(targetDate);
|
|
|
|
// This might not exist, if the event spans the view start or end
|
|
if (box) {
|
|
boxes.push(box);
|
|
}
|
|
targetDate.day += 1;
|
|
targetDate.normalize();
|
|
}
|
|
|
|
return boxes;
|
|
]]></body>
|
|
</method>
|
|
|
|
<method name="doAddItem">
|
|
<parameter name="aItem"/>
|
|
<body><![CDATA[
|
|
var boxes = this.findBoxesForItem(aItem);
|
|
|
|
if (!boxes.length)
|
|
return;
|
|
|
|
for each (box in boxes) {
|
|
box.box.addItem(aItem);
|
|
}
|
|
]]></body>
|
|
</method>
|
|
|
|
<method name="doDeleteItem">
|
|
<parameter name="aItem"/>
|
|
<body><![CDATA[
|
|
var boxes = this.findBoxesForItem(aItem);
|
|
|
|
if (!boxes.length)
|
|
return;
|
|
|
|
if (this.mSelectedItem == aItem)
|
|
this.mSelectedItem = null;
|
|
|
|
for each (box in boxes) {
|
|
box.box.deleteItem(aItem);
|
|
}
|
|
]]></body>
|
|
</method>
|
|
|
|
<method name="today">
|
|
<body><![CDATA[
|
|
var date = Components.classes["@mozilla.org/calendar/datetime;1"]
|
|
.createInstance(Components.interfaces.calIDateTime);
|
|
date.jsDate = new Date();
|
|
date = date.getInTimezone(this.mTimezone);
|
|
date.isDate = true;
|
|
return date;
|
|
]]></body>
|
|
</method>
|
|
|
|
<!-- our private observers and listeners -->
|
|
|
|
<field name="mOperationListener"><![CDATA[
|
|
({
|
|
calView: this,
|
|
|
|
QueryInterface: function (aIID) {
|
|
if (!aIID.equals(Components.interfaces.calIOperationListener) &&
|
|
!aIID.equals(Components.interfaces.nsISupports)) {
|
|
throw Components.results.NS_ERROR_NO_INTERFACE;
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
onOperationComplete: function(aCalendar, aStatus, aOperationType, aId, aDetail) {
|
|
if (this.calView.controller.selectionManager &&
|
|
this.calView.controller.selectionManager.selectedEvents[0])
|
|
this.calView.selectedItem = (this.calView.controller
|
|
.selectionManager.selectedEvents[0]);
|
|
},
|
|
onGetResult: function(aCalendar, aStatus, aItemType, aDetail, aCount, aItems) {
|
|
if (!Components.isSuccessCode(aStatus))
|
|
return;
|
|
|
|
for each (var item in aItems) {
|
|
this.calView.doAddItem(item);
|
|
}
|
|
}
|
|
})
|
|
]]></field>
|
|
|
|
<field name="mObserver"><![CDATA[
|
|
// the calIObserver, and calICompositeObserver
|
|
({
|
|
calView: this,
|
|
|
|
QueryInterface: function (aIID) {
|
|
if (!aIID.equals(Components.interfaces.calIObserver) &&
|
|
!aIID.equals(Components.interfaces.calICompositeObserver) &&
|
|
!aIID.equals(Components.interfaces.nsISupports)) {
|
|
throw Components.results.NS_ERROR_NO_INTERFACE;
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
onStartBatch: function() {
|
|
this.calView.mBatchCount++;
|
|
},
|
|
onEndBatch: function() {
|
|
this.mBatchCount--;
|
|
if (this.mBatchCount == 0) {
|
|
this.calView.refresh();
|
|
}
|
|
},
|
|
onLoad: function() {
|
|
this.calView.refresh();
|
|
},
|
|
onAddItem: function (aItem) {
|
|
if (this.mBatchCount) {
|
|
return;
|
|
}
|
|
var occs = aItem.getOccurrencesBetween(this.calView.startDate,
|
|
this.calView.queryEndDate,
|
|
{});
|
|
for each (var occ in occs)
|
|
this.calView.doAddItem(occ);
|
|
},
|
|
onModifyItem: function (aNewItem, aOldItem) {
|
|
if (this.mBatchCount) {
|
|
return;
|
|
}
|
|
var occs;
|
|
occs = aOldItem.getOccurrencesBetween(this.calView.startDate,
|
|
this.calView.queryEndDate,
|
|
{});
|
|
for each (var occ in occs)
|
|
this.calView.doDeleteItem(occ);
|
|
|
|
occs = aNewItem.getOccurrencesBetween(this.calView.startDate,
|
|
this.calView.queryEndDate,
|
|
{});
|
|
for each (var occ in occs)
|
|
this.calView.doAddItem(occ);
|
|
},
|
|
onDeleteItem: function (aItem) {
|
|
if (this.mBatchCount) {
|
|
return;
|
|
}
|
|
var occs = aItem.getOccurrencesBetween(this.calView.startDate,
|
|
this.calView.queryEndDate,
|
|
{});
|
|
for each (var occ in occs) {
|
|
this.calView.doDeleteItem(occ);
|
|
}
|
|
},
|
|
onError: function (aErrNo, aMessage) { },
|
|
|
|
//
|
|
// calICompositeObserver stuff
|
|
// XXXvv we can be smarter about how we handle this stuff
|
|
//
|
|
onCalendarAdded: function (aCalendar) {
|
|
this.calView.refresh();
|
|
},
|
|
|
|
onCalendarRemoved: function (aCalendar) {
|
|
this.calView.refresh();
|
|
},
|
|
|
|
onDefaultCalendarChanged: function (aNewDefaultCalendar) {
|
|
// don't care, for now
|
|
}
|
|
})
|
|
]]></field>
|
|
|
|
</implementation>
|
|
|
|
<handlers>
|
|
<handler event="keypress"><![CDATA[
|
|
const kKE = Components.interfaces.nsIDOMKeyEvent;
|
|
if (event.keyCode == kKE.DOM_VK_BACK_SPACE ||
|
|
event.keyCode == kKE.DOM_VK_DELETE)
|
|
{
|
|
if (!this.activeInPlaceEdit && this.selectedItem && this.controller) {
|
|
var item = (event.ctrlKey) ? this.selectedItem.parentItem : this.selectedItem;
|
|
this.controller.deleteOccurrence(item);
|
|
}
|
|
}
|
|
]]></handler>
|
|
</handlers>
|
|
</binding>
|
|
|
|
</bindings>
|
|
|
|
<!-- -*- Mode: xml; indent-tabs-mode: nil; -*- -->
|