cacert-testmgr/external/ZendFramework-1.9.5/externals/dojo/dojox/widget/Calendar.js

818 lines
24 KiB
JavaScript
Raw Normal View History

dojo.provide("dojox.widget.Calendar");
dojo.experimental("dojox.widget.Calendar");
dojo.require("dijit._Calendar");
dojo.require("dijit._Container");
dojo.declare("dojox.widget._CalendarBase", [dijit._Widget, dijit._Templated, dijit._Container], {
// summary: The Root class for all _Calendar extensions
// templatePath: URL
// the path to the template to be used to construct the widget.
templatePath: dojo.moduleUrl("dojox.widget","Calendar/Calendar.html"),
// _views: Array
// The list of mixin views available on this calendar.
_views: null,
// useFx: Boolean
// Specifies if visual effects should be applied to the widget.
// The default behavior of the widget does not contain any effects.
// The dojox.widget.CalendarFx package is needed for these.
useFx: true,
// widgetsInTemplate: Boolean
// This widget is a container of other widgets, so this is true.
widgetsInTemplate: true,
// value: Date
// the currently selected Date
value: new Date(),
constraints: null,
// footerFormat: String
// The date format of the date displayed in the footer. Can be
// 'short', 'medium', and 'long'
footerFormat: "medium",
constructor: function(){
// summary: constructor for the widget
this._views = [];
},
postMixInProperties: function(){
var c = this.constraints;
if (c) {
var fromISO = dojo.date.stamp.fromISOString;
if (typeof c.min == "string") {
c.min = fromISO(c.min);
}
if (typeof c.max == "string") {
c.max = fromISO(c.max);
}
}
},
postCreate: function(){
// summary: Instantiates the mixin views
this._height = dojo.style(this.containerNode, "height");
this.displayMonth = new Date(this.attr('value'));
var mixin = {
parent: this,
_getValueAttr: dojo.hitch(this, function(){return new Date(this.displayMonth);}),
_getConstraintsAttr: dojo.hitch(this, function(){return this.constraints;}),
getLang: dojo.hitch(this, function(){return this.lang;}),
isDisabledDate: dojo.hitch(this, this.isDisabledDate),
getClassForDate: dojo.hitch(this, this.getClassForDate),
addFx: this.useFx ? dojo.hitch(this, this.addFx) : function(){}
};
//Add the mixed in views.
dojo.forEach(this._views, function(widgetType){
var widget = new widgetType(mixin, dojo.create('div'));
this.addChild(widget);
var header = widget.getHeader();
if (header) {
//place the views's header node in the header of the main widget
this.header.appendChild(header);
//hide the header node of the widget
dojo.style(header, "display", "none");
}
//Hide all views
dojo.style(widget.domNode, "visibility", "hidden");
//Listen for the values in a view to be selected
dojo.connect(widget, "onValueSelected", this, "_onDateSelected");
widget.attr("value", this.attr('value'));
}, this);
if(this._views.length < 2) {
dojo.style(this.header, "cursor", "auto");
}
this.inherited(arguments);
// Cache the list of children widgets.
this._children = this.getChildren();
this._currentChild = 0;
//Populate the footer with today's date.
var today = new Date();
this.footer.innerHTML = "Today: " + dojo.date.locale.format(today,
{formatLength:this.footerFormat,selector:'date', locale:this.lang});
dojo.connect(this.footer, "onclick", this, "goToToday");
var first = this._children[0];
dojo.style(first.domNode, "top", "0px");
dojo.style(first.domNode, "visibility", "visible");
var header = first.getHeader();
if (header) {
dojo.style(first.getHeader(), "display", "");
}
dojo[first.useHeader ? "removeClass" : "addClass"](this.container, "no-header");
first.onDisplay();
var _this = this;
var typematic = function(nodeProp, dateProp, adj){
dijit.typematic.addMouseListener(_this[nodeProp], _this, function(count){
if(count >= 0){ _this._adjustDisplay(dateProp, adj);}
}, 0.8, 500);
};
typematic("incrementMonth", "month", 1);
typematic("decrementMonth", "month", -1);
this._updateTitleStyle();
},
addFx: function(query, fromNode) {
// Stub function than can be overridden to add effects.
},
_setValueAttr: function(/*Date*/ value){
// summary: set the current date and update the UI. If the date is disabled, the selection will
// not change, but the display will change to the corresponding month.
if (!value["getFullYear"]) {
value = dojo.date.stamp.fromISOString(value + "");
}
if(!this.value || dojo.date.compare(value, this.value)){
value = new Date(value);
this.displayMonth = new Date(value);
if(!this.isDisabledDate(value, this.lang)){
this.value = value;
this.onChange(value);
}
this._children[this._currentChild].attr("value", this.value);
return true;
}
return false;
},
isDisabledDate: function(/*Date*/date, /*String?*/locale){
// summary:
// May be overridden to disable certain dates in the calendar e.g. `isDisabledDate=dojo.date.locale.isWeekend`
var c = this.constraints;
var compare = dojo.date.compare;
return c && (c.min && (compare(c.min, date, "date") > 0) ||
(c.max && compare(c.max, date, "date") < 0));
},
onValueSelected: function(/*Date*/date){
// summary: a date cell was selected. It may be the same as the previous value.
},
_onDateSelected: function(date, formattedValue, force){
this.displayMonth = date;
this.attr("value", date)
//Only change the selected value if it was chosen from the
//first child.
if (!this._transitionVert(-1)) {
if (!formattedValue && formattedValue !== 0) {
formattedValue = this.attr('value');
}
this.onValueSelected(formattedValue);
}
},
onChange: function(/*Date*/date){
// summary: called only when the selected date has changed
},
onHeaderClick: function(e) {
// summary: Transitions to the next view.
this._transitionVert(1);
},
goToToday: function(){
this.attr("value", new Date());
this.onValueSelected(this.attr('value'));
},
_transitionVert: function(/*Number*/direction){
// summary: Animates the views to show one and hide another, in a
// vertical direction.
// If 'direction' is 1, then the views slide upwards.
// If 'direction' is -1, the views slide downwards.
var curWidget = this._children[this._currentChild];
var nextWidget = this._children[this._currentChild + direction];
if(!nextWidget){return false;}
dojo.style(nextWidget.domNode, "visibility", "visible");
var height = dojo.style(this.containerNode, "height");
nextWidget.attr("value", this.displayMonth);
if (curWidget.header) {
dojo.style(curWidget.header, "display", "none");
}
if (nextWidget.header) {
dojo.style(nextWidget.header, "display", "");
}
dojo.style(nextWidget.domNode, "top", (height * -1) + "px");
dojo.style(nextWidget.domNode, "visibility", "visible");
this._currentChild += direction;
var height1 = height * direction;
var height2 = 0;
dojo.style(nextWidget.domNode, "top", (height1 * -1) + "px");
// summary: Slides two nodes vertically.
var anim1 = dojo.animateProperty({
node: curWidget.domNode,
properties: {top: height1},
onEnd: function(){
dojo.style(curWidget.domNode, "visibility", "hidden");
}
});
var anim2 = dojo.animateProperty({
node: nextWidget.domNode,
properties: {top: height2},
onEnd: function(){
nextWidget.onDisplay();
}
});
dojo[nextWidget.useHeader ? "removeClass" : "addClass"](this.container, "no-header");
anim1.play();
anim2.play();
curWidget.onBeforeUnDisplay()
nextWidget.onBeforeDisplay();
this._updateTitleStyle();
return true;
},
_updateTitleStyle: function(){
dojo[this._currentChild < this._children.length -1 ? "addClass" : "removeClass"](this.header, "navToPanel");
},
_slideTable: function(/*String*/widget, /*Number*/direction, /*Function*/callback){
// summary: Animates the horizontal sliding of a table.
var table = widget.domNode;
//Clone the existing table
var newTable = table.cloneNode(true);
var left = dojo.style(table, "width");
table.parentNode.appendChild(newTable);
//Place the existing node either to the left or the right of the new node,
//depending on which direction it is to slide.
dojo.style(table, "left", (left * direction) + "px");
//Call the function that generally populates the new cloned node with new data.
//It may also attach event listeners.
callback();
//Animate the two nodes.
var anim1 = dojo.animateProperty({node: newTable, properties:{left: left * direction * -1}, duration: 500, onEnd: function(){
newTable.parentNode.removeChild(newTable);
}});
var anim2 = dojo.animateProperty({node: table, properties:{left: 0}, duration: 500});
anim1.play();
anim2.play();
},
_addView: function(view) {
//Insert the view at the start of the array.
this._views.push(view);
},
getClassForDate: function(/*Date*/dateObject, /*String?*/locale){
// summary:
// May be overridden to return CSS classes to associate with the date entry for the given dateObject,
// for example to indicate a holiday in specified locale.
/*=====
return ""; // String
=====*/
},
_adjustDisplay: function(/*String*/part, /*int*/amount, noSlide){
// summary: This function overrides the base function defined in dijit._Calendar.
// It changes the displayed years, months and days depending on the inputs.
var child = this._children[this._currentChild];
var month = this.displayMonth = child.adjustDate(this.displayMonth, amount);
this._slideTable(child, amount, function(){
child.attr("value", month);
});
}
});
dojo.declare("dojox.widget._CalendarView", dijit._Widget, {
// summary: Base implementation for all view mixins.
// All calendar views should extend this widget.
headerClass: "",
useHeader: true,
cloneClass: function(clazz, n, before){
// summary: Clones all nodes with the class 'clazz' in a widget
var template = dojo.query(clazz, this.domNode)[0];
if (!before) {
for (var i = 0; i < n; i++) {
template.parentNode.appendChild(template.cloneNode(true));
}
} else {
var bNode = dojo.query(clazz, this.domNode)[0];
for (var i = 0; i < n; i++) {
template.parentNode.insertBefore(template.cloneNode(true), bNode);
}
}
},
_setText: function(node, text){
// summary: sets the text inside a node
while(node.firstChild){
node.removeChild(node.firstChild);
}
node.appendChild(dojo.doc.createTextNode(text));
},
getHeader: function(){
// summary: Returns the header node of a view. If none exists,
// an empty DIV is created and returned.
return this.header || (this.header = this.header = dojo.create("span", { "class":this.headerClass }));
},
onValueSelected: function(date){
//Stub function called when a date is selected
},
adjustDate: function(date, amount){
// summary: Adds or subtracts values from a date.
// The unit, e.g. "day", "month" or "year", is
// specified in the "datePart" property of the
// calendar view mixin.
return dojo.date.add(date, this.datePart, amount);
},
onDisplay: function(){
// summary: Stub function that can be used to tell a view when it is shown.
},
onBeforeDisplay: function(){
// summary: Stub function that can be used to tell a view it is about to be shown.
},
onBeforeUnDisplay: function(){
// summary: Stub function that can be used to tell
// a view when it is no longer shown.
}
});
dojo.declare("dojox.widget._CalendarDay", null, {
// summary: Mixin for the dojox.widget.Calendar which provides
// the standard day-view. A single month is shown at a time.
parent: null,
constructor: function(){
this._addView(dojox.widget._CalendarDayView);
}
});
dojo.declare("dojox.widget._CalendarDayView", [dojox.widget._CalendarView, dijit._Templated], {
// summary: View class for the dojox.widget.Calendar.
// Adds a view showing every day of a single month to the calendar.
// This should not be mixed in directly with dojox.widget._CalendarBase.
// Instead, use dojox.widget._CalendarDay
// templatePath: URL
// the path to the template to be used to construct the widget.
templatePath: dojo.moduleUrl("dojox.widget","Calendar/CalendarDay.html"),
// datePart: String
// Specifies how much to increment the displayed date when the user
// clicks the array button to increment of decrement the view.
datePart: "month",
// dayWidth: String
// Specifies the type of day name to display. "narrow" causes just one letter to be shown.
dayWidth: "narrow",
postCreate: function(){
// summary: Constructs the calendar view.
this.cloneClass(".dijitCalendarDayLabelTemplate", 6);
this.cloneClass(".dijitCalendarDateTemplate", 6);
// now make 6 week rows
this.cloneClass(".dijitCalendarWeekTemplate", 5);
// insert localized day names in the header
var dayNames = dojo.date.locale.getNames('days', this.dayWidth, 'standAlone', this.getLang());
var dayOffset = dojo.cldr.supplemental.getFirstDayOfWeek(this.getLang());
// Set the text of the day labels.
dojo.query(".dijitCalendarDayLabel", this.domNode).forEach(function(label, i){
this._setText(label, dayNames[(i + dayOffset) % 7]);
}, this);
},
onDisplay: function(){
if(!this._addedFx) {
// Add visual effects to the view, if any has been specified.
this._addedFx = true;
this.addFx(".dijitCalendarDateTemplate div", this.domNode);
}
},
_onDayClick: function(e) {
// summary: executed when a day value is clicked.
var date = new Date(this.attr("value"));
var p = e.target.parentNode;
var c = "dijitCalendar";
var d = dojo.hasClass(p, c + "PreviousMonth") ? -1 :
(dojo.hasClass(p, c + "NextMonth") ? 1 : 0);
if (d){date = dojo.date.add(date, "month", d)}
date.setDate(e.target._date);
// If the day is disabled, ignore it
if (this.isDisabledDate(date)) {
dojo.stopEvent(e);
return;
}
this.attr('value', date);
this.parent._onDateSelected(date);
},
_setValueAttr: function(value) {
//Change the day values
this._populateDays();
},
_populateDays: function() {
// summary: Fills the days of the current month.
var month = this.attr("value");
month.setDate(1);
var firstDay = month.getDay();
var daysInMonth = dojo.date.getDaysInMonth(month);
var daysInPreviousMonth = dojo.date.getDaysInMonth(dojo.date.add(month, "month", -1));
var today = new Date();
var selected = this.attr('value');
var dayOffset = dojo.cldr.supplemental.getFirstDayOfWeek(this.getLang());
if(dayOffset > firstDay){ dayOffset -= 7; }
// Iterate through dates in the calendar and fill in date numbers and style info
dojo.query(".dijitCalendarDateTemplate", this.domNode).forEach(function(template, i){
i += dayOffset;
var date = new Date(month);
var number, clazz = "dijitCalendar", adj = 0;
if(i < firstDay){
number = daysInPreviousMonth - firstDay + i + 1;
adj = -1;
clazz += "Previous";
}else if(i >= (firstDay + daysInMonth)){
number = i - firstDay - daysInMonth + 1;
adj = 1;
clazz += "Next";
}else{
number = i - firstDay + 1;
clazz += "Current";
}
if(adj){
date = dojo.date.add(date, "month", adj);
}
date.setDate(number);
if(!dojo.date.compare(date, today, "date")){
clazz = "dijitCalendarCurrentDate " + clazz;
}
if(!dojo.date.compare(date, selected, "date")){
clazz = "dijitCalendarSelectedDate " + clazz;
}
if(this.isDisabledDate(date, this.getLang())){
clazz = " dijitCalendarDisabledDate " + clazz;
}
var clazz2 = this.getClassForDate(date, this.getLang());
if(clazz2){
clazz += clazz2 + " " + clazz;
}
template.className = clazz + "Month dijitCalendarDateTemplate";
template.dijitDateValue = date.valueOf();
var label = dojo.query(".dijitCalendarDateLabel", template)[0];
this._setText(label, date.getDate());
label._date = label.parentNode._date = date.getDate();
}, this);
// Fill in localized month name
var monthNames = dojo.date.locale.getNames('months', 'wide', 'standAlone', this.getLang());
this._setText(this.monthLabelNode, monthNames[month.getMonth()]);
this._setText(this.yearLabelNode, month.getFullYear());
}
});
dojo.declare("dojox.widget._CalendarMonthYear", null, {
// summary: Mixin class for adding a view listing all 12 months of the year to the
// dojox.widget._CalendarBase
constructor: function(){
// summary: Adds a dojox.widget._CalendarMonthView view to the calendar widget.
this._addView(dojox.widget._CalendarMonthYearView);
}
});
dojo.declare("dojox.widget._CalendarMonthYearView", [dojox.widget._CalendarView, dijit._Templated], {
// summary: A Calendar view listing the 12 months of the year
// templatePath: URL
// the path to the template to be used to construct the widget.
templatePath: dojo.moduleUrl("dojox.widget","Calendar/CalendarMonthYear.html"),
// datePart: String
// Specifies how much to increment the displayed date when the user
// clicks the array button to increment of decrement the view.
datePart: "year",
displayedYears: 10,
useHeader: false,
postCreate: function(){
// summary: Constructs the view
this.cloneClass(".dojoxCal-MY-G-Template", 5, ".dojoxCal-MY-btns");
this.monthContainer = this.yearContainer = this.myContainer;
var yClass = "dojoxCalendarYearLabel";
var dClass = "dojoxCalendarDecrease";
var iClass = "dojoxCalendarIncrease";
dojo.query("." + yClass, this.myContainer).forEach(function(node, idx){
var clazz = iClass;
switch (idx) {
case 0:
clazz = dClass;
case 1:
dojo.removeClass(node, yClass);
dojo.addClass(node, clazz);
break;
}
});
// Get the year increment and decrement buttons.
this._decBtn = dojo.query('.' + dClass, this.myContainer)[0];
this._incBtn = dojo.query('.' + iClass, this.myContainer)[0];
dojo.query(".dojoxCal-MY-M-Template", this.domNode)
.filter(function(item){
return item.cellIndex == 1;
})
.addClass("dojoxCal-MY-M-last");
dojo.connect(this, "onBeforeDisplay", dojo.hitch(this, function(){
this._cachedDate = new Date(this.attr("value").getTime());
this._populateYears(this._cachedDate.getFullYear());
this._populateMonths();
this._updateSelectedMonth();
this._updateSelectedYear();
}));
dojo.connect(this, "_populateYears", dojo.hitch(this, function(){
this._updateSelectedYear();
}));
dojo.connect(this, "_populateMonths", dojo.hitch(this, function(){
this._updateSelectedMonth();
}));
this._cachedDate = this.attr("value");
this._populateYears();
this._populateMonths();
// Add visual effects to the view, if any have been mixed in
this.addFx(".dojoxCalendarMonthLabel,.dojoxCalendarYearLabel ", this.myContainer);
},
_setValueAttr: function(value){
this._populateYears(value.getFullYear());
},
getHeader: function(){
return null;
},
_getMonthNames: function(format) {
// summary: Returns localized month names
this._monthNames = this._monthNames || dojo.date.locale.getNames('months', format, 'standAlone', this.getLang());
return this._monthNames;
},
_populateMonths: function() {
// summary: Populate the month names using the localized values.
var monthNames = this._getMonthNames('abbr');
dojo.query(".dojoxCalendarMonthLabel", this.monthContainer).forEach(dojo.hitch(this, function(node, cnt){
this._setText(node, monthNames[cnt]);
}));
var constraints = this.attr('constraints');
if (constraints) {
var date = new Date();
date.setFullYear(this._year);
var min = -1, max = 12;
if (constraints.min) {
var minY = constraints.min.getFullYear();
if (minY > this._year) {
min = 12;
} else if (minY == this._year) {
min = constraints.min.getMonth();
}
}
if (constraints.max) {
var maxY = constraints.max.getFullYear();
if (maxY < this._year) {
max = -1;
} else if (maxY == this._year) {
max = constraints.max.getMonth();
}
}
dojo.query(".dojoxCalendarMonthLabel", this.monthContainer).forEach(dojo.hitch(this, function(node, cnt){
dojo[(cnt < min || cnt > max) ? "addClass" : "removeClass"](node, 'dijitCalendarDisabledDate');
}));
}
var h = this.getHeader();
if (h) {
this._setText(this.getHeader(), this.attr("value").getFullYear());
}
},
_populateYears: function(year) {
// summary: Fills the list of years with a range of 12 numbers, with the current year
// being the 6th number.
var constraints = this.attr('constraints');
var dispYear = year || this.attr("value").getFullYear();
var firstYear = dispYear - Math.floor(this.displayedYears/2);
var min = constraints && constraints.min ? constraints.min.getFullYear() : firstYear -10000;
firstYear = Math.max(min, firstYear);
// summary: Writes the years to display to the view
this._displayedYear = dispYear;
var yearLabels = dojo.query(".dojoxCalendarYearLabel", this.yearContainer);
var max = constraints && constraints.max ? constraints.max.getFullYear() - firstYear : yearLabels.length;
var disabledClass = 'dijitCalendarDisabledDate';
yearLabels.forEach(dojo.hitch(this, function(node, cnt){
if (cnt <= max) {
this._setText(node, firstYear + cnt);
dojo.removeClass(node, disabledClass);
} else {
dojo.addClass(node, disabledClass);
}
}));
if (this._incBtn) {
dojo[max < yearLabels.length ? "addClass" : "removeClass"](this._incBtn, disabledClass);
}
if (this._decBtn) {
dojo[min >= firstYear ? "addClass" : "removeClass"](this._decBtn, disabledClass);
}
var h = this.getHeader();
if (h) {
this._setText(this.getHeader(), firstYear + " - " + (firstYear + 11));
}
},
_updateSelectedYear: function(){
this._year = String((this._cachedDate || this.attr("value")).getFullYear());
this._updateSelectedNode(".dojoxCalendarYearLabel", dojo.hitch(this, function(node, idx){
return this._year !== null && node.innerHTML == this._year;
}));
},
_updateSelectedMonth: function(){
var month = (this._cachedDate || this.attr("value")).getMonth();
this._month = month;
this._updateSelectedNode(".dojoxCalendarMonthLabel", function(node, idx){
return idx == month;
});
},
_updateSelectedNode: function(query, filter){
var sel = "dijitCalendarSelectedDate";
dojo.query(query, this.domNode)
.forEach(function(node, idx, array) {
dojo[filter(node, idx, array) ? "addClass" : "removeClass"](node.parentNode, sel);
});
var selMonth = dojo.query('.dojoxCal-MY-M-Template div', this.myContainer).filter(function(node){
return dojo.hasClass(node.parentNode, sel);
})[0];
if (!selMonth){return;}
var disabled = dojo.hasClass(selMonth, 'dijitCalendarDisabledDate');
dojo[disabled ? 'addClass' : 'removeClass'](this.okBtn, "dijitDisabled");
},
onClick: function(evt) {
var clazz;
var _this = this;
var sel = "dijitCalendarSelectedDate";
function hc(c) {
return dojo.hasClass(evt.target, c);
}
if (hc('dijitCalendarDisabledDate')) {
dojo.stopEvent(evt);
return;
}
// summary: Handles clicks on month names
if(hc("dojoxCalendarMonthLabel")){
clazz = "dojoxCal-MY-M-Template";
this._month = evt.target.parentNode.cellIndex + (evt.target.parentNode.parentNode.rowIndex * 2);
this._cachedDate.setMonth(this._month);
this._updateSelectedMonth();
} else if (hc( "dojoxCalendarYearLabel")) {
clazz = "dojoxCal-MY-Y-Template";
this._year = Number(evt.target.innerHTML);
this._cachedDate.setYear(this._year);
this._populateMonths();
this._updateSelectedYear();
} else if(hc("dojoxCalendarDecrease")) {
this._populateYears(this._displayedYear - 10);
return
} else if(hc("dojoxCalendarIncrease")) {
this._populateYears(this._displayedYear + 10);
return
} else {
return true;
}
dojo.stopEvent(evt);
return false;
},
onOk: function(evt){
dojo.stopEvent(evt);
if (dojo.hasClass(this.okBtn, "dijitDisabled")) {
return false;
}
this.onValueSelected(this._cachedDate);
return false;
},
onCancel: function(evt){
dojo.stopEvent(evt);
this.onValueSelected(this.attr("value"));
return false;
}
});
dojo.declare("dojox.widget.Calendar2Pane",
[dojox.widget._CalendarBase,
dojox.widget._CalendarDay,
dojox.widget._CalendarMonthYear], {
// summary: A Calendar with two panes, the second one
// containing both month and year
}
);
dojo.declare("dojox.widget.Calendar",
[dojox.widget._CalendarBase,
dojox.widget._CalendarDay,
dojox.widget._CalendarMonthYear], {
// summary: The standard Calendar. It includes day and month/year views.
// No visual effects are included.
}
);
dojo.declare("dojox.widget.DailyCalendar",
[dojox.widget._CalendarBase,
dojox.widget._CalendarDay], {
// summary: A calendar with only a daily view.
}
);
dojo.declare("dojox.widget.MonthAndYearlyCalendar",
[dojox.widget._CalendarBase,
dojox.widget._CalendarMonthYear], {
// summary: A calendar with only a daily view.
}
);