You are viewing a plain text version of this content. The canonical link for it is here.
Posted to xap-commits@incubator.apache.org by jm...@apache.org on 2006/06/27 22:49:06 UTC
svn commit: r417618 [2/19] - in /incubator/xap/trunk/src/dojo/src: ./ lfx/
logging/ rpc/ selection/ storage/ string/ text/ undo/ uri/ uuid/ widget/
widget/html/ widget/svg/ widget/templates/ widget/templates/buttons/
widget/templates/images/ widget/tem...
Added: incubator/xap/trunk/src/dojo/src/date.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/src/dojo/src/date.js?rev=417618&view=auto
==============================================================================
--- incubator/xap/trunk/src/dojo/src/date.js (added)
+++ incubator/xap/trunk/src/dojo/src/date.js Tue Jun 27 15:48:54 2006
@@ -0,0 +1,761 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.date");
+
+
+/* Supplementary Date Functions
+ *******************************/
+
+dojo.date.setDayOfYear = function (dateObject, dayofyear) {
+ dateObject.setMonth(0);
+ dateObject.setDate(dayofyear);
+ return dateObject;
+}
+
+dojo.date.getDayOfYear = function (dateObject) {
+ var firstDayOfYear = new Date(dateObject.getFullYear(), 0, 1);
+ return Math.floor((dateObject.getTime() -
+ firstDayOfYear.getTime()) / 86400000);
+}
+
+
+
+
+dojo.date.setWeekOfYear = function (dateObject, week, firstDay) {
+ if (arguments.length == 1) { firstDay = 0; } // Sunday
+ dojo.unimplemented("dojo.date.setWeekOfYear");
+}
+
+dojo.date.getWeekOfYear = function (dateObject, firstDay) {
+ if (arguments.length == 1) { firstDay = 0; } // Sunday
+
+ // work out the first day of the year corresponding to the week
+ var firstDayOfYear = new Date(dateObject.getFullYear(), 0, 1);
+ var day = firstDayOfYear.getDay();
+ firstDayOfYear.setDate(firstDayOfYear.getDate() -
+ day + firstDay - (day > firstDay ? 7 : 0));
+
+ return Math.floor((dateObject.getTime() -
+ firstDayOfYear.getTime()) / 604800000);
+}
+
+
+
+
+dojo.date.setIsoWeekOfYear = function (dateObject, week, firstDay) {
+ if (arguments.length == 1) { firstDay = 1; } // Monday
+ dojo.unimplemented("dojo.date.setIsoWeekOfYear");
+}
+
+dojo.date.getIsoWeekOfYear = function (dateObject, firstDay) {
+ if (arguments.length == 1) { firstDay = 1; } // Monday
+ dojo.unimplemented("dojo.date.getIsoWeekOfYear");
+}
+
+
+
+
+/* ISO 8601 Functions
+ *********************/
+
+dojo.date.setIso8601 = function (dateObject, string){
+ var comps = (string.indexOf("T") == -1) ? string.split(" ") : string.split("T");
+ dojo.date.setIso8601Date(dateObject, comps[0]);
+ if (comps.length == 2) { dojo.date.setIso8601Time(dateObject, comps[1]); }
+ return dateObject;
+}
+
+dojo.date.fromIso8601 = function (string) {
+ return dojo.date.setIso8601(new Date(0, 0), string);
+}
+
+
+
+
+dojo.date.setIso8601Date = function (dateObject, string) {
+ var regexp = "^([0-9]{4})((-?([0-9]{2})(-?([0-9]{2}))?)|" +
+ "(-?([0-9]{3}))|(-?W([0-9]{2})(-?([1-7]))?))?$";
+ var d = string.match(new RegExp(regexp));
+ if(!d) {
+ dojo.debug("invalid date string: " + string);
+ return false;
+ }
+ var year = d[1];
+ var month = d[4];
+ var date = d[6];
+ var dayofyear = d[8];
+ var week = d[10];
+ var dayofweek = (d[12]) ? d[12] : 1;
+
+ dateObject.setYear(year);
+
+ if (dayofyear) { dojo.date.setDayOfYear(dateObject, Number(dayofyear)); }
+ else if (week) {
+ dateObject.setMonth(0);
+ dateObject.setDate(1);
+ var gd = dateObject.getDay();
+ var day = (gd) ? gd : 7;
+ var offset = Number(dayofweek) + (7 * Number(week));
+
+ if (day <= 4) { dateObject.setDate(offset + 1 - day); }
+ else { dateObject.setDate(offset + 8 - day); }
+ } else {
+ if (month) {
+ dateObject.setDate(1);
+ dateObject.setMonth(month - 1);
+ }
+ if (date) { dateObject.setDate(date); }
+ }
+
+ return dateObject;
+}
+
+dojo.date.fromIso8601Date = function (string) {
+ return dojo.date.setIso8601Date(new Date(0, 0), string);
+}
+
+
+
+
+dojo.date.setIso8601Time = function (dateObject, string) {
+ // first strip timezone info from the end
+ var timezone = "Z|(([-+])([0-9]{2})(:?([0-9]{2}))?)$";
+ var d = string.match(new RegExp(timezone));
+
+ var offset = 0; // local time if no tz info
+ if (d) {
+ if (d[0] != 'Z') {
+ offset = (Number(d[3]) * 60) + Number(d[5]);
+ offset *= ((d[2] == '-') ? 1 : -1);
+ }
+ offset -= dateObject.getTimezoneOffset();
+ string = string.substr(0, string.length - d[0].length);
+ }
+
+ // then work out the time
+ var regexp = "^([0-9]{2})(:?([0-9]{2})(:?([0-9]{2})(\.([0-9]+))?)?)?$";
+ var d = string.match(new RegExp(regexp));
+ if(!d) {
+ dojo.debug("invalid time string: " + string);
+ return false;
+ }
+ var hours = d[1];
+ var mins = Number((d[3]) ? d[3] : 0);
+ var secs = (d[5]) ? d[5] : 0;
+ var ms = d[7] ? (Number("0." + d[7]) * 1000) : 0;
+
+ dateObject.setHours(hours);
+ dateObject.setMinutes(mins);
+ dateObject.setSeconds(secs);
+ dateObject.setMilliseconds(ms);
+
+ return dateObject;
+}
+
+dojo.date.fromIso8601Time = function (string) {
+ return dojo.date.setIso8601Time(new Date(0, 0), string);
+}
+
+
+
+/* Informational Functions
+ **************************/
+
+dojo.date.shortTimezones = ["IDLW", "BET", "HST", "MART", "AKST", "PST", "MST",
+ "CST", "EST", "AST", "NFT", "BST", "FST", "AT", "GMT", "CET", "EET", "MSK",
+ "IRT", "GST", "AFT", "AGTT", "IST", "NPT", "ALMT", "MMT", "JT", "AWST",
+ "JST", "ACST", "AEST", "LHST", "VUT", "NFT", "NZT", "CHAST", "PHOT",
+ "LINT"];
+dojo.date.timezoneOffsets = [-720, -660, -600, -570, -540, -480, -420, -360,
+ -300, -240, -210, -180, -120, -60, 0, 60, 120, 180, 210, 240, 270, 300,
+ 330, 345, 360, 390, 420, 480, 540, 570, 600, 630, 660, 690, 720, 765, 780,
+ 840];
+/*
+dojo.date.timezones = ["International Date Line West", "Bering Standard Time",
+ "Hawaiian Standard Time", "Marquesas Time", "Alaska Standard Time",
+ "Pacific Standard Time (USA)", "Mountain Standard Time",
+ "Central Standard Time (USA)", "Eastern Standard Time (USA)",
+ "Atlantic Standard Time", "Newfoundland Time", "Brazil Standard Time",
+ "Fernando de Noronha Standard Time (Brazil)", "Azores Time",
+ "Greenwich Mean Time", "Central Europe Time", "Eastern Europe Time",
+ "Moscow Time", "Iran Standard Time", "Gulf Standard Time",
+ "Afghanistan Time", "Aqtobe Time", "Indian Standard Time", "Nepal Time",
+ "Almaty Time", "Myanmar Time", "Java Time",
+ "Australian Western Standard Time", "Japan Standard Time",
+ "Australian Central Standard Time", "Lord Hove Standard Time (Australia)",
+ "Vanuata Time", "Norfolk Time (Australia)", "New Zealand Standard Time",
+ "Chatham Standard Time (New Zealand)", "Phoenix Islands Time (Kribati)",
+ "Line Islands Time (Kribati)"];
+*/
+dojo.date.months = ["January", "February", "March", "April", "May", "June",
+ "July", "August", "September", "October", "November", "December"];
+dojo.date.shortMonths = ["Jan", "Feb", "Mar", "Apr", "May", "June",
+ "July", "Aug", "Sep", "Oct", "Nov", "Dec"];
+dojo.date.days = ["Sunday", "Monday", "Tuesday", "Wednesday",
+ "Thursday", "Friday", "Saturday"];
+dojo.date.shortDays = ["Sun", "Mon", "Tues", "Wed", "Thur", "Fri", "Sat"];
+
+
+dojo.date.getDaysInMonth = function (dateObject) {
+ var month = dateObject.getMonth();
+ var days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+ if (month == 1 && dojo.date.isLeapYear(dateObject)) { return 29; }
+ else { return days[month]; }
+}
+
+dojo.date.isLeapYear = function (dateObject) {
+ /*
+ * Leap years are years with an additional day YYYY-02-29, where the year
+ * number is a multiple of four with the following exception: If a year
+ * is a multiple of 100, then it is only a leap year if it is also a
+ * multiple of 400. For example, 1900 was not a leap year, but 2000 is one.
+ */
+ var year = dateObject.getFullYear();
+ return (year%400 == 0) ? true : (year%100 == 0) ? false : (year%4 == 0) ? true : false;
+}
+
+
+
+dojo.date.getDayName = function (dateObject) {
+ return dojo.date.days[dateObject.getDay()];
+}
+
+dojo.date.getDayShortName = function (dateObject) {
+ return dojo.date.shortDays[dateObject.getDay()];
+}
+
+
+
+
+dojo.date.getMonthName = function (dateObject) {
+ return dojo.date.months[dateObject.getMonth()];
+}
+
+dojo.date.getMonthShortName = function (dateObject) {
+ return dojo.date.shortMonths[dateObject.getMonth()];
+}
+
+
+
+
+dojo.date.getTimezoneName = function (dateObject) {
+ // need to negate timezones to get it right
+ // i.e UTC+1 is CET winter, but getTimezoneOffset returns -60
+ var timezoneOffset = -(dateObject.getTimezoneOffset());
+
+ for (var i = 0; i < dojo.date.timezoneOffsets.length; i++) {
+ if (dojo.date.timezoneOffsets[i] == timezoneOffset) {
+ return dojo.date.shortTimezones[i];
+ }
+ }
+
+ // we don't know so return it formatted as "+HH:MM"
+ function $ (s) { s = String(s); while (s.length < 2) { s = "0" + s; } return s; }
+ return (timezoneOffset < 0 ? "-" : "+") + $(Math.floor(Math.abs(
+ timezoneOffset)/60)) + ":" + $(Math.abs(timezoneOffset)%60);
+}
+
+
+
+
+dojo.date.getOrdinal = function (dateObject) {
+ var date = dateObject.getDate();
+
+ if (date%100 != 11 && date%10 == 1) { return "st"; }
+ else if (date%100 != 12 && date%10 == 2) { return "nd"; }
+ else if (date%100 != 13 && date%10 == 3) { return "rd"; }
+ else { return "th"; }
+}
+
+
+
+/* Date Formatter Functions
+ ***************************/
+
+// POSIX strftime
+// see <http://www.opengroup.org/onlinepubs/007908799/xsh/strftime.html>
+dojo.date.format = dojo.date.strftime = function (dateObject, format) {
+
+ // zero pad
+ var padChar = null;
+ function _ (s, n) {
+ s = String(s);
+ n = (n || 2) - s.length;
+ while (n-- > 0) { s = (padChar == null ? "0" : padChar) + s; }
+ return s;
+ }
+
+ function $ (property) {
+ switch (property) {
+ case "a": // abbreviated weekday name according to the current locale
+ return dojo.date.getDayShortName(dateObject); break;
+
+ case "A": // full weekday name according to the current locale
+ return dojo.date.getDayName(dateObject); break;
+
+ case "b":
+ case "h": // abbreviated month name according to the current locale
+ return dojo.date.getMonthShortName(dateObject); break;
+
+ case "B": // full month name according to the current locale
+ return dojo.date.getMonthName(dateObject); break;
+
+ case "c": // preferred date and time representation for the current
+ // locale
+ return dateObject.toLocaleString(); break;
+
+ case "C": // century number (the year divided by 100 and truncated
+ // to an integer, range 00 to 99)
+ return _(Math.floor(dateObject.getFullYear()/100)); break;
+
+ case "d": // day of the month as a decimal number (range 01 to 31)
+ return _(dateObject.getDate()); break;
+
+ case "D": // same as %m/%d/%y
+ return $("m") + "/" + $("d") + "/" + $("y"); break;
+
+ case "e": // day of the month as a decimal number, a single digit is
+ // preceded by a space (range ' 1' to '31')
+ if (padChar == null) { padChar = " "; }
+ return _(dateObject.getDate(), 2); break;
+
+ case "g": // like %G, but without the century.
+ break;
+
+ case "G": // The 4-digit year corresponding to the ISO week number
+ // (see %V). This has the same format and value as %Y,
+ // except that if the ISO week number belongs to the
+ // previous or next year, that year is used instead.
+ break;
+
+ case "F": // same as %Y-%m-%d
+ return $("Y") + "-" + $("m") + "-" + $("d"); break;
+
+ case "H": // hour as a decimal number using a 24-hour clock (range
+ // 00 to 23)
+ return _(dateObject.getHours()); break;
+
+ case "I": // hour as a decimal number using a 12-hour clock (range
+ // 01 to 12)
+ return _(dateObject.getHours() % 12 || 12); break;
+
+ case "j": // day of the year as a decimal number (range 001 to 366)
+ return _(dojo.date.getDayOfYear(dateObject), 3); break;
+
+ case "m": // month as a decimal number (range 01 to 12)
+ return _(dateObject.getMonth() + 1); break;
+
+ case "M": // minute as a decimal numbe
+ return _(dateObject.getMinutes()); break;
+
+ case "n":
+ return "\n"; break;
+
+ case "p": // either `am' or `pm' according to the given time value,
+ // or the corresponding strings for the current locale
+ return dateObject.getHours() < 12 ? "am" : "pm"; break;
+
+ case "r": // time in a.m. and p.m. notation
+ return $("I") + ":" + $("M") + ":" + $("S") + " " + $("p"); break;
+
+ case "R": // time in 24 hour notation
+ return $("H") + ":" + $("M"); break;
+
+ case "S": // second as a decimal number
+ return _(dateObject.getSeconds()); break;
+
+ case "t":
+ return "\t"; break;
+
+ case "T": // current time, equal to %H:%M:%S
+ return $("H") + ":" + $("M") + ":" + $("S"); break;
+
+ case "u": // weekday as a decimal number [1,7], with 1 representing
+ // Monday
+ return String(dateObject.getDay() || 7); break;
+
+ case "U": // week number of the current year as a decimal number,
+ // starting with the first Sunday as the first day of the
+ // first week
+ return _(dojo.date.getWeekOfYear(dateObject)); break;
+
+ case "V": // week number of the year (Monday as the first day of the
+ // week) as a decimal number [01,53]. If the week containing
+ // 1 January has four or more days in the new year, then it
+ // is considered week 1. Otherwise, it is the last week of
+ // the previous year, and the next week is week 1.
+ return _(dojo.date.getIsoWeekOfYear(dateObject)); break;
+
+ case "W": // week number of the current year as a decimal number,
+ // starting with the first Monday as the first day of the
+ // first week
+ return _(dojo.date.getWeekOfYear(dateObject, 1)); break;
+
+ case "w": // day of the week as a decimal, Sunday being 0
+ return String(dateObject.getDay()); break;
+
+ case "x": // preferred date representation for the current locale
+ // without the time
+ break;
+
+ case "X": // preferred date representation for the current locale
+ // without the time
+ break;
+
+ case "y": // year as a decimal number without a century (range 00 to
+ // 99)
+ return _(dateObject.getFullYear()%100); break;
+
+ case "Y": // year as a decimal number including the century
+ return String(dateObject.getFullYear()); break;
+
+ case "z": // time zone or name or abbreviation
+ var timezoneOffset = dateObject.getTimezoneOffset();
+ return (timezoneOffset < 0 ? "-" : "+") +
+ _(Math.floor(Math.abs(timezoneOffset)/60)) + ":" +
+ _(Math.abs(timezoneOffset)%60); break;
+
+ case "Z": // time zone or name or abbreviation
+ return dojo.date.getTimezoneName(dateObject); break;
+
+ case "%":
+ return "%"; break;
+ }
+ }
+
+ // parse the formatting string and construct the resulting string
+ var string = "";
+ var i = 0, index = 0, switchCase;
+ while ((index = format.indexOf("%", i)) != -1) {
+ string += format.substring(i, index++);
+
+ // inspect modifier flag
+ switch (format.charAt(index++)) {
+ case "_": // Pad a numeric result string with spaces.
+ padChar = " "; break;
+ case "-": // Do not pad a numeric result string.
+ padChar = ""; break;
+ case "0": // Pad a numeric result string with zeros.
+ padChar = "0"; break;
+ case "^": // Convert characters in result string to upper case.
+ switchCase = "upper"; break;
+ case "#": // Swap the case of the result string.
+ switchCase = "swap"; break;
+ default: // no modifer flag so decremenet the index
+ padChar = null; index--; break;
+ }
+
+ // toggle case if a flag is set
+ property = $(format.charAt(index++));
+ if (switchCase == "upper" ||
+ (switchCase == "swap" && /[a-z]/.test(property))) {
+ property = property.toUpperCase();
+ } else if (switchCase == "swap" && !/[a-z]/.test(property)) {
+ property = property.toLowerCase();
+ }
+ swicthCase = null;
+
+ string += property;
+ i = index;
+ }
+ string += format.substring(i);
+
+ return string;
+}
+
+/* compare and add
+ ******************/
+dojo.date.compareTypes={
+ // summary
+ // bitmask for comparison operations.
+ DATE:1, TIME:2
+};
+dojo.date.compare=function(/* Date */ dateA, /* Date */ dateB, /* int */ options){
+ // summary
+ // Compare two date objects by date, time, or both.
+ var dA=dateA;
+ var dB=dateB||new Date();
+ var now=new Date();
+ var opt=options||(dojo.date.compareTypes.DATE|dojo.date.compareTypes.TIME);
+ var d1=new Date(
+ ((opt&dojo.date.compareTypes.DATE)?(dA.getFullYear()):now.getFullYear()),
+ ((opt&dojo.date.compareTypes.DATE)?(dA.getMonth()):now.getMonth()),
+ ((opt&dojo.date.compareTypes.DATE)?(dA.getDate()):now.getDate()),
+ ((opt&dojo.date.compareTypes.TIME)?(dA.getHours()):0),
+ ((opt&dojo.date.compareTypes.TIME)?(dA.getMinutes()):0),
+ ((opt&dojo.date.compareTypes.TIME)?(dA.getSeconds()):0)
+ );
+ var d2=new Date(
+ ((opt&dojo.date.compareTypes.DATE)?(dB.getFullYear()):now.getFullYear()),
+ ((opt&dojo.date.compareTypes.DATE)?(dB.getMonth()):now.getMonth()),
+ ((opt&dojo.date.compareTypes.DATE)?(dB.getDate()):now.getDate()),
+ ((opt&dojo.date.compareTypes.TIME)?(dB.getHours()):0),
+ ((opt&dojo.date.compareTypes.TIME)?(dB.getMinutes()):0),
+ ((opt&dojo.date.compareTypes.TIME)?(dB.getSeconds()):0)
+ );
+ if(d1.valueOf()>d2.valueOf()){
+ return 1; // int
+ }
+ if(d1.valueOf()<d2.valueOf()){
+ return -1; // int
+ }
+ return 0; // int
+}
+
+dojo.date.dateParts={
+ // summary
+ // constants for use in dojo.date.add
+ YEAR:0, MONTH:1, DAY:2, HOUR:3, MINUTE:4, SECOND:5, MILLISECOND:6
+};
+dojo.date.add=function(/* Date */ d, /* dojo.date.dateParts */ unit, /* int */ amount){
+ var n=(amount)?amount:1;
+ var v;
+ switch(unit){
+ case dojo.date.dateParts.YEAR:{
+ v=new Date(d.getFullYear()+n, d.getMonth(), d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
+ break;
+ }
+ case dojo.date.dateParts.MONTH:{
+ v=new Date(d.getFullYear(), d.getMonth()+n, d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
+ break;
+ }
+ case dojo.date.dateParts.HOUR:{
+ v=new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours()+n, d.getMinutes(), d.getSeconds(), d.getMilliseconds());
+ break;
+ }
+ case dojo.date.dateParts.MINUTE:{
+ v=new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours(), d.getMinutes()+n, d.getSeconds(), d.getMilliseconds());
+ break;
+ }
+ case dojo.date.dateParts.SECOND:{
+ v=new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds()+n, d.getMilliseconds());
+ break;
+ }
+ case dojo.date.dateParts.MILLISECOND:{
+ v=new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds()+n);
+ break;
+ }
+ default:{
+ v=new Date(d.getFullYear(), d.getMonth(), d.getDate()+n, d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
+ }
+ };
+ return v; // Date
+};
+
+/* Deprecated
+ *************/
+
+
+dojo.date.toString = function(date, format){
+ dojo.deprecated("dojo.date.toString",
+ "use dojo.date.format instead", "0.4");
+
+ if (format.indexOf("#d") > -1) {
+ format = format.replace(/#dddd/g, dojo.date.getDayOfWeekName(date));
+ format = format.replace(/#ddd/g, dojo.date.getShortDayOfWeekName(date));
+ format = format.replace(/#dd/g, (date.getDate().toString().length==1?"0":"")+date.getDate());
+ format = format.replace(/#d/g, date.getDate());
+ }
+
+ if (format.indexOf("#M") > -1) {
+ format = format.replace(/#MMMM/g, dojo.date.getMonthName(date));
+ format = format.replace(/#MMM/g, dojo.date.getShortMonthName(date));
+ format = format.replace(/#MM/g, ((date.getMonth()+1).toString().length==1?"0":"")+(date.getMonth()+1));
+ format = format.replace(/#M/g, date.getMonth() + 1);
+ }
+
+ if (format.indexOf("#y") > -1) {
+ var fullYear = date.getFullYear().toString();
+ format = format.replace(/#yyyy/g, fullYear);
+ format = format.replace(/#yy/g, fullYear.substring(2));
+ format = format.replace(/#y/g, fullYear.substring(3));
+ }
+
+ // Return if only date needed;
+ if (format.indexOf("#") == -1) {
+ return format;
+ }
+
+ if (format.indexOf("#h") > -1) {
+ var hours = date.getHours();
+ hours = (hours > 12 ? hours - 12 : (hours == 0) ? 12 : hours);
+ format = format.replace(/#hh/g, (hours.toString().length==1?"0":"")+hours);
+ format = format.replace(/#h/g, hours);
+ }
+
+ if (format.indexOf("#H") > -1) {
+ format = format.replace(/#HH/g, (date.getHours().toString().length==1?"0":"")+date.getHours());
+ format = format.replace(/#H/g, date.getHours());
+ }
+
+ if (format.indexOf("#m") > -1) {
+ format = format.replace(/#mm/g, (date.getMinutes().toString().length==1?"0":"")+date.getMinutes());
+ format = format.replace(/#m/g, date.getMinutes());
+ }
+
+ if (format.indexOf("#s") > -1) {
+ format = format.replace(/#ss/g, (date.getSeconds().toString().length==1?"0":"")+date.getSeconds());
+ format = format.replace(/#s/g, date.getSeconds());
+ }
+
+ if (format.indexOf("#T") > -1) {
+ format = format.replace(/#TT/g, date.getHours() >= 12 ? "PM" : "AM");
+ format = format.replace(/#T/g, date.getHours() >= 12 ? "P" : "A");
+ }
+
+ if (format.indexOf("#t") > -1) {
+ format = format.replace(/#tt/g, date.getHours() >= 12 ? "pm" : "am");
+ format = format.replace(/#t/g, date.getHours() >= 12 ? "p" : "a");
+ }
+
+ return format;
+
+}
+
+
+dojo.date.daysInMonth = function (month, year) {
+ dojo.deprecated("daysInMonth(month, year)",
+ "replaced by getDaysInMonth(dateObject)", "0.4");
+ return dojo.date.getDaysInMonth(new Date(year, month, 1));
+}
+
+/**
+ *
+ * Returns a string of the date in the version "January 1, 2004"
+ *
+ * @param date The date object
+ */
+dojo.date.toLongDateString = function(date) {
+ dojo.deprecated("dojo.date.toLongDateString",
+ 'use dojo.date.format(date, "%B %e, %Y") instead', "0.4");
+ return dojo.date.format(date, "%B %e, %Y")
+}
+
+/**
+ *
+ * Returns a string of the date in the version "Jan 1, 2004"
+ *
+ * @param date The date object
+ */
+dojo.date.toShortDateString = function(date) {
+ dojo.deprecated("dojo.date.toShortDateString",
+ 'use dojo.date.format(date, "%b %e, %Y") instead', "0.4");
+ return dojo.date.format(date, "%b %e, %Y");
+}
+
+/**
+ *
+ * Returns military formatted time
+ *
+ * @param date the date object
+ */
+dojo.date.toMilitaryTimeString = function(date){
+ dojo.deprecated("dojo.date.toMilitaryTimeString",
+ 'use dojo.date.format(date, "%T")', "0.4");
+ return dojo.date.format(date, "%T");
+}
+
+/**
+ *
+ * Returns a string of the date relative to the current date.
+ *
+ * @param date The date object
+ *
+ * Example returns:
+ * - "1 minute ago"
+ * - "4 minutes ago"
+ * - "Yesterday"
+ * - "2 days ago"
+ */
+dojo.date.toRelativeString = function(date) {
+ var now = new Date();
+ var diff = (now - date) / 1000;
+ var end = " ago";
+ var future = false;
+ if(diff < 0) {
+ future = true;
+ end = " from now";
+ diff = -diff;
+ }
+
+ if(diff < 60) {
+ diff = Math.round(diff);
+ return diff + " second" + (diff == 1 ? "" : "s") + end;
+ } else if(diff < 3600) {
+ diff = Math.round(diff/60);
+ return diff + " minute" + (diff == 1 ? "" : "s") + end;
+ } else if(diff < 3600*24 && date.getDay() == now.getDay()) {
+ diff = Math.round(diff/3600);
+ return diff + " hour" + (diff == 1 ? "" : "s") + end;
+ } else if(diff < 3600*24*7) {
+ diff = Math.round(diff/(3600*24));
+ if(diff == 1) {
+ return future ? "Tomorrow" : "Yesterday";
+ } else {
+ return diff + " days" + end;
+ }
+ } else {
+ return dojo.date.toShortDateString(date);
+ }
+}
+
+/**
+ * Retrieves the day of the week the Date is set to.
+ *
+ * @return The day of the week
+ */
+dojo.date.getDayOfWeekName = function (date) {
+ dojo.deprecated("dojo.date.getDayOfWeekName",
+ "use dojo.date.getDayName instead", "0.4");
+ return dojo.date.days[date.getDay()];
+}
+
+/**
+ * Retrieves the short day of the week name the Date is set to.
+ *
+ * @return The short day of the week name
+ */
+dojo.date.getShortDayOfWeekName = function (date) {
+ dojo.deprecated("dojo.date.getShortDayOfWeekName",
+ "use dojo.date.getDayShortName instead", "0.4");
+ return dojo.date.shortDays[date.getDay()];
+}
+
+/**
+ * Retrieves the short month name the Date is set to.
+ *
+ * @return The short month name
+ */
+dojo.date.getShortMonthName = function (date) {
+ dojo.deprecated("dojo.date.getShortMonthName",
+ "use dojo.date.getMonthShortName instead", "0.4");
+ return dojo.date.shortMonths[date.getMonth()];
+}
+
+
+/**
+ * Convert a Date to a SQL string, optionally ignoring the HH:MM:SS portion of the Date
+ */
+dojo.date.toSql = function(date, noTime) {
+ return dojo.date.format(date, "%F" + !noTime ? " %T" : "");
+}
+
+/**
+ * Convert a SQL date string to a JavaScript Date object
+ */
+dojo.date.fromSql = function(sqlDate) {
+ var parts = sqlDate.split(/[\- :]/g);
+ while(parts.length < 6) {
+ parts.push(0);
+ }
+ return new Date(parts[0], (parseInt(parts[1],10)-1), parts[2], parts[3], parts[4], parts[5]);
+}
+
Added: incubator/xap/trunk/src/dojo/src/debug.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/src/dojo/src/debug.js?rev=417618&view=auto
==============================================================================
--- incubator/xap/trunk/src/dojo/src/debug.js (added)
+++ incubator/xap/trunk/src/dojo/src/debug.js Tue Jun 27 15:48:54 2006
@@ -0,0 +1,79 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+/**
+ * Produce a line of debug output.
+ * Does nothing unless djConfig.isDebug is true.
+ * varargs, joined with ''.
+ * Caller should not supply a trailing "\n".
+ */
+dojo.debug = function(){
+ if (!djConfig.isDebug) { return; }
+ var args = arguments;
+ if(dj_undef("println", dojo.hostenv)){
+ dojo.raise("dojo.debug not available (yet?)");
+ }
+ var isJUM = dj_global["jum"] && !dj_global["jum"].isBrowser;
+ var s = [(isJUM ? "": "DEBUG: ")];
+ for(var i=0;i<args.length;++i){
+ if(!false && args[i] instanceof Error){
+ var msg = "[" + args[i].name + ": " + dojo.errorToString(args[i]) +
+ (args[i].fileName ? ", file: " + args[i].fileName : "") +
+ (args[i].lineNumber ? ", line: " + args[i].lineNumber : "") + "]";
+ } else {
+ try {
+ var msg = String(args[i]);
+ } catch(e) {
+ if(dojo.render.html.ie) {
+ var msg = "[ActiveXObject]";
+ } else {
+ var msg = "[unknown]";
+ }
+ }
+ }
+ s.push(msg);
+ }
+ if(isJUM){ // this seems to be the only way to get JUM to "play nice"
+ jum.debug(s.join(" "));
+ }else{
+ dojo.hostenv.println(s.join(" "));
+ }
+}
+
+/**
+ * this is really hacky for now - just
+ * display the properties of the object
+**/
+
+dojo.debugShallow = function(obj){
+ if (!djConfig.isDebug) { return; }
+ dojo.debug('------------------------------------------------------------');
+ dojo.debug('Object: '+obj);
+ var props = [];
+ for(var prop in obj){
+ try {
+ props.push(prop + ': ' + obj[prop]);
+ } catch(E) {
+ props.push(prop + ': ERROR - ' + E.message);
+ }
+ }
+ props.sort();
+ for(var i = 0; i < props.length; i++) {
+ dojo.debug(props[i]);
+ }
+ dojo.debug('------------------------------------------------------------');
+}
+
+dojo.debugDeep = function(obj){
+ if (!djConfig.isDebug) { return; }
+ if (!window.open){ return dojo.debug('Deep debugging is only supported in host environments with window.open'); }
+ var win = window.open(dojo.uri.dojoUri("src/debug/deep.html"), '_blank', 'width=600, height=400, resizable=yes, scrollbars=yes, status=yes');
+ win.debugVar = obj;
+}
Propchange: incubator/xap/trunk/src/dojo/src/debug.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/xap/trunk/src/dojo/src/doc.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/src/dojo/src/doc.js?rev=417618&view=auto
==============================================================================
--- incubator/xap/trunk/src/dojo/src/doc.js (added)
+++ incubator/xap/trunk/src/dojo/src/doc.js Tue Jun 27 15:48:54 2006
@@ -0,0 +1,650 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.doc");
+dojo.require("dojo.io.*");
+dojo.require("dojo.event.topic");
+dojo.require("dojo.rpc.JotService");
+dojo.require("dojo.dom");
+
+/*
+ * TODO:
+ *
+ * Package summary needs to compensate for "is"
+ * Handle host environments
+ * Deal with dojo.widget weirdness
+ * Parse parameters
+ * Limit function parameters to only the valid ones (Involves packing parameters onto meta during rewriting)
+ * Package display page
+ *
+ */
+
+dojo.doc._count = 0;
+dojo.doc._keys = {};
+dojo.doc._myKeys = [];
+dojo.doc._callbacks = {function_names: []};
+dojo.doc._cache = {}; // Saves the JSON objects in cache
+dojo.doc._rpc = new dojo.rpc.JotService;
+dojo.doc._rpc.serviceUrl = "http://dojotoolkit.org/~pottedmeat/jsonrpc.php";
+
+dojo.doc.functionNames = function(/*mixed*/ selectKey, /*Function*/ callback){
+ // summary: Returns an ordered list of package and function names.
+ dojo.debug("functionNames()");
+ if(!selectKey){
+ selectKey = ++dojo.doc._count;
+ }
+ dojo.doc._buildCache({
+ type: "function_names",
+ callbacks: [dojo.doc._functionNames, callback],
+ selectKey: selectKey
+ });
+}
+
+dojo.doc._functionNames = function(/*String*/ type, /*Array*/ data, /*Object*/ evt){
+ var searchData = [];
+ for(var key in data){
+ // Add the package if it doesn't exist in its children
+ if(!dojo.lang.inArray(data[key], key)){
+ searchData.push([key, key]);
+ }
+ // Add the functions
+ for(var pkg_key in data[key]){
+ searchData.push([data[key][pkg_key], data[key][pkg_key]]);
+ }
+ }
+
+ searchData = searchData.sort(dojo.doc._sort);
+
+ if(evt.callbacks && evt.callbacks.length){
+ var callback = evt.callbacks.shift();
+ callback.call(null, type, searchData, evt);
+ }
+}
+
+dojo.doc.getMeta = function(/*mixed*/ selectKey, /*Function*/ callback, /*Function*/ name, /*String?*/ id){
+ // summary: Gets information about a function in regards to its meta data
+ dojo.debug("getMeta(" + name + ")");
+ if(!selectKey){
+ selectKey = ++dojo.doc._count;
+ }
+ dojo.doc._buildCache({
+ type: "meta",
+ callbacks: [callback],
+ name: name,
+ id: id,
+ selectKey: selectKey
+ });
+}
+
+dojo.doc._getMeta = function(/*String*/ type, /*Object*/ data, /*Object*/ evt){
+ dojo.debug("_getMeta(" + evt.name + ") has package: " + evt.pkg + " with: " + type);
+ if("load" == type && evt.pkg){
+ evt.type = "meta";
+ dojo.doc._buildCache(evt);
+ }else{
+ if(evt.callbacks && evt.callbacks.length){
+ var callback = evt.callbacks.shift();
+ callback.call(null, "error", {}, evt);
+ }
+ }
+}
+
+dojo.doc.getSrc = function(/*mixed*/ selectKey, /*Function*/ callback, /*String*/ name, /*String?*/ id){
+ // summary: Gets src file (created by the doc parser)
+ dojo.debug("getSrc()");
+ if(!selectKey){
+ selectKey = ++dojo.doc._count;
+ }
+ dojo.doc._buildCache({
+ type: "src",
+ callbacks: [callback],
+ name: name,
+ id: id,
+ selectKey: selectKey
+ });
+}
+
+dojo.doc._getSrc = function(/*String*/ type, /*Object*/ data, /*Object*/ evt){
+ dojo.debug("_getSrc()");
+ if(evt.pkg){
+ evt.type = "src";
+ dojo.doc._buildCache(evt);
+ }else{
+ if(evt.callbacks && evt.callbacks.length){
+ var callback = evt.callbacks.shift();
+ callback.call(null, "error", {}, evt);
+ }
+ }
+}
+
+dojo.doc.getDoc = function(/*mixed*/ selectKey, /*Function*/ callback, /*String*/ name, /*String?*/ id){
+ // summary: Gets external documentation stored on jot
+ dojo.debug("getDoc()");
+ if(!selectKey){
+ selectKey = ++dojo.doc._count;
+ }
+ var input = {
+ type: "doc",
+ callbacks: [callback],
+ name: name,
+ id: id,
+ selectKey: selectKey
+ }
+ dojo.doc.functionPackage(dojo.doc._getDoc, input);
+}
+
+dojo.doc._getDoc = function(/*String*/ type, /*Object*/ data, /*Object*/ evt){
+ dojo.debug("_getDoc(" + evt.pkg + "/" + evt.name + ")");
+
+ dojo.doc._keys[evt.selectKey] = {count: 0};
+
+ var search = {};
+ search.forFormName = "DocFnForm";
+ search.limit = 1;
+
+ if(!evt.id){
+ search.filter = "it/DocFnForm/require = '" + evt.pkg + "' and it/DocFnForm/name = '" + evt.name + "' and not(it/DocFnForm/id)";
+ }else{
+ search.filter = "it/DocFnForm/require = '" + evt.pkg + "' and it/DocFnForm/name = '" + evt.name + "' and it/DocFnForm/id = '" + evt.id + "'";
+ }
+
+ dojo.doc._rpc.callRemote("search", search).addCallbacks(function(data){ evt.type = "fn"; dojo.doc._gotDoc("load", data.list[0], evt); }, function(data){ evt.type = "fn"; dojo.doc._gotDoc("error", {}, evt); });
+
+ search.forFormName = "DocParamForm";
+
+ if(!evt.id){
+ search.filter = "it/DocParamForm/fns = '" + evt.pkg + "=>" + evt.name + "'";
+ }else{
+ search.filter = "it/DocParamForm/fns = '" + evt.pkg + "=>" + evt.name + "=>" + evt.id + "'";
+ }
+ delete search.limit;
+
+ dojo.doc._rpc.callRemote("search", search).addCallbacks(function(data){ evt.type = "param"; dojo.doc._gotDoc("load", data.list, evt); }, function(data){ evt.type = "param"; dojo.doc._gotDoc("error", {}, evt); });
+}
+
+dojo.doc._gotDoc = function(/*String*/ type, /*Array*/ data, /*Object*/ evt){
+ dojo.debug("_gotDoc(" + evt.type + ") for " + evt.selectKey);
+ dojo.doc._keys[evt.selectKey][evt.type] = data;
+ if(++dojo.doc._keys[evt.selectKey].count == 2){
+ dojo.debug("_gotDoc() finished");
+ var keys = dojo.doc._keys[evt.selectKey];
+ var description = '';
+ if(!keys.fn){
+ keys.fn = {}
+ }
+ if(keys.fn["main/text"]){
+ description = dojo.dom.createDocumentFromText(keys.fn["main/text"]).childNodes[0].innerHTML;
+ if(!description){
+ description = keys.fn["main/text"];
+ }
+ }
+ data = {
+ description: description,
+ returns: keys.fn["DocFnForm/returns"],
+ id: keys.fn["DocFnForm/id"],
+ parameters: {},
+ variables: []
+ }
+ for(var i = 0, param; param = keys["param"][i]; i++){
+ data.parameters[param["DocParamForm/name"]] = {
+ description: param["DocParamForm/desc"]
+ };
+ }
+
+ delete dojo.doc._keys[evt.selectKey];
+
+ if(evt.callbacks && evt.callbacks.length){
+ var callback = evt.callbacks.shift();
+ callback.call(null, "load", data, evt);
+ }
+ }
+}
+
+dojo.doc.getPkgMeta = function(/*mixed*/ selectKey, /*Function*/ callback, /*String*/ name){
+ dojo.debug("getPkgMeta(" + name + ")");
+ if(!selectKey){
+ selectKey = ++dojo.doc._count;
+ }
+ dojo.doc._buildCache({
+ type: "pkgmeta",
+ callbacks: [callback],
+ name: name,
+ selectKey: selectKey
+ });
+}
+
+dojo.doc._getPkgMeta = function(/*Object*/ input){
+ dojo.debug("_getPkgMeta(" + input.name + ")");
+ input.type = "pkgmeta";
+ dojo.doc._buildCache(input);
+}
+
+dojo.doc._onDocSearch = function(/*Object*/ input){
+ dojo.debug("_onDocSearch(" + input.name + ")");
+ if(!input.name){
+ return;
+ }
+ if(!input.selectKey){
+ input.selectKey = ++dojo.doc._count;
+ }
+ input.callbacks = [dojo.doc._onDocSearchFn];
+ input.name = input.name.toLowerCase();
+ input.type = "function_names";
+
+ dojo.doc._buildCache(input);
+}
+
+dojo.doc._onDocSearchFn = function(/*String*/ type, /*Array*/ data, /*Object*/ evt){
+ dojo.debug("_onDocSearchFn(" + evt.name + ")");
+ var packages = [];
+ var size = 0;
+ pkgLoop:
+ for(var pkg in data){
+ for(var i = 0, fn; fn = data[pkg][i]; i++){
+ if(fn.toLowerCase().indexOf(evt.name) > -1){
+ // Build a list of all packages that need to be loaded and their loaded state.
+ ++size;
+ packages.push(pkg);
+ continue pkgLoop;
+ }
+ }
+ }
+ dojo.doc._keys[evt.selectKey] = {};
+ dojo.doc._keys[evt.selectKey].pkgs = packages;
+ dojo.doc._keys[evt.selectKey].pkg = evt.name; // Remember what we were searching for
+ dojo.doc._keys[evt.selectKey].loaded = 0;
+ for(var i = 0, pkg; pkg = packages[i]; i++){
+ setTimeout("dojo.doc.getPkgMeta(\"" + evt.selectKey + "\", dojo.doc._onDocResults, \"" + pkg + "\");", i*10);
+ }
+}
+
+dojo.doc._onDocResults = function(/*String*/ type, /*Object*/ data, /*Object*/ evt){
+ dojo.debug("_onDocResults(" + evt.name + "/" + dojo.doc._keys[evt.selectKey].pkg + ") " + type);
+ ++dojo.doc._keys[evt.selectKey].loaded;
+
+ if(dojo.doc._keys[evt.selectKey].loaded == dojo.doc._keys[evt.selectKey].pkgs.length){
+ var info = dojo.doc._keys[evt.selectKey];
+ var pkgs = info.pkgs;
+ var name = info.pkg;
+ delete dojo.doc._keys[evt.selectKey];
+ var results = {selectKey: evt.selectKey, docResults: []};
+ data = dojo.doc._cache;
+
+ for(var i = 0, pkg; pkg = pkgs[i]; i++){
+ if(!data[pkg]){
+ continue;
+ }
+ for(var fn in data[pkg]["meta"]){
+ if(fn.toLowerCase().indexOf(name) == -1){
+ continue;
+ }
+ if(fn != "requires"){
+ for(var sig in data[pkg]["meta"][fn]){
+ var result = {
+ pkg: pkg,
+ name: fn,
+ summary: ""
+ }
+ if(data[pkg]["meta"][fn][sig]["summary"]){
+ result.summary = data[pkg]["meta"][fn][sig]["summary"];
+ }
+ results.docResults.push(result);
+ }
+ }
+ }
+ }
+
+ dojo.debug("Publishing docResults");
+ dojo.event.topic.publish("docResults", results);
+ }
+}
+
+// Get doc
+// Get meta
+// Get src
+// Get function signature
+dojo.doc._onDocSelectFunction = function(/*Object*/ input){
+ dojo.debug("_onDocSelectFunction(" + input.name + ")");
+ if(!input.name){
+ return false;
+ }
+ if(!input.selectKey){
+ input.selectKey = ++dojo.doc._count;
+ }
+
+ dojo.doc._keys[input.selectKey] = {size: 0};
+ dojo.doc._myKeys[++dojo.doc._count] = {selectKey: input.selectKey, type: "meta"}
+ dojo.doc.getMeta(dojo.doc._count, dojo.doc._onDocSelectResults, input.name);
+ dojo.doc._myKeys[++dojo.doc._count] = {selectKey: input.selectKey, type: "src"}
+ dojo.doc.getSrc(dojo.doc._count, dojo.doc._onDocSelectResults, input.name);
+ dojo.doc._myKeys[++dojo.doc._count] = {selectKey: input.selectKey, type: "doc"}
+ dojo.doc.getDoc(dojo.doc._count, dojo.doc._onDocSelectResults, input.name);
+}
+
+dojo.doc._onDocSelectResults = function(/*String*/ type, /*Object*/ data, /*Object*/ evt){
+ dojo.debug("dojo.doc._onDocSelectResults(" + evt.type + ", " + evt.name + ")");
+ var myKey = dojo.doc._myKeys[evt.selectKey];
+ dojo.doc._keys[myKey.selectKey][myKey.type] = data;
+ dojo.doc._keys[myKey.selectKey].size;
+ if(++dojo.doc._keys[myKey.selectKey].size == 3){
+ var key = dojo.lang.mixin(evt, dojo.doc._keys[myKey.selectKey]);
+ delete key.size;
+ dojo.debug(dojo.json.serialize(key));
+ dojo.debug("Publishing docFunctionDetail");
+ dojo.event.topic.publish("docFunctionDetail", key);
+ delete dojo.doc._keys[myKey.selectKey];
+ delete dojo.doc._myKeys[evt.selectKey];
+ }
+}
+
+dojo.doc._buildCache = function(/*Object*/ input){
+ dojo.debug("_buildCache() type: " + input.type);
+ if(input.type == "function_names"){
+ if(!dojo.doc._cache["function_names"]){
+ dojo.debug("_buildCache() new cache");
+ if(input.callbacks && input.callbacks.length){
+ dojo.doc._callbacks.function_names.push([input, input.callbacks.shift()]);
+ }
+ dojo.doc._cache["function_names"] = {loading: true};
+ dojo.io.bind({
+ url: "json/function_names",
+ mimetype: "text/json",
+ error: function(type, data, evt){
+ for(var i = 0, callback; callback = dojo.doc._callbacks.function_names[i]; i++){
+ callback[1].call(null, "error", {}, callback[0]);
+ }
+ },
+ load: function(type, data, evt){
+ for(var key in data){
+ // Packages starting with _ have a parent of "dojo"
+ if(key.charAt(0) == "_"){
+ var new_key = "dojo" + key.substring(1, key.length);
+ data[new_key] = data[key];
+ delete data[key];
+ key = new_key;
+ }
+ // Function names starting with _ have a parent of their package name
+ for(var pkg_key in data[key]){
+ if(data[key][pkg_key].charAt(0) == "_"){
+ var new_value = key + data[key][pkg_key].substring(1, data[key][pkg_key].length);
+ data[key][pkg_key] = new_value;
+ }
+ }
+ // Save data to the cache
+ }
+ dojo.doc._cache['function_names'] = data;
+ for(var i = 0, callback; callback = dojo.doc._callbacks.function_names[i]; i++){
+ callback[1].call(null, "load", data, callback[0]);
+ }
+ }
+ });
+ }else if(dojo.doc._cache["function_names"].loading){
+ dojo.debug("_buildCache() loading cache");
+ if(input.callbacks && input.callbacks.length){
+ dojo.doc._callbacks.function_names.push([input, input.callbacks.shift()]);
+ }
+ }else{
+ dojo.debug("_buildCache() from cache");
+ if(input.callbacks && input.callbacks.length){
+ var callback = input.callbacks.shift();
+ callback.call(null, "load", dojo.doc._cache["function_names"], input);
+ }
+ }
+ }else if(input.type == "meta" || input.type == "src"){
+ if(!input.pkg){
+ if(input.type == "meta"){
+ dojo.doc.functionPackage(dojo.doc._getMeta, input);
+ }else{
+ dojo.doc.functionPackage(dojo.doc._getSrc, input);
+ }
+ }else{
+ try{
+ if(input.id){
+ var cached = dojo.doc._cache[input.pkg][input.name][input.id][input.type];
+ }else{
+ var cached = dojo.doc._cache[input.pkg][input.name][input.type];
+ }
+ }catch(e){}
+
+ if(cached){
+ if(input.callbacks && input.callbacks.length){
+ var callback = input.callbacks.shift();
+ callback.call(null, "load", cached, input);
+ return;
+ }
+ }
+
+ dojo.debug("Finding " + input.type + " for: " + input.pkg + ", function: " + input.name + ", id: " + input.id);
+
+ var name = input.name.replace(new RegExp('^' + input.pkg.replace(/\./g, "\\.")), "_");
+ var pkg = input.pkg.replace(/^(dojo|\*)/g, "_");
+
+ var mimetype = "text/json";
+ if(input.type == "src"){
+ mimetype = "text/plain"
+ }
+
+ var url;
+ if(input.id){
+ url = "json/" + pkg + "/" + name + "/" + input.id + "/" + input.type;
+ }else{
+ url = "json/" + pkg + "/" + name + "/" + input.type;
+ }
+
+ dojo.io.bind({
+ url: url,
+ input: input,
+ mimetype: mimetype,
+ error: function(type, data, evt, args){
+ if(args.input.callbacks && args.input.callbacks.length){
+ if(!data){
+ data = {};
+ }
+ if(!dojo.doc._cache[args.input.pkg]){
+ dojo.doc._cache[args.input.pkg] = {};
+ }
+ if(!dojo.doc._cache[args.input.pkg][args.input.name]){
+ dojo.doc._cache[args.input.pkg][args.input.name] = {};
+ }
+ if(args.input.type == "meta"){
+ if(args.input.id){
+ data.sig = dojo.doc._cache[args.input.pkg][args.input.name][args.input.id].sig;
+ data.params = dojo.doc._cache[args.input.pkg][args.input.name][args.input.id].params;
+ }else{
+ data.sig = dojo.doc._cache[args.input.pkg][args.input.name].sig;
+ data.params = dojo.doc._cache[args.input.pkg][args.input.name].params;
+ }
+ }
+ var callback = args.input.callbacks.shift();
+ callback.call(null, "error", data, args.input);
+ }
+ },
+ load: function(type, data, evt, args){
+ if(!data){
+ data = {};
+ }
+ if(!dojo.doc._cache[args.input.pkg]){
+ dojo.doc._cache[args.input.pkg] = {};
+ }
+ if(!dojo.doc._cache[args.input.pkg][args.input.name]){
+ dojo.doc._cache[args.input.pkg][args.input.name] = {};
+ }
+ if(args.input.id){
+ dojo.doc._cache[args.input.pkg][args.input.name][args.input.id][args.input.type] = data;
+ if(args.input.type == "meta"){
+ data.sig = dojo.doc._cache[args.input.pkg][args.input.name][args.input.id].sig;
+ data.params = dojo.doc._cache[args.input.pkg][args.input.name][args.input.id].params;
+ }
+ }else{
+ dojo.doc._cache[args.input.pkg][args.input.name][args.input.type] = data;
+ if(args.input.type == "meta"){
+ data.sig = dojo.doc._cache[args.input.pkg][args.input.name].sig;
+ data.params = dojo.doc._cache[args.input.pkg][args.input.name].params;
+ }
+ }
+ if(args.input.callbacks && args.input.callbacks.length){
+ var callback = input.callbacks.shift();
+ callback.call(null, "load", data, args.input);
+ }
+ }
+ });
+ }
+ }else if(input.type == "pkgmeta"){
+ try{
+ var cached = dojo.doc._cache[input.name]["meta"];
+ }catch(e){}
+
+ if(cached){
+ if(input.callbacks && input.callbacks.length){
+ var callback = input.callbacks.shift();
+ callback.call(null, "load", cached, input);
+ return;
+ }
+ }
+
+ dojo.debug("Finding package meta for: " + input.name);
+
+ var pkg = input.name.replace(/^(dojo|\*)/g, "_");
+
+ dojo.io.bind({
+ url: "json/" + pkg + "/meta",
+ input: input,
+ mimetype: "text/json",
+ error: function(type, data, evt, args){
+ if(args.input.callbacks && args.input.callbacks.length){
+ var callback = args.input.callbacks.shift();
+ callback.call(null, "error", {}, args.input);
+ }
+ },
+ load: function(type, data, evt, args){
+ if(!dojo.doc._cache[args.input.name]){
+ dojo.doc._cache[args.input.name] = {};
+ }
+
+ for(var key in data){
+ if(key != "requires"){
+ if(key.charAt(0) == "_"){
+ var new_key = args.input.name + key.substring(1, key.length);
+ data[new_key] = data[key];
+ delete data[key];
+ for(var sig in data[new_key]){
+ if(sig == "is"){
+ continue;
+ }
+ var real_sig = sig;
+ if(sig.charAt(0) == "("){
+ real_sig = "undefined " + real_sig;
+ }
+ real_sig = real_sig.split("(");
+ real_sig = real_sig[0] + new_key + "(" + real_sig[1];
+ var parameters = {};
+ var parRegExp = /(?:\(|,)([^,\)]+)/g;
+ var result;
+ while(result = parRegExp.exec(real_sig)){
+ var parts = result[1].split(" ");
+ if(parts.length > 1){
+ var pName = parts.pop();
+ var pType = parts.join(" ");
+ var pOpt = false;
+ if(pType.indexOf("?") != -1){
+ pType = pType.replace("?", "");
+ pOpt = true;
+ }
+ parameters[pName] = {type: pType, opt: pOpt};
+ }else{
+ parameters[parts[0]] = {type: "", opt: false};
+ }
+ }
+ real_sig = real_sig.replace(/\?/g, "");
+ if(data[new_key][sig].summary || dojo.lang.isArray(data[new_key][sig])){
+ if(!dojo.doc._cache[args.input.name][new_key]){
+ dojo.doc._cache[args.input.name][new_key] = {};
+ }
+ dojo.doc._cache[args.input.name][new_key].sig = real_sig;
+ dojo.doc._cache[args.input.name][new_key].params = parameters;
+ }else{
+ // Polymorphic sigs
+ }
+ }
+ }
+ }
+ }
+
+ dojo.doc._cache[args.input.name]["meta"] = data;
+ if(input.callbacks && input.callbacks.length){
+ var callback = input.callbacks.shift();
+ callback.call(null, "load", data, input);
+ }
+ }
+ });
+ }
+}
+
+dojo.doc.selectFunction = function(/*String*/ name, /*String?*/ id){
+ // summary: The combined information
+}
+
+
+
+dojo.doc.savePackage = function(/*String*/ name, /*String*/ description){
+ dojo.doc._rpc.callRemote(
+ "saveForm",
+ {
+ form: "DocPkgForm",
+ path: "/WikiHome/DojoDotDoc/id",
+ pname1: "main/text",
+ pvalue1: "Test"
+ }
+ ).addCallbacks(dojo.doc._results, dojo.doc._results);
+}
+
+dojo.doc.functionPackage = function(/*Function*/ callback, /*Object*/ input){
+ dojo.debug("functionPackage() name: " + input.name + " for type: " + input.type);
+ input.type = "function_names";
+ input.callbacks.unshift(callback);
+ input.callbacks.unshift(dojo.doc._functionPackage);
+ dojo.doc._buildCache(input);
+}
+
+dojo.doc._functionPackage = function(/*String*/ type, /*Array*/ data, /*Object*/ evt){
+ dojo.debug("_functionPackage() name: " + evt.name + " for: " + evt.type + " with: " + type);
+ evt.pkg = '';
+
+ var data = dojo.doc._cache['function_names'];
+ for(var key in data){
+ if(dojo.lang.inArray(data[key], evt.name)){
+ evt.pkg = key;
+ break;
+ }
+ }
+
+ if(evt.callbacks && evt.callbacks.length){
+ var callback = evt.callbacks.shift();
+ callback.call(null, type, data[key], evt);
+ }
+}
+
+dojo.doc._sort = function(a, b){
+ if(a[0] < b[0]){
+ return -1;
+ }
+ if(a[0] > b[0]){
+ return 1;
+ }
+ return 0;
+}
+
+dojo.event.topic.registerPublisher("docSearch");
+dojo.event.topic.registerPublisher("docResults");
+dojo.event.topic.registerPublisher("docSelectFunction");
+dojo.event.topic.registerPublisher("docFunctionDetail");
+
+dojo.event.topic.subscribe("docSearch", dojo.doc, "_onDocSearch");
+dojo.event.topic.subscribe("docSelectFunction", dojo.doc, "_onDocSelectFunction");
Added: incubator/xap/trunk/src/dojo/src/dom.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/src/dojo/src/dom.js?rev=417618&view=auto
==============================================================================
--- incubator/xap/trunk/src/dojo/src/dom.js (added)
+++ incubator/xap/trunk/src/dojo/src/dom.js Tue Jun 27 15:48:54 2006
@@ -0,0 +1,463 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.dom");
+dojo.require("dojo.lang.array");
+
+dojo.dom.ELEMENT_NODE = 1;
+dojo.dom.ATTRIBUTE_NODE = 2;
+dojo.dom.TEXT_NODE = 3;
+dojo.dom.CDATA_SECTION_NODE = 4;
+dojo.dom.ENTITY_REFERENCE_NODE = 5;
+dojo.dom.ENTITY_NODE = 6;
+dojo.dom.PROCESSING_INSTRUCTION_NODE = 7;
+dojo.dom.COMMENT_NODE = 8;
+dojo.dom.DOCUMENT_NODE = 9;
+dojo.dom.DOCUMENT_TYPE_NODE = 10;
+dojo.dom.DOCUMENT_FRAGMENT_NODE = 11;
+dojo.dom.NOTATION_NODE = 12;
+
+dojo.dom.dojoml = "http://www.dojotoolkit.org/2004/dojoml";
+
+/**
+ * comprehensive list of XML namespaces
+**/
+dojo.dom.xmlns = {
+ svg : "http://www.w3.org/2000/svg",
+ smil : "http://www.w3.org/2001/SMIL20/",
+ mml : "http://www.w3.org/1998/Math/MathML",
+ cml : "http://www.xml-cml.org",
+ xlink : "http://www.w3.org/1999/xlink",
+ xhtml : "http://www.w3.org/1999/xhtml",
+ xul : "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
+ xbl : "http://www.mozilla.org/xbl",
+ fo : "http://www.w3.org/1999/XSL/Format",
+ xsl : "http://www.w3.org/1999/XSL/Transform",
+ xslt : "http://www.w3.org/1999/XSL/Transform",
+ xi : "http://www.w3.org/2001/XInclude",
+ xforms : "http://www.w3.org/2002/01/xforms",
+ saxon : "http://icl.com/saxon",
+ xalan : "http://xml.apache.org/xslt",
+ xsd : "http://www.w3.org/2001/XMLSchema",
+ dt: "http://www.w3.org/2001/XMLSchema-datatypes",
+ xsi : "http://www.w3.org/2001/XMLSchema-instance",
+ rdf : "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+ rdfs : "http://www.w3.org/2000/01/rdf-schema#",
+ dc : "http://purl.org/dc/elements/1.1/",
+ dcq: "http://purl.org/dc/qualifiers/1.0",
+ "soap-env" : "http://schemas.xmlsoap.org/soap/envelope/",
+ wsdl : "http://schemas.xmlsoap.org/wsdl/",
+ AdobeExtensions : "http://ns.adobe.com/AdobeSVGViewerExtensions/3.0/"
+};
+
+dojo.dom.isNode = function(wh){
+ if(typeof Element == "object") {
+ try {
+ return wh instanceof Element;
+ } catch(E) {}
+ } else {
+ // best-guess
+ return wh && !isNaN(wh.nodeType);
+ }
+}
+
+dojo.dom.getTagName = function(node){
+ dojo.deprecated("dojo.dom.getTagName", "use node.tagName instead", "0.4");
+
+ var tagName = node.tagName;
+ if(tagName.substr(0,5).toLowerCase()!="dojo:"){
+
+ if(tagName.substr(0,4).toLowerCase()=="dojo"){
+ // FIXME: this assuumes tag names are always lower case
+ return "dojo:" + tagName.substring(4).toLowerCase();
+ }
+
+ // allow lower-casing
+ var djt = node.getAttribute("dojoType")||node.getAttribute("dojotype");
+ if(djt){
+ return "dojo:"+djt.toLowerCase();
+ }
+
+ if((node.getAttributeNS)&&(node.getAttributeNS(this.dojoml,"type"))){
+ return "dojo:" + node.getAttributeNS(this.dojoml,"type").toLowerCase();
+ }
+ try{
+ // FIXME: IE really really doesn't like this, so we squelch
+ // errors for it
+ djt = node.getAttribute("dojo:type");
+ }catch(e){ /* FIXME: log? */ }
+ if(djt){
+ return "dojo:"+djt.toLowerCase();
+ }
+
+ if((!dj_global["djConfig"])||(!djConfig["ignoreClassNames"])){
+ // FIXME: should we make this optionally enabled via djConfig?
+ var classes = node.className||node.getAttribute("class");
+ // FIXME: following line, without check for existence of classes.indexOf
+ // breaks firefox 1.5's svg widgets
+ if((classes)&&(classes.indexOf)&&(classes.indexOf("dojo-") != -1)){
+ var aclasses = classes.split(" ");
+ for(var x=0; x<aclasses.length; x++){
+ if((aclasses[x].length>5)&&(aclasses[x].indexOf("dojo-")>=0)){
+ return "dojo:"+aclasses[x].substr(5).toLowerCase();
+ }
+ }
+ }
+ }
+
+ }
+ return tagName.toLowerCase();
+}
+
+dojo.dom.getUniqueId = function(){
+ do {
+ var id = "dj_unique_" + (++arguments.callee._idIncrement);
+ }while(document.getElementById(id));
+ return id;
+}
+dojo.dom.getUniqueId._idIncrement = 0;
+
+dojo.dom.firstElement = dojo.dom.getFirstChildElement = function(parentNode, tagName){
+ var node = parentNode.firstChild;
+ while(node && node.nodeType != dojo.dom.ELEMENT_NODE){
+ node = node.nextSibling;
+ }
+ if(tagName && node && node.tagName && node.tagName.toLowerCase() != tagName.toLowerCase()) {
+ node = dojo.dom.nextElement(node, tagName);
+ }
+ return node;
+}
+
+dojo.dom.lastElement = dojo.dom.getLastChildElement = function(parentNode, tagName){
+ var node = parentNode.lastChild;
+ while(node && node.nodeType != dojo.dom.ELEMENT_NODE) {
+ node = node.previousSibling;
+ }
+ if(tagName && node && node.tagName && node.tagName.toLowerCase() != tagName.toLowerCase()) {
+ node = dojo.dom.prevElement(node, tagName);
+ }
+ return node;
+}
+
+dojo.dom.nextElement = dojo.dom.getNextSiblingElement = function(node, tagName){
+ if(!node) { return null; }
+ do {
+ node = node.nextSibling;
+ } while(node && node.nodeType != dojo.dom.ELEMENT_NODE);
+
+ if(node && tagName && tagName.toLowerCase() != node.tagName.toLowerCase()) {
+ return dojo.dom.nextElement(node, tagName);
+ }
+ return node;
+}
+
+dojo.dom.prevElement = dojo.dom.getPreviousSiblingElement = function(node, tagName){
+ if(!node) { return null; }
+ if(tagName) { tagName = tagName.toLowerCase(); }
+ do {
+ node = node.previousSibling;
+ } while(node && node.nodeType != dojo.dom.ELEMENT_NODE);
+
+ if(node && tagName && tagName.toLowerCase() != node.tagName.toLowerCase()) {
+ return dojo.dom.prevElement(node, tagName);
+ }
+ return node;
+}
+
+// TODO: hmph
+/*this.forEachChildTag = function(node, unaryFunc) {
+ var child = this.getFirstChildTag(node);
+ while(child) {
+ if(unaryFunc(child) == "break") { break; }
+ child = this.getNextSiblingTag(child);
+ }
+}*/
+
+dojo.dom.moveChildren = function(srcNode, destNode, trim){
+ var count = 0;
+ if(trim) {
+ while(srcNode.hasChildNodes() &&
+ srcNode.firstChild.nodeType == dojo.dom.TEXT_NODE) {
+ srcNode.removeChild(srcNode.firstChild);
+ }
+ while(srcNode.hasChildNodes() &&
+ srcNode.lastChild.nodeType == dojo.dom.TEXT_NODE) {
+ srcNode.removeChild(srcNode.lastChild);
+ }
+ }
+ while(srcNode.hasChildNodes()){
+ destNode.appendChild(srcNode.firstChild);
+ count++;
+ }
+ return count;
+}
+
+dojo.dom.copyChildren = function(srcNode, destNode, trim){
+ var clonedNode = srcNode.cloneNode(true);
+ return this.moveChildren(clonedNode, destNode, trim);
+}
+
+dojo.dom.removeChildren = function(node){
+ var count = node.childNodes.length;
+ while(node.hasChildNodes()){ node.removeChild(node.firstChild); }
+ return count;
+}
+
+dojo.dom.replaceChildren = function(node, newChild){
+ // FIXME: what if newChild is an array-like object?
+ dojo.dom.removeChildren(node);
+ node.appendChild(newChild);
+}
+
+dojo.dom.removeNode = function(node){
+ if(node && node.parentNode){
+ // return a ref to the removed child
+ return node.parentNode.removeChild(node);
+ }
+}
+
+dojo.dom.getAncestors = function(node, filterFunction, returnFirstHit) {
+ var ancestors = [];
+ var isFunction = dojo.lang.isFunction(filterFunction);
+ while(node) {
+ if (!isFunction || filterFunction(node)) {
+ ancestors.push(node);
+ }
+ if (returnFirstHit && ancestors.length > 0) { return ancestors[0]; }
+
+ node = node.parentNode;
+ }
+ if (returnFirstHit) { return null; }
+ return ancestors;
+}
+
+dojo.dom.getAncestorsByTag = function(node, tag, returnFirstHit) {
+ tag = tag.toLowerCase();
+ return dojo.dom.getAncestors(node, function(el){
+ return ((el.tagName)&&(el.tagName.toLowerCase() == tag));
+ }, returnFirstHit);
+}
+
+dojo.dom.getFirstAncestorByTag = function(node, tag) {
+ return dojo.dom.getAncestorsByTag(node, tag, true);
+}
+
+dojo.dom.isDescendantOf = function(node, ancestor, guaranteeDescendant){
+ // guaranteeDescendant allows us to be a "true" isDescendantOf function
+ if(guaranteeDescendant && node) { node = node.parentNode; }
+ while(node) {
+ if(node == ancestor){ return true; }
+ node = node.parentNode;
+ }
+ return false;
+}
+
+dojo.dom.innerXML = function(node){
+ if(node.innerXML){
+ return node.innerXML;
+ }else if(typeof XMLSerializer != "undefined"){
+ return (new XMLSerializer()).serializeToString(node);
+ }
+}
+
+dojo.dom.createDocumentFromText = function(str, mimetype){
+ if(!mimetype) { mimetype = "text/xml"; }
+ if(typeof DOMParser != "undefined") {
+ var parser = new DOMParser();
+ return parser.parseFromString(str, mimetype);
+ }else if(typeof ActiveXObject != "undefined"){
+ var domDoc = new ActiveXObject("Microsoft.XMLDOM");
+ if(domDoc) {
+ domDoc.async = false;
+ domDoc.loadXML(str);
+ return domDoc;
+ }else{
+ dojo.debug("toXml didn't work?");
+ }
+ /*
+ }else if((dojo.render.html.capable)&&(dojo.render.html.safari)){
+ // FIXME: this doesn't appear to work!
+ // from: http://web-graphics.com/mtarchive/001606.php
+ // var xml = '<?xml version="1.0"?>'+str;
+ var mtype = "text/xml";
+ var xml = '<?xml version="1.0"?>'+str;
+ var url = "data:"+mtype+";charset=utf-8,"+encodeURIComponent(xml);
+ var req = new XMLHttpRequest();
+ req.open("GET", url, false);
+ req.overrideMimeType(mtype);
+ req.send(null);
+ return req.responseXML;
+ */
+ }else if(document.createElement){
+ // FIXME: this may change all tags to uppercase!
+ var tmp = document.createElement("xml");
+ tmp.innerHTML = str;
+ if(document.implementation && document.implementation.createDocument) {
+ var xmlDoc = document.implementation.createDocument("foo", "", null);
+ for(var i = 0; i < tmp.childNodes.length; i++) {
+ xmlDoc.importNode(tmp.childNodes.item(i), true);
+ }
+ return xmlDoc;
+ }
+ // FIXME: probably not a good idea to have to return an HTML fragment
+ // FIXME: the tmp.doc.firstChild is as tested from IE, so it may not
+ // work that way across the board
+ return tmp.document && tmp.document.firstChild ?
+ tmp.document.firstChild : tmp;
+ }
+ return null;
+}
+
+dojo.dom.prependChild = function(node, parent) {
+ if(parent.firstChild) {
+ parent.insertBefore(node, parent.firstChild);
+ } else {
+ parent.appendChild(node);
+ }
+ return true;
+}
+
+dojo.dom.insertBefore = function(node, ref, force){
+ if (force != true &&
+ (node === ref || node.nextSibling === ref)){ return false; }
+ var parent = ref.parentNode;
+ parent.insertBefore(node, ref);
+ return true;
+}
+
+dojo.dom.insertAfter = function(node, ref, force){
+ var pn = ref.parentNode;
+ if(ref == pn.lastChild){
+ if((force != true)&&(node === ref)){
+ return false;
+ }
+ pn.appendChild(node);
+ }else{
+ return this.insertBefore(node, ref.nextSibling, force);
+ }
+ return true;
+}
+
+dojo.dom.insertAtPosition = function(node, ref, position){
+ if((!node)||(!ref)||(!position)){ return false; }
+ switch(position.toLowerCase()){
+ case "before":
+ return dojo.dom.insertBefore(node, ref);
+ case "after":
+ return dojo.dom.insertAfter(node, ref);
+ case "first":
+ if(ref.firstChild){
+ return dojo.dom.insertBefore(node, ref.firstChild);
+ }else{
+ ref.appendChild(node);
+ return true;
+ }
+ break;
+ default: // aka: last
+ ref.appendChild(node);
+ return true;
+ }
+}
+
+dojo.dom.insertAtIndex = function(node, containingNode, insertionIndex){
+ var siblingNodes = containingNode.childNodes;
+
+ // if there aren't any kids yet, just add it to the beginning
+
+ if (!siblingNodes.length){
+ containingNode.appendChild(node);
+ return true;
+ }
+
+ // otherwise we need to walk the childNodes
+ // and find our spot
+
+ var after = null;
+
+ for(var i=0; i<siblingNodes.length; i++){
+
+ var sibling_index = siblingNodes.item(i)["getAttribute"] ? parseInt(siblingNodes.item(i).getAttribute("dojoinsertionindex")) : -1;
+
+ if (sibling_index < insertionIndex){
+ after = siblingNodes.item(i);
+ }
+ }
+
+ if (after){
+ // add it after the node in {after}
+
+ return dojo.dom.insertAfter(node, after);
+ }else{
+ // add it to the start
+
+ return dojo.dom.insertBefore(node, siblingNodes.item(0));
+ }
+}
+
+/**
+ * implementation of the DOM Level 3 attribute.
+ *
+ * @param node The node to scan for text
+ * @param text Optional, set the text to this value.
+ */
+dojo.dom.textContent = function(node, text){
+ if (text) {
+ dojo.dom.replaceChildren(node, document.createTextNode(text));
+ return text;
+ } else {
+ var _result = "";
+ if (node == null) { return _result; }
+ for (var i = 0; i < node.childNodes.length; i++) {
+ switch (node.childNodes[i].nodeType) {
+ case 1: // ELEMENT_NODE
+ case 5: // ENTITY_REFERENCE_NODE
+ _result += dojo.dom.textContent(node.childNodes[i]);
+ break;
+ case 3: // TEXT_NODE
+ case 2: // ATTRIBUTE_NODE
+ case 4: // CDATA_SECTION_NODE
+ _result += node.childNodes[i].nodeValue;
+ break;
+ default:
+ break;
+ }
+ }
+ return _result;
+ }
+}
+
+dojo.dom.collectionToArray = function(collection){
+ dojo.deprecated("dojo.dom.collectionToArray", "use dojo.lang.toArray instead", "0.4");
+ return dojo.lang.toArray(collection);
+}
+
+dojo.dom.hasParent = function (node) {
+ return node && node.parentNode && dojo.dom.isNode(node.parentNode);
+}
+
+/**
+ * Determines if node has any of the provided tag names and
+ * returns the tag name that matches, empty string otherwise.
+ *
+ * Examples:
+ *
+ * myFooNode = <foo />
+ * isTag(myFooNode, "foo"); // returns "foo"
+ * isTag(myFooNode, "bar"); // returns ""
+ * isTag(myFooNode, "FOO"); // returns ""
+ * isTag(myFooNode, "hey", "foo", "bar"); // returns "foo"
+**/
+dojo.dom.isTag = function(node /* ... */) {
+ if(node && node.tagName) {
+ var arr = dojo.lang.toArray(arguments, 1);
+ return arr[ dojo.lang.find(node.tagName, arr) ] || "";
+ }
+ return "";
+}
Added: incubator/xap/trunk/src/dojo/src/event.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/src/dojo/src/event.js?rev=417618&view=auto
==============================================================================
--- incubator/xap/trunk/src/dojo/src/event.js (added)
+++ incubator/xap/trunk/src/dojo/src/event.js Tue Jun 27 15:48:54 2006
@@ -0,0 +1,569 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.event");
+
+dojo.require("dojo.lang.array");
+dojo.require("dojo.lang.extras");
+dojo.require("dojo.lang.func");
+
+dojo.event = new function(){
+ this.canTimeout = dojo.lang.isFunction(dj_global["setTimeout"])||dojo.lang.isAlien(dj_global["setTimeout"]);
+
+ // FIXME: where should we put this method (not here!)?
+ function interpolateArgs(args){
+ var dl = dojo.lang;
+ var ao = {
+ srcObj: dj_global,
+ srcFunc: null,
+ adviceObj: dj_global,
+ adviceFunc: null,
+ aroundObj: null,
+ aroundFunc: null,
+ adviceType: (args.length>2) ? args[0] : "after",
+ precedence: "last",
+ once: false,
+ delay: null,
+ rate: 0,
+ adviceMsg: false
+ };
+
+ switch(args.length){
+ case 0: return;
+ case 1: return;
+ case 2:
+ ao.srcFunc = args[0];
+ ao.adviceFunc = args[1];
+ break;
+ case 3:
+ if((dl.isObject(args[0]))&&(dl.isString(args[1]))&&(dl.isString(args[2]))){
+ ao.adviceType = "after";
+ ao.srcObj = args[0];
+ ao.srcFunc = args[1];
+ ao.adviceFunc = args[2];
+ }else if((dl.isString(args[1]))&&(dl.isString(args[2]))){
+ ao.srcFunc = args[1];
+ ao.adviceFunc = args[2];
+ }else if((dl.isObject(args[0]))&&(dl.isString(args[1]))&&(dl.isFunction(args[2]))){
+ ao.adviceType = "after";
+ ao.srcObj = args[0];
+ ao.srcFunc = args[1];
+ var tmpName = dojo.lang.nameAnonFunc(args[2], ao.adviceObj);
+ ao.adviceFunc = tmpName;
+ }else if((dl.isFunction(args[0]))&&(dl.isObject(args[1]))&&(dl.isString(args[2]))){
+ ao.adviceType = "after";
+ ao.srcObj = dj_global;
+ var tmpName = dojo.lang.nameAnonFunc(args[0], ao.srcObj);
+ ao.srcFunc = tmpName;
+ ao.adviceObj = args[1];
+ ao.adviceFunc = args[2];
+ }
+ break;
+ case 4:
+ if((dl.isObject(args[0]))&&(dl.isObject(args[2]))){
+ // we can assume that we've got an old-style "connect" from
+ // the sigslot school of event attachment. We therefore
+ // assume after-advice.
+ ao.adviceType = "after";
+ ao.srcObj = args[0];
+ ao.srcFunc = args[1];
+ ao.adviceObj = args[2];
+ ao.adviceFunc = args[3];
+ }else if((dl.isString(args[0]))&&(dl.isString(args[1]))&&(dl.isObject(args[2]))){
+ ao.adviceType = args[0];
+ ao.srcObj = dj_global;
+ ao.srcFunc = args[1];
+ ao.adviceObj = args[2];
+ ao.adviceFunc = args[3];
+ }else if((dl.isString(args[0]))&&(dl.isFunction(args[1]))&&(dl.isObject(args[2]))){
+ ao.adviceType = args[0];
+ ao.srcObj = dj_global;
+ var tmpName = dojo.lang.nameAnonFunc(args[1], dj_global);
+ ao.srcFunc = tmpName;
+ ao.adviceObj = args[2];
+ ao.adviceFunc = args[3];
+ }else if((dl.isString(args[0]))&&(dl.isObject(args[1]))&&(dl.isString(args[2]))&&(dl.isFunction(args[3]))){
+ ao.srcObj = args[1];
+ ao.srcFunc = args[2];
+ var tmpName = dojo.lang.nameAnonFunc(args[3], dj_global);
+ ao.adviceObj = dj_global;
+ ao.adviceFunc = tmpName;
+ }else if(dl.isObject(args[1])){
+ ao.srcObj = args[1];
+ ao.srcFunc = args[2];
+ ao.adviceObj = dj_global;
+ ao.adviceFunc = args[3];
+ }else if(dl.isObject(args[2])){
+ ao.srcObj = dj_global;
+ ao.srcFunc = args[1];
+ ao.adviceObj = args[2];
+ ao.adviceFunc = args[3];
+ }else{
+ ao.srcObj = ao.adviceObj = ao.aroundObj = dj_global;
+ ao.srcFunc = args[1];
+ ao.adviceFunc = args[2];
+ ao.aroundFunc = args[3];
+ }
+ break;
+ case 6:
+ ao.srcObj = args[1];
+ ao.srcFunc = args[2];
+ ao.adviceObj = args[3]
+ ao.adviceFunc = args[4];
+ ao.aroundFunc = args[5];
+ ao.aroundObj = dj_global;
+ break;
+ default:
+ ao.srcObj = args[1];
+ ao.srcFunc = args[2];
+ ao.adviceObj = args[3]
+ ao.adviceFunc = args[4];
+ ao.aroundObj = args[5];
+ ao.aroundFunc = args[6];
+ ao.once = args[7];
+ ao.delay = args[8];
+ ao.rate = args[9];
+ ao.adviceMsg = args[10];
+ break;
+ }
+
+ if(dl.isFunction(ao.aroundFunc)){
+ var tmpName = dojo.lang.nameAnonFunc(ao.aroundFunc, ao.aroundObj);
+ ao.aroundFunc = tmpName;
+ }
+
+ if(!dl.isString(ao.srcFunc)){
+ ao.srcFunc = dojo.lang.getNameInObj(ao.srcObj, ao.srcFunc);
+ }
+
+ if(!dl.isString(ao.adviceFunc)){
+ ao.adviceFunc = dojo.lang.getNameInObj(ao.adviceObj, ao.adviceFunc);
+ }
+
+ if((ao.aroundObj)&&(!dl.isString(ao.aroundFunc))){
+ ao.aroundFunc = dojo.lang.getNameInObj(ao.aroundObj, ao.aroundFunc);
+ }
+
+ if(!ao.srcObj){
+ dojo.raise("bad srcObj for srcFunc: "+ao.srcFunc);
+ }
+ if(!ao.adviceObj){
+ dojo.raise("bad adviceObj for adviceFunc: "+ao.adviceFunc);
+ }
+ return ao;
+ }
+
+ this.connect = function(){
+ if(arguments.length == 1){
+ var ao = arguments[0];
+ }else{
+ var ao = interpolateArgs(arguments);
+ }
+
+ if(dojo.lang.isArray(ao.srcObj) && ao.srcObj!=""){
+ var tmpAO = {};
+ for(var x in ao){
+ tmpAO[x] = ao[x];
+ }
+ var mjps = [];
+ dojo.lang.forEach(ao.srcObj, function(src){
+ if((dojo.render.html.capable)&&(dojo.lang.isString(src))){
+ src = dojo.byId(src);
+ // dojo.debug(src);
+ }
+ tmpAO.srcObj = src;
+ // dojo.debug(tmpAO.srcObj, tmpAO.srcFunc);
+ // dojo.debug(tmpAO.adviceObj, tmpAO.adviceFunc);
+ mjps.push(dojo.event.connect.call(dojo.event, tmpAO));
+ });
+ return mjps;
+ }
+
+ // FIXME: just doing a "getForMethod()" seems to be enough to put this into infinite recursion!!
+ var mjp = dojo.event.MethodJoinPoint.getForMethod(ao.srcObj, ao.srcFunc);
+ if(ao.adviceFunc){
+ var mjp2 = dojo.event.MethodJoinPoint.getForMethod(ao.adviceObj, ao.adviceFunc);
+ }
+
+ mjp.kwAddAdvice(ao);
+
+ return mjp; // advanced users might want to fsck w/ the join point
+ // manually
+ }
+
+ this.log = function(a1, a2){
+ var kwArgs;
+ if((arguments.length == 1)&&(typeof a1 == "object")){
+ kwArgs = a1;
+ }else{
+ kwArgs = {
+ srcObj: a1,
+ srcFunc: a2
+ };
+ }
+ kwArgs.adviceFunc = function(){
+ var argsStr = [];
+ for(var x=0; x<arguments.length; x++){
+ argsStr.push(arguments[x]);
+ }
+ dojo.debug("("+kwArgs.srcObj+")."+kwArgs.srcFunc, ":", argsStr.join(", "));
+ }
+ this.kwConnect(kwArgs);
+ }
+
+ this.connectBefore = function(){
+ var args = ["before"];
+ for(var i = 0; i < arguments.length; i++) { args.push(arguments[i]); }
+ return this.connect.apply(this, args);
+ }
+
+ this.connectAround = function(){
+ var args = ["around"];
+ for(var i = 0; i < arguments.length; i++) { args.push(arguments[i]); }
+ return this.connect.apply(this, args);
+ }
+
+ this.connectOnce = function(){
+ var ao = interpolateArgs(arguments);
+ ao.once = true;
+ return this.connect(ao);
+ }
+
+ this._kwConnectImpl = function(kwArgs, disconnect){
+ var fn = (disconnect) ? "disconnect" : "connect";
+ if(typeof kwArgs["srcFunc"] == "function"){
+ kwArgs.srcObj = kwArgs["srcObj"]||dj_global;
+ var tmpName = dojo.lang.nameAnonFunc(kwArgs.srcFunc, kwArgs.srcObj);
+ kwArgs.srcFunc = tmpName;
+ }
+ if(typeof kwArgs["adviceFunc"] == "function"){
+ kwArgs.adviceObj = kwArgs["adviceObj"]||dj_global;
+ var tmpName = dojo.lang.nameAnonFunc(kwArgs.adviceFunc, kwArgs.adviceObj);
+ kwArgs.adviceFunc = tmpName;
+ }
+ return dojo.event[fn]( (kwArgs["type"]||kwArgs["adviceType"]||"after"),
+ kwArgs["srcObj"]||dj_global,
+ kwArgs["srcFunc"],
+ kwArgs["adviceObj"]||kwArgs["targetObj"]||dj_global,
+ kwArgs["adviceFunc"]||kwArgs["targetFunc"],
+ kwArgs["aroundObj"],
+ kwArgs["aroundFunc"],
+ kwArgs["once"],
+ kwArgs["delay"],
+ kwArgs["rate"],
+ kwArgs["adviceMsg"]||false );
+ }
+
+ this.kwConnect = function(kwArgs){
+ return this._kwConnectImpl(kwArgs, false);
+
+ }
+
+ this.disconnect = function(){
+ var ao = interpolateArgs(arguments);
+ if(!ao.adviceFunc){ return; } // nothing to disconnect
+ var mjp = dojo.event.MethodJoinPoint.getForMethod(ao.srcObj, ao.srcFunc);
+ return mjp.removeAdvice(ao.adviceObj, ao.adviceFunc, ao.adviceType, ao.once);
+ }
+
+ this.kwDisconnect = function(kwArgs){
+ return this._kwConnectImpl(kwArgs, true);
+ }
+}
+
+// exactly one of these is created whenever a method with a joint point is run,
+// if there is at least one 'around' advice.
+dojo.event.MethodInvocation = function(join_point, obj, args) {
+ this.jp_ = join_point;
+ this.object = obj;
+ this.args = [];
+ for(var x=0; x<args.length; x++){
+ this.args[x] = args[x];
+ }
+ // the index of the 'around' that is currently being executed.
+ this.around_index = -1;
+}
+
+dojo.event.MethodInvocation.prototype.proceed = function() {
+ this.around_index++;
+ if(this.around_index >= this.jp_.around.length){
+ return this.jp_.object[this.jp_.methodname].apply(this.jp_.object, this.args);
+ // return this.jp_.run_before_after(this.object, this.args);
+ }else{
+ var ti = this.jp_.around[this.around_index];
+ var mobj = ti[0]||dj_global;
+ var meth = ti[1];
+ return mobj[meth].call(mobj, this);
+ }
+}
+
+
+dojo.event.MethodJoinPoint = function(obj, methname){
+ this.object = obj||dj_global;
+ this.methodname = methname;
+ this.methodfunc = this.object[methname];
+ this.before = [];
+ this.after = [];
+ this.around = [];
+}
+
+dojo.event.MethodJoinPoint.getForMethod = function(obj, methname) {
+ // if(!(methname in obj)){
+ if(!obj){ obj = dj_global; }
+ if(!obj[methname]){
+ // supply a do-nothing method implementation
+ obj[methname] = function(){};
+ }else if((!dojo.lang.isFunction(obj[methname]))&&(!dojo.lang.isAlien(obj[methname]))){
+ return null; // FIXME: should we throw an exception here instead?
+ }
+ // we hide our joinpoint instance in obj[methname + '$joinpoint']
+ var jpname = methname + "$joinpoint";
+ var jpfuncname = methname + "$joinpoint$method";
+ var joinpoint = obj[jpname];
+ if(!joinpoint){
+ var isNode = false;
+ if(dojo.event["browser"]){
+ if( (obj["attachEvent"])||
+ (obj["nodeType"])||
+ (obj["addEventListener"]) ){
+ isNode = true;
+ dojo.event.browser.addClobberNodeAttrs(obj, [jpname, jpfuncname, methname]);
+ }
+ }
+ var origArity = obj[methname].length;
+ obj[jpfuncname] = obj[methname];
+ // joinpoint = obj[jpname] = new dojo.event.MethodJoinPoint(obj, methname);
+ joinpoint = obj[jpname] = new dojo.event.MethodJoinPoint(obj, jpfuncname);
+ obj[methname] = function(){
+ var args = [];
+
+ if((isNode)&&(!arguments.length)){
+ var evt = null;
+ try{
+ if(obj.ownerDocument){
+ evt = obj.ownerDocument.parentWindow.event;
+ }else if(obj.documentElement){
+ evt = obj.documentElement.ownerDocument.parentWindow.event;
+ }else{
+ evt = window.event;
+ }
+ }catch(e){
+ evt = window.event;
+ }
+
+ if(evt){
+ args.push(dojo.event.browser.fixEvent(evt, this));
+ }
+ }else{
+ for(var x=0; x<arguments.length; x++){
+ if((x==0)&&(isNode)&&(dojo.event.browser.isEvent(arguments[x]))){
+ args.push(dojo.event.browser.fixEvent(arguments[x], this));
+ }else{
+ args.push(arguments[x]);
+ }
+ }
+ }
+ // return joinpoint.run.apply(joinpoint, arguments);
+ return joinpoint.run.apply(joinpoint, args);
+ }
+ obj[methname].__preJoinArity = origArity;
+ }
+ return joinpoint;
+}
+
+dojo.lang.extend(dojo.event.MethodJoinPoint, {
+ unintercept: function(){
+ this.object[this.methodname] = this.methodfunc;
+ this.before = [];
+ this.after = [];
+ this.around = [];
+ },
+
+ disconnect: dojo.lang.forward("unintercept"),
+
+ run: function() {
+ var obj = this.object||dj_global;
+ var args = arguments;
+
+ // optimization. We only compute once the array version of the arguments
+ // pseudo-arr in order to prevent building it each time advice is unrolled.
+ var aargs = [];
+ for(var x=0; x<args.length; x++){
+ aargs[x] = args[x];
+ }
+
+ var unrollAdvice = function(marr){
+ if(!marr){
+ dojo.debug("Null argument to unrollAdvice()");
+ return;
+ }
+
+ var callObj = marr[0]||dj_global;
+ var callFunc = marr[1];
+
+ if(!callObj[callFunc]){
+ dojo.raise("function \"" + callFunc + "\" does not exist on \"" + callObj + "\"");
+ }
+
+ var aroundObj = marr[2]||dj_global;
+ var aroundFunc = marr[3];
+ var msg = marr[6];
+ var undef;
+
+ var to = {
+ args: [],
+ jp_: this,
+ object: obj,
+ proceed: function(){
+ return callObj[callFunc].apply(callObj, to.args);
+ }
+ };
+ to.args = aargs;
+
+ var delay = parseInt(marr[4]);
+ var hasDelay = ((!isNaN(delay))&&(marr[4]!==null)&&(typeof marr[4] != "undefined"));
+ if(marr[5]){
+ var rate = parseInt(marr[5]);
+ var cur = new Date();
+ var timerSet = false;
+ if((marr["last"])&&((cur-marr.last)<=rate)){
+ if(dojo.event.canTimeout){
+ if(marr["delayTimer"]){
+ clearTimeout(marr.delayTimer);
+ }
+ var tod = parseInt(rate*2); // is rate*2 naive?
+ var mcpy = dojo.lang.shallowCopy(marr);
+ marr.delayTimer = setTimeout(function(){
+ // FIXME: on IE at least, event objects from the
+ // browser can go out of scope. How (or should?) we
+ // deal with it?
+ mcpy[5] = 0;
+ unrollAdvice(mcpy);
+ }, tod);
+ }
+ return;
+ }else{
+ marr.last = cur;
+ }
+ }
+
+ // FIXME: need to enforce rates for a connection here!
+
+ if(aroundFunc){
+ // NOTE: around advice can't delay since we might otherwise depend
+ // on execution order!
+ aroundObj[aroundFunc].call(aroundObj, to);
+ }else{
+ // var tmjp = dojo.event.MethodJoinPoint.getForMethod(obj, methname);
+ if((hasDelay)&&((dojo.render.html)||(dojo.render.svg))){ // FIXME: the render checks are grotty!
+ dj_global["setTimeout"](function(){
+ if(msg){
+ callObj[callFunc].call(callObj, to);
+ }else{
+ callObj[callFunc].apply(callObj, args);
+ }
+ }, delay);
+ }else{ // many environments can't support delay!
+ if(msg){
+ callObj[callFunc].call(callObj, to);
+ }else{
+ callObj[callFunc].apply(callObj, args);
+ }
+ }
+ }
+ }
+
+ if(this.before.length>0){
+ dojo.lang.forEach(this.before, unrollAdvice);
+ }
+
+ var result;
+ if(this.around.length>0){
+ var mi = new dojo.event.MethodInvocation(this, obj, args);
+ result = mi.proceed();
+ }else if(this.methodfunc){
+ result = this.object[this.methodname].apply(this.object, args);
+ }
+
+ if(this.after.length>0){
+ dojo.lang.forEach(this.after, unrollAdvice);
+ }
+
+ return (this.methodfunc) ? result : null;
+ },
+
+ getArr: function(kind){
+ var arr = this.after;
+ // FIXME: we should be able to do this through props or Array.in()
+ if((typeof kind == "string")&&(kind.indexOf("before")!=-1)){
+ arr = this.before;
+ }else if(kind=="around"){
+ arr = this.around;
+ }
+ return arr;
+ },
+
+ kwAddAdvice: function(args){
+ this.addAdvice( args["adviceObj"], args["adviceFunc"],
+ args["aroundObj"], args["aroundFunc"],
+ args["adviceType"], args["precedence"],
+ args["once"], args["delay"], args["rate"],
+ args["adviceMsg"]);
+ },
+
+ addAdvice: function( thisAdviceObj, thisAdvice,
+ thisAroundObj, thisAround,
+ advice_kind, precedence,
+ once, delay, rate, asMessage){
+ var arr = this.getArr(advice_kind);
+ if(!arr){
+ dojo.raise("bad this: " + this);
+ }
+
+ var ao = [thisAdviceObj, thisAdvice, thisAroundObj, thisAround, delay, rate, asMessage];
+
+ if(once){
+ if(this.hasAdvice(thisAdviceObj, thisAdvice, advice_kind, arr) >= 0){
+ return;
+ }
+ }
+
+ if(precedence == "first"){
+ arr.unshift(ao);
+ }else{
+ arr.push(ao);
+ }
+ },
+
+ hasAdvice: function(thisAdviceObj, thisAdvice, advice_kind, arr){
+ if(!arr){ arr = this.getArr(advice_kind); }
+ var ind = -1;
+ for(var x=0; x<arr.length; x++){
+ if((arr[x][0] == thisAdviceObj)&&(arr[x][1] == thisAdvice)){
+ ind = x;
+ }
+ }
+ return ind;
+ },
+
+ removeAdvice: function(thisAdviceObj, thisAdvice, advice_kind, once){
+ var arr = this.getArr(advice_kind);
+ var ind = this.hasAdvice(thisAdviceObj, thisAdvice, advice_kind, arr);
+ if(ind == -1){
+ return false;
+ }
+ while(ind != -1){
+ arr.splice(ind, 1);
+ if(once){ break; }
+ ind = this.hasAdvice(thisAdviceObj, thisAdvice, advice_kind, arr);
+ }
+ return true;
+ }
+});
Added: incubator/xap/trunk/src/dojo/src/experimental.js
URL: http://svn.apache.org/viewvc/incubator/xap/trunk/src/dojo/src/experimental.js?rev=417618&view=auto
==============================================================================
--- incubator/xap/trunk/src/dojo/src/experimental.js (added)
+++ incubator/xap/trunk/src/dojo/src/experimental.js Tue Jun 27 15:48:54 2006
@@ -0,0 +1,21 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.experimental");
+
+/**
+ * Convenience for informing of experimental code.
+ */
+dojo.experimental = function(packageName, extra){
+ var mess = "EXPERIMENTAL: " + packageName;
+ mess += " -- Not yet ready for use. APIs subject to change without notice.";
+ if(extra){ mess += " " + extra; }
+ dojo.debug(mess);
+}