.
+// It's useful as a child of LayoutContainer, SplitContainer, or TabContainer.
+// But note that those classes can contain any widget as a child.
+
+dojo.provide("dojo.widget.ContentPane");
+
+dojo.require("dojo.widget.*");
+dojo.require("dojo.io.*");
+dojo.require("dojo.widget.HtmlWidget");
+dojo.require("dojo.string");
+dojo.require("dojo.string.extras");
+dojo.require("dojo.html.style");
+
+dojo.widget.defineWidget(
+ "dojo.widget.ContentPane",
+ dojo.widget.HtmlWidget,
+ function(){
+ // per widgetImpl variables
+ this._styleNodes = [];
+ this._onLoadStack = [];
+ this._onUnLoadStack = [];
+ this._callOnUnLoad = false;
+ this.scriptScope; // undefined for now
+ this._ioBindObj;
+
+ // loading option
+ this.bindArgs = {}; // example bindArgs="preventCache:false;" overrides cacheContent
+ },
+ {
+ isContainer: true,
+
+ // loading options
+ adjustPaths: true, // fix relative paths in content to fit in this page
+ href: "", // only usable on construction, use setUrl or setContent after that
+ extractContent: true, // extract visible content from inside of ....
+ parseContent: true, // construct all widgets that is in content
+ cacheContent: true,
+ preload: false, // force load of data even if pane is hidden
+ refreshOnShow: false, // use with cacheContent: false
+ handler: "", // generate pane content from a java function
+ executeScripts: false, // if true scripts in content will be evaled after content is innerHTML'ed
+
+ postCreate: function(args, frag, parentComp){
+ if (this.handler!==""){
+ this.setHandler(this.handler);
+ }
+ if(this.isShowing() || this.preload){
+ this.loadContents();
+ }
+ },
+
+ show: function(){
+ // if refreshOnShow is true, reload the contents every time; otherwise, load only the first time
+ if(this.refreshOnShow){
+ this.refresh();
+ }else{
+ this.loadContents();
+ }
+ dojo.widget.ContentPane.superclass.show.call(this);
+ },
+
+ refresh: function(){
+ this.isLoaded=false;
+ this.loadContents();
+ },
+
+ loadContents: function() {
+ if ( this.isLoaded ){
+ return;
+ }
+ if ( dojo.lang.isFunction(this.handler)) {
+ this._runHandler();
+ } else if ( this.href != "" ) {
+ this._downloadExternalContent(this.href, this.cacheContent && !this.refreshOnShow);
+ }else{
+ this.isLoaded=true;
+ }
+ },
+
+
+ setUrl: function(/*String or dojo.uri.Uri*/ url) {
+ // summary:
+ // Reset the (external defined) content of this pane and replace with new url
+ this.href = url;
+ this.isLoaded = false;
+ if ( this.preload || this.isShowing() ){
+ this.loadContents();
+ }
+ },
+
+ abort: function(){
+ // summary
+ // abort download of content
+ var bind = this._ioBindObj;
+ if(!bind || !bind.abort){ return; }
+ bind.abort();
+ delete this._ioBindObj;
+ },
+
+ _downloadExternalContent: function(url, useCache) {
+ this.abort();
+ this._handleDefaults("Loading...", "onDownloadStart");
+ var self = this;
+ this._ioBindObj = dojo.io.bind(
+ this._cacheSetting({
+ url: url,
+ mimetype: "text/html",
+ load: function(type, data, xhr){
+ self.onDownloadEnd.call(self, url, data);
+ },
+ error: function(type, err, xhr){
+ // XHR insnt a normal JS object, IE doesnt have prototype on XHR so we cant extend it or shallowCopy it
+ var e = {
+ responseText: xhr.responseText,
+ status: xhr.status,
+ statusText: xhr.statusText,
+ responseHeaders: xhr.getAllResponseHeaders(),
+ _text: "Error loading '" + url + "' (" + xhr.status + " "+ xhr.statusText + ")"
+ };
+ self._handleDefaults.call(self, e, "onDownloadError");
+ self.onLoad();
+ }
+ }, useCache)
+ );
+ },
+
+ _cacheSetting: function(bindObj, useCache){
+ for(var x in this.bindArgs){
+ if(dojo.lang.isUndefined(bindObj[x])){
+ bindObj[x] = this.bindArgs[x];
+ }
+ }
+
+ if(dojo.lang.isUndefined(bindObj.useCache)){ bindObj.useCache = useCache; }
+ if(dojo.lang.isUndefined(bindObj.preventCache)){ bindObj.preventCache = !useCache; }
+ if(dojo.lang.isUndefined(bindObj.mimetype)){ bindObj.mimetype = "text/html"; }
+ return bindObj;
+ },
+
+ // called when setContent is finished
+ onLoad: function(e){
+ this._runStack("_onLoadStack");
+ this.isLoaded=true;
+ },
+
+ // called before old content is cleared
+ onUnLoad: function(e){
+ this._runStack("_onUnLoadStack");
+ delete this.scriptScope;
+ },
+
+ _runStack: function(stName){
+ var st = this[stName]; var err = "";
+ var scope = this.scriptScope || window;
+ for(var i = 0;i < st.length; i++){
+ try{
+ st[i].call(scope);
+ }catch(e){
+ err += "\n"+st[i]+" failed: "+e.description;
+ }
+ }
+ this[stName] = [];
+
+ if(err.length){
+ var name = (stName== "_onLoadStack") ? "addOnLoad" : "addOnUnLoad";
+ this._handleDefaults(name+" failure\n "+err, "onExecError", true);
+ }
+ },
+
+ addOnLoad: function(/*Function or Object ?*/ obj, /*Function*/ func){
+ // summary
+ // same as to dojo.addOnLoad but does not take "function_name" as a string
+ this._pushOnStack(this._onLoadStack, obj, func);
+ },
+
+ addOnUnLoad: function(/*Function or Object ?*/ obj, /*Function*/ func){
+ // summary
+ // same as to dojo.addUnOnLoad but does not take "function_name" as a string
+ this._pushOnStack(this._onUnLoadStack, obj, func);
+ },
+
+ _pushOnStack: function(stack, obj, func){
+ if(typeof func == 'undefined') {
+ stack.push(obj);
+ }else{
+ stack.push(function(){ obj[func](); });
+ }
+ },
+
+ destroy: function(){
+ // make sure we call onUnLoad
+ this.onUnLoad();
+ dojo.widget.ContentPane.superclass.destroy.call(this);
+ },
+
+ // called when content script eval error or Java error occurs, preventDefault-able
+ onExecError: function(e){ /*stub*/ },
+
+ // called on DOM faults, require fault etc in content, preventDefault-able
+ onContentError: function(e){ /*stub*/ },
+
+ // called when download error occurs, preventDefault-able
+ onDownloadError: function(e){ /*stub*/ },
+
+ // called before download starts, preventDefault-able
+ onDownloadStart: function(e){ /*stub*/ },
+
+ // called when download is finished
+ onDownloadEnd: function(/*String*/ url, /*content*/ data){
+ data = this.splitAndFixPaths(data, url);
+ this.setContent(data);
+ },
+
+ // usefull if user wants to prevent default behaviour ie: _setContent("Error...")
+ _handleDefaults: function(e, handler, useAlert){
+ if(!handler){ handler = "onContentError"; }
+
+ if(dojo.lang.isString(e)){ e = {_text: e}; }
+
+ if(!e._text){ e._text = e.toString(); }
+
+ e.toString = function(){ return this._text; };
+
+ if(typeof e.returnValue != "boolean"){
+ e.returnValue = true;
+ }
+ if(typeof e.preventDefault != "function"){
+ e.preventDefault = function(){ this.returnValue = false; };
+ }
+ // call our handler
+ this[handler](e);
+ if(e.returnValue){
+ if(useAlert){
+ alert(e.toString());
+ }else{
+ // makes sure scripts can clean up after themselves, before we setContent
+ if(this._callOnUnLoad){ this.onUnLoad(); }
+ this._callOnUnLoad = false; // makes sure we dont try to call onUnLoad again on this event,
+ // ie onUnLoad before 'Loading...' but not before clearing 'Loading...'
+ this._setContent(e.toString());
+ }
+ }
+ },
+
+ // pathfixes, require calls, css stuff and neccesary content clean
+ splitAndFixPaths: function(/*String*/s, /*dojo.uri.Uri?*/url){
+ // summary:
+ // fixes all relative paths in (hopefully) all cases for example images, remote scripts, links etc.
+ // splits up content in different pieces, scripts, title, style, link and whats left becomes .xml
+
+ // init vars
+ var titles = [], scripts = [],tmp = [];
+ var match = [], requires = [], attr = [], styles = [];
+ var str = '', path = '', fix = '', tagFix = '', tag = '', origPath = '';
+
+ if(!url) { url = "./"; } // point to this page if not set
+
+ if(s){ // make sure we dont run regexes on empty content
+
+ /**************
***********/
+ // khtml is picky about dom faults, you can't attach a <style> or <title> node as child of body
+ // must go into head, so we need to cut out those tags
+ var regex = /<title[^>]*>([\s\S]*?)<\/title>/i;
+ while(match = regex.exec(s)){
+ titles.push(match[1]);
+ s = s.substring(0, match.index) + s.substr(match.index + match[0].length);
+ };
+
+ /************** adjust paths *****************/
+ if(this.adjustPaths){
+ // attributepaths one tag can have multiple paths example:
+ // <input src="..." style="url(..)"/> or <a style="url(..)" href="..">
+ // strip out the tag and run fix on that.
+ // this guarantees that we won't run replace on another tag's attribute + it was easier do
+ var regexFindTag = /<[a-z][a-z0-9]*[^>]*\s(?:(?:src|href|style)=[^>])+[^>]*>/i;
+ var regexFindAttr = /\s(src|href|style)=(['"]?)([\w()\[\]\/.,\\'"-:;#=&?\s@]+?)\2/i;
+ // these are the supported protocols, all other is considered relative
+ var regexProtocols = /^(?:[#]|(?:(?:https?|ftps?|file|javascript|mailto|news):))/;
+
+ while(tag = regexFindTag.exec(s)){
+ str += s.substring(0, tag.index);
+ s = s.substring((tag.index + tag[0].length), s.length);
+ tag = tag[0];
+
+ // loop through attributes
+ tagFix = '';
+ while(attr = regexFindAttr.exec(tag)){
+ path = ""; origPath = attr[3];
+ switch(attr[1].toLowerCase()){
+ case "src":// falltrough
+ case "href":
+ if(regexProtocols.exec(origPath)){
+ path = origPath;
+ } else {
+ path = (new dojo.uri.Uri(url, origPath).toString());
+ }
+ break;
+ case "style":// style
+ path = dojo.html.fixPathsInCssText(origPath, url);
+ break;
+ default:
+ path = origPath;
+ }
+
+ fix = " " + attr[1] + "=" + attr[2] + path + attr[2];
+
+ // slices up tag before next attribute check
+ tagFix += tag.substring(0, attr.index) + fix;
+ tag = tag.substring((attr.index + attr[0].length), tag.length);
+ }
+ str += tagFix + tag; //dojo.debug(tagFix + tag);
+ }
+ s = str+s;
+ }
+
+ /**************** cut out all <style> and <link rel="stylesheet" href=".."> **************/
+ regex = /(?:<(style)[^>]*>([\s\S]*?)<\/style>|<link ([^>]*rel=['"]?stylesheet['"]?[^>]*)>)/i;
+ while(match = regex.exec(s)){
+ if(match[1] && match[1].toLowerCase() == "style"){
+ styles.push(dojo.html.fixPathsInCssText(match[2],url));
+ }else if(attr = match[3].match(/href=(['"]?)([^'">]*)\1/i)){
+ styles.push({path: attr[2]});
+ }
+ s = s.substring(0, match.index) + s.substr(match.index + match[0].length);
+ };
+
+ /***************** cut out all <script> tags, push them into scripts array ***************/
+ var regex = /<script([^>]*)>([\s\S]*?)<\/script>/i;
+ var regexSrc = /src=(['"]?)([^"']*)\1/i;
+ var regexDojoJs = /.*(\bdojo\b\.js(?:\.uncompressed\.js)?)$/;
+ var regexInvalid = /(?:var )?\bdjConfig\b(?:[\s]*=[\s]*\{[^}]+\}|\.[\w]*[\s]*=[\s]*[^;\n]*)?;?|dojo\.hostenv\.writeIncludes\(\s*\);?/g;
+ var regexRequires = /dojo\.(?:(?:require(?:After)?(?:If)?)|(?:widget\.(?:manager\.)?registerWidgetPackage)|(?:(?:hostenv\.)?setModulePrefix)|defineNamespace)\((['"]).*?\1\)\s*;?/;
+
+ while(match = regex.exec(s)){
+ if(this.executeScripts && match[1]){
+ if(attr = regexSrc.exec(match[1])){
+ // remove a dojo.js or dojo.js.uncompressed.js from remoteScripts
+ // we declare all files named dojo.js as bad, regardless of path
+ if(regexDojoJs.exec(attr[2])){
+ dojo.debug("Security note! inhibit:"+attr[2]+" from beeing loaded again.");
+ }else{
+ scripts.push({path: attr[2]});
+ }
+ }
+ }
+ if(match[2]){
+ // remove all invalid variables etc like djConfig and dojo.hostenv.writeIncludes()
+ var sc = match[2].replace(regexInvalid, "");
+ if(!sc){ continue; }
+
+ // cut out all dojo.require (...) calls, if we have execute
+ // scripts false widgets dont get there require calls
+ // takes out possible widgetpackage registration as well
+ while(tmp = regexRequires.exec(sc)){
+ requires.push(tmp[0]);
+ sc = sc.substring(0, tmp.index) + sc.substr(tmp.index + tmp[0].length);
+ }
+ if(this.executeScripts){
+ scripts.push(sc);
+ }
+ }
+ s = s.substr(0, match.index) + s.substr(match.index + match[0].length);
+ }
+
+ /********* extract content *********/
+ if(this.extractContent){
+ match = s.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im);
+ if(match) { s = match[1]; }
+ }
+
+ /******** scan for scriptScope in html eventHandlers and replace with link to this pane *********/
+ if(this.executeScripts){
+ var regex = /(<[a-zA-Z][a-zA-Z0-9]*\s[^>]*\S=(['"])[^>]*[^\.\]])scriptScope([^>]*>)/;
+ str = "";
+ while(tag = regex.exec(s)){
+ tmp = ((tag[2]=="'") ? '"': "'");
+ str += s.substring(0, tag.index);
+ s = s.substr(tag.index).replace(regex, "$1dojo.widget.byId("+ tmp + this.widgetId + tmp + ").scriptScope$3");
+ }
+ s = str + s;
+ }
+ }
+
+ return {"xml": s, // Object
+ "styles": styles,
+ "titles": titles,
+ "requires": requires,
+ "scripts": scripts,
+ "url": url};
+ },
+
+
+ _setContent: function(cont){
+ this.destroyChildren();
+
+ // remove old stylenodes from HEAD
+ for(var i = 0; i < this._styleNodes.length; i++){
+ if(this._styleNodes[i] && this._styleNodes[i].parentNode){
+ this._styleNodes[i].parentNode.removeChild(this._styleNodes[i]);
+ }
+ }
+ this._styleNodes = [];
+
+ var node = this.containerNode || this.domNode;
+ while(node.firstChild){
+ try{
+ dojo.event.browser.clean(node.firstChild);
+ }catch(e){}
+ node.removeChild(node.firstChild);
+ }
+ try{
+ if(typeof cont != "string"){
+ node.innerHTML = "";
+ node.appendChild(cont);
+ }else{
+ node.innerHTML = cont;
+ }
+ }catch(e){
+ e._text = "Could'nt load content:"+e.description;
+ this._handleDefaults(e, "onContentError");
+ }
+ },
+
+ setContent: function(/*String or DOMNode*/ data){
+ // summary:
+ // Destroys old content and sets new content, and possibly initialize any widgets within 'data'
+ this.abort();
+ if(this._callOnUnLoad){ this.onUnLoad(); }// this tells a remote script clean up after itself
+ this._callOnUnLoad = true;
+
+ if(!data || dojo.html.isNode(data)){
+ // if we do a clean using setContent(""); or setContent(#node) bypass all parsing, extractContent etc
+ this._setContent(data);
+ this.onResized();
+ this.onLoad();
+ }else{
+ // need to run splitAndFixPaths? ie. manually setting content
+ // adjustPaths is taken care of inside splitAndFixPaths
+ if(!data.xml){
+ this.href = ""; // so we can refresh safely
+ data = this.splitAndFixPaths(data);
+ }
+
+ this._setContent(data.xml);
+
+ // insert styles from content (in same order they came in)
+ for(var i = 0; i < data.styles.length; i++){
+ if(data.styles[i].path){
+ this._styleNodes.push(dojo.html.insertCssFile(data.styles[i].path));
+ }else{
+ this._styleNodes.push(dojo.html.insertCssText(data.styles[i]));
+ }
+ }
+
+ if(this.parseContent){
+ for(var i = 0; i < data.requires.length; i++){
+ try{
+ eval(data.requires[i]);
+ } catch(e){
+ e._text = "Error in packageloading calls, "+e.description;
+ this._handleDefaults(e, "onContentError", true);
+ }
+ }
+ }
+ // need to allow async load, Xdomain uses it
+ // is inline function because we cant send args to dojo.addOnLoad
+ var _self = this;
+ function asyncParse(){
+ if(_self.executeScripts){
+ _self._executeScripts(data.scripts);
+ }
+
+ if(_self.parseContent){
+ var node = _self.containerNode || _self.domNode;
+ var parser = new dojo.xml.Parse();
+ var frag = parser.parseElement(node, null, true);
+ // createSubComponents not createComponents because frag has already been created
+ dojo.widget.getParser().createSubComponents(frag, _self);
+ }
+
+ _self.onResized();
+ _self.onLoad();
+ }
+ // try as long as possible to make setContent sync call
+ if(dojo.hostenv.isXDomain && data.requires.length){
+ dojo.addOnLoad(asyncParse);
+ }else{
+ asyncParse();
+ }
+ }
+ },
+
+ // Generate pane content from given java function
+ setHandler: function(handler) {
+ var fcn = dojo.lang.isFunction(handler) ? handler : window[handler];
+ if(!dojo.lang.isFunction(fcn)) {
+ // FIXME: needs testing! somebody with java knowledge needs to try this
+ this._handleDefaults("Unable to set handler, '" + handler + "' not a function.", "onExecError", true);
+ return;
+ }
+ this.handler = function() {
+ return fcn.apply(this, arguments);
+ }
+ },
+
+ _runHandler: function() {
+ var ret = true;
+ if(dojo.lang.isFunction(this.handler)) {
+ this.handler(this, this.domNode);
+ ret = false;
+ }
+ this.onLoad();
+ return ret;
+ },
+
+ _executeScripts: function(scripts) {
+ // loop through the scripts in the order they came in
+ var self = this;
+ var tmp = "", code = "";
+ for(var i = 0; i < scripts.length; i++){
+ if(scripts[i].path){ // remotescript
+ dojo.io.bind(this._cacheSetting({
+ "url": scripts[i].path,
+ "load": function(type, scriptStr){
+ dojo.lang.hitch(self, tmp = scriptStr);
+ },
+ "error": function(type, error){
+ error._text = type + " downloading remote script";
+ self._handleDefaults.call(self, error, "onExecError", true);
+ },
+ "mimetype": "text/plain",
+ "sync": true
+ }, this.cacheContent));
+ code += tmp;
+ }else{
+ code += scripts[i];
+ }
+ }
+
+ try{
+ // initialize a new anonymous container for our script, dont make it part of this widgets scope chain
+ // instead send in a variable that points to this widget, usefull to connect events to onLoad, onUnLoad etc..
+ delete this.scriptScope;
+ this.scriptScope = new (new Function('_container_', code+'; return this;'))(self);
+ }catch(e){
+ e._text = "Error running scripts from content:\n"+e.description;
+ this._handleDefaults(e, "onExecError", true);
+ }
+ }
+ }
+);
+
diff --git a/source/web/scripts/ajax/src/widget/ContextMenu.js b/source/web/scripts/ajax/src/widget/ContextMenu.js
new file mode 100644
index 0000000000..b47f4a7541
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/ContextMenu.js
@@ -0,0 +1,33 @@
+/*
+ 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.widget.ContextMenu");
+
+dojo.deprecated("dojo.widget.ContextMenu", "use dojo.widget.Menu2", "0.4");
+
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.DomWidget");
+
+dojo.widget.ContextMenu = function(){
+ dojo.widget.Widget.call(this);
+ this.widgetType = "ContextMenu";
+ this.isContainer = true;
+ this.isOpened = false;
+
+ // copy children widgets output directly to parent (this node), to avoid
+ // errors trying to insert an <li> under a <div>
+ this.snarfChildDomOutput = true;
+
+}
+
+dojo.inherits(dojo.widget.ContextMenu, dojo.widget.Widget);
+dojo.widget.tags.addParseTreeHandler("dojo:contextmenu");
+
+dojo.requireAfterIf("html", "dojo.widget.html.ContextMenu");
diff --git a/source/web/scripts/ajax/src/widget/DatePicker.js b/source/web/scripts/ajax/src/widget/DatePicker.js
new file mode 100644
index 0000000000..f604581d8b
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/DatePicker.js
@@ -0,0 +1,379 @@
+dojo.provide("dojo.widget.DatePicker");
+dojo.provide("dojo.widget.DatePicker.util");
+dojo.require("dojo.date");
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.HtmlWidget");
+dojo.require("dojo.event.*");
+dojo.require("dojo.dom");
+dojo.require("dojo.html.style");
+dojo.require("dojo.i18n.calendar.GregorianNames");
+
+/*
+ Some assumptions:
+ - I'm planning on always showing 42 days at a time, and we can scroll by week,
+ not just by month or year
+ - To get a sense of what month to highlight, I basically initialize on the
+ first Saturday of each month, since that will be either the first of two or
+ the second of three months being partially displayed, and then I work forwards
+ and backwards from that point.
+ Currently, I assume that dates are stored in the RFC 3339 format,
+ because I find it to be most human readable and easy to parse
+ http://www.faqs.org/rfcs/rfc3339.html: 2005-06-30T08:05:00-07:00
+*/
+
+dojo.widget.defineWidget(
+ "dojo.widget.DatePicker",
+ dojo.widget.HtmlWidget,
+ function() {
+ // today's date, JS Date object
+ this.today = "";
+ // selected date, JS Date object
+ this.date = "";
+ // rfc 3339 date
+ this.storedDate = "";
+ // date currently selected in the UI, stored in year, month, date in the format that will be actually displayed
+ this.currentDate = {};
+ // stored in year, month, date in the format that will be actually displayed
+ this.firstSaturday = {};
+ },
+ {
+ lang: "", // would be better if this could be undefined if the attribute is undefined
+ dayWidth: 'narrow',
+
+ classNames: {
+ previous: "previousMonth",
+ current: "currentMonth",
+ next: "nextMonth",
+ currentDate: "currentDate",
+ selectedDate: "selectedItem"
+ },
+ templatePath: dojo.uri.dojoUri("src/widget/templates/DatePicker.html"),
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/DatePicker.css"),
+
+ fillInTemplate: function(){
+ dojo.widget.DatePicker.call(this);
+ this.initData();
+ this.initUI();
+ },
+ initData: function() {
+ this.today = new Date();
+ if(this.storedDate && (this.storedDate.split("-").length > 2)) {
+ this.date = dojo.widget.DatePicker.util.fromRfcDate(this.storedDate);
+ } else {
+ this.date = this.today;
+ }
+ // calendar math is simplified if time is set to 0
+ this.today.setHours(0);
+ this.date.setHours(0);
+ var month = this.date.getMonth();
+ var tempSaturday = dojo.widget.DatePicker.util.initFirstSaturday(this.date.getMonth().toString(), this.date.getFullYear());
+ this.firstSaturday.year = tempSaturday.year;
+ this.firstSaturday.month = tempSaturday.month;
+ this.firstSaturday.date = tempSaturday.date;
+ },
+
+ setDate: function(rfcDate) {
+ this.storedDate = rfcDate;
+ },
+
+ initUI: function() {
+ var dayLabels = dojo.i18n.calendar.GregorianNames.getNames('days', this.dayWidth, 'standAlone', this.lang);
+ var dayLabelNodes = this.dayLabelsRow.getElementsByTagName("td");
+ for(var i=0; i<7; i++) {
+ dayLabelNodes.item(i).innerHTML = dayLabels[i];
+ }
+
+ this.selectedIsUsed = false;
+ this.currentIsUsed = false;
+ var currentClassName = "";
+ var previousDate = new Date();
+ var calendarNodes = this.calendarDatesContainerNode.getElementsByTagName("td");
+ var currentCalendarNode;
+ // set hours of date such that there is no chance of rounding error due to
+ // time change in local time zones
+ previousDate.setHours(8);
+ var nextDate = new Date(this.firstSaturday.year, this.firstSaturday.month, this.firstSaturday.date, 8);
+
+ if(this.firstSaturday.date < 7) {
+ // this means there are days to show from the previous month
+ var dayInWeek = 6;
+ for (var i=this.firstSaturday.date; i>0; i--) {
+ currentCalendarNode = calendarNodes.item(dayInWeek);
+ currentCalendarNode.innerHTML = nextDate.getDate();
+ dojo.html.setClass(currentCalendarNode, this.getDateClassName(nextDate, "current"));
+ dayInWeek--;
+ previousDate = nextDate;
+ nextDate = this.incrementDate(nextDate, false);
+ }
+ for(var i=dayInWeek; i>-1; i--) {
+ currentCalendarNode = calendarNodes.item(i);
+ currentCalendarNode.innerHTML = nextDate.getDate();
+ dojo.html.setClass(currentCalendarNode, this.getDateClassName(nextDate, "previous"));
+ previousDate = nextDate;
+ nextDate = this.incrementDate(nextDate, false);
+ }
+ } else {
+ nextDate.setDate(this.firstSaturday.date-6);
+ for(var i=0; i<7; i++) {
+ currentCalendarNode = calendarNodes.item(i);
+ currentCalendarNode.innerHTML = nextDate.getDate();
+ dojo.html.setClass(currentCalendarNode, this.getDateClassName(nextDate, "current"));
+ previousDate = nextDate;
+ nextDate = this.incrementDate(nextDate, true);
+ }
+ }
+ previousDate.setDate(this.firstSaturday.date);
+ previousDate.setMonth(this.firstSaturday.month);
+ previousDate.setFullYear(this.firstSaturday.year);
+ nextDate = this.incrementDate(previousDate, true);
+ var count = 7;
+ currentCalendarNode = calendarNodes.item(count);
+ while((nextDate.getMonth() == previousDate.getMonth()) && (count<42)) {
+ currentCalendarNode.innerHTML = nextDate.getDate();
+ dojo.html.setClass(currentCalendarNode, this.getDateClassName(nextDate, "current"));
+ currentCalendarNode = calendarNodes.item(++count);
+ previousDate = nextDate;
+ nextDate = this.incrementDate(nextDate, true);
+ }
+
+ while(count < 42) {
+ currentCalendarNode.innerHTML = nextDate.getDate();
+ dojo.html.setClass(currentCalendarNode, this.getDateClassName(nextDate, "next"));
+ currentCalendarNode = calendarNodes.item(++count);
+ previousDate = nextDate;
+ nextDate = this.incrementDate(nextDate, true);
+ }
+ this.setMonthLabel(this.firstSaturday.month);
+ this.setYearLabels(this.firstSaturday.year);
+ },
+
+ incrementDate: function(date, bool) {
+ // bool: true to increase, false to decrease
+ var time = date.getTime();
+ var increment = 1000 * 60 * 60 * 24;
+ time = (bool) ? (time + increment) : (time - increment);
+ var returnDate = new Date();
+ returnDate.setTime(time);
+ return returnDate;
+ },
+
+ incrementWeek: function(evt) {
+ var date = this.firstSaturday.date;
+ var month = this.firstSaturday.month;
+ var year = this.firstSaturday.year;
+ switch(evt.target) {
+ case this.increaseWeekNode.getElementsByTagName("img").item(0):
+ case this.increaseWeekNode:
+ date = date + 7;
+ if (date>this._daysIn(month,year)) {
+ date = date - this._daysIn(month,year);
+ if (month < 11) {
+ month++;
+ } else {
+ month=0;
+ year++;
+ }
+ }
+ break;
+ case this.decreaseWeekNode.getElementsByTagName("img").item(0):
+ case this.decreaseWeekNode:
+ if (date > 7) {
+ date = date - 7;
+ } else {
+ var diff = 7 - date;
+ if (month > 0) {
+ month--;
+ date = this._daysIn(month,year) - diff;
+ }else {
+ year--;
+ month=11;
+ date = 31 - diff;
+ }
+ }
+ break;
+
+ }
+
+ this.firstSaturday.date=date;
+ this.firstSaturday.month=month;
+ this.firstSaturday.year=year;
+ this.initUI();
+ },
+
+ incrementMonth: function(evt) {
+ var month = this.firstSaturday.month;
+ var year = this.firstSaturday.year;
+ switch(evt.currentTarget) {
+ case this.increaseMonthNode:
+ if(month < 11) {
+ month++;
+ } else {
+ month = 0;
+ year++;
+
+ this.setYearLabels(year);
+ }
+ break;
+ case this.decreaseMonthNode:
+ if(month > 0) {
+ month--;
+ } else {
+ month = 11;
+ year--;
+ this.setYearLabels(year);
+ }
+ break;
+ case this.increaseMonthNode.getElementsByTagName("img").item(0):
+ if(month < 11) {
+ month++;
+ } else {
+ month = 0;
+ year++;
+ this.setYearLabels(year);
+ }
+ break;
+ case this.decreaseMonthNode.getElementsByTagName("img").item(0):
+ if(month > 0) {
+ month--;
+ } else {
+ month = 11;
+ year--;
+ this.setYearLabels(year);
+ }
+ break;
+ }
+ var tempSaturday = dojo.widget.DatePicker.util.initFirstSaturday(month.toString(), year);
+ this.firstSaturday.year = tempSaturday.year;
+ this.firstSaturday.month = tempSaturday.month;
+ this.firstSaturday.date = tempSaturday.date;
+ this.initUI();
+ },
+
+ incrementYear: function(evt) {
+ var year = this.firstSaturday.year;
+ switch(evt.target) {
+ case this.nextYearLabelNode:
+ year++;
+ break;
+ case this.previousYearLabelNode:
+ year--;
+ break;
+ }
+ var tempSaturday = dojo.widget.DatePicker.util.initFirstSaturday(this.firstSaturday.month.toString(), year);
+ this.firstSaturday.year = tempSaturday.year;
+ this.firstSaturday.month = tempSaturday.month;
+ this.firstSaturday.date = tempSaturday.date;
+ this.initUI();
+ },
+
+ _daysIn: function(month,year) {
+ var daysIn = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+
+ if (month==1) {
+ return (year%400 == 0) ? 29: (year%100 == 0) ? 28: (year%4 == 0) ? 29: 28;
+ } else {
+ return daysIn[month];
+ }
+ },
+
+ onIncrementDate: function(evt) {
+ dojo.unimplemented('dojo.widget.DatePicker.onIncrementDate');
+ },
+
+ onIncrementWeek: function(evt) {
+ evt.stopPropagation();
+ this.incrementWeek(evt);
+ },
+
+ onIncrementMonth: function(evt) {
+ evt.stopPropagation();
+ this.incrementMonth(evt);
+ },
+
+ onIncrementYear: function(evt) {
+ evt.stopPropagation();
+ this.incrementYear(evt);
+ },
+
+ setMonthLabel: function(monthIndex) {
+ this.monthLabelNode.innerHTML = dojo.i18n.calendar.GregorianNames.getNames('months', 'wide', 'standAlone', this.lang)[monthIndex];
+ },
+
+ setYearLabels: function(year) {
+ this.previousYearLabelNode.innerHTML = year - 1;
+ this.currentYearLabelNode.innerHTML = year;
+ this.nextYearLabelNode.innerHTML = year + 1;
+ },
+
+ getDateClassName: function(date, monthState) {
+ var currentClassName = this.classNames[monthState];
+ if ((!this.selectedIsUsed) && (date.getDate() == this.date.getDate()) && (date.getMonth() == this.date.getMonth()) && (date.getFullYear() == this.date.getFullYear())) {
+ currentClassName = this.classNames.selectedDate + " " + currentClassName;
+ this.selectedIsUsed = 1;
+ }
+ if((!this.currentIsUsed) && (date.getDate() == this.today.getDate()) && (date.getMonth() == this.today.getMonth()) && (date.getFullYear() == this.today.getFullYear())) {
+ currentClassName = currentClassName + " " + this.classNames.currentDate;
+ this.currentIsUsed = 1;
+ }
+ return currentClassName;
+ },
+
+ onClick: function(evt) {
+ dojo.event.browser.stopEvent(evt);
+ },
+
+ onSetDate: function(evt) {
+ var eventTarget = (evt.target.nodeType == dojo.dom.ELEMENT_NODE) ?
+ evt.target : evt.target.parentNode;
+ dojo.event.browser.stopEvent(evt);
+ this.selectedIsUsed = 0;
+ this.todayIsUsed = 0;
+ var month = this.firstSaturday.month;
+ var year = this.firstSaturday.year;
+ if (dojo.html.hasClass(eventTarget, this.classNames["next"])) {
+ month = ++month % 12;
+ // if month is now == 0, add a year
+ year = (month==0) ? ++year : year;
+ } else if (dojo.html.hasClass(eventTarget, this.classNames["previous"])) {
+ month = --month % 12;
+ // if month is now == 0, add a year
+ year = (month==11) ? --year : year;
+ }
+ this.date = new Date(year, month, eventTarget.innerHTML);
+ this.setDate(dojo.widget.DatePicker.util.toRfcDate(this.date));
+ this.initUI();
+ }
+ }
+);
+
+dojo.widget.DatePicker.util = new function() {
+ this.toRfcDate = function(jsDate) {
+ if(!jsDate) {
+ jsDate = new Date();
+ }
+ // because this is a date picker and not a time picker, we don't return a time
+ return dojo.date.format(jsDate, "%Y-%m-%d");
+ }
+
+ this.fromRfcDate = function(rfcDate) {
+ // backwards compatible support for use of "any" instead of just not
+ // including the time
+ if(rfcDate.indexOf("Tany")!=-1) {
+ rfcDate = rfcDate.replace("Tany","");
+ }
+ var jsDate = new Date();
+ dojo.date.setIso8601(jsDate, rfcDate);
+ return jsDate;
+ }
+
+ this.initFirstSaturday = function(month, year) {
+ if(!month) {
+ month = this.date.getMonth();
+ }
+ if(!year) {
+ year = this.date.getFullYear();
+ }
+ var firstOfMonth = new Date(year, month, 1);
+ return {year: year, month: month, date: 7 - firstOfMonth.getDay()};
+ }
+}
diff --git a/source/web/scripts/ajax/src/widget/DebugConsole.js b/source/web/scripts/ajax/src/widget/DebugConsole.js
new file mode 100644
index 0000000000..0a26236d1c
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/DebugConsole.js
@@ -0,0 +1,16 @@
+dojo.provide("dojo.widget.DebugConsole");
+dojo.require("dojo.widget.Widget");
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.FloatingPane");
+
+dojo.widget.defineWidget(
+ "dojo.widget.DebugConsole",
+ dojo.widget.FloatingPane,
+{
+ fillInTemplate: function() {
+ dojo.widget.DebugConsole.superclass.fillInTemplate.apply(this, arguments);
+ this.containerNode.id = "debugConsoleClientPane";
+ djConfig.isDebug = true;
+ djConfig.debugContainerId = this.containerNode.id;
+ }
+});
diff --git a/source/web/scripts/ajax/src/widget/Dialog.js b/source/web/scripts/ajax/src/widget/Dialog.js
new file mode 100644
index 0000000000..09940eed64
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/Dialog.js
@@ -0,0 +1,282 @@
+dojo.provide("dojo.widget.Dialog");
+
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.ContentPane");
+dojo.require("dojo.event.*");
+dojo.require("dojo.graphics.color");
+dojo.require("dojo.html.layout");
+dojo.require("dojo.html.display");
+dojo.require("dojo.html.iframe");
+
+dojo.declare(
+ "dojo.widget.ModalDialogBase",
+ null,
+ {
+ isContainer: true,
+ _scrollConnected: false,
+
+ // provide a focusable element or element id if you need to
+ // work around FF's tendency to send focus into outer space on hide
+ focusElement: "",
+
+ shared: {bg: null, bgIframe: null},
+ bgColor: "black",
+ bgOpacity: 0.4,
+ followScroll: true,
+ _fromTrap: false,
+
+ trapTabs: function(e){
+ if(e.target == this.tabStart) {
+ if(this._fromTrap) {
+ this._fromTrap = false;
+ } else {
+ this._fromTrap = true;
+ this.tabEnd.focus();
+ }
+ } else if(e.target == this.tabEnd) {
+ if(this._fromTrap) {
+ this._fromTrap = false;
+ } else {
+ this._fromTrap = true;
+ this.tabStart.focus();
+ }
+ }
+ },
+
+ clearTrap: function(e) {
+ var _this = this;
+ setTimeout(function() {
+ _this._fromTrap = false;
+ }, 100);
+ },
+
+ //if the target mixin class already defined postCreate,
+ //dojo.widget.ModalDialogBase.prototype.postCreate.call(this)
+ //should be called in its postCreate()
+ postCreate: function() {
+ with(this.domNode.style) {
+ position = "absolute";
+ zIndex = 999;
+ display = "none";
+ overflow = "visible";
+ }
+ var b = dojo.body();
+ b.appendChild(this.domNode);
+
+ if(!this.shared.bg){
+ this.shared.bg = document.createElement("div");
+ this.shared.bg.className = "dialogUnderlay";
+ with(this.shared.bg.style) {
+ position = "absolute";
+ left = top = "0px";
+ zIndex = 998;
+ display = "none";
+ }
+ this.setBackgroundColor(this.bgColor);
+ b.appendChild(this.shared.bg);
+
+ this.shared.bgIframe = new dojo.html.BackgroundIframe(this.shared.bg);
+ }
+ },
+
+ setBackgroundColor: function(color) {
+ if(arguments.length >= 3) {
+ color = new dojo.graphics.color.Color(arguments[0], arguments[1], arguments[2]);
+ } else {
+ color = new dojo.graphics.color.Color(color);
+ }
+ this.shared.bg.style.backgroundColor = color.toString();
+ return this.bgColor = color;
+ },
+
+ setBackgroundOpacity: function(op) {
+ if(arguments.length == 0) { op = this.bgOpacity; }
+ dojo.html.setOpacity(this.shared.bg, op);
+ try {
+ this.bgOpacity = dojo.html.getOpacity(this.shared.bg);
+ } catch (e) {
+ this.bgOpacity = op;
+ }
+ return this.bgOpacity;
+ },
+
+ sizeBackground: function() {
+ if(this.bgOpacity > 0) {
+ var viewport = dojo.html.getViewport();
+ var h = Math.max(
+ dojo.doc().documentElement.scrollHeight || dojo.body().scrollHeight,
+ viewport.height);
+ var w = viewport.width;
+ this.shared.bg.style.width = w + "px";
+ this.shared.bg.style.height = h + "px";
+ }
+ this.shared.bgIframe.onResized();
+ },
+
+ showBackground: function() {
+ this.sizeBackground();
+ if(this.bgOpacity > 0) {
+ this.shared.bg.style.display = "block";
+ }
+ },
+
+ placeModalDialog: function() {
+ var scroll_offset = dojo.html.getScroll().offset;
+ var viewport_size = dojo.html.getViewport();
+
+ // find the size of the dialog
+ var mb = dojo.html.getMarginBox(this.containerNode);
+
+ var x = scroll_offset.x + (viewport_size.width - mb.width)/2;
+ var y = scroll_offset.y + (viewport_size.height - mb.height)/2;
+
+ with(this.domNode.style) {
+ left = x + "px";
+ top = y + "px";
+ }
+ },
+
+ //if the target mixin class already defined show,
+ //dojo.widget.ModalDialogBase.prototype.show.call(this)
+ //should be called in its show()
+ show: function() {
+ this.setBackgroundOpacity();
+ this.showBackground();
+
+ this.inherited("show");
+ },
+
+ //if the target mixin class already defined hide,
+ //dojo.widget.ModalDialogBase.prototype.hide.call(this)
+ //should be called in its hide()
+ hide: function(){
+ // workaround for FF focus going into outer space
+ if (this.focusElement) {
+ dojo.byId(this.focusElement).focus();
+ dojo.byId(this.focusElement).blur();
+ }
+
+ this.shared.bg.style.display = "none";
+ this.shared.bg.style.width = this.shared.bg.style.height = "1px";
+
+ this.inherited("hide");
+ }
+ });
+
+dojo.widget.defineWidget(
+ "dojo.widget.Dialog",
+ [dojo.widget.ContentPane, dojo.widget.ModalDialogBase],
+ {
+ templatePath: dojo.uri.dojoUri("src/widget/templates/Dialog.html"),
+
+ anim: null,
+ blockDuration: 0,
+ lifetime: 0,
+
+ show: function() {
+ dojo.widget.ModalDialogBase.prototype.show.call(this);
+
+ if (this.followScroll && !this._scrollConnected){
+ this._scrollConnected = true;
+ dojo.event.connect(window, "onscroll", this, "onScroll");
+ }
+
+ if(this.lifetime){
+ this.timeRemaining = this.lifetime;
+ if(!this.blockDuration){
+ dojo.event.connect(this.shared.bg, "onclick", this, "hide");
+ }else{
+ dojo.event.disconnect(this.shared.bg, "onclick", this, "hide");
+ }
+ if(this.timerNode){
+ this.timerNode.innerHTML = Math.ceil(this.timeRemaining/1000);
+ }
+ if(this.blockDuration && this.closeNode){
+ if(this.lifetime > this.blockDuration){
+ this.closeNode.style.visibility = "hidden";
+ }else{
+ this.closeNode.style.display = "none";
+ }
+ }
+ this.timer = setInterval(dojo.lang.hitch(this, "onTick"), 100);
+ }
+
+ this.checkSize();
+ },
+
+ onLoad: function(){
+ // when href is specified we need to reposition
+ // the dialog after the data is loaded
+ this.placeModalDialog();
+ },
+
+ fillInTemplate: function(){
+ // dojo.event.connect(this.domNode, "onclick", this, "killEvent");
+ },
+
+ hide: function(){
+ dojo.widget.ModalDialogBase.prototype.hide.call(this)
+
+ if(this.timer){
+ clearInterval(this.timer);
+ }
+
+ if (this._scrollConnected){
+ this._scrollConnected = false;
+ dojo.event.disconnect(window, "onscroll", this, "onScroll");
+ }
+ },
+
+ setTimerNode: function(node){
+ this.timerNode = node;
+ },
+
+ setCloseControl: function(node) {
+ this.closeNode = node;
+ dojo.event.connect(node, "onclick", this, "hide");
+ },
+
+ setShowControl: function(node) {
+ dojo.event.connect(node, "onclick", this, "show");
+ },
+
+ onTick: function(){
+ if(this.timer){
+ this.timeRemaining -= 100;
+ if(this.lifetime - this.timeRemaining >= this.blockDuration){
+ dojo.event.connect(this.shared.bg, "onclick", this, "hide");
+ if(this.closeNode){
+ this.closeNode.style.visibility = "visible";
+ }
+ }
+ if(!this.timeRemaining){
+ clearInterval(this.timer);
+ this.hide();
+ }else if(this.timerNode){
+ this.timerNode.innerHTML = Math.ceil(this.timeRemaining/1000);
+ }
+ }
+ },
+
+ onScroll: function(){
+ this.placeModalDialog();
+ this.domNode.style.display = "block";
+ },
+
+ // Called when the browser window's size is changed
+ checkSize: function() {
+ if(this.isShowing()){
+ this.sizeBackground();
+ this.placeModalDialog();
+ this.domNode.style.display="block";
+ this.onResized();
+ }
+ },
+
+ killEvent: function(evt){
+ evt.preventDefault();
+ evt.stopPropagation();
+ }
+
+ }
+);
diff --git a/source/web/scripts/ajax/src/widget/DocPane.js b/source/web/scripts/ajax/src/widget/DocPane.js
new file mode 100644
index 0000000000..245c0ae093
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/DocPane.js
@@ -0,0 +1,372 @@
+dojo.provide("dojo.widget.DocPane");
+
+dojo.require("dojo.widget.*");
+dojo.require("dojo.io.*");
+dojo.require("dojo.event.*");
+dojo.require("dojo.widget.HtmlWidget");
+dojo.require("dojo.widget.Editor2");
+dojo.require("dojo.widget.Dialog");
+
+dojo.require("dojo.html.common");
+dojo.require("dojo.html.display");
+
+dojo.widget.defineWidget(
+ "dojo.widget.DocPane",
+ dojo.widget.HtmlWidget,
+ function(){
+ dojo.event.topic.subscribe("/docs/function/results", this, "onDocResults");
+ dojo.event.topic.subscribe("/docs/package/results", this, "onPkgResults");
+ dojo.event.topic.subscribe("/docs/function/detail", this, "onDocSelectFunction");
+ },
+ {
+ // Template parameters
+ dialog: null,
+ dialogBg: null,
+ dialogFg: null,
+ logIn: null,
+ edit: null,
+ save: null,
+ cancel: null,
+ detail: null,
+ result: null,
+ packag: null,
+ fn: null,
+ fnLink: null,
+ count: null,
+ row: null,
+ summary: null,
+ description: null,
+ variables: null,
+ vRow: null,
+ vLink: null,
+ vDesc: null,
+ methods: null,
+ mRow: null,
+ mLink: null,
+ mDesc: null,
+ requires: null,
+ rRow: null,
+ rRow2: null,
+ rH3: null,
+ rLink: null,
+ parameters: null,
+ pRow: null,
+ pLink: null,
+ pDesc: null,
+ pOpt: null,
+ pType: null,
+ sType: null,
+ sName: null,
+ sParams: null,
+ sPType: null,
+ sPTypeSave: null,
+ sPName: null,
+ sPNameSave: null,
+ pkgDescription: null,
+
+ // Fields and methods
+ _appends: [],
+ templatePath: dojo.uri.dojoUri("src/widget/templates/DocPane.html"),
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/DocPane.css"),
+ isContainer: true,
+
+ fillInTemplate: function(){
+ this.requires = dojo.html.removeNode(this.requires);
+ this.rRow.style.display = "none";
+ this.rRow2.style.display = "none";
+
+ this.methods = dojo.html.removeNode(this.methods);
+ this.mRow.style.display = "none";
+
+ this.dialog = dojo.widget.createWidget("dialog", {}, this.dialog);
+ this.dialog.setCloseControl(this.cancel);
+ dojo.html.setOpacity(this.dialogBg, 0.8);
+ dojo.html.setOpacity(this.dialogFg, 1);
+
+ dojo.event.connect(this.edit, "onclick", dojo.lang.hitch(this, function(){
+ if(!this._isLoggedIn){
+ this.dialog.show();
+ }
+ }));
+ dojo.event.connect(this.logIn, "onclick", this, "_logIn");
+ dojo.event.connect(this.save, "onclick", this, "_save");
+ dojo.event.connect(dojo.docs, "logInSuccess", this, "_loggedIn");
+
+ /*
+ this.pkgDescription = dojo.widget.createWidget("editor2", {
+ toolbarAlwaysVisible: true
+ }, this.pkgDescription);
+ */
+
+ this.homeSave = this.containerNode.cloneNode(true);
+ this.detailSave = dojo.html.removeNode(this.detail);
+ this.resultSave = dojo.html.removeNode(this.result);
+ this.packageSave = dojo.html.removeNode(this.packag);
+ this.results = dojo.html.removeNode(this.results);
+ this.rowParent = this.row.parentNode;
+ this.rowSave = dojo.html.removeNode(this.row);
+ this.vParent = this.vRow.parentNode;
+ this.vSave = dojo.html.removeNode(this.vRow);
+ this.pParent = this.pRow.parentNode;
+ this.pSave = dojo.html.removeNode(this.pRow);
+ this.sPTypeSave = dojo.html.removeNode(this.sPType);
+ this.sPNameSave = dojo.html.removeNode(this.sPName);
+ this.navSave = dojo.html.removeNode(this.nav);
+ },
+
+ _logIn: function(){
+ dojo.docs.setUserName(this.userName.value);
+ dojo.docs.setPassword(this.password.value);
+ },
+
+ _loggedIn: function(){
+ this._isLoggedIn = true;
+ this.dialog.hide();
+ this.pkgEditor = dojo.widget.createWidget("editor2", {
+ toolbarAlwaysVisible: true
+ }, this.pkgDescription);
+ },
+
+ _save: function(){
+ if(this.pkgEditor){
+ dojo.docs.savePackage(this._pkgPath, {
+ description: this.pkgEditor.getEditorContent()
+ });
+ }
+ },
+
+ onDocSelectFunction: function(message){
+ dojo.debug("onDocSelectFunction()");
+ for(var key in message){
+ dojo.debug(key + ": " + dojo.json.serialize(message[key]));
+ }
+ var meta = message.meta;
+ if(meta){
+ var variables = meta.variables;
+ var this_variables = meta.this_variables;
+ var child_variables = meta.child_variables;
+ var parameters = meta.parameters;
+ }
+ var doc = message.doc;
+ dojo.debug(dojo.json.serialize(doc));
+
+ var appends = this._appends;
+ dojo.html.removeChildren(this.domNode);
+ this.fn.innerHTML = message.name;
+
+ this.variables.style.display = "block";
+ var all = [];
+ if(variables){
+ all = variables;
+ }
+ if(this_variables){
+ all = all.concat(this_variables);
+ }
+ if(child_variables){
+ all = all.concat(child_variables);
+ }
+ if(!all.length){
+ this.variables.style.display = "none";
+ }else{
+ for(var i = 0, one; one = all[i]; i++){
+ this.vLink.innerHTML = one;
+ this.vDesc.parentNode.style.display = "none";
+ appends.push(this.vParent.appendChild(this.vSave.cloneNode(true)));
+ }
+ }
+
+ this.sParams.innerHTML = "";
+ var first = true;
+ for(var param in parameters){
+ var paramType = parameters[param].type;
+ var paramSummary = parameters[param].summary;
+ var paramName = param;
+ this.parameters.style.display = "block";
+ this.pLink.innerHTML = paramName;
+ this.pOpt.style.display = "none";
+ if(parameters[param].opt){
+ this.pOpt.style.display = "inline";
+ }
+ this.pType.parentNode.style.display = "none";
+ if(parameters[param][0]){
+ this.pType.parentNode.style.display = "inline";
+ this.pType.innerHTML = paramType;
+ }
+ this.pDesc.parentNode.style.display = "none";
+ if(paramSummary){
+ this.pDesc.parentNode.style.display = "inline";
+ this.pDesc.innerHTML = paramSummary;
+ }
+ appends.push(this.pParent.appendChild(this.pSave.cloneNode(true)));
+
+ if(!first) {
+ this.sParams.appendChild(document.createTextNode(", "));
+ }
+ first = false;
+ if(paramType){
+ dojo.debug(this.sPTypeSave);
+ this.sPTypeSave.innerHTML = paramType;
+ this.sParams.appendChild(this.sPTypeSave.cloneNode(true));
+ this.sParams.appendChild(document.createTextNode(" "));
+ }
+ dojo.debug(this.sPNameSave);
+ this.sPNameSave.innerHTML = paramName;
+ this.sParams.appendChild(this.sPNameSave.cloneNode(true))
+ }
+
+ if(message.returns){
+ this.sType.innerHTML = message.returns;
+ }else{
+ this.sType.innerHTML = "void";
+ }
+
+ this.sName.innerHTML = message.name;
+
+ this.domNode.appendChild(this.navSave);
+ this.domNode.appendChild(this.detailSave.cloneNode(true));
+
+ for(var i = 0, append; append = appends[i]; i++){
+ dojo.html.removeNode(append);
+ }
+ },
+
+ onPkgResults: function(/*Object*/ results){
+ if(this.pkgEditor){
+ this.pkgEditor.close(true);
+ dojo.debug(this.pkgDescription);
+ }
+ var methods = results.methods;
+ var requires = results.requires;
+ var description = results.description;
+ this._pkgPath = results.path;
+ var requireLinks = [];
+ var appends = this._appends;
+ while(appends.length){
+ dojo.html.removeNode(appends.shift());
+ }
+
+ dojo.html.removeChildren(this.domNode);
+
+ this.pkg.innerHTML = results.pkg;
+
+ var hasRequires = false;
+ for(var env in requires){
+ hasRequires = true;
+
+ this.rH3.style.display = "none";
+ if(env != "common"){
+ this.rH3.style.display = "";
+ this.rH3.innerHTML = env;
+ }
+
+ for(var i = 0, require; require = requires[env][i]; i++){
+ requireLinks.push({
+ name: require
+ });
+ this.rLink.innerHTML = require;
+ this.rLink.href = "#" + require;
+ var rRow2 = this.rRow2.parentNode.insertBefore(this.rRow2.cloneNode(true), this.rRow2);
+ rRow2.style.display = "";
+ appends.push(rRow2);
+ }
+ var rRow = this.rRow.parentNode.insertBefore(this.rRow.cloneNode(true), this.rRow);
+ rRow.style.display = "";
+ appends.push(rRow);
+ }
+
+ if(hasRequires){
+ appends.push(this.packageSave.appendChild(this.requires.cloneNode(true)));
+ }
+
+ if(results.size){
+ for(var i = 0, method; method = methods[i]; i++){
+ this.mLink.innerHTML = method.name;
+ this.mLink.href = "#" + method.name;
+ this.mDesc.parentNode.style.display = "none";
+ if(method.summary){
+ this.mDesc.parentNode.style.display = "inline";
+ this.mDesc.innerHTML = method.summary;
+ }
+ var mRow = this.mRow.parentNode.insertBefore(this.mRow.cloneNode(true), this.mRow);
+ mRow.style.display = "";
+ appends.push(mRow);
+ }
+ appends.push(this.packageSave.appendChild(this.methods.cloneNode(true)));
+ }
+
+ this.domNode.appendChild(this.packageSave);
+
+ /*
+ dojo.debug(description);
+ function fillContent(){
+ this.pkgDescription.replaceEditorContent(description);
+ this.pkgDescription._updateHeight();
+ }
+ if(this.pkgDescription.isLoaded){
+ fillContent();
+ }else{
+ dojo.event.connect(this.pkgDescription, "onLoad", dojo.lang.hitch(this, fillContent));
+ }
+ */
+ this.pkgDescription.innerHTML = description;
+
+ function makeSelect(fOrP, x){
+ return function(e) {
+ dojo.event.topic.publish("/docs/" + fOrP + "/select", x);
+ }
+ }
+
+ var as = this.domNode.getElementsByTagName("a");
+ for(var i = 0, a; a = as[i]; i++){
+ if(a.className == "docMLink"){
+ dojo.event.connect(a, "onclick", makeSelect("function", methods[i]));
+ }else if(a.className == "docRLink"){
+ dojo.event.connect(a, "onclick", makeSelect("package", requireLinks[i]));
+ }
+ }
+ },
+
+ onDocResults: function(message){
+ var results = message.docResults;
+
+ if(results.length == 1){
+ dojo.event.topic.publish("/docs/function/select", results[0]);
+ return;
+ }
+
+ dojo.html.removeChildren(this.domNode);
+
+ this.count.innerHTML = results.length;
+ var appends = [];
+ for(var i = 0, row; row = results[i]; i++){
+ this.fnLink.innerHTML = row.name;
+ this.fnLink.href = "#" + row.name;
+ if(row.id){
+ this.fnLink.href = this.fnLink.href + "," + row.id;
+ }
+ this.summary.parentNode.style.display = "none";
+ if(row.summary){
+ this.summary.parentNode.style.display = "inline";
+ this.summary.innerHTML = row.summary;
+ }
+ appends.push(this.rowParent.appendChild(this.rowSave.cloneNode(true)));
+ }
+
+ function makeSelect(x){
+ return function(e) {
+ dojo.event.topic.publish("/docs/function/select", x);
+ }
+ }
+
+ this.domNode.appendChild(this.resultSave.cloneNode(true));
+ var as = this.domNode.getElementsByTagName("a");
+ for(var i = 0, a; a = as[i]; i++){
+ dojo.event.connect(a, "onclick", makeSelect(results[i]));
+ }
+
+ for(var i = 0, append; append = appends[i]; i++){
+ this.rowParent.removeChild(append);
+ }
+ }
+ }
+);
diff --git a/source/web/scripts/ajax/src/widget/DomWidget.js b/source/web/scripts/ajax/src/widget/DomWidget.js
new file mode 100644
index 0000000000..5727593d68
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/DomWidget.js
@@ -0,0 +1,617 @@
+dojo.provide("dojo.widget.DomWidget");
+
+dojo.require("dojo.event.*");
+dojo.require("dojo.widget.Widget");
+dojo.require("dojo.dom");
+dojo.require("dojo.html.style");
+dojo.require("dojo.xml.Parse");
+dojo.require("dojo.uri.*");
+dojo.require("dojo.lang.func");
+dojo.require("dojo.lang.extras");
+
+dojo.widget._cssFiles = {};
+dojo.widget._cssStrings = {};
+dojo.widget._templateCache = {};
+
+dojo.widget.defaultStrings = {
+ dojoRoot: dojo.hostenv.getBaseScriptUri(),
+ baseScriptUri: dojo.hostenv.getBaseScriptUri()
+};
+
+dojo.widget.buildFromTemplate = function() {
+ dojo.lang.forward("fillFromTemplateCache");
+}
+
+// static method to build from a template w/ or w/o a real widget in place
+dojo.widget.fillFromTemplateCache = function(obj, templatePath, templateString, avoidCache){
+ // dojo.debug("avoidCache:", avoidCache);
+ var tpath = templatePath || obj.templatePath;
+
+ // DEPRECATED: use Uri objects, not strings
+ if (tpath && !(tpath instanceof dojo.uri.Uri)) {
+ tpath = dojo.uri.dojoUri(tpath);
+ dojo.deprecated("templatePath should be of type dojo.uri.Uri", null, "0.4");
+ }
+
+ var tmplts = dojo.widget._templateCache;
+ if(!obj["widgetType"]) { // don't have a real template here
+ do {
+ var dummyName = "__dummyTemplate__" + dojo.widget._templateCache.dummyCount++;
+ } while(tmplts[dummyName]);
+ obj.widgetType = dummyName;
+ }
+ var wt = obj.widgetType;
+
+ var ts = tmplts[wt];
+ if(!ts){
+ tmplts[wt] = { "string": null, "node": null };
+ if(avoidCache){
+ ts = {};
+ }else{
+ ts = tmplts[wt];
+ }
+ }
+ if((!obj.templateString)&&(!avoidCache)){
+ obj.templateString = templateString || ts["string"];
+ }
+ if((!obj.templateNode)&&(!avoidCache)){
+ obj.templateNode = ts["node"];
+ }
+ if((!obj.templateNode)&&(!obj.templateString)&&(tpath)){
+ // fetch a text fragment and assign it to templateString
+ // NOTE: we rely on blocking IO here!
+ var tstring = dojo.hostenv.getText(tpath);
+ if(tstring){
+ // strip <?xml ...?> declarations so that external SVG and XML
+ // documents can be added to a document without worry
+ tstring = tstring.replace(/^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im, "");
+ var matches = tstring.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im);
+ if(matches){
+ tstring = matches[1];
+ }
+ }else{
+ tstring = "";
+ }
+ obj.templateString = tstring;
+ if(!avoidCache){
+ tmplts[wt]["string"] = tstring;
+ }
+ }
+ if((!ts["string"])&&(!avoidCache)){
+ ts.string = obj.templateString;
+ }
+}
+dojo.widget._templateCache.dummyCount = 0;
+
+dojo.widget.attachProperties = ["dojoAttachPoint", "id"];
+dojo.widget.eventAttachProperty = "dojoAttachEvent";
+dojo.widget.onBuildProperty = "dojoOnBuild";
+dojo.widget.waiNames = ["waiRole", "waiState"];
+dojo.widget.wai = {
+ waiRole: { name: "waiRole",
+ namespace: "http://www.w3.org/TR/xhtml2",
+ alias: "x2",
+ prefix: "wairole:"
+ },
+ waiState: { name: "waiState",
+ namespace: "http://www.w3.org/2005/07/aaa" ,
+ alias: "aaa",
+ prefix: ""
+ },
+ setAttr: function(node, ns, attr, value){
+ if(dojo.render.html.ie){
+ node.setAttribute(this[ns].alias+":"+ attr, this[ns].prefix+value);
+ }else{
+ node.setAttributeNS(this[ns].namespace, attr, this[ns].prefix+value);
+ }
+ },
+
+ getAttr: function(node, ns, attr){
+ if(dojo.render.html.ie){
+ return node.getAttribute(this[ns].alias+":"+attr);
+ }else{
+ return node.getAttributeNS(this[ns].namespace, attr);
+ }
+ }
+};
+
+dojo.widget.attachTemplateNodes = function(rootNode, targetObj, events){
+ // FIXME: this method is still taking WAAAY too long. We need ways of optimizing:
+ // a.) what we are looking for on each node
+ // b.) the nodes that are subject to interrogation (use xpath instead?)
+ // c.) how expensive event assignment is (less eval(), more connect())
+ // var start = new Date();
+ var elementNodeType = dojo.dom.ELEMENT_NODE;
+
+ function trim(str){
+ return str.replace(/^\s+|\s+$/g, "");
+ }
+
+ if(!rootNode){
+ rootNode = targetObj.domNode;
+ }
+
+ if(rootNode.nodeType != elementNodeType){
+ return;
+ }
+ // alert(events.length);
+
+ var nodes = rootNode.all || rootNode.getElementsByTagName("*");
+ var _this = targetObj;
+ for(var x=-1; x<nodes.length; x++){
+ var baseNode = (x == -1) ? rootNode : nodes[x];
+ // FIXME: is this going to have capitalization problems? Could use getAttribute(name, 0); to get attributes case-insensitve
+ var attachPoint = [];
+ for(var y=0; y<this.attachProperties.length; y++){
+ var tmpAttachPoint = baseNode.getAttribute(this.attachProperties[y]);
+ if(tmpAttachPoint){
+ attachPoint = tmpAttachPoint.split(";");
+ for(var z=0; z<attachPoint.length; z++){
+ if(dojo.lang.isArray(targetObj[attachPoint[z]])){
+ targetObj[attachPoint[z]].push(baseNode);
+ }else{
+ targetObj[attachPoint[z]]=baseNode;
+ }
+ }
+ break;
+ }
+ }
+ // continue;
+
+ // FIXME: we need to put this into some kind of lookup structure
+ // instead of direct assignment
+ var tmpltPoint = baseNode.getAttribute(this.templateProperty);
+ if(tmpltPoint){
+ targetObj[tmpltPoint]=baseNode;
+ }
+
+ dojo.lang.forEach(dojo.widget.waiNames, function(name){
+ var wai = dojo.widget.wai[name];
+ var val = baseNode.getAttribute(wai.name);
+ if(val){
+ if(val.indexOf('-') == -1){
+ dojo.widget.wai.setAttr(baseNode, wai.name, "role", val);
+ }else{
+ // this is a state-value pair
+ var statePair = val.split('-');
+ dojo.widget.wai.setAttr(baseNode, wai.name, statePair[0], statePair[1]);
+ }
+ }
+ }, this);
+
+ var attachEvent = baseNode.getAttribute(this.eventAttachProperty);
+ if(attachEvent){
+ // NOTE: we want to support attributes that have the form
+ // "domEvent: nativeEvent; ..."
+ var evts = attachEvent.split(";");
+ for(var y=0; y<evts.length; y++){
+ if((!evts[y])||(!evts[y].length)){ continue; }
+ var thisFunc = null;
+ var tevt = trim(evts[y]);
+ if(evts[y].indexOf(":") >= 0){
+ // oh, if only JS had tuple assignment
+ var funcNameArr = tevt.split(":");
+ tevt = trim(funcNameArr[0]);
+ thisFunc = trim(funcNameArr[1]);
+ }
+ if(!thisFunc){
+ thisFunc = tevt;
+ }
+
+ var tf = function(){
+ var ntf = new String(thisFunc);
+ return function(evt){
+ if(_this[ntf]){
+ _this[ntf](dojo.event.browser.fixEvent(evt, this));
+ }
+ };
+ }();
+ dojo.event.browser.addListener(baseNode, tevt, tf, false, true);
+ // dojo.event.browser.addListener(baseNode, tevt, dojo.lang.hitch(_this, thisFunc));
+ }
+ }
+
+ for(var y=0; y<events.length; y++){
+ //alert(events[x]);
+ var evtVal = baseNode.getAttribute(events[y]);
+ if((evtVal)&&(evtVal.length)){
+ var thisFunc = null;
+ var domEvt = events[y].substr(4); // clober the "dojo" prefix
+ thisFunc = trim(evtVal);
+ var funcs = [thisFunc];
+ if(thisFunc.indexOf(";")>=0){
+ funcs = dojo.lang.map(thisFunc.split(";"), trim);
+ }
+ for(var z=0; z<funcs.length; z++){
+ if(!funcs[z].length){ continue; }
+ var tf = function(){
+ var ntf = new String(funcs[z]);
+ return function(evt){
+ if(_this[ntf]){
+ _this[ntf](dojo.event.browser.fixEvent(evt, this));
+ }
+ }
+ }();
+ dojo.event.browser.addListener(baseNode, domEvt, tf, false, true);
+ // dojo.event.browser.addListener(baseNode, domEvt, dojo.lang.hitch(_this, funcs[z]));
+ }
+ }
+ }
+
+ var onBuild = baseNode.getAttribute(this.onBuildProperty);
+ if(onBuild){
+ eval("var node = baseNode; var widget = targetObj; "+onBuild);
+ }
+ }
+
+}
+
+dojo.widget.getDojoEventsFromStr = function(str){
+ // var lstr = str.toLowerCase();
+ var re = /(dojoOn([a-z]+)(\s?))=/gi;
+ var evts = str ? str.match(re)||[] : [];
+ var ret = [];
+ var lem = {};
+ for(var x=0; x<evts.length; x++){
+ if(evts[x].legth < 1){ continue; }
+ var cm = evts[x].replace(/\s/, "");
+ cm = (cm.slice(0, cm.length-1));
+ if(!lem[cm]){
+ lem[cm] = true;
+ ret.push(cm);
+ }
+ }
+ return ret;
+}
+
+/*
+dojo.widget.buildAndAttachTemplate = function(obj, templatePath, templateCssPath, templateString, targetObj) {
+ this.buildFromTemplate(obj, templatePath, templateCssPath, templateString);
+ var node = dojo.dom.createNodesFromText(obj.templateString, true)[0];
+ this.attachTemplateNodes(node, targetObj||obj, dojo.widget.getDojoEventsFromStr(templateString));
+ return node;
+}
+*/
+
+dojo.declare("dojo.widget.DomWidget", dojo.widget.Widget,
+ function() {
+ if((arguments.length>0)&&(typeof arguments[0] == "object")){
+ this.create(arguments[0]);
+ }
+ },
+{
+ templateNode: null,
+ templateString: null,
+ templateCssString: null,
+ preventClobber: false,
+ domNode: null, // this is our visible representation of the widget!
+ containerNode: null, // holds child elements
+
+ // Process the given child widget, inserting it's dom node as a child of our dom node
+ // FIXME: should we support addition at an index in the children arr and
+ // order the display accordingly? Right now we always append.
+ addChild: function(widget, overrideContainerNode, pos, ref, insertIndex){
+ if(!this.isContainer){ // we aren't allowed to contain other widgets, it seems
+ dojo.debug("dojo.widget.DomWidget.addChild() attempted on non-container widget");
+ return null;
+ }else{
+ if(insertIndex == undefined){
+ insertIndex = this.children.length;
+ }
+ this.addWidgetAsDirectChild(widget, overrideContainerNode, pos, ref, insertIndex);
+ this.registerChild(widget, insertIndex);
+ }
+ return widget;
+ },
+
+ addWidgetAsDirectChild: function(widget, overrideContainerNode, pos, ref, insertIndex){
+ if((!this.containerNode)&&(!overrideContainerNode)){
+ this.containerNode = this.domNode;
+ }
+ var cn = (overrideContainerNode) ? overrideContainerNode : this.containerNode;
+ if(!pos){ pos = "after"; }
+ if(!ref){
+ if(!cn){ cn = dojo.body(); }
+ ref = cn.lastChild;
+ }
+ if(!insertIndex) { insertIndex = 0; }
+ widget.domNode.setAttribute("dojoinsertionindex", insertIndex);
+
+ // insert the child widget domNode directly underneath my domNode, in the
+ // specified position (by default, append to end)
+ if(!ref){
+ cn.appendChild(widget.domNode);
+ }else{
+ // FIXME: was this meant to be the (ugly hack) way to support insert @ index?
+ //dojo.dom[pos](widget.domNode, ref, insertIndex);
+
+ // CAL: this appears to be the intended way to insert a node at a given position...
+ if (pos == 'insertAtIndex'){
+ // dojo.debug("idx:", insertIndex, "isLast:", ref === cn.lastChild);
+ dojo.dom.insertAtIndex(widget.domNode, ref.parentNode, insertIndex);
+ }else{
+ // dojo.debug("pos:", pos, "isLast:", ref === cn.lastChild);
+ if((pos == "after")&&(ref === cn.lastChild)){
+ cn.appendChild(widget.domNode);
+ }else{
+ dojo.dom.insertAtPosition(widget.domNode, cn, pos);
+ }
+ }
+ }
+ },
+
+ // Record that given widget descends from me
+ registerChild: function(widget, insertionIndex){
+
+ // we need to insert the child at the right point in the parent's
+ // 'children' array, based on the insertionIndex
+
+ widget.dojoInsertionIndex = insertionIndex;
+
+ var idx = -1;
+ for(var i=0; i<this.children.length; i++){
+ if (this.children[i].dojoInsertionIndex < insertionIndex){
+ idx = i;
+ }
+ }
+
+ this.children.splice(idx+1, 0, widget);
+
+ widget.parent = this;
+ widget.addedTo(this, idx+1);
+
+ // If this widget was created programatically, then it was erroneously added
+ // to dojo.widget.manager.topWidgets. Fix that here.
+ delete dojo.widget.manager.topWidgets[widget.widgetId];
+ },
+
+ removeChild: function(widget){
+ // detach child domNode from parent domNode
+ dojo.dom.removeNode(widget.domNode);
+
+ // remove child widget from parent widget
+ return dojo.widget.DomWidget.superclass.removeChild.call(this, widget);
+ },
+
+ getFragNodeRef: function(frag){
+ if(!frag || !frag[this.namespace+":"+this.widgetType.toLowerCase()]){
+ dojo.raise("Error: no frag for widget type " + this.widgetType
+ + " with namespace "+this.namespace + ", id " + this.widgetId
+ + " (maybe a widget has set it's type incorrectly)");
+ }
+ return frag ? frag[this.namespace+":"+this.widgetType.toLowerCase()]["nodeRef"] : null;
+ },
+
+ // Replace source domNode with generated dom structure, and register
+ // widget with parent.
+ postInitialize: function(args, frag, parentComp){
+
+ //dojo.profile.start(this.widgetType + " postInitialize");
+
+ var sourceNodeRef = this.getFragNodeRef(frag);
+ // Stick my generated dom into the output tree
+ //alert(this.widgetId + ": replacing " + sourceNodeRef + " with " + this.domNode.innerHTML);
+ if (parentComp && (parentComp.snarfChildDomOutput || !sourceNodeRef)){
+ // Add my generated dom as a direct child of my parent widget
+ // This is important for generated widgets, and also cases where I am generating an
+ // <li> node that can't be inserted back into the original DOM tree
+ parentComp.addWidgetAsDirectChild(this, "", "insertAtIndex", "", args["dojoinsertionindex"], sourceNodeRef);
+ } else if (sourceNodeRef){
+ // Do in-place replacement of the my source node with my generated dom
+ if(this.domNode && (this.domNode !== sourceNodeRef)){
+ var oldNode = sourceNodeRef.parentNode.replaceChild(this.domNode, sourceNodeRef);
+ }
+ }
+
+ // Register myself with my parent, or with the widget manager if
+ // I have no parent
+ // TODO: the code below erroneously adds all programatically generated widgets
+ // to topWidgets (since we don't know who the parent is until after creation finishes)
+ if ( parentComp ) {
+ parentComp.registerChild(this, args.dojoinsertionindex);
+ } else {
+ dojo.widget.manager.topWidgets[this.widgetId]=this;
+ }
+
+
+ //dojo.profile.end(this.widgetType + " postInitialize");
+
+ // Expand my children widgets
+ /* dojoDontFollow is important for a very special case
+ * basically if you have a widget that you instantiate from script
+ * and that widget is a container, and it contains a reference to a parent
+ * instance, the parser will start recursively parsing until the browser
+ * complains. So the solution is to set an initialization property of
+ * dojoDontFollow: true and then it won't recurse where it shouldn't
+ */
+ if(this.isContainer && !frag["dojoDontFollow"]){
+ //alert("recurse from " + this.widgetId);
+ // build any sub-components with us as the parent
+ var fragParser = dojo.widget.getParser();
+ fragParser.createSubComponents(frag, this);
+ }
+ },
+
+ // method over-ride
+ buildRendering: function(args, frag){
+ // DOM widgets construct themselves from a template
+ var ts = dojo.widget._templateCache[this.widgetType];
+
+ // Handle style for this widget here, as even if templatePath
+ // is not set, style specified by templateCssString or templateCssPath
+ // should be applied. templateCssString has higher priority
+ // than templateCssPath
+ if(args["templatecsspath"]){
+ args["templateCssPath"] = args["templatecsspath"];
+ }
+ var cpath = args["templateCssPath"] || this.templateCssPath;
+ // DEPRECATED: use Uri objects, not strings
+ if (cpath && !(cpath instanceof dojo.uri.Uri)) {
+ cpath = dojo.uri.dojoUri(cpath);
+ dojo.deprecated("templateCssPath should be of type dojo.uri.Uri", null, "0.4");
+ }
+ if(cpath && !dojo.widget._cssFiles[cpath.toString()]){
+ if((!this.templateCssString)&&(cpath)){
+ this.templateCssString = dojo.hostenv.getText(cpath);
+ this.templateCssPath = null;
+ }
+ dojo.widget._cssFiles[cpath.toString()] = true;
+ }
+
+ if((this["templateCssString"])&&(!this.templateCssString["loaded"])){
+ dojo.html.insertCssText(this.templateCssString, null, cpath);
+ if(!this.templateCssString){ this.templateCssString = ""; }
+ this.templateCssString.loaded = true;
+ }
+ if(
+ (!this.preventClobber)&&(
+ (this.templatePath)||
+ (this.templateNode)||
+ (
+ (this["templateString"])&&(this.templateString.length)
+ )||
+ (
+ (typeof ts != "undefined")&&( (ts["string"])||(ts["node"]) )
+ )
+ )
+ ){
+ // if it looks like we can build the thing from a template, do it!
+ this.buildFromTemplate(args, frag);
+ }else{
+ // otherwise, assign the DOM node that was the source of the widget
+ // parsing to be the root node
+ this.domNode = this.getFragNodeRef(frag);
+ }
+ this.fillInTemplate(args, frag); // this is where individual widgets
+ // will handle population of data
+ // from properties, remote data
+ // sets, etc.
+ },
+
+ buildFromTemplate: function(args, frag){
+ // var start = new Date();
+ // copy template properties if they're already set in the templates object
+ // dojo.debug("buildFromTemplate:", this);
+ var avoidCache = false;
+ if(args["templatepath"]){
+ avoidCache = true;
+ args["templatePath"] = args["templatepath"];
+ }
+ dojo.widget.fillFromTemplateCache( this,
+ args["templatePath"],
+ null,
+ avoidCache);
+ var ts = dojo.widget._templateCache[this.widgetType];
+ if((ts)&&(!avoidCache)){
+ if(!this.templateString.length){
+ this.templateString = ts["string"];
+ }
+ if(!this.templateNode){
+ this.templateNode = ts["node"];
+ }
+ }
+ var matches = false;
+ var node = null;
+ // var tstr = new String(this.templateString);
+ var tstr = this.templateString;
+ // attempt to clone a template node, if there is one
+ if((!this.templateNode)&&(this.templateString)){
+ matches = this.templateString.match(/\$\{([^\}]+)\}/g);
+ if(matches) {
+ // if we do property replacement, don't create a templateNode
+ // to clone from.
+ var hash = this.strings || {};
+ // FIXME: should this hash of default replacements be cached in
+ // templateString?
+ for(var key in dojo.widget.defaultStrings) {
+ if(dojo.lang.isUndefined(hash[key])) {
+ hash[key] = dojo.widget.defaultStrings[key];
+ }
+ }
+ // FIXME: this is a lot of string munging. Can we make it faster?
+ for(var i = 0; i < matches.length; i++) {
+ var key = matches[i];
+ key = key.substring(2, key.length-1);
+ var kval = (key.substring(0, 5) == "this.") ? dojo.lang.getObjPathValue(key.substring(5), this) : hash[key];
+ var value;
+ if((kval)||(dojo.lang.isString(kval))){
+ value = (dojo.lang.isFunction(kval)) ? kval.call(this, key, this.templateString) : kval;
+ tstr = tstr.replace(matches[i], value);
+ }
+ }
+ }else{
+ // otherwise, we are required to instantiate a copy of the template
+ // string if one is provided.
+
+ // FIXME: need to be able to distinguish here what should be done
+ // or provide a generic interface across all DOM implementations
+ // FIMXE: this breaks if the template has whitespace as its first
+ // characters
+ // node = this.createNodesFromText(this.templateString, true);
+ // this.templateNode = node[0].cloneNode(true); // we're optimistic here
+ this.templateNode = this.createNodesFromText(this.templateString, true)[0];
+ if(!avoidCache){
+ ts.node = this.templateNode;
+ }
+ }
+ }
+ if((!this.templateNode)&&(!matches)){
+ dojo.debug("DomWidget.buildFromTemplate: could not create template");
+ return false;
+ }else if(!matches){
+ node = this.templateNode.cloneNode(true);
+ if(!node){ return false; }
+ }else{
+ node = this.createNodesFromText(tstr, true)[0];
+ }
+
+ // recurse through the node, looking for, and attaching to, our
+ // attachment points which should be defined on the template node.
+
+ this.domNode = node;
+ // dojo.profile.start("attachTemplateNodes");
+ this.attachTemplateNodes(this.domNode, this);
+ // dojo.profile.end("attachTemplateNodes");
+
+ // relocate source contents to templated container node
+ // this.containerNode must be able to receive children, or exceptions will be thrown
+ if (this.isContainer && this.containerNode){
+ var src = this.getFragNodeRef(frag);
+ if (src){
+ dojo.dom.moveChildren(src, this.containerNode);
+ }
+ }
+ },
+
+ attachTemplateNodes: function(baseNode, targetObj){
+ if(!targetObj){ targetObj = this; }
+ return dojo.widget.attachTemplateNodes(baseNode, targetObj,
+ dojo.widget.getDojoEventsFromStr(this.templateString));
+ },
+
+ fillInTemplate: function(){
+ // dojo.unimplemented("dojo.widget.DomWidget.fillInTemplate");
+ },
+
+ // method over-ride
+ destroyRendering: function(){
+ try{
+ delete this.domNode;
+ }catch(e){ /* squelch! */ }
+ },
+
+ // FIXME: method over-ride
+ cleanUp: function(){},
+
+ getContainerHeight: function(){
+ dojo.unimplemented("dojo.widget.DomWidget.getContainerHeight");
+ },
+
+ getContainerWidth: function(){
+ dojo.unimplemented("dojo.widget.DomWidget.getContainerWidth");
+ },
+
+ createNodesFromText: function(){
+ dojo.unimplemented("dojo.widget.DomWidget.createNodesFromText");
+ }
+});
diff --git a/source/web/scripts/ajax/src/widget/DropdownButton.js b/source/web/scripts/ajax/src/widget/DropdownButton.js
new file mode 100644
index 0000000000..e81fe99762
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/DropdownButton.js
@@ -0,0 +1,29 @@
+/*
+ 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.widget.DropdownButton");
+
+dojo.deprecated("dojo.widget.DropdownButton", "use dojo.widget.ComboButton", "0.4");
+
+// Draws a button with a down arrow;
+// when you press the down arrow something appears (usually a menu)
+
+dojo.require("dojo.widget.*");
+
+dojo.widget.tags.addParseTreeHandler("dojo:dropdownbutton");
+
+dojo.widget.DropdownButton = function(){
+ dojo.widget.Widget.call(this);
+
+ this.widgetType = "DropdownButton";
+}
+dojo.inherits(dojo.widget.DropdownButton, dojo.widget.Widget);
+
+dojo.requireAfterIf("html", "dojo.widget.html.DropdownButton");
diff --git a/source/web/scripts/ajax/src/widget/DropdownContainer.js b/source/web/scripts/ajax/src/widget/DropdownContainer.js
new file mode 100644
index 0000000000..396c0e67a7
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/DropdownContainer.js
@@ -0,0 +1,62 @@
+dojo.provide("dojo.widget.DropdownContainer");
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.HtmlWidget");
+dojo.require("dojo.widget.Menu2"); // for PopupContainer
+dojo.require("dojo.event.*");
+dojo.require("dojo.html.layout");
+dojo.require("dojo.html.display");
+dojo.require("dojo.html.iframe");
+dojo.require("dojo.html.util");
+
+dojo.widget.defineWidget(
+ "dojo.widget.DropdownContainer",
+ dojo.widget.HtmlWidget,
+ {
+ inputWidth: "7em",
+ inputId: "",
+ inputName: "",
+ iconURL: dojo.uri.dojoUri("src/widget/templates/images/combo_box_arrow.png"),
+ iconAlt: "",
+
+ inputNode: null,
+ buttonNode: null,
+ containerNode: null,
+
+ containerToggle: "plain",
+ containerToggleDuration: 150,
+ containerAnimInProgress: false,
+
+ templateString: '<span style="white-space:nowrap"><input type="text" value="" style="vertical-align:middle;" dojoAttachPoint="inputNode" autocomplete="off" /> <img src="${this.iconURL}" alt="${this.iconAlt}" dojoAttachEvent="onclick: onIconClick;" dojoAttachPoint="buttonNode" style="vertical-align:middle; cursor:pointer; cursor:hand;" /></span>',
+ templateCssPath: "",
+
+ fillInTemplate: function(args, frag){
+ var source = this.getFragNodeRef(frag);
+
+ this.popup = dojo.widget.createWidget("PopupContainer", {toggle: this.containerToggle});
+
+ this.containerNode = this.popup.domNode;
+
+ this.domNode.appendChild(this.popup.domNode);
+
+ if(this.inputId){ this.inputNode.id = this.inputId; }
+ if(this.inputName){ this.inputNode.name = this.inputName; }
+ this.inputNode.style.width = this.inputWidth;
+
+ dojo.event.connect(this.inputNode, "onchange", this, "onInputChange");
+ },
+
+ onIconClick: function(evt){
+ if(!this.popup.isShowingNow){
+ this.popup.open(this.inputNode, this, this.buttonNode);
+ }else{
+ this.popup.close();
+ }
+ },
+
+ hideContainer: function(){
+ this.popup.close();
+ },
+
+ onInputChange: function(){}
+ }
+);
diff --git a/source/web/scripts/ajax/src/widget/DropdownDatePicker.js b/source/web/scripts/ajax/src/widget/DropdownDatePicker.js
new file mode 100644
index 0000000000..db3e5c3bbb
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/DropdownDatePicker.js
@@ -0,0 +1,55 @@
+dojo.provide("dojo.widget.DropdownDatePicker");
+
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.DropdownContainer");
+dojo.require("dojo.widget.DatePicker");
+dojo.require("dojo.event.*");
+dojo.require("dojo.html.*");
+
+dojo.widget.defineWidget(
+ "dojo.widget.DropdownDatePicker",
+ dojo.widget.DropdownContainer,
+ {
+ iconURL: dojo.uri.dojoUri("src/widget/templates/images/dateIcon.gif"),
+ iconAlt: "Select a Date",
+ zIndex: "10",
+ datePicker: null,
+
+ dateFormat: "%m/%d/%Y",
+ date: null,
+
+ fillInTemplate: function(args, frag){
+ dojo.widget.DropdownDatePicker.superclass.fillInTemplate.call(this, args, frag);
+ var source = this.getFragNodeRef(frag);
+
+ if(args.date){ this.date = new Date(args.date); }
+
+ var dpNode = document.createElement("div");
+ this.containerNode.appendChild(dpNode);
+
+ var dateProps = { widgetContainerId: this.widgetId };
+ if(this.date){
+ dateProps["date"] = this.date;
+ dateProps["storedDate"] = dojo.widget.DatePicker.util.toRfcDate(this.date);
+ this.inputNode.value = dojo.date.format(this.date, this.dateFormat);
+ }
+ this.datePicker = dojo.widget.createWidget("DatePicker", dateProps, dpNode);
+ dojo.event.connect(this.datePicker, "onSetDate", this, "onSetDate");
+ this.containerNode.style.zIndex = this.zIndex;
+ this.containerNode.style.backgroundColor = "transparent";
+ },
+
+ onSetDate: function(){
+ this.inputNode.value = dojo.date.format(this.datePicker.date, this.dateFormat);
+ this.hideContainer();
+ },
+
+ onInputChange: function(){
+ var tmp = new Date(this.inputNode.value);
+ this.datePicker.date = tmp;
+ this.datePicker.setDate(dojo.widget.DatePicker.util.toRfcDate(tmp));
+ this.datePicker.initData();
+ this.datePicker.initUI();
+ }
+ }
+);
diff --git a/source/web/scripts/ajax/src/widget/Editor.js b/source/web/scripts/ajax/src/widget/Editor.js
new file mode 100644
index 0000000000..0a140949ae
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/Editor.js
@@ -0,0 +1,523 @@
+/* TODO:
+ * - font selector
+ * - test, bug fix, more features :)
+*/
+dojo.provide("dojo.widget.Editor");
+dojo.provide("dojo.widget.Editor");
+dojo.require("dojo.io.*");
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.Toolbar");
+dojo.require("dojo.widget.RichText");
+dojo.require("dojo.widget.ColorPalette");
+dojo.require("dojo.string.extras");
+
+dojo.widget.tags.addParseTreeHandler("dojo:Editor");
+
+dojo.widget.Editor = function() {
+ dojo.widget.HtmlWidget.call(this);
+ this.contentFilters = [];
+ this._toolbars = [];
+}
+dojo.inherits(dojo.widget.Editor, dojo.widget.HtmlWidget);
+
+dojo.widget.Editor.itemGroups = {
+ textGroup: ["bold", "italic", "underline", "strikethrough"],
+ blockGroup: ["formatBlock", "fontName", "fontSize"],
+ justifyGroup: ["justifyleft", "justifycenter", "justifyright"],
+ commandGroup: ["save", "cancel"],
+ colorGroup: ["forecolor", "hilitecolor"],
+ listGroup: ["insertorderedlist", "insertunorderedlist"],
+ indentGroup: ["outdent", "indent"],
+ linkGroup: ["createlink", "insertimage", "inserthorizontalrule"]
+};
+
+dojo.widget.Editor.formatBlockValues = {
+ "Normal": "p",
+ "Main heading": "h2",
+ "Sub heading": "h3",
+ "Sub sub heading": "h4",
+ "Preformatted": "pre"
+};
+
+dojo.widget.Editor.fontNameValues = {
+ "Arial": "Arial, Helvetica, sans-serif",
+ "Verdana": "Verdana, sans-serif",
+ "Times New Roman": "Times New Roman, serif",
+ "Courier": "Courier New, monospace"
+};
+
+dojo.widget.Editor.fontSizeValues = {
+ "1 (8 pt)" : "1",
+ "2 (10 pt)": "2",
+ "3 (12 pt)": "3",
+ "4 (14 pt)": "4",
+ "5 (18 pt)": "5",
+ "6 (24 pt)": "6",
+ "7 (36 pt)": "7"
+};
+
+dojo.widget.Editor.defaultItems = [
+ "commandGroup", "|", "blockGroup", "|", "textGroup", "|", "colorGroup", "|", "justifyGroup", "|", "listGroup", "indentGroup", "|", "linkGroup"
+];
+
+// ones we support by default without asking the RichText component
+// NOTE: you shouldn't put buttons like bold, italic, etc in here
+dojo.widget.Editor.supportedCommands = ["save", "cancel", "|", "-", "/", " "];
+
+dojo.lang.extend(dojo.widget.Editor, {
+ widgetType: "Editor",
+
+ saveUrl: "",
+ saveMethod: "post",
+ saveArgName: "editorContent",
+ closeOnSave: false,
+ items: dojo.widget.Editor.defaultItems,
+ formatBlockItems: dojo.lang.shallowCopy(dojo.widget.Editor.formatBlockValues),
+ fontNameItems: dojo.lang.shallowCopy(dojo.widget.Editor.fontNameValues),
+ fontSizeItems: dojo.lang.shallowCopy(dojo.widget.Editor.fontSizeValues),
+
+ // used to get the properties of an item if it is given as a string
+ getItemProperties: function(name) {
+ var props = {};
+ switch(name.toLowerCase()) {
+ case "bold":
+ case "italic":
+ case "underline":
+ case "strikethrough":
+ props.toggleItem = true;
+ break;
+
+ case "justifygroup":
+ props.defaultButton = "justifyleft";
+ props.preventDeselect = true;
+ props.buttonGroup = true;
+ break;
+
+ case "listgroup":
+ props.buttonGroup = true;
+ break;
+
+ case "save":
+ case "cancel":
+ props.label = dojo.string.capitalize(name);
+ break;
+
+ case "forecolor":
+ case "hilitecolor":
+ props.name = name;
+ props.toggleItem = true; // FIXME: they aren't exactly toggle items
+ props.icon = this.getCommandImage(name);
+ break;
+
+ case "formatblock":
+ props.name = "formatBlock";
+ props.values = this.formatBlockItems;
+ break;
+
+ case "fontname":
+ props.name = "fontName";
+ props.values = this.fontNameItems;
+
+ case "fontsize":
+ props.name = "fontSize";
+ props.values = this.fontSizeItems;
+ }
+ return props;
+ },
+
+ validateItems: true, // set to false to add items, regardless of support
+ focusOnLoad: true,
+ minHeight: "1em",
+
+ _richText: null, // RichText widget
+ _richTextType: "RichText",
+
+ _toolbarContainer: null, // ToolbarContainer widget
+ _toolbarContainerType: "ToolbarContainer",
+
+ _toolbars: [],
+ _toolbarType: "Toolbar",
+
+ _toolbarItemType: "ToolbarItem",
+
+ buildRendering: function(args, frag) {
+ // get the node from args/frag
+ var node = frag["dojo:"+this.widgetType.toLowerCase()]["nodeRef"];
+ var trt = dojo.widget.createWidget(this._richTextType, {
+ focusOnLoad: this.focusOnLoad,
+ minHeight: this.minHeight
+ }, node)
+ var _this = this;
+ // this appears to fix a weird timing bug on Safari
+ setTimeout(function(){
+ _this.setRichText(trt);
+
+ _this.initToolbar();
+
+ _this.fillInTemplate(args, frag);
+ }, 0);
+ },
+
+ setRichText: function(richText) {
+ if(this._richText && this._richText == richText) {
+ dojo.debug("Already set the richText to this richText!");
+ return;
+ }
+
+ if(this._richText && !this._richText.isClosed) {
+ dojo.debug("You are switching richTexts yet you haven't closed the current one. Losing reference!");
+ }
+ this._richText = richText;
+ dojo.event.connect(this._richText, "close", this, "onClose");
+ dojo.event.connect(this._richText, "onLoad", this, "onLoad");
+ dojo.event.connect(this._richText, "onDisplayChanged", this, "updateToolbar");
+ if(this._toolbarContainer) {
+ this._toolbarContainer.enable();
+ this.updateToolbar(true);
+ }
+ },
+
+ initToolbar: function() {
+ // var tic = new Date();
+ if(this._toolbarContainer) { return; } // only create it once
+ this._toolbarContainer = dojo.widget.createWidget(this._toolbarContainerType);
+ var tb = this.addToolbar();
+ var last = true;
+ for(var i = 0; i < this.items.length; i++) {
+ if(this.items[i] == "\n") { // new row
+ tb = this.addToolbar();
+ } else {
+ if((this.items[i] == "|")&&(!last)){
+ last = true;
+ }else{
+ last = this.addItem(this.items[i], tb);
+ }
+ }
+ }
+ this.insertToolbar(this._toolbarContainer.domNode, this._richText.domNode);
+ // alert(new Date - tic);
+ },
+
+ // allow people to override this so they can make their own placement logic
+ insertToolbar: function(tbNode, richTextNode) {
+ dojo.html.insertBefore(tbNode, richTextNode);
+ //dojo.html.insertBefore(this._toolbarContainer.domNode, this._richText.domNode);
+ },
+
+ addToolbar: function(toolbar) {
+ this.initToolbar();
+ if(!(toolbar instanceof dojo.widget.Toolbar)) {
+ toolbar = dojo.widget.createWidget(this._toolbarType);
+ }
+ this._toolbarContainer.addChild(toolbar);
+ this._toolbars.push(toolbar);
+ return toolbar;
+ },
+
+ addItem: function(item, tb, dontValidate) {
+ if(!tb) { tb = this._toolbars[0]; }
+ var cmd = ((item)&&(!dojo.lang.isUndefined(item["getValue"]))) ? cmd = item["getValue"](): item;
+
+ var groups = dojo.widget.Editor.itemGroups;
+ if(item instanceof dojo.widget.ToolbarItem) {
+ tb.addChild(item);
+ } else if(groups[cmd]) {
+ var group = groups[cmd];
+ var worked = true;
+ if(cmd == "justifyGroup" || cmd == "listGroup") {
+ var btnGroup = [cmd];
+ for(var i = 0 ; i < group.length; i++) {
+ if(dontValidate || this.isSupportedCommand(group[i])) {
+ btnGroup.push(this.getCommandImage(group[i]));
+ }else{
+ worked = false;
+ }
+ }
+ if(btnGroup.length){
+ /*
+ // the addChild interface is assinine. Work around it.
+ var tprops = this.getItemProperties(cmd);
+ var tmpGroup = dojo.widget.createWidget("ToolbarButtonGroup", tprops);
+ dojo.debug(btnGroup);
+ dojo.event.connect(tmpGroup, "onClick", this, "_action");
+ dojo.event.connect(tmpGroup, "onChangeSelect", this, "_action");
+ */
+ var btn = tb.addChild(btnGroup, null, this.getItemProperties(cmd));
+ dojo.event.connect(btn, "onClick", this, "_action");
+ dojo.event.connect(btn, "onChangeSelect", this, "_action");
+ }
+ return worked;
+ } else {
+ for(var i = 0; i < group.length; i++) {
+ if(!this.addItem(group[i], tb)){
+ worked = false;
+ }
+ }
+ return worked;
+ }
+ } else {
+ if((!dontValidate)&&(!this.isSupportedCommand(cmd))){
+ return false;
+ }
+ if(dontValidate || this.isSupportedCommand(cmd)) {
+ cmd = cmd.toLowerCase();
+ if(cmd == "formatblock") {
+ var select = dojo.widget.createWidget("ToolbarSelect", {
+ name: "formatBlock",
+ values: this.formatBlockItems
+ });
+ tb.addChild(select);
+ var _this = this;
+ dojo.event.connect(select, "onSetValue", function(item, value) {
+ _this.onAction("formatBlock", value);
+ });
+ } else if(cmd == "fontname") {
+ var select = dojo.widget.createWidget("ToolbarSelect", {
+ name: "fontName",
+ values: this.fontNameItems
+ });
+ tb.addChild(select);
+ dojo.event.connect(select, "onSetValue", dojo.lang.hitch(this, function(item, value) {
+ this.onAction("fontName", value);
+ }));
+ } else if(cmd == "fontsize") {
+ var select = dojo.widget.createWidget("ToolbarSelect", {
+ name: "fontSize",
+ values: this.fontSizeItems
+ });
+ tb.addChild(select);
+ dojo.event.connect(select, "onSetValue", dojo.lang.hitch(this, function(item, value) {
+ this.onAction("fontSize", value);
+ }));
+ } else if(dojo.lang.inArray(cmd, ["forecolor", "hilitecolor"])) {
+ var btn = tb.addChild(dojo.widget.createWidget("ToolbarColorDialog", this.getItemProperties(cmd)));
+ dojo.event.connect(btn, "onSetValue", this, "_setValue");
+ } else {
+ var btn = tb.addChild(this.getCommandImage(cmd), null, this.getItemProperties(cmd));
+ if(cmd == "save"){
+ dojo.event.connect(btn, "onClick", this, "_save");
+ }else if(cmd == "cancel"){
+ dojo.event.connect(btn, "onClick", this, "_close");
+ } else {
+ dojo.event.connect(btn, "onClick", this, "_action");
+ dojo.event.connect(btn, "onChangeSelect", this, "_action");
+ }
+ }
+ }
+ }
+ return true;
+ },
+
+ enableToolbar: function() {
+ if(this._toolbarContainer) {
+ this._toolbarContainer.domNode.style.display = "";
+ this._toolbarContainer.enable();
+ }
+ },
+
+ disableToolbar: function(hide){
+ if(hide){
+ if(this._toolbarContainer){
+ this._toolbarContainer.domNode.style.display = "none";
+ }
+ }else{
+ if(this._toolbarContainer){
+ this._toolbarContainer.disable();
+ }
+ }
+ },
+
+ _updateToolbarLastRan: null,
+ _updateToolbarTimer: null,
+ _updateToolbarFrequency: 500,
+
+ updateToolbar: function(force) {
+ if(!this._toolbarContainer) { return; }
+
+ // keeps the toolbar from updating too frequently
+ // TODO: generalize this functionality?
+ var diff = new Date() - this._updateToolbarLastRan;
+ if(!force && this._updateToolbarLastRan && (diff < this._updateToolbarFrequency)) {
+ clearTimeout(this._updateToolbarTimer);
+ var _this = this;
+ this._updateToolbarTimer = setTimeout(function() {
+ _this.updateToolbar();
+ }, this._updateToolbarFrequency/2);
+ return;
+ } else {
+ this._updateToolbarLastRan = new Date();
+ }
+ // end frequency checker
+
+ var items = this._toolbarContainer.getItems();
+ for(var i = 0; i < items.length; i++) {
+ var item = items[i];
+ if(item instanceof dojo.widget.ToolbarSeparator) { continue; }
+ var cmd = item._name;
+ if (cmd == "save" || cmd == "cancel") { continue; }
+ else if(cmd == "justifyGroup") {
+ try {
+ if(!this._richText.queryCommandEnabled("justifyleft")) {
+ item.disable(false, true);
+ } else {
+ item.enable(false, true);
+ var jitems = item.getItems();
+ for(var j = 0; j < jitems.length; j++) {
+ var name = jitems[j]._name;
+ var value = this._richText.queryCommandValue(name);
+ if(typeof value == "boolean" && value) {
+ value = name;
+ break;
+ } else if(typeof value == "string") {
+ value = "justify"+value;
+ } else {
+ value = null;
+ }
+ }
+ if(!value) { value = "justifyleft"; } // TODO: query actual style
+ item.setValue(value, false, true);
+ }
+ } catch(err) {}
+ } else if(cmd == "listGroup") {
+ var litems = item.getItems();
+ for(var j = 0; j < litems.length; j++) {
+ this.updateItem(litems[j]);
+ }
+ } else {
+ this.updateItem(item);
+ }
+ }
+ },
+
+ updateItem: function(item) {
+ try {
+ var cmd = item._name;
+ var enabled = this._richText.queryCommandEnabled(cmd);
+ item.setEnabled(enabled, false, true);
+
+ var active = this._richText.queryCommandState(cmd);
+ if(active && cmd == "underline") {
+ // don't activate underlining if we are on a link
+ active = !this._richText.queryCommandEnabled("unlink");
+ }
+ item.setSelected(active, false, true);
+ return true;
+ } catch(err) {
+ return false;
+ }
+ },
+
+ supportedCommands: dojo.widget.Editor.supportedCommands.concat(),
+
+ isSupportedCommand: function(cmd) {
+ // FIXME: how do we check for ActiveX?
+ var yes = dojo.lang.inArray(cmd, this.supportedCommands);
+ if(!yes) {
+ try {
+ var richText = this._richText || dojo.widget.HtmlRichText.prototype;
+ yes = richText.queryCommandAvailable(cmd);
+ } catch(E) {}
+ }
+ return yes;
+ },
+
+ getCommandImage: function(cmd) {
+ if(cmd == "|") {
+ return cmd;
+ } else {
+ return dojo.uri.dojoUri("src/widget/templates/buttons/" + cmd + ".gif");
+ }
+ },
+
+ _action: function(e) {
+ this._fire("onAction", e.getValue());
+ },
+
+ _setValue: function(a, b) {
+ this._fire("onAction", a.getValue(), b);
+ },
+
+ _save: function(e){
+ // FIXME: how should this behave when there's a larger form in play?
+ if(!this._richText.isClosed){
+ if(this.saveUrl.length){
+ var content = {};
+ content[this.saveArgName] = this.getHtml();
+ dojo.io.bind({
+ method: this.saveMethod,
+ url: this.saveUrl,
+ content: content
+ });
+ }else{
+ dojo.debug("please set a saveUrl for the editor");
+ }
+ if(this.closeOnSave){
+ this._richText.close(e.getName().toLowerCase() == "save");
+ }
+ }
+ },
+
+ _close: function(e) {
+ if(!this._richText.isClosed) {
+ this._richText.close(e.getName().toLowerCase() == "save");
+ }
+ },
+
+ onAction: function(cmd, value) {
+ switch(cmd) {
+ case "createlink":
+ if(!(value = prompt("Please enter the URL of the link:", "http://"))) {
+ return;
+ }
+ break;
+ case "insertimage":
+ if(!(value = prompt("Please enter the URL of the image:", "http://"))) {
+ return;
+ }
+ break;
+ }
+ this._richText.execCommand(cmd, value);
+ },
+
+ fillInTemplate: function(args, frag) {
+ // dojo.event.connect(this, "onResized", this._richText, "onResized");
+ },
+
+ _fire: function(eventName) {
+ if(dojo.lang.isFunction(this[eventName])) {
+ var args = [];
+ if(arguments.length == 1) {
+ args.push(this);
+ } else {
+ for(var i = 1; i < arguments.length; i++) {
+ args.push(arguments[i]);
+ }
+ }
+ this[eventName].apply(this, args);
+ }
+ },
+
+ getHtml: function(){
+ this._richText.contentFilters = this._richText.contentFilters.concat(this.contentFilters);
+ return this._richText.getEditorContent();
+ },
+
+ getEditorContent: function(){
+ return this.getHtml();
+ },
+
+ onClose: function(save, hide){
+ this.disableToolbar(hide);
+ if(save) {
+ this._fire("onSave");
+ } else {
+ this._fire("onCancel");
+ }
+ },
+
+ // events baby!
+ onLoad: function(){},
+ onSave: function(){},
+ onCancel: function(){}
+});
+
diff --git a/source/web/scripts/ajax/src/widget/Editor2.js b/source/web/scripts/ajax/src/widget/Editor2.js
new file mode 100644
index 0000000000..0c2474904b
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/Editor2.js
@@ -0,0 +1,395 @@
+/* TODO:
+ * - font selector
+ * - test, bug fix, more features :)
+*/
+dojo.provide("dojo.widget.Editor2");
+dojo.require("dojo.io.*");
+dojo.require("dojo.html.*");
+dojo.require("dojo.html.layout");
+dojo.require("dojo.html.iframe");
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.RichText");
+dojo.require("dojo.widget.Editor2Toolbar");
+// dojo.require("dojo.widget.ColorPalette");
+// dojo.require("dojo.string.extras");
+
+//The current focused Editor2 Instance
+dojo.widget.Editor2._CurrentInstance = null;
+
+dojo.widget.defineWidget(
+ "dojo.widget.Editor2",
+ dojo.widget.RichText,
+ {
+ saveUrl: "",
+ saveMethod: "post",
+ saveArgName: "editorContent",
+ closeOnSave: false,
+ shareToolbar: false,
+ toolbarAlwaysVisible: false,
+ htmlEditing: false,
+ _inHtmlMode: false,
+ _htmlEditNode: null,
+
+ commandList: dojo.widget.Editor2Toolbar.prototype.commandList,
+ toolbarWidget: null,
+ scrollInterval: null,
+ toolbarTemplatePath: null,
+
+
+ editorOnLoad: function(){
+ var toolbars = dojo.widget.byType("Editor2Toolbar");
+ if((!toolbars.length)||(!this.shareToolbar)){
+ var tbOpts = {};
+ this.toolbarTemplatePath = this.toolbarTemplatePath || "src/widget/templates/EditorToolbarOneline.html";
+ tbOpts.templatePath = dojo.uri.dojoUri(this.toolbarTemplatePath);
+ if(this.toolbarWidget){
+ this.toolbarWidget.show();
+ }else{
+ this.toolbarWidget = dojo.widget.createWidget("Editor2Toolbar",
+ tbOpts, this.domNode, "before");
+ dojo.event.connect(this, "close", this.toolbarWidget, "hide");
+ dojo.event.connect(this, "destroy", this.toolbarWidget, "destroy");
+ this.toolbarWidget.hideUnusableButtons(this);
+ }
+
+ if(this.object){
+ this.tbBgIframe = new dojo.html.BackgroundIframe(this.toolbarWidget.domNode);
+ this.tbBgIframe.iframe.style.height = "30px";
+ }
+
+ // need to set position fixed to wherever this thing has landed
+ if(this.toolbarAlwaysVisible){
+ var src = document.documentElement||window;
+ this.scrollInterval = setInterval(dojo.lang.hitch(this, "globalOnScrollHandler"), 100);
+ // dojo.event.connect(src, "onscroll", this, "globalOnScrollHandler");
+ dojo.event.connect("before", this, "destroyRendering", this, "unhookScroller");
+ }
+ }else{
+ // FIXME: should we try harder to explicitly manage focus in
+ // order to prevent too many editors from all querying
+ // for button status concurrently?
+ // FIXME: selecting in one shared toolbar doesn't clobber
+ // selection in the others. This is problematic.
+ this.toolbarWidget = toolbars[0];
+ }
+ dojo.event.topic.registerPublisher("Editor2.clobberFocus", this, "clobberFocus");
+ dojo.event.topic.subscribe("Editor2.clobberFocus", this, "setBlur");
+ dojo.event.connect(this.toolbarWidget.linkButton, "onclick",
+ dojo.lang.hitch(this, function(){
+ var range;
+ if(this.document.selection){
+ range = this.document.selection.createRange().text;
+ }else if(dojo.render.html.mozilla){
+ range = this.window.getSelection().toString();
+ }
+ if(range.length){
+ this.toolbarWidget.exec("createlink",
+ prompt("Please enter the URL of the link:", "http://"));
+ }else{
+ alert("Please select text to link");
+ }
+ })
+ );
+
+ dojo.event.connect(this.toolbarWidget, "formatSelectClick", this, "focus");
+ dojo.event.connect(this.toolbarWidget, "saveClick", this, "save");
+ dojo.event.connect(this.toolbarWidget, "insertimageClick", this, "insertImage");
+ dojo.event.connect(this, "execCommand", this, "focus");
+
+ if(this.htmlEditing){
+ var tb = this.toolbarWidget.htmltoggleButton;
+ if(tb){
+ tb.style.display = "";
+ dojo.event.connect(this.toolbarWidget, "htmltoggleClick",
+ this, "toggleHtmlEditing");
+ }
+ }
+ },
+
+ clobberFocus: function(){},
+ save: function(){ dojo.debug("Editor2.save"); },
+ insertImage: function(){ dojo.debug("Editor2.insertImage"); },
+ toggleHtmlEditing: function(){
+ if(this===dojo.widget.Editor2._CurrentInstance){
+ if(!this._inHtmlMode){
+ this._inHtmlMode = true;
+ this.toolbarWidget.highlightButton("htmltoggle");
+ if(!this._htmlEditNode){
+ this._htmlEditNode = document.createElement("textarea");
+ dojo.html.insertBefore(this._htmlEditNode, this.domNode);
+ }
+ this._htmlEditNode.style.display = "";
+ this._htmlEditNode.style.width = "100%";
+ this._htmlEditNode.style.height = dojo.html.getBorderBox(this.editNode).height+"px";
+ this._htmlEditNode.value = this.editNode.innerHTML;
+ this.domNode.style.display = "none";
+ }else{
+ this._inHtmlMode = false;
+ this.domNode.style.display = "";
+ this.toolbarWidget.unhighlightButton("htmltoggle");
+ dojo.lang.setTimeout(this, "replaceEditorContent", 1, this._htmlEditNode.value);
+ this._htmlEditNode.style.display = "none";
+ this.editNode.focus();
+ }
+ }
+ },
+
+ setFocus: function(){
+ if(dojo.widget.Editor2._CurrentInstance == this){ return; }
+
+ if(this.toolbarWidget){
+ this.clobberFocus();
+ // dojo.debug("setFocus:", this);
+ dojo.widget.Editor2._CurrentInstance = this;
+ dojo.event.connect(this.toolbarWidget, "exec", this, "execCommand");
+ }
+ },
+
+ setBlur: function(){
+ // dojo.debug("setBlur:", this);
+ dojo.event.disconnect(this.toolbarWidget, "exec", this, "execCommand");
+ },
+
+ _scrollSetUp: false,
+ _fixEnabled: false,
+ _scrollThreshold: false,
+ _handleScroll: true,
+ globalOnScrollHandler: function(){
+ var isIE = dojo.render.html.ie;
+ if(!this._handleScroll){ return; }
+ var dh = dojo.html;
+ var tdn = this.toolbarWidget.domNode;
+ var db = dojo.body();
+ var totalHeight = dh.getMarginBox(tdn).height;
+ if(!this._scrollSetUp){
+ this._scrollSetUp = true;
+ var editorWidth = dh.getMarginBox(this.domNode).width;
+ this._scrollThreshold = dh.abs(tdn, false).y;
+ // dojo.debug("threshold:", this._scrollThreshold);
+ if((isIE)&&(db)&&(dh.getStyle(db, "background-image")=="none")){
+ with(db.style){
+ backgroundImage = "url(" + dojo.uri.dojoUri("src/widget/templates/images/blank.gif") + ")";
+ backgroundAttachment = "fixed";
+ }
+ }
+ }
+
+ var scrollPos = (window["pageYOffset"]) ? window["pageYOffset"] : (document["documentElement"]||document["body"]).scrollTop;
+
+ // FIXME: need to have top and bottom thresholds so toolbar doesn't keep scrolling past the bottom
+ if(scrollPos > this._scrollThreshold){
+ // dojo.debug(scrollPos);
+ if(!this._fixEnabled){
+ this.domNode.style.marginTop = totalHeight+"px";
+ if(isIE){
+ // FIXME: should we just use setBehvior() here instead?
+ var cl = dojo.html.abs(tdn).x;
+ document.body.appendChild(tdn);
+ tdn.style.left = cl+dojo.html.getPixelValue(document.body, "margin-left")+"px";
+ dojo.html.addClass(tdn, "IEFixedToolbar");
+ if(this.object){
+ dojo.html.addClass(this.tbBgIframe, "IEFixedToolbar");
+ }
+
+ }else{
+ with(tdn.style){
+ position = "fixed";
+ top = "0px";
+ }
+ }
+ tdn.style.zIndex = 1000;
+ this._fixEnabled = true;
+ }
+ // if we're showing the floating toolbar, make sure that if
+ // we've scrolled past the bottom of the editor that we hide
+ // the toolbar for this instance of the editor.
+
+ // TODO: when we get multiple editor toolbar support working
+ // correctly, ensure that we check this against the scroll
+ // position of the bottom-most editor instance.
+ if(!dojo.render.html.safari){
+ // safari reports a bunch of things incorrectly here
+ var eHeight = (this.height) ? parseInt(this.height) : ((this.object) ? dojo.html.getBorderBox(this.editNode).height : this._lastHeight);
+ if(scrollPos > (this._scrollThreshold+eHeight)){
+ tdn.style.display = "none";
+ }else{
+ tdn.style.display = "";
+ }
+ }
+
+ }else if(this._fixEnabled){
+ this.domNode.style.marginTop = null;
+ with(tdn.style){
+ position = "";
+ top = "";
+ zIndex = "";
+ if(isIE){
+ marginTop = "";
+ }
+ }
+ if(isIE){
+ dojo.html.removeClass(tdn, "IEFixedToolbar");
+ dojo.html.insertBefore(tdn, this._htmlEditNode||this.domNode);
+ }
+ this._fixEnabled = false;
+ }
+ },
+
+ unhookScroller: function(){
+ this._handleScroll = false;
+ clearInterval(this.scrollInterval);
+ // var src = document["documentElement"]||window;
+ // dojo.event.disconnect(src, "onscroll", this, "globalOnScrollHandler");
+ if(dojo.render.html.ie){
+ dojo.html.removeClass(this.toolbarWidget.domNode, "IEFixedToolbar");
+ }
+ },
+
+ _updateToolbarLastRan: null,
+ _updateToolbarTimer: null,
+ _updateToolbarFrequency: 500,
+
+ updateToolbar: function(force){
+ if((!this.isLoaded)||(!this.toolbarWidget)){ return; }
+
+ // keeps the toolbar from updating too frequently
+ // TODO: generalize this functionality?
+ var diff = new Date() - this._updateToolbarLastRan;
+ if( (!force)&&(this._updateToolbarLastRan)&&
+ ((diff < this._updateToolbarFrequency)) ){
+
+ clearTimeout(this._updateToolbarTimer);
+ var _this = this;
+ this._updateToolbarTimer = setTimeout(function() {
+ _this.updateToolbar();
+ }, this._updateToolbarFrequency/2);
+ return;
+
+ }else{
+ this._updateToolbarLastRan = new Date();
+ }
+ // end frequency checker
+
+ // FIXME: SEVERE: This forEach block breaks undo on IE
+ dojo.lang.forEach(this.commandList,
+ function(cmd){
+ if((cmd == "inserthtml") || (cmd == "save")){ return; }
+ try{
+ if(this.queryCommandEnabled(cmd)){
+ if(this.queryCommandState(cmd)){
+ this.toolbarWidget.highlightButton(cmd);
+ }else{
+ this.toolbarWidget.unhighlightButton(cmd);
+ }
+ }
+ }catch(e){
+ // alert(cmd+":"+e);
+ }
+ },
+ this
+ );
+
+ var h = dojo.render.html;
+
+ // safari f's us for selection primitives
+ if(h.safari){ return; }
+
+ var selectedNode = (h.ie) ? this.document.selection.createRange().parentElement() : this.window.getSelection().anchorNode;
+ // make sure we actuall have an element
+ while((selectedNode)&&(selectedNode.nodeType != 1)){
+ selectedNode = selectedNode.parentNode;
+ }
+ if(!selectedNode){ return; }
+
+ var formats = ["p", "pre", "h1", "h2", "h3", "h4"];
+ // gotta run some specialized updates for the various
+ // formatting options
+ var type = formats[dojo.lang.find(formats, selectedNode.nodeName.toLowerCase())];
+ while((selectedNode)&&(selectedNode!=this.editNode)&&(!type)){
+ selectedNode = selectedNode.parentNode;
+ type = formats[dojo.lang.find(formats, selectedNode.nodeName.toLowerCase())];
+ }
+ if(!type){
+ type = "";
+ }else{
+ if(type.charAt(0)=="h"){
+ this.toolbarWidget.unhighlightButton("bold");
+ }
+ }
+ this.toolbarWidget.selectFormat(type);
+ },
+
+ updateItem: function(item) {
+ try {
+ var cmd = item._name;
+ var enabled = this._richText.queryCommandEnabled(cmd);
+ item.setEnabled(enabled, false, true);
+
+ var active = this._richText.queryCommandState(cmd);
+ if(active && cmd == "underline") {
+ // don't activate underlining if we are on a link
+ active = !this._richText.queryCommandEnabled("unlink");
+ }
+ item.setSelected(active, false, true);
+ return true;
+ } catch(err) {
+ return false;
+ }
+ },
+
+ _save: function(e){
+ // FIXME: how should this behave when there's a larger form in play?
+ if(!this.isClosed){
+ dojo.debug("save attempt");
+ if(this.saveUrl.length){
+ var content = {};
+ content[this.saveArgName] = this.getHtml();
+ dojo.io.bind({
+ method: this.saveMethod,
+ url: this.saveUrl,
+ content: content
+ });
+ }else{
+ dojo.debug("please set a saveUrl for the editor");
+ }
+ if(this.closeOnSave){
+ this.close(e.getName().toLowerCase() == "save");
+ }
+ }
+ }
+ },
+ "html",
+ function(){
+ var cp = dojo.widget.Editor2.prototype;
+ if(!cp._wrappersSet){
+ cp._wrappersSet = true;
+
+ cp.onDisplayChanged = (function(odc){
+ return function(){
+ try{
+ odc.call(this);
+ this.updateToolbar();
+ }catch(e){}
+ };
+ })(cp.onDisplayChanged);
+
+ cp.onLoad = (function(ol){
+ return function(){
+ try{
+ ol.call(this);
+ }catch(e){ // FIXME: debug why this is throwing errors in IE!
+ dojo.debug(e);
+ }
+ this.editorOnLoad();
+ };
+ })(cp.onLoad);
+
+ cp.onFocus = (function(of){
+ return function(){
+ of.call(this);
+ this.setFocus();
+ };
+ })(cp.onFocus);
+ }
+ }
+);
diff --git a/source/web/scripts/ajax/src/widget/Editor2Toolbar.js b/source/web/scripts/ajax/src/widget/Editor2Toolbar.js
new file mode 100644
index 0000000000..bfd4ba00ac
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/Editor2Toolbar.js
@@ -0,0 +1,317 @@
+dojo.provide("dojo.widget.Editor2Toolbar");
+
+dojo.require("dojo.lang.*");
+dojo.require("dojo.widget.*");
+dojo.require("dojo.event.*");
+dojo.require("dojo.html.layout");
+dojo.require("dojo.html.display");
+dojo.require("dojo.widget.RichText");
+dojo.require("dojo.widget.ColorPalette");
+
+dojo.widget.defineWidget(
+ "dojo.widget.Editor2Toolbar",
+ dojo.widget.HtmlWidget,
+ {
+ commandList: [ "bold", "italic", "underline", "subscript", "superscript",
+ "fontname", "fontsize", "forecolor", "hilitecolor", "justifycenter",
+ "justifyfull", "justifyleft", "justifyright", "cut", "copy", "paste",
+ "delete", "undo", "redo", "createlink", "unlink", "removeformat",
+ "inserthorizontalrule", "insertimage", "insertorderedlist",
+ "insertunorderedlist", "indent", "outdent", "formatblock", "strikethrough",
+ "inserthtml", "blockdirltr", "blockdirrtl", "dirltr", "dirrtl",
+ "inlinedirltr", "inlinedirrtl", "inserttable", "insertcell",
+ "insertcol", "insertrow", "deletecells", "deletecols", "deleterows",
+ "mergecells", "splitcell"
+ ],
+
+ templatePath: dojo.uri.dojoUri("src/widget/templates/EditorToolbarOneline.html"),
+ // templatePath: dojo.uri.dojoUri("src/widget/templates/EditorToolbar.html"),
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/EditorToolbar.css"),
+
+ forecolorPalette: null,
+ hilitecolorPalette: null,
+
+ // DOM Nodes
+ wikiwordButton: null,
+ htmltoggleButton: null,
+ insertimageButton: null,
+ styleDropdownButton: null,
+ styleDropdownContainer: null,
+ copyButton: null,
+ boldButton: null,
+ italicButton: null,
+ underlineButton: null,
+ justifycenterButton: null,
+ justifyleftButton: null,
+ justifyfullButton: null,
+ justifyrightButton: null,
+ pasteButton: null,
+ undoButton: null,
+ redoButton: null,
+ linkButton: null,
+ insertunorderedlistButton: null,
+ insertorderedlistButton: null,
+ forecolorButton: null,
+ forecolorDropDown: null,
+ hilitecolorButton: null,
+ hilitecolorDropDown: null,
+ formatSelectBox: null,
+ inserthorizontalruleButton: null,
+ strikethroughButton: null,
+ clickInterceptDiv: null,
+ oneLineTr: null,
+ saveButton: null,
+
+ buttonClick: function(e){ e.preventDefault(); /* dojo.debug("buttonClick"); */ },
+
+ buttonMouseOver: function(e){ },
+ buttonMouseOut: function(e){ },
+
+
+ // event signals
+ preventSelect: function(e){ if(dojo.render.html.safari){ e.preventDefault(); } },
+ wikiwordClick: function(){ },
+ insertimageClick: function(){ },
+ htmltoggleClick: function(){ },
+ saveClick: function(){ },
+
+ styleDropdownClick: function(){
+ dojo.debug("styleDropdownClick:", this.styleDropdownContainer);
+ dojo.html.toggleShowing(this.styleDropdownContainer);
+ },
+
+ copyClick: function(){ this.exec("copy"); },
+ boldClick: function(){ this.exec("bold"); },
+ italicClick: function(){ this.exec("italic"); },
+ underlineClick: function(){ this.exec("underline"); },
+ justifyleftClick: function(){ this.exec("justifyleft"); },
+ justifycenterClick: function(){ this.exec("justifycenter"); },
+ justifyfullClick: function(){ this.exec("justifyfull"); },
+ justifyrightClick: function(){ this.exec("justifyright"); },
+ pasteClick: function(){ this.exec("paste"); },
+ undoClick: function(){ this.exec("undo"); },
+ redoClick: function(){ this.exec("redo"); },
+ linkClick: function(){
+ // FIXME: we need to alert the user if they haven't selected any text
+ // this.exec( "createlink",
+ // prompt("Please enter the URL of the link:", "http://"));
+ },
+ insertunorderedlistClick: function(){ this.exec("insertunorderedlist"); },
+ insertorderedlistClick: function(){ this.exec("insertorderedlist"); },
+ inserthorizontalruleClick: function(){ this.exec("inserthorizontalrule"); },
+ strikethroughClick: function(){ this.exec("strikethrough"); },
+
+ formatSelectClick: function(){
+ var sv = this.formatSelectBox.value.toLowerCase();
+ this.exec("formatblock", sv);
+ },
+
+ normalTextClick: function(){ this.exec("formatblock", "p"); },
+ h1TextClick: function(){ this.exec("formatblock", "h1"); },
+ h2TextClick: function(){ this.exec("formatblock", "h2"); },
+ h3TextClick: function(){ this.exec("formatblock", "h3"); },
+ h4TextClick: function(){ this.exec("formatblock", "h4"); },
+ indentClick: function(){ this.exec("indent"); },
+ outdentClick: function(){ this.exec("outdent"); },
+
+
+ hideAllDropDowns: function(){
+ this.domNode.style.height = "";
+ dojo.lang.forEach(dojo.widget.byType("Editor2Toolbar"), function(tb){
+ try{
+ dojo.html.hide(tb.forecolorDropDown);
+ dojo.html.hide(tb.hilitecolorDropDown);
+ dojo.html.hide(tb.styleDropdownContainer);
+ if(tb.clickInterceptDiv){
+ dojo.html.hide(tb.clickInterceptDiv);
+ }
+ }catch(e){}
+ if(dojo.render.html.ie){
+ try{
+ dojo.html.hide(tb.forecolorPalette.bgIframe);
+ }catch(e){}
+ try{
+ dojo.html.hide(tb.hilitecolorPalette.bgIframe);
+ }catch(e){}
+ }
+ });
+ },
+
+ selectFormat: function(format){
+ if(this.formatSelectBox) {
+ dojo.lang.forEach(this.formatSelectBox.options, function(item){
+ if(item.value.toLowerCase() == format.toLowerCase()){
+ // FIXME: SEVERE: setting selected on this item breaks the undo stack on IE
+ item.selected = true;
+ }
+ });
+ }
+ },
+
+ forecolorClick: function(e){
+ this.colorClick(e, "forecolor");
+ },
+
+ hilitecolorClick: function(e){
+ this.colorClick(e, "hilitecolor");
+ },
+
+ // FIXME: these methods aren't currently dealing with clicking in the
+ // general document to hide the menu
+ colorClick: function(e, type){
+ var h = dojo.render.html;
+ this.hideAllDropDowns();
+ // FIXME: if we've been "popped out", we need to set the height of the toolbar.
+ e.stopPropagation();
+ var dd = this[type+"DropDown"];
+ var pal = this[type+"Palette"];
+ dojo.html.toggleShowing(dd);
+ if(!pal){
+ pal = this[type+"Palette"] = dojo.widget.createWidget("ColorPalette", {}, dd, "first");
+ var fcp = pal.domNode;
+ var mb = dojo.html.getMarginBox(fcp);
+ with(dd.style){
+ width = mb.width + "px";
+ height = mb.height + "px";
+ zIndex = 1002;
+ position = "absolute";
+ }
+
+ dojo.event.connect( "after",
+ pal, "onColorSelect",
+ this, "exec",
+ function(mi){ mi.args.unshift(type); return mi.proceed(); }
+ );
+
+ dojo.event.connect( "after",
+ pal, "onColorSelect",
+ dojo.html, "toggleShowing",
+ this, function(mi){ mi.args.unshift(dd); return mi.proceed(); }
+ );
+
+ var cid = this.clickInterceptDiv;
+ if(!cid){
+ cid = this.clickInterceptDiv = document.createElement("div");
+ document.body.appendChild(cid);
+ with(cid.style){
+ backgroundColor = "transparent";
+ top = left = "0px";
+ height = width = "100%";
+ position = "absolute";
+ border = "none";
+ display = "none";
+ zIndex = 1001;
+ }
+ dojo.event.connect(cid, "onclick", function(){ cid.style.display = "none"; });
+ }
+ dojo.event.connect(pal, "onColorSelect", function(){ cid.style.display = "none"; });
+
+ dojo.event.kwConnect({
+ srcObj: document.body,
+ srcFunc: "onclick",
+ targetObj: this,
+ targetFunc: "hideAllDropDowns",
+ once: true
+ });
+ document.body.appendChild(dd);
+ }
+ dojo.html.toggleShowing(this.clickInterceptDiv);
+ var pos = dojo.html.abs(this[type+"Button"]);
+ dojo.html.placeOnScreenPoint(dd, pos.x, pos.y, 0, false);
+ if(pal.bgIframe){
+ var mb = dojo.html.getMarginBox(dd);
+ with(pal.bgIframe.style){
+ display = "block";
+ left = dd.style.left;
+ top = dd.style.top;
+ width = mb.width+"px";
+ height = mb.height+"px";
+ }
+ }
+ },
+
+ uninitialize: function(){
+ if(!dojo.render.html.ie){
+ // apparently this causes leakage on IE!
+ dojo.event.kwDisconnect({
+ srcObj: document.body,
+ srcFunc: "onclick",
+ targetObj: this,
+ targetFunc: "hideAllDropDowns",
+ once: true
+ });
+ }
+ },
+
+ // stub for observers
+ exec: function(what, arg){ /* dojo.debug(what, new Date()); */ },
+
+ hideUnusableButtons: function(obj){
+ var op = obj||dojo.widget.RichText.prototype;
+ dojo.lang.forEach(this.commandList,
+ function(cmd){
+ if(this[cmd+"Button"]){
+ var cb = this[cmd+"Button"];
+ if(!op.queryCommandAvailable(cmd)){
+ cb.style.display = "none";
+ cb.parentNode.style.display = "none";
+ }
+ }
+ },
+ this);
+ if(this.oneLineTr){
+ var lastVisibleIsSpacer = false;
+ var lastVisible = false;
+ var tds = this.oneLineTr.getElementsByTagName("td");
+ dojo.lang.forEach(tds, function(td){
+ if(td.getAttribute("isSpacer")){
+ if(td.style.display != "none"){
+ if(lastVisibleIsSpacer){
+ td.style.display = "none";
+ }
+ lastVisibleIsSpacer = true;
+ }else{
+ lastVisible = td;
+ lastVisibleIsSpacer = true;
+ }
+ }else{
+ if(td.style.display != "none"){
+ lastVisible = td;
+ lastVisibleIsSpacer = false;
+ }
+ }
+ });
+ }
+ },
+
+ highlightButton: function(name){
+ var bn = name+"Button";
+ if(this[bn]){
+ with(this[bn].style){
+ backgroundColor = "White";
+ border = "1px solid #aeaeab";
+ }
+ }
+ },
+
+ unhighlightButton: function(name){
+ var bn = name+"Button";
+ if(this[bn]){
+ // dojo.debug("unhighlighting:", name);
+ with(this[bn].style){
+ backgroundColor = "";
+ border = "";
+ }
+ }
+ }
+ },
+ "html",
+ function(){
+ // dojo.event.connect(this, "fillInTemplate", this, "hideUnusableButtons");
+ dojo.event.connect(this, "fillInTemplate", dojo.lang.hitch(this, function(){
+ if(dojo.render.html.ie){
+ this.domNode.style.zoom = 1.0;
+ }
+ }));
+ }
+);
diff --git a/source/web/scripts/ajax/src/widget/FilteringTable.js b/source/web/scripts/ajax/src/widget/FilteringTable.js
new file mode 100644
index 0000000000..9b78cfe3c4
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/FilteringTable.js
@@ -0,0 +1,871 @@
+dojo.provide("dojo.widget.FilteringTable");
+
+dojo.require("dojo.date");
+dojo.require("dojo.json");
+dojo.require("dojo.data.SimpleStore");
+dojo.require("dojo.html.*");
+dojo.require("dojo.html.util");
+dojo.require("dojo.html.style");
+dojo.require("dojo.html.selection");
+dojo.require("dojo.event.*");
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.HtmlWidget");
+
+dojo.widget.defineWidget(
+ "dojo.widget.FilteringTable",
+ dojo.widget.HtmlWidget,
+ function(){
+ this.store=new dojo.data.SimpleStore();
+
+ //declare per instance changeable widget properties
+ this.valueField="Id";
+ this.multiple=false;
+ this.maxSelect=0;
+ this.maxSortable=1; // how many columns can be sorted at once.
+ this.minRows=0;
+ this.defaultDateFormat = "%D";
+ this.isInitialized=false;
+
+ this.columns=[];
+ this.sortInformation=[{
+ index:0,
+ direction:0
+ }];
+
+ // CSS definitions
+ this.headClass="";
+ this.tbodyClass="";
+ this.headerClass="";
+ this.headerUpClass="selectedUp";
+ this.headerDownClass="selectedDown";
+ this.rowClass="";
+ this.rowAlternateClass="alt";
+ this.rowSelectedClass="selected";
+ this.columnSelected="sorted-column";
+ },
+{
+ // dojo widget properties
+ isContainer: false,
+ templatePath: null,
+ templateCssPath: null,
+
+ // methods.
+ getTypeFromString: function(s){
+ var parts = s.split("."), i = 0, obj = dj_global;
+ do{
+ obj = obj[parts[i++]];
+ } while (i < parts.length && obj);
+ return (obj != dj_global) ? obj : null;
+ },
+
+ // custom data access.
+ getByRow: function(/*HTMLTableRow*/row){
+ return this.store.getByKey(dojo.html.getAttribute(row, "value"));
+ },
+ getDataByRow: function(/*HTMLTableRow*/row){
+ return this.store.getDataByKey(dojo.html.getAttribute(row, "value"));
+ },
+
+ getSelectedData: function(){
+ // summary
+ // returns all objects that are selected.
+ var data=this.store.get();
+ var a=[];
+ for(var i=0; i<data.length; i++){
+ if(data[i].isSelected){
+ a.push(data[i].src);
+ }
+ }
+ if(this.multiple){
+ return a; // array
+ } else {
+ return a[0]; // object
+ }
+ },
+
+ isSelected: function(/* object */obj){
+ var data = this.store.get();
+ for(var i=0; i<data.length; i++){
+ if(data[i].src == obj){
+ return true; // boolean
+ }
+ }
+ return false; // boolean
+ },
+ isValueSelected: function(/* string */val){
+ var v = this.store.getByKey(val);
+ if(v){
+ return v.isSelected;
+ }
+ return false;
+ },
+ isIndexSelected: function(/* number */idx){
+ var v = this.store.getByIndex(idx);
+ if(v){
+ return v.isSelected;
+ }
+ return false;
+ },
+ isRowSelected: function(/* HTMLTableRow */row){
+ var v = this.getByRow(row);
+ if(v){
+ return v.isSelected;
+ }
+ return false;
+ },
+
+ reset: function(){
+ this.store.clearData();
+ this.columns = [];
+ this.sortInformation = [ {index:0, direction:0} ];
+ this.resetSelections();
+ this.isInitialized = false;
+ this.onReset();
+ },
+ resetSelections: function(){
+ this.store.forEach(function(element){
+ element.isSelected = false;
+ });
+ },
+ onReset:function(){ },
+
+ // selection and toggle functions
+ select: function(/*object*/ obj){
+ var data = this.store.get();
+ for(var i=0; i<data.length; i++){
+ if(data[i].src == obj){
+ data[i].isSelected = true;
+ break;
+ }
+ }
+ this.onDataSelect(obj);
+ },
+ selectByValue: function(/*string*/ val){
+ this.select(this.getDataByKey(val));
+ },
+ selectByIndex: function(/*number*/ idx){
+ this.select(this.getDataByIndex(idx));
+ },
+ selectByRow: function(/*HTMLTableRow*/ row){
+ this.select(this.getDataByRow(row));
+ },
+ onDataSelect: function(/* object */obj){ },
+
+ toggleSelection: function(/*object*/obj){
+ var data = this.store.get();
+ for(var i=0; i<data.length; i++){
+ if(data[i].src == obj){
+ data[i].isSelected = !data[i].isSelected;
+ break;
+ }
+ }
+ this.onDataToggle(obj);
+ },
+ toggleSelectionByValue: function(/*string*/val){
+ this.toggleSelection(this.getDataByKey(val));
+ },
+ toggleSelectionByIndex: function(/*number*/idx){
+ this.toggleSelection(this.getDataByIndex(idx));
+ },
+ toggleSelectionByRow: function(/*HTMLTableRow*/row){
+ this.toggleSelection(this.getDataByRow(row));
+ },
+ onDataToggle: function(/* object */obj){ },
+
+ // parsing functions, from HTML to metadata/SimpleStore
+ _meta:{
+ field:null,
+ format:null,
+ filterer:null,
+ noSort:false,
+ sortType:"String",
+ dataType:String,
+ sortFunction:null,
+ filterFunction:null,
+ label:null,
+ align:"left",
+ valign:"middle",
+ getField:function(){
+ return this.field || this.label;
+ },
+ getType:function(){
+ return this.dataType;
+ }
+ },
+ createMetaData: function(/* object */obj){
+ // summary
+ // Take a JSON-type structure and make it into a ducktyped metadata object.
+ for(var p in this._meta){
+ // rudimentary mixin
+ if(!obj[p]){
+ obj[p] = this._meta[p];
+ }
+ }
+ if(!obj.label){
+ obj.label=obj.field;
+ }
+ if(!obj.filterFunction){
+ obj.filterFunction=this._defaultFilter;
+ }
+ return obj; // object
+ },
+ parseMetadata: function(/* HTMLTableHead */head){
+ this.columns=[];
+ this.sortInformation=[];
+ var row = head.getElementsByTagName("tr")[0];
+ var cells = row.getElementsByTagName("td");
+ if (cells.length == 0){
+ cells = row.getElementsByTagName("th");
+ }
+ for(var i=0; i<cells.length; i++){
+ var o = this.createMetaData({ });
+
+ // presentation attributes
+ if(dojo.html.hasAttribute(cells[i], "align")){
+ o.align = dojo.html.getAttribute(cells[i],"align");
+ }
+ if(dojo.html.hasAttribute(cells[i], "valign")){
+ o.valign = dojo.html.getAttribute(cells[i],"valign");
+ }
+ if(dojo.html.hasAttribute(cells[i], "nosort")){
+ o.noSort = (dojo.html.getAttribute(cells[i],"nosort")=="true");
+ }
+ if(dojo.html.hasAttribute(cells[i], "sortusing")){
+ var trans = dojo.html.getAttribute(cells[i],"sortusing");
+ var f = this.getTypeFromString(trans);
+ if (f != null && f != window && typeof(f)=="function"){
+ o.sortFunction=f;
+ }
+ }
+ if(dojo.html.hasAttribute(cells[i], "field")){
+ o.field=dojo.html.getAttribute(cells[i],"field");
+ } else {
+ o.field="field"+i;
+ }
+ if(dojo.html.hasAttribute(cells[i], "format")){
+ o.format=dojo.html.getAttribute(cells[i],"format");
+ }
+ if(dojo.html.hasAttribute(cells[i], "dataType")){
+ var sortType = dojo.html.getAttribute(cells[i],"dataType");
+ // FIXME: switch this to let sorting happen based on dojo.html.renderedTextContent
+ if(sortType.toLowerCase()=="html" || sortType.toLowerCase()=="markup"){
+ o.sortType = "__markup__"; // always convert to "__markup__"
+ o.noSort = true;
+ }else{
+ var type = this.getTypeFromString(sortType);
+ if(type){
+ o.sortType = sortType;
+ o.dataType = type;
+ }
+ }
+ }
+ o.label = dojo.html.renderedTextContent(cells[i]);
+
+ // TODO: set up filtering mechanisms here.
+ if(dojo.html.hasAttribute(cells[i], "filterusing")){
+ var trans = dojo.html.getAttribute(cells[i],"filterusing");
+ var f = this.getTypeFromString(trans);
+ if (f != null && f != window && typeof(f)=="function"){
+ o.filterFunction=f;
+ }
+ }
+
+ this.columns.push(o);
+
+ // check to see if there's a default sort, and set the properties necessary
+ if(dojo.html.hasAttribute(cells[i], "sort")){
+ var info = {
+ index:i,
+ direction:0
+ };
+ var dir = dojo.html.getAttribute(cells[i], "sort");
+ if(!isNaN(parseInt(dir))){
+ dir = parseInt(dir);
+ info.direction = (dir != 0) ? 1 : 0;
+ }else{
+ info.direction = (dir.toLowerCase() == "desc") ? 1 : 0;
+ }
+ this.sortInformation.push(info);
+ }
+ }
+ if(this.sortInformation.length == 0){
+ this.sortInformation.push({
+ index:0,
+ direction:0
+ });
+ } else if (this.sortInformation.length > this.maxSortable){
+ this.sortInformation.length = this.maxSortable;
+ }
+ },
+ parseData: function(/* HTMLTableBody */body){
+ // summary
+ // Parse HTML data into native JSON structure for the store.
+ var rows = body.rows;
+ if(rows.length == 0 && this.columns.length == 0) return; // there's no data, ignore me.
+
+ // create a data constructor based on what we've got for the fields.
+ var self=this;
+ var ctor=function(row){
+ var obj = {};
+ for(var i=0; i<self.columns.length; i++){
+ var o = obj;
+ var data = row.cells[i].innerHTML;
+ var p = self.columns[i].getField();
+ if(p.indexOf(".") > -1){
+ p = p.split(".");
+ while(p.length>1){
+ var pr = p.shift();
+ o[pr] = {};
+ o = o[pr];
+ }
+ p = p[0];
+ }
+
+ if(self.columns[i].sortType=="__markup__") o[p] = String(data);
+ else{
+ var type = self.columns[i].getType();
+ if(data){
+ o[p] = new type(data);
+ } else {
+ o[p] = new type();
+ }
+ }
+ }
+ return obj;
+ };
+
+ // we have initialization data, let's parse it.
+ var arr=[];
+ var selected=[];
+ for(var i=0; i<rows.length; i++){
+ var row = rows[i];
+ var o = ctor(row); // yay. magic. love. sigh.
+ o[this.valueField] = dojo.html.getAttribute(row,"value");
+ if(dojo.html.getAttribute(row,"selected")=="true"){
+ selected.push(o);
+ }
+ arr.push(o);
+ }
+ this.store.setData(arr);
+
+ for(var i=0; i<selected.length; i++){
+ this.select(selected[i]);
+ }
+ this.renderSelections();
+
+ // say that we are already initialized so that we don't kill anything
+ this.isInitialized=true;
+ },
+
+ // standard events
+ onSelect: function(/* HTMLEvent */e){
+ // summary
+ // Handles the onclick event of any element.
+ var row = dojo.html.getParentByType(e.target,"tr");
+ var body = dojo.html.getParentByType(row,"tbody");
+ if(this.multiple){
+ if(e.shiftKey){
+ var startRow;
+ var rows=body.rows;
+ for(var i=0;i<rows.length;i++){
+ if(rows[i]==row){
+ break;
+ }
+ if(this.isRowSelected(rows[i])){
+ startRow=rows[i];
+ }
+ }
+ if(!startRow){
+ startRow = row;
+ for(; i<rows.length; i++){
+ if(this.isRowSelected(rows[i])){
+ row = rows[i];
+ break;
+ }
+ }
+ }
+ this.resetSelections();
+ if(startRow == row){
+ this.toggleSelectionByRow(row);
+ } else {
+ var doSelect = false;
+ for(var i=0; i<rows.length; i++){
+ if(rows[i] == startRow){
+ doSelect=true;
+ }
+ if(doSelect){
+ this.selectByRow(rows[i]);
+ }
+ if(rows[i] == row){
+ doSelect = false;
+ }
+ }
+ }
+ } else {
+ this.toggleSelectionByRow(row);
+ }
+ } else {
+ this.resetSelections();
+ this.toggleSelectionByRow(row);
+ }
+ this.renderSelections();
+ },
+ onSort: function(/* HTMLEvent */e){
+ // summary
+ // Sort the table based on the column selected.
+ var oldIndex=this.sortIndex;
+ var oldDirection=this.sortDirection;
+
+ var source=e.target;
+ var row=dojo.html.getParentByType(source,"tr");
+ var cellTag="td";
+ if(row.getElementsByTagName(cellTag).length==0){
+ cellTag="th";
+ }
+
+ var headers=row.getElementsByTagName(cellTag);
+ var header=dojo.html.getParentByType(source,cellTag);
+
+ for(var i=0; i<headers.length; i++){
+ dojo.html.setClass(headers[i], this.headerClass);
+ if(headers[i]==header){
+ if(this.sortInformation[0].index != i){
+ this.sortInformation.unshift({
+ index:i,
+ direction:0
+ });
+ } else {
+ this.sortInformation[0] = {
+ index:i,
+ direction:(~this.sortInformation[0].direction)&1
+ };
+ }
+ }
+ }
+
+ this.sortInformation.length = Math.min(this.sortInformation.length, this.maxSortable);
+ for(var i=0; i<this.sortInformation.length; i++){
+ var idx=this.sortInformation[i].index;
+ var dir=(~this.sortInformation[i].direction)&1;
+ dojo.html.setClass(headers[idx], dir==0?this.headerDownClass:this.headerUpClass);
+ }
+ this.render();
+ },
+ onFilter: function(){
+ // summary
+ // show or hide rows based on the parameters of the passed filter.
+ },
+
+ // Filtering methods
+ _defaultFilter: function(/* HTMLTableRow */row){
+ // summary
+ // Always return true as the result of the default filter.
+ return true;
+ },
+ setFilter: function(/* string */field, /* function */fn){
+ // summary
+ // set a filtering function on the passed field.
+ for(var i=0; i<this.columns.length; i++){
+ if(this.columns[i].getField() == field){
+ this.columns[i].filterFunction=fn;
+ break;
+ }
+ }
+ this.applyFilters();
+ },
+ setFilterByIndex: function(/* number */idx, /* function */fn){
+ // summary
+ // set a filtering function on the passed column index.
+ this.columns[idx].filterFunction=fn;
+ this.applyFilters();
+ },
+ clearFilter: function(/* string */field){
+ // summary
+ // clear a filtering function on the passed field.
+ for(var i=0; i<this.columns.length; i++){
+ if(this.columns[i].getField() == field){
+ this.columns[i].filterFunction=this._defaultFilter;
+ break;
+ }
+ }
+ this.applyFilters();
+ },
+ clearFilterByIndex: function(/* string */field){
+ // summary
+ // clear a filtering function on the passed column index.
+ this.columns[idx].filterFunction=this._defaultFilter;
+ this.applyFilters();
+ },
+ clearFilters: function(){
+ // summary
+ // clears all filters.
+ for(var i=0; i<this.columns.length; i++){
+ this.columns[i].filterFunction=this._defaultFilter;
+ }
+ // we'll do the clear manually, it will be faster.
+ var rows=this.domNode.tBodies[0].rows;
+ for(var i=0; i<rows.length; i++){
+ rows[i].style.display="";
+ }
+ this.onFilter();
+ },
+ applyFilters: function(){
+ // summary
+ // apply all filters to the table.
+ var rows=this.domNode.tBodies[0].rows;
+ for(var i=0; i<rows.length; i++){
+ var b=true;
+ var row=rows[i];
+ for(var j=0; j<this.columns.length; j++){
+ if(!this.columns[j].filterFunction(this.store.getField(this.getDataByRow(row), this.columns[j].getField()))){
+ b=false;
+ break;
+ }
+ }
+ row.style.display=(b?"":"none");
+ }
+ this.onFilter();
+ },
+
+ // sorting functionality
+ createSorter: function(/* array */info){
+ // summary
+ // creates a custom function to be used for sorting.
+ var self=this;
+ var sortFunctions=[]; // our function stack.
+
+ function createSortFunction(field, dir){
+ return function(rowA, rowB){
+ var a = self.store.getField(self.getDataByRow(rowA), field);
+ var b = self.store.getField(self.getDataByRow(rowB), field);
+ var ret = 0;
+ if(a > b) ret = 1;
+ if(a < b) ret = -1;
+ return dir * ret;
+ }
+ }
+
+ var current=0;
+ var max = Math.min(info.length, this.maxSortable, this.columns.length);
+ while(current < max){
+ var field = this.columns[info[current].index].getField();
+ var direction = (info[current].direction == 0) ? 1 : -1;
+ sortFunctions.push(createSortFunction(field, direction));
+ current++;
+ }
+
+ return function(rowA, rowB){
+ var idx=0;
+ while(idx < sortFunctions.length){
+ var ret = sortFunctions[idx++](rowA, rowB);
+ if(ret != 0) return ret;
+ }
+ // if we got here then we must be equal.
+ return 0;
+ }; // function
+ },
+
+ // rendering
+ createRow: function(/* object */obj){
+ var row=document.createElement("tr");
+ dojo.html.disableSelection(row);
+ if(obj.key != null){
+ row.setAttribute("value", obj.key);
+ }
+ for(var j=0; j<this.columns.length; j++){
+ var cell=document.createElement("td");
+ cell.setAttribute("align", this.columns[j].align);
+ cell.setAttribute("valign", this.columns[j].valign);
+ dojo.html.disableSelection(cell);
+ var val = this.store.getField(obj.src, this.columns[j].getField());
+ if(typeof(val)=="undefined"){
+ val="";
+ }
+ if (this.columns[j].sortType=="__markup__"){
+ cell.innerHTML=val;
+ } else {
+ if(this.columns[j].getType()==Date) {
+ val=new Date(val);
+ if(!isNaN(val)){
+ var format = this.defaultDateFormat;
+ if(this.columns[j].format){
+ format = this.columns[j].format;
+ }
+ cell.appendChild(document.createTextNode(dojo.date.format(val, format)));
+ } else {
+ cell.appendChild(document.createTextNode(val));
+ }
+ } else if ("Number number int Integer float Float".indexOf(this.columns[j].getType())>-1){
+ // TODO: number formatting
+ if(val.length == 0){
+ val="0";
+ }
+ var n = parseFloat(val, 10) + "";
+ // TODO: numeric formatting + rounding :)
+ if(n.indexOf(".")>-1){
+ n = dojo.math.round(parseFloat(val,10),2);
+ }
+ cell.appendChild(document.createTextNode(n));
+ }else{
+ cell.appendChild(document.createTextNode(val));
+ }
+ }
+ row.appendChild(cell);
+ }
+ return row;
+ },
+ prefill: function(){
+ // summary
+ // if there's no data in the table, then prefill it with this.minRows.
+ this.isInitialized = false;
+ var body = this.domNode.tBodies[0];
+ while (body.childNodes.length > 0){
+ body.removeChild(body.childNodes[0]);
+ }
+
+ if(this.minRows>0){
+ for(var i=0; i < this.minRows; i++){
+ var row = document.createElement("tr");
+ if(this.alternateRows){
+ dojo.html[((i % 2 == 1)?"addClass":"removeClass")](row, this.rowAlternateClass);
+ }
+ row.setAttribute("emptyRow","true");
+ for(var j=0; j<this.columns.length; j++){
+ var cell = document.createElement("td");
+ cell.innerHTML = " ";
+ row.appendChild(cell);
+ }
+ body.appendChild(row);
+ }
+ }
+ },
+ init: function(){
+ // summary
+ // initializes the table of data
+ this.isInitialized=false;
+
+ // if there is no thead, create it now.
+ var head=this.domNode.getElementsByTagName("thead")[0];
+ if(head.getElementsByTagName("tr").length == 0){
+ // render the column code.
+ var row=document.createElement("tr");
+ for(var i=0; i<this.columns.length; i++){
+ var cell=document.createElement("td");
+ cell.setAttribute("align", this.columns[i].align);
+ cell.setAttribute("valign", this.columns[i].valign);
+ dojo.html.disableSelection(cell);
+ cell.innerHTML=this.columns[i].label;
+ row.appendChild(cell);
+
+ // attach the events.
+ if(!this.columns[i].noSort){
+ dojo.event.connect(cell, "onclick", this, "onSort");
+ }
+ }
+ dojo.html.prependChild(row, head);
+ }
+
+ if(this.store.get().length == 0){
+ return false;
+ }
+
+ var idx=this.domNode.tBodies[0].rows.length;
+ if(!idx || idx==0 || this.domNode.tBodies[0].rows[0].getAttribute("emptyrow")=="true"){
+ idx = 0;
+ var body = this.domNode.tBodies[0];
+ while(body.childNodes.length>0){
+ body.removeChild(body.childNodes[0]);
+ }
+
+ var data = this.store.get();
+ for(var i=0; i<data.length; i++){
+ var row = this.createRow(data[i]);
+ body.appendChild(row);
+ dojo.event.connect(row, "onclick", this, "onSelect");
+ idx++;
+ }
+ }
+
+ // add empty rows
+ if(this.minRows > 0 && idx < this.minRows){
+ idx = this.minRows - idx;
+ for(var i=0; i<idx; i++){
+ row=document.createElement("tr");
+ row.setAttribute("emptyRow","true");
+ for(var j=0; j<this.columns.length; j++){
+ cell=document.createElement("td");
+ cell.innerHTML=" ";
+ row.appendChild(cell);
+ }
+ body.appendChild(row);
+ }
+ }
+
+ // last but not least, show any columns that have sorting already on them.
+ var row=this.domNode.getElementsByTagName("thead")[0].rows[0];
+ var cellTag="td";
+ if(row.getElementsByTagName(cellTag).length==0) cellTag="th";
+ var headers=row.getElementsByTagName(cellTag);
+ for(var i=0; i<headers.length; i++){
+ dojo.html.setClass(headers[i], this.headerClass);
+ }
+ for(var i=0; i<this.sortInformation.length; i++){
+ var idx=this.sortInformation[i].index;
+ var dir=(~this.sortInformation[i].direction)&1;
+ dojo.html.setClass(headers[idx], dir==0?this.headerDownClass:this.headerUpClass);
+ }
+
+ this.isInitialized=true;
+ return this.isInitialized;
+ },
+ render: function(){
+ /* The method that should be called once underlying changes
+ * are made, including sorting, filtering, data changes.
+ * Rendering the selections themselves are a different method,
+ * which render() will call as the last step.
+ ****************************************************************/
+ if(!this.isInitialized){
+ var b = this.init();
+ if(!b){
+ this.prefill();
+ return;
+ }
+ }
+
+ // do the sort
+ var rows=[];
+ var body=this.domNode.tBodies[0];
+ var emptyRowIdx=-1;
+ for(var i=0; i<body.rows.length; i++){
+ if(body.rows[i].getAttribute("emptyRow")){
+ emptyRowIdx=i;
+ break;
+ }
+ rows.push(body.rows[i]);
+ }
+
+ // build the sorting function, and do the sorting.
+ var sortFunction = this.createSorter(this.sortInformation);
+ if(sortFunction){
+ rows.sort(sortFunction);
+ }
+ if(emptyRowIdx>-1){
+ for(var i=emptyRowIdx; i<body.rows.length; i++){
+ rows.push(body.rows[i]);
+ }
+ }
+
+ // append the rows without killing them, this should help with the HTML problems.
+ for(var i=0; i<rows.length; i++){
+ if(this.alternateRows){
+ dojo.html[((i%2==1)?"addClass":"removeClass")](rows[i], this.rowAlternateClass);
+ }
+ body.appendChild(rows[i]);
+ }
+
+ // now re-render any selections.
+ this.renderSelections();
+ },
+ renderSelections: function(){
+ var body=this.domNode.tBodies[0];
+ for(var i=0; i<body.rows.length; i++){
+ dojo.html[(this.isRowSelected(body.rows[i])?"addClass":"removeClass")](body.rows[i], this.rowSelectedClass);
+ }
+ },
+ renderFilter: function(){
+ },
+
+ // widget lifetime handlers
+ initialize: function(){
+ var self=this;
+ // connect up binding listeners here.
+ dojo.event.connect(this.store, "onSetData", function(){
+ self.store.forEach(function(element){
+ element.isSelected = false;
+ });
+ self.isInitialized=false;
+ var body = self.domNode.tBodies[0];
+ if(body){
+ while(body.childNodes.length>0){
+ body.removeChild(body.childNodes[0]);
+ }
+ }
+ self.render();
+ });
+ dojo.event.connect(this.store, "onClearData", function(){
+ self.render();
+ });
+ dojo.event.connect(this.store, "onAddData", function(addedObject){
+ var row=self.createRow(addedObject);
+ self.domNode.tBodies[0].appendChild(row);
+ self.render();
+ });
+ dojo.event.connect(this.store, "onAddDataRange", function(arr){
+ for(var i=0; i<arr.length; i++){
+ arr[i].isSelected=false;
+ var row=self.createRow(arr[i]);
+ self.domNode.tBodies[0].appendChild(row);
+ };
+ self.render();
+ });
+ dojo.event.connect(this.store, "onRemoveData", function(removedObject){
+ var rows = self.domNode.tBodies[0].rows;
+ for(var i=0; i<rows.length; i++){
+ if(self.getDataByRow(rows[i]) == removedObject.src){
+ rows[i].parentNode.removeChild(rows[i]);
+ break;
+ }
+ }
+ self.render();
+ });
+ },
+// fillInTemplate: function(args, frag){ },
+ postCreate: function(){
+ // summary
+ // finish widget initialization.
+
+ this.store.keyField = this.valueField;
+
+ if(this.domNode){
+ // start by making sure domNode is a table element;
+ if(this.domNode.nodeName.toLowerCase() != "table"){
+ }
+
+ // see if there is columns set up already
+ if(this.domNode.getElementsByTagName("thead")[0]){
+ var head=this.domNode.getElementsByTagName("thead")[0];
+ if(this.headClass.length > 0){
+ head.className = this.headClass;
+ }
+ dojo.html.disableSelection(this.domNode);
+ this.parseMetadata(head);
+
+ var header="td";
+ if(head.getElementsByTagName(header).length==0){
+ header="th";
+ }
+ var headers = head.getElementsByTagName(header);
+ for(var i=0; i<headers.length; i++){
+ if(!this.columns[i].noSort){
+ dojo.event.connect(headers[i], "onclick", this, "onSort");
+ }
+ }
+ } else {
+ this.domNode.appendChild(document.createElement("thead"));
+ }
+
+ // if the table doesn't have a tbody already, add one and grab a reference to it
+ if (this.domNode.tBodies.length < 1) {
+ var body = document.createElement("tbody");
+ this.domNode.appendChild(body);
+ } else {
+ var body = this.domNode.tBodies[0];
+ }
+
+ if (this.tbodyClass.length > 0){
+ body.className = this.tbodyClass;
+ }
+ this.parseData(body);
+ }
+ }
+});
diff --git a/source/web/scripts/ajax/src/widget/FisheyeList.js b/source/web/scripts/ajax/src/widget/FisheyeList.js
new file mode 100644
index 0000000000..a3ad61837e
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/FisheyeList.js
@@ -0,0 +1,720 @@
+dojo.provide("dojo.widget.FisheyeList");
+dojo.provide("dojo.widget.FisheyeListItem");
+
+//
+// TODO
+// fix SVG support, and turn it on only if the browser supports it
+// fix really long labels in vertical mode
+//
+
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.HtmlWidget");
+dojo.require("dojo.html.style");
+dojo.require("dojo.html.selection");
+dojo.require("dojo.html.util");
+dojo.require("dojo.event");
+
+dojo.widget.defineWidget(
+ "dojo.widget.FisheyeList",
+ dojo.widget.HtmlWidget,
+{
+ templateString: '<div class="dojoHtmlFisheyeListBar"></div>',
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/FisheyeList.css"),
+
+ EDGE: {
+ CENTER: 0,
+ LEFT: 1,
+ RIGHT: 2,
+ TOP: 3,
+ BOTTOM: 4
+ },
+
+ isContainer: true,
+ snarfChildDomOutput: true,
+
+ pos: {x: -1, y: -1}, // current cursor position, relative to the grid
+
+ // for conservative trigger mode, when triggered, timerScale is gradually increased from 0 to 1
+ timerScale: 1.0,
+
+ /////////////////////////////////////////////////////////////////
+ //
+ // i spy OPTIONS!!!!
+ //
+
+ itemWidth: 40,
+ itemHeight: 40,
+
+ itemMaxWidth: 150,
+ itemMaxHeight: 150,
+
+ orientation: 'horizontal',
+
+ conservativeTrigger: false, // don't active menu until mouse is over an image (macintosh style)
+
+ effectUnits: 2,
+ itemPadding: 10,
+
+ attachEdge: 'center',
+ labelEdge: 'bottom',
+
+ enableCrappySvgSupport: false,
+
+
+ //
+ //
+ //
+ /////////////////////////////////////////////////////////////////
+
+ fillInTemplate: function(args, frag) {
+ //dojo.debug(this.orientation);
+
+ dojo.html.disableSelection(this.domNode);
+
+ this.isHorizontal = (this.orientation == 'horizontal') ? 1 : 0;
+ this.selectedNode = -1;
+
+ this.isOver = false;
+ this.hitX1 = -1;
+ this.hitY1 = -1;
+ this.hitX2 = -1;
+ this.hitY2 = -1;
+
+ //
+ // only some edges make sense...
+ //
+
+ this.anchorEdge = this.toEdge(this.attachEdge, this.EDGE.CENTER);
+ this.labelEdge = this.toEdge(this.labelEdge, this.EDGE.TOP);
+
+ if ( this.isHorizontal && (this.anchorEdge == this.EDGE.LEFT )){ this.anchorEdge = this.EDGE.CENTER; }
+ if ( this.isHorizontal && (this.anchorEdge == this.EDGE.RIGHT )){ this.anchorEdge = this.EDGE.CENTER; }
+ if (!this.isHorizontal && (this.anchorEdge == this.EDGE.TOP )){ this.anchorEdge = this.EDGE.CENTER; }
+ if (!this.isHorizontal && (this.anchorEdge == this.EDGE.BOTTOM)){ this.anchorEdge = this.EDGE.CENTER; }
+
+ if (this.labelEdge == this.EDGE.CENTER){ this.labelEdge = this.EDGE.TOP; }
+ if ( this.isHorizontal && (this.labelEdge == this.EDGE.LEFT )){ this.labelEdge = this.EDGE.TOP; }
+ if ( this.isHorizontal && (this.labelEdge == this.EDGE.RIGHT )){ this.labelEdge = this.EDGE.TOP; }
+ if (!this.isHorizontal && (this.labelEdge == this.EDGE.TOP )){ this.labelEdge = this.EDGE.LEFT; }
+ if (!this.isHorizontal && (this.labelEdge == this.EDGE.BOTTOM)){ this.labelEdge = this.EDGE.LEFT; }
+
+
+ //
+ // figure out the proximity size
+ //
+
+ this.proximityLeft = this.itemWidth * (this.effectUnits - 0.5);
+ this.proximityRight = this.itemWidth * (this.effectUnits - 0.5);
+ this.proximityTop = this.itemHeight * (this.effectUnits - 0.5);
+ this.proximityBottom = this.itemHeight * (this.effectUnits - 0.5);
+
+ if (this.anchorEdge == this.EDGE.LEFT){
+ this.proximityLeft = 0;
+ }
+ if (this.anchorEdge == this.EDGE.RIGHT){
+ this.proximityRight = 0;
+ }
+ if (this.anchorEdge == this.EDGE.TOP){
+ this.proximityTop = 0;
+ }
+ if (this.anchorEdge == this.EDGE.BOTTOM){
+ this.proximityBottom = 0;
+ }
+ if (this.anchorEdge == this.EDGE.CENTER){
+ this.proximityLeft /= 2;
+ this.proximityRight /= 2;
+ this.proximityTop /= 2;
+ this.proximityBottom /= 2;
+ }
+ },
+
+ postCreate: function(args, frag) {
+ this.initializePositioning();
+
+ //
+ // in liberal trigger mode, activate menu whenever mouse is close
+ //
+ if( !this.conservativeTrigger ){
+ dojo.event.connect(document.documentElement, "onmousemove", this, "mouseHandler");
+ }
+
+ // Deactivate the menu if mouse is moved off screen (doesn't work for FF?)
+ dojo.event.connect(document.documentElement, "onmouseout", this, "onBodyOut");
+ dojo.event.connect(this, "addChild", this, "initializePositioning");
+ },
+
+ initializePositioning: function(){
+ this.itemCount = this.children.length;
+
+ this.barWidth = (this.isHorizontal ? this.itemCount : 1) * this.itemWidth;
+ this.barHeight = (this.isHorizontal ? 1 : this.itemCount) * this.itemHeight;
+
+ this.totalWidth = this.proximityLeft + this.proximityRight + this.barWidth;
+ this.totalHeight = this.proximityTop + this.proximityBottom + this.barHeight;
+
+ //
+ // calculate effect ranges for each item
+ //
+
+ for (var i=0; i<this.children.length; i++){
+
+ this.children[i].posX = this.itemWidth * (this.isHorizontal ? i : 0);
+ this.children[i].posY = this.itemHeight * (this.isHorizontal ? 0 : i);
+
+ this.children[i].cenX = this.children[i].posX + (this.itemWidth / 2);
+ this.children[i].cenY = this.children[i].posY + (this.itemHeight / 2);
+
+ var isz = this.isHorizontal ? this.itemWidth : this.itemHeight;
+ var r = this.effectUnits * isz;
+ var c = this.isHorizontal ? this.children[i].cenX : this.children[i].cenY;
+ var lhs = this.isHorizontal ? this.proximityLeft : this.proximityTop;
+ var rhs = this.isHorizontal ? this.proximityRight : this.proximityBottom;
+ var siz = this.isHorizontal ? this.barWidth : this.barHeight;
+
+ var range_lhs = r;
+ var range_rhs = r;
+
+ if (range_lhs > c+lhs){ range_lhs = c+lhs; }
+ if (range_rhs > (siz-c+rhs)){ range_rhs = siz-c+rhs; }
+
+ this.children[i].effectRangeLeft = range_lhs / isz;
+ this.children[i].effectRangeRght = range_rhs / isz;
+
+ //dojo.debug('effect range for '+i+' is '+range_lhs+'/'+range_rhs);
+ }
+
+
+ //
+ // create the bar
+ //
+
+ this.domNode.style.width = this.barWidth + 'px';
+ this.domNode.style.height = this.barHeight + 'px';
+
+
+ //
+ // position the items
+ //
+ for (var i=0; i<this.children.length; i++){
+ var itm = this.children[i];
+ var elm = itm.domNode;
+ elm.style.left = itm.posX + 'px';
+ elm.style.top = itm.posY + 'px';
+ elm.style.width = this.itemWidth + 'px';
+ elm.style.height = this.itemHeight + 'px';
+
+ if ( itm.svgNode ) {
+ itm.svgNode.style.position = 'absolute';
+ itm.svgNode.style.left = this.itemPadding+'%';
+ itm.svgNode.style.top = this.itemPadding+'%';
+ itm.svgNode.style.width = (100 - 2 * this.itemPadding) + '%';
+ itm.svgNode.style.height = (100 - 2 * this.itemPadding) + '%';
+ itm.svgNode.style.zIndex = 1;
+
+ itm.svgNode.setSize(this.itemWidth, this.itemHeight);
+ } else {
+ itm.imgNode.style.left = this.itemPadding+'%';
+ itm.imgNode.style.top = this.itemPadding+'%';
+ itm.imgNode.style.width = (100 - 2 * this.itemPadding) + '%';
+ itm.imgNode.style.height = (100 - 2 * this.itemPadding) + '%';
+ }
+ }
+
+ //
+ // calc the grid
+ //
+
+ this.calcHitGrid();
+ },
+
+ onBodyOut: function(e){
+ // clicking over an object inside of body causes this event to fire; ignore that case
+ if( dojo.html.overElement(dojo.body(), e) ){
+ return;
+ }
+ this.setDormant(e);
+ },
+
+ // when mouse moves out of menu's range
+ setDormant: function(e){
+ if( !this.isOver ){ return; } // already dormant?
+ this.isOver = false;
+
+ if ( this.conservativeTrigger ) {
+ // user can't re-trigger the menu expansion
+ // until he mouses over a icon again
+ dojo.event.disconnect(document.documentElement, "onmousemove", this, "mouseHandler");
+ }
+ this.onGridMouseMove(-1, -1);
+ },
+
+ // when mouse is moved into menu's range
+ setActive: function(e){
+ if( this.isOver ){ return; } // already activated?
+ this.isOver = true;
+
+ if ( this.conservativeTrigger ) {
+ // switch event handlers so that we handle mouse events from anywhere near
+ // the menu
+ dojo.event.connect(document.documentElement, "onmousemove", this, "mouseHandler");
+
+ this.timerScale=0.0;
+
+ // call mouse handler to do some initial necessary calculations/positioning
+ this.mouseHandler(e);
+
+ // slowly expand the icon size so it isn't jumpy
+ this.expandSlowly();
+ }
+ },
+
+ // when mouse is moved
+ mouseHandler: function(e) {
+ if ((e.pageX >= this.hitX1) && (e.pageX <= this.hitX2) &&
+ (e.pageY >= this.hitY1) && (e.pageY <= this.hitY2)){
+ if( !this.isOver ){
+ this.setActive(e);
+ }
+ this.onGridMouseMove(e.pageX-this.hitX1, e.pageY-this.hitY1);
+ }else{
+ if (this.isOver){
+ this.setDormant(e);
+ }
+ }
+ },
+
+ onResized: function() {
+ this.calcHitGrid();
+ },
+
+ onGridMouseMove: function(x, y){
+ this.pos = {x:x, y:y};
+ this.paint();
+ },
+
+ paint: function(){
+ var x=this.pos.x;
+ var y=this.pos.y;
+
+ if( this.itemCount <= 0 ){ return; }
+
+ //
+ // figure out our main index
+ //
+
+ var pos = this.isHorizontal ? x : y;
+ var prx = this.isHorizontal ? this.proximityLeft : this.proximityTop;
+ var siz = this.isHorizontal ? this.itemWidth : this.itemHeight;
+ var sim = this.isHorizontal ?
+ (1.0-this.timerScale)*this.itemWidth + this.timerScale*this.itemMaxWidth :
+ (1.0-this.timerScale)*this.itemHeight + this.timerScale*this.itemMaxHeight ;
+
+ var cen = ((pos - prx) / siz) - 0.5;
+ var max_off_cen = (sim / siz) - 0.5;
+
+ if (max_off_cen > this.effectUnits){ max_off_cen = this.effectUnits; }
+
+
+ //
+ // figure out our off-axis weighting
+ //
+
+ var off_weight = 0;
+
+ if (this.anchorEdge == this.EDGE.BOTTOM){
+ var cen2 = (y - this.proximityTop) / this.itemHeight;
+ off_weight = (cen2 > 0.5) ? 1 : y / (this.proximityTop + (this.itemHeight / 2));
+ }
+ if (this.anchorEdge == this.EDGE.TOP){
+ var cen2 = (y - this.proximityTop) / this.itemHeight;
+ off_weight = (cen2 < 0.5) ? 1 : (this.totalHeight - y) / (this.proximityBottom + (this.itemHeight / 2));
+ }
+ if (this.anchorEdge == this.EDGE.RIGHT){
+ var cen2 = (x - this.proximityLeft) / this.itemWidth;
+ off_weight = (cen2 > 0.5) ? 1 : x / (this.proximityLeft + (this.itemWidth / 2));
+ }
+ if (this.anchorEdge == this.EDGE.LEFT){
+ var cen2 = (x - this.proximityLeft) / this.itemWidth;
+ off_weight = (cen2 < 0.5) ? 1 : (this.totalWidth - x) / (this.proximityRight + (this.itemWidth / 2));
+ }
+ if (this.anchorEdge == this.EDGE.CENTER){
+
+ if (this.isHorizontal){
+ off_weight = y / (this.totalHeight);
+ }else{
+ off_weight = x / (this.totalWidth);
+ }
+
+ if (off_weight > 0.5){
+ off_weight = 1 - off_weight;
+ }
+
+ off_weight *= 2;
+ }
+
+
+ //
+ // set the sizes
+ //
+
+ for(var i=0; i<this.itemCount; i++){
+
+ var weight = this.weightAt(cen, i);
+
+ if (weight < 0){weight = 0;}
+
+ this.setitemsize(i, weight * off_weight);
+ }
+
+ //
+ // set the positions
+ //
+
+ var main_p = Math.round(cen);
+ var offset = 0;
+
+ if (cen < 0){
+ main_p = 0;
+
+ }else if (cen > this.itemCount - 1){
+
+ main_p = this.itemCount -1;
+
+ }else{
+
+ offset = (cen - main_p) * ((this.isHorizontal ? this.itemWidth : this.itemHeight) - this.children[main_p].sizeMain);
+ }
+
+ this.positionElementsFrom(main_p, offset);
+ },
+
+ weightAt: function(cen, i){
+
+ var dist = Math.abs(cen - i);
+
+ var limit = ((cen - i) > 0) ? this.children[i].effectRangeRght : this.children[i].effectRangeLeft;
+
+ return (dist > limit) ? 0 : (1 - dist / limit);
+ },
+
+ positionFromNode: function(p, w){
+
+ //
+ // we need to grow all the nodes growing out from node 'i'
+ //
+
+ this.setitemsize(p, w);
+
+ var wx = w;
+ for(var i=p; i<this.itemCount; i++){
+ wx = 0.8 * wx;
+ this.setitemsize(i, wx);
+ }
+
+ var wx = w;
+ for(var i=p; i>=0; i--){
+ wx = 0.8 * wx;
+ this.setitemsize(i, wx);
+ }
+ },
+
+ setitemsize: function(p, scale){
+ scale *= this.timerScale;
+ var w = Math.round(this.itemWidth + ((this.itemMaxWidth - this.itemWidth ) * scale));
+ var h = Math.round(this.itemHeight + ((this.itemMaxHeight - this.itemHeight) * scale));
+
+ if (this.isHorizontal){
+
+ this.children[p].sizeW = w;
+ this.children[p].sizeH = h;
+
+ this.children[p].sizeMain = w;
+ this.children[p].sizeOff = h;
+
+ var y = 0;
+
+ if (this.anchorEdge == this.EDGE.TOP){
+
+ y = (this.children[p].cenY - (this.itemHeight / 2));
+
+ }else if (this.anchorEdge == this.EDGE.BOTTOM){
+
+ y = (this.children[p].cenY - (h - (this.itemHeight / 2)));
+
+ }else{
+
+ y = (this.children[p].cenY - (h / 2));
+ }
+
+ this.children[p].usualX = Math.round(this.children[p].cenX - (w / 2));
+
+ this.children[p].domNode.style.top = y + 'px';
+
+ this.children[p].domNode.style.left = this.children[p].usualX + 'px';
+
+ }else{
+
+ this.children[p].sizeW = w;
+ this.children[p].sizeH = h;
+
+ this.children[p].sizeOff = w;
+ this.children[p].sizeMain = h;
+
+ var x = 0;
+
+ if (this.anchorEdge == this.EDGE.LEFT){
+
+ x = this.children[p].cenX - (this.itemWidth / 2);
+
+ }else if (this.anchorEdge == this.EDGE.RIGHT){
+
+ x = this.children[p].cenX - (w - (this.itemWidth / 2));
+ }else{
+
+ x = this.children[p].cenX - (w / 2);
+ }
+
+ this.children[p].domNode.style.left = x + 'px';
+ this.children[p].usualY = Math.round(this.children[p].cenY - (h / 2));
+
+ this.children[p].domNode.style.top = this.children[p].usualY + 'px';
+ }
+
+ this.children[p].domNode.style.width = w + 'px';
+ this.children[p].domNode.style.height = h + 'px';
+
+ if (this.children[p].svgNode){
+ this.children[p].svgNode.setSize(w, h);
+ }
+ },
+
+ positionElementsFrom: function(p, offset){
+
+ var pos = 0;
+
+ if (this.isHorizontal){
+ pos = Math.round(this.children[p].usualX + offset);
+ this.children[p].domNode.style.left = pos + 'px';
+ }else{
+ pos = Math.round(this.children[p].usualY + offset);
+ this.children[p].domNode.style.top = pos + 'px';
+ }
+ this.positionLabel(this.children[p]);
+
+
+ //
+ // position before
+ //
+
+ var bpos = pos;
+
+ for(var i=p-1; i>=0; i--){
+
+ bpos -= this.children[i].sizeMain;
+
+ if (this.isHorizontal){
+ this.children[i].domNode.style.left = bpos + 'px';
+ }else{
+ this.children[i].domNode.style.top = bpos + 'px';
+ }
+ this.positionLabel(this.children[i]);
+ }
+
+ //
+ // position after
+ //
+
+ var apos = pos;
+
+ for(var i=p+1; i<this.itemCount; i++){
+
+ apos += this.children[i-1].sizeMain;
+
+ if (this.isHorizontal){
+ this.children[i].domNode.style.left = apos + 'px';
+ }else{
+ this.children[i].domNode.style.top = apos + 'px';
+ }
+ this.positionLabel(this.children[i]);
+ }
+
+ },
+
+ positionLabel: function(itm){
+
+ var x = 0;
+ var y = 0;
+
+ var mb = dojo.html.getMarginBox(itm.lblNode);
+
+ if (this.labelEdge == this.EDGE.TOP){
+ x = Math.round((itm.sizeW / 2) - (mb.width / 2));
+ y = -mb.height;
+ }
+
+ if (this.labelEdge == this.EDGE.BOTTOM){
+ x = Math.round((itm.sizeW / 2) - (mb.width / 2));
+ y = itm.sizeH;
+ }
+
+ if (this.labelEdge == this.EDGE.LEFT){
+ x = -mb.width;
+ y = Math.round((itm.sizeH / 2) - (mb.height / 2));
+ }
+
+ if (this.labelEdge == this.EDGE.RIGHT){
+ x = itm.sizeW;
+ y = Math.round((itm.sizeH / 2) - (mb.height / 2));
+ }
+
+ itm.lblNode.style.left = x + 'px';
+ itm.lblNode.style.top = y + 'px';
+ },
+
+ calcHitGrid: function(){
+
+ var pos = dojo.html.getAbsolutePosition(this.domNode, true);
+
+ this.hitX1 = pos.x - this.proximityLeft;
+ this.hitY1 = pos.y - this.proximityTop;
+ this.hitX2 = this.hitX1 + this.totalWidth;
+ this.hitY2 = this.hitY1 + this.totalHeight;
+
+ //dojo.debug(this.hitX1+','+this.hitY1+' // '+this.hitX2+','+this.hitY2);
+ },
+
+ toEdge: function(inp, def){
+ return this.EDGE[inp.toUpperCase()] || def;
+ },
+
+ // slowly expand the image to user specified max size
+ expandSlowly: function(){
+ if( !this.isOver ){ return; }
+ this.timerScale += 0.2;
+ this.paint();
+ if ( this.timerScale<1.0 ) {
+ dojo.lang.setTimeout(this, "expandSlowly", 10);
+ }
+ },
+
+ destroy: function(){
+ // need to disconnect when we destroy
+ dojo.event.disconnect(document.documentElement, "onmouseout", this, "onBodyOut");
+ dojo.event.disconnect(document.documentElement, "onmousemove", this, "mouseHandler");
+ dojo.widget.FisheyeList.superclass.destroy.call(this);
+ }
+});
+
+dojo.widget.defineWidget(
+ "dojo.widget.FisheyeListItem",
+ dojo.widget.HtmlWidget,
+{
+ // Constructor arguments
+ iconSrc: "",
+ svgSrc: "",
+ caption: "",
+
+ blankImgPath: dojo.uri.dojoUri("src/widget/templates/images/blank.gif"),
+
+ templateString:
+ '<div class="dojoHtmlFisheyeListItem">' +
+ ' <img class="dojoHtmlFisheyeListItemImage" dojoAttachPoint="imgNode" dojoAttachEvent="onMouseOver;onMouseOut;onClick">' +
+ ' <div class="dojoHtmlFisheyeListItemLabel" dojoAttachPoint="lblNode"></div>' +
+ '</div>',
+
+ imgNode: null,
+
+ fillInTemplate: function() {
+ //
+ // set image
+ // TODO: turn on/off SVG support based on browser version.
+ // this.parent.enableCrappySvgSupport is not available to this function
+ //
+ if (this.svgSrc != ""){
+ this.svgNode = this.createSvgNode(this.svgSrc);
+ this.domNode.appendChild(this.svgNode);
+ this.imgNode.style.display = 'none';
+ } else if((this.iconSrc.toLowerCase().substring(this.iconSrc.length-4)==".png")&&(dojo.render.html.ie)&&(!dojo.render.html.ie70)){
+ this.imgNode.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='"+this.iconSrc+"', sizingMethod='scale')";
+ this.imgNode.src = this.blankImgPath.toString();
+ } else {
+ this.imgNode.src = this.iconSrc;
+ }
+
+ //
+ // Label
+ //
+ if ( this.lblNode ) {
+ this.lblNode.appendChild(document.createTextNode(this.caption));
+ }
+ dojo.html.disableSelection(this.domNode);
+ },
+
+ createSvgNode: function(src){
+
+ var elm = document.createElement('embed');
+ elm.src = src;
+ elm.type = 'image/svg+xml';
+ //elm.style.border = '1px solid black';
+ elm.style.width = '1px';
+ elm.style.height = '1px';
+ elm.loaded = 0;
+ elm.setSizeOnLoad = false;
+
+ elm.onload = function(){
+ this.svgRoot = this.getSVGDocument().rootElement;
+ this.svgDoc = this.getSVGDocument().documentElement;
+ this.zeroWidth = this.svgRoot.width.baseVal.value;
+ this.zeroHeight = this.svgRoot.height.baseVal.value;
+ this.loaded = true;
+
+ if (this.setSizeOnLoad){
+ this.setSize(this.setWidth, this.setHeight);
+ }
+ }
+
+ elm.setSize = function(w, h){
+ if (!this.loaded){
+ this.setWidth = w;
+ this.setHeight = h;
+ this.setSizeOnLoad = true;
+ return;
+ }
+
+ this.style.width = w+'px';
+ this.style.height = h+'px';
+ this.svgRoot.width.baseVal.value = w;
+ this.svgRoot.height.baseVal.value = h;
+
+ var scale_x = w / this.zeroWidth;
+ var scale_y = h / this.zeroHeight;
+
+ for(var i=0; i<this.svgDoc.childNodes.length; i++){
+ if (this.svgDoc.childNodes[i].setAttribute){
+ this.svgDoc.childNodes[i].setAttribute( "transform", "scale("+scale_x+","+scale_y+")" );
+ }
+ }
+ }
+
+ return elm;
+ },
+
+ onMouseOver: function(e) {
+ // in conservative mode, don't activate the menu until user mouses over an icon
+ if( !this.parent.isOver ){
+ this.parent.setActive(e);
+ }
+ if ( this.caption != "" ) {
+ dojo.html.addClass(this.lblNode, "selected");
+ this.parent.positionLabel(this);
+ }
+ },
+
+ onMouseOut: function() {
+ dojo.html.removeClass(this.lblNode, "selected");
+ },
+
+ onClick: function() {
+ }
+});
+
diff --git a/source/web/scripts/ajax/src/widget/FloatingPane.js b/source/web/scripts/ajax/src/widget/FloatingPane.js
new file mode 100644
index 0000000000..8582c4084c
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/FloatingPane.js
@@ -0,0 +1,354 @@
+dojo.provide("dojo.widget.FloatingPane");
+
+//
+// this widget provides a window-like floating pane
+//
+
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.Manager");
+dojo.require("dojo.html.*");
+dojo.require("dojo.html.layout");
+dojo.require("dojo.html.shadow");
+dojo.require("dojo.html.iframe");
+dojo.require("dojo.html.selection");
+dojo.require("dojo.widget.html.layout");
+dojo.require("dojo.widget.ContentPane");
+dojo.require("dojo.dnd.HtmlDragMove");
+dojo.require("dojo.dnd.HtmlDragMoveSource");
+dojo.require("dojo.dnd.HtmlDragMoveObject");
+dojo.require("dojo.widget.ResizeHandle");
+
+dojo.widget.defineWidget(
+ "dojo.widget.FloatingPane",
+ dojo.widget.ContentPane,
+ {
+ // Constructor arguments
+ title: '',
+ iconSrc: '',
+ hasShadow: false,
+ constrainToContainer: false,
+ taskBarId: "",
+ resizable: true,
+ titleBarDisplay: "fancy",
+
+ windowState: "normal",
+ displayCloseAction: false,
+ displayMinimizeAction: false,
+ displayMaximizeAction: false,
+
+ maxTaskBarConnectAttempts: 5,
+ taskBarConnectAttempts: 0,
+
+ templatePath: dojo.uri.dojoUri("src/widget/templates/FloatingPane.html"),
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/FloatingPane.css"),
+
+ drag: null,
+
+ fillInTemplate: function(args, frag){
+ // Copy style info from input node to output node
+ var source = this.getFragNodeRef(frag);
+ dojo.html.copyStyle(this.domNode, source);
+
+ // necessary for safari, khtml (for computing width/height)
+ dojo.body().appendChild(this.domNode);
+
+ // if display:none then state=minimized, otherwise state=normal
+ if(!this.isShowing()){
+ this.windowState="minimized";
+ }
+
+ // <img src=""> can hang IE! better get rid of it
+ if(this.iconSrc==""){
+ dojo.html.removeNode(this.titleBarIcon);
+ }else{
+ this.titleBarIcon.src = this.iconSrc.toString();// dojo.uri.Uri obj req. toString()
+ }
+
+ if(this.titleBarDisplay!="none"){
+ this.titleBar.style.display="";
+ dojo.html.disableSelection(this.titleBar);
+
+ this.titleBarIcon.style.display = (this.iconSrc=="" ? "none" : "");
+
+ this.minimizeAction.style.display = (this.displayMinimizeAction ? "" : "none");
+ this.maximizeAction.style.display=
+ (this.displayMaximizeAction && this.windowState!="maximized" ? "" : "none");
+ this.restoreAction.style.display=
+ (this.displayMaximizeAction && this.windowState=="maximized" ? "" : "none");
+ this.closeAction.style.display= (this.displayCloseAction ? "" : "none");
+
+ this.drag = new dojo.dnd.HtmlDragMoveSource(this.domNode);
+ if (this.constrainToContainer) {
+ this.drag.constrainTo();
+ }
+ this.drag.setDragHandle(this.titleBar);
+
+ var self = this;
+
+ dojo.event.topic.subscribe("dragMove",
+ function (info){
+ if (info.source.domNode == self.domNode){
+ dojo.event.topic.publish('floatingPaneMove', { source: self } );
+ }
+ }
+ );
+ }
+
+ if(this.resizable){
+ this.resizeBar.style.display="";
+ this.resizeHandle = dojo.widget.createWidget("ResizeHandle", {targetElmId: this.widgetId, id:this.widgetId+"_resize"});
+ this.resizeBar.appendChild(this.resizeHandle.domNode);
+ }
+
+ // add a drop shadow
+ if(this.hasShadow){
+ this.shadow=new dojo.html.shadow(this.domNode);
+ }
+
+ // Prevent IE bleed-through problem
+ this.bgIframe = new dojo.html.BackgroundIframe(this.domNode);
+
+ if( this.taskBarId ){
+ this.taskBarSetup();
+ }
+
+ // counteract body.appendChild above
+ dojo.body().removeChild(this.domNode);
+
+ dojo.widget.FloatingPane.superclass.fillInTemplate.call(this, args, frag);
+ },
+
+ postCreate: function(){
+ if (dojo.hostenv.post_load_) {
+ this.setInitialWindowState();
+ } else {
+ dojo.addOnLoad(this, "setInitialWindowState");
+ }
+ },
+
+ maximizeWindow: function(evt) {
+ var mb = dojo.html.getMarginBox(this.domNode);
+ this.previous={
+ width: mb.width || this.width,
+ height: mb.height || this.height,
+ left: this.domNode.style.left,
+ top: this.domNode.style.top,
+ bottom: this.domNode.style.bottom,
+ right: this.domNode.style.right
+ };
+ if(this.domNode.parentNode.style.overflow.toLowerCase() != 'hidden'){
+ this.parentPrevious={
+ overflow: this.domNode.parentNode.style.overflow
+ };
+ dojo.debug(this.domNode.parentNode.style.overflow);
+ this.domNode.parentNode.style.overflow = 'hidden';
+ }
+
+ this.domNode.style.left =
+ dojo.html.getPixelValue(this.domNode.parentNode, "padding-left", true) + "px";
+ this.domNode.style.top =
+ dojo.html.getPixelValue(this.domNode.parentNode, "padding-top", true) + "px";
+
+ if ((this.domNode.parentNode.nodeName.toLowerCase() == 'body')) {
+ var viewport = dojo.html.getViewport();
+ var padding = dojo.html.getPadding(dojo.body());
+ this.resizeTo(viewport.width-padding.width, viewport.height-padding.height);
+ } else {
+ var content = dojo.html.getContentBox(this.domNode.parentNode);
+ this.resizeTo(content.width, content.height);
+ }
+ this.maximizeAction.style.display="none";
+ this.restoreAction.style.display="";
+
+ //disable resize and drag
+ if(this.resizeHandle){
+ this.resizeHandle.domNode.style.display="none";
+ }
+ this.drag.setDragHandle(null);
+
+ this.windowState="maximized";
+ },
+
+ minimizeWindow: function(evt) {
+ this.hide();
+ for(var attr in this.parentPrevious){
+ this.domNode.parentNode.style[attr] = this.parentPrevious[attr];
+ }
+ this.lastWindowState = this.windowState;
+ this.windowState = "minimized";
+ },
+
+ restoreWindow: function(evt) {
+ if (this.windowState=="minimized") {
+ this.show();
+ if(this.lastWindowState == "maximized"){
+ this.domNode.parentNode.style.overflow = 'hidden';
+ this.windowState="maximized";
+ }else{ //normal
+ this.windowState="normal";
+ }
+ } else if (this.windowState=="maximized"){
+ for(var attr in this.previous){
+ this.domNode.style[attr] = this.previous[attr];
+ }
+ for(var attr in this.parentPrevious){
+ this.domNode.parentNode.style[attr] = this.parentPrevious[attr];
+ }
+ this.resizeTo(this.previous.width, this.previous.height);
+ this.previous=null;
+ this.parentPrevious=null;
+
+ this.restoreAction.style.display="none";
+ this.maximizeAction.style.display=this.displayMaximizeAction ? "" : "none";
+
+ if(this.resizeHandle){
+ this.resizeHandle.domNode.style.display="";
+ }
+ this.drag.setDragHandle(this.titleBar);
+ this.windowState="normal";
+ } else { //normal
+ // do nothing
+ }
+ },
+
+ toggleDisplay: function(){
+ if(this.windowState=="minimized"){
+ this.restoreWindow();
+ }else{
+ this.minimizeWindow();
+ }
+ },
+
+ closeWindow: function(evt) {
+ dojo.html.removeNode(this.domNode);
+ this.destroy();
+ },
+
+ onMouseDown: function(evt) {
+ this.bringToTop();
+ },
+
+ bringToTop: function() {
+ var floatingPanes= dojo.widget.manager.getWidgetsByType(this.widgetType);
+ var windows = [];
+ for (var x=0; x<floatingPanes.length; x++) {
+ if (this.widgetId != floatingPanes[x].widgetId) {
+ windows.push(floatingPanes[x]);
+ }
+ }
+
+ windows.sort(function(a,b) {
+ return a.domNode.style.zIndex - b.domNode.style.zIndex;
+ });
+
+ windows.push(this);
+
+ var floatingPaneStartingZ = 100;
+ for (x=0; x<windows.length;x++) {
+ windows[x].domNode.style.zIndex = floatingPaneStartingZ + x*2;
+ }
+ },
+
+ setInitialWindowState: function() {
+ if(this.isShowing()){
+ this.width=-1; // force resize
+ var mb = dojo.html.getMarginBox(this.domNode);
+ this.resizeTo(mb.width, mb.height);
+ }
+ if (this.windowState == "maximized") {
+ this.maximizeWindow();
+ this.show();
+ return;
+ }
+
+ if (this.windowState=="normal") {
+ this.show();
+ return;
+ }
+
+ if (this.windowState=="minimized") {
+ this.hide();
+ return;
+ }
+
+ this.windowState="minimized";
+ },
+
+ // add icon to task bar, connected to me
+ taskBarSetup: function() {
+ var taskbar = dojo.widget.getWidgetById(this.taskBarId);
+ if (!taskbar){
+ if (this.taskBarConnectAttempts < this.maxTaskBarConnectAttempts) {
+ dojo.lang.setTimeout(this, this.taskBarSetup, 50);
+ this.taskBarConnectAttempts++;
+ } else {
+ dojo.debug("Unable to connect to the taskBar");
+ }
+ return;
+ }
+ taskbar.addChild(this);
+ },
+
+ show: function(){
+ dojo.widget.FloatingPane.superclass.show.apply(this, arguments);
+ this.bringToTop();
+ },
+
+ onShow: function(){
+ dojo.widget.FloatingPane.superclass.onShow.call(this);
+ var mb = dojo.html.getMarginBox(this.domNode);
+ this.resizeTo(mb.width, mb.height);
+ },
+
+ // This is called when the user adjusts the size of the floating pane
+ resizeTo: function(w, h){
+ dojo.html.setMarginBox(this.domNode, { width: w, height: h });
+
+ dojo.widget.html.layout(this.domNode,
+ [
+ {domNode: this.titleBar, layoutAlign: "top"},
+ {domNode: this.resizeBar, layoutAlign: "bottom"},
+ {domNode: this.containerNode, layoutAlign: "client"}
+ ] );
+
+ // If any of the children have layoutAlign specified, obey it
+ dojo.widget.html.layout(this.containerNode, this.children, "top-bottom");
+
+ this.bgIframe.onResized();
+ if(this.shadow){ this.shadow.size(w, h); }
+ this.onResized();
+ },
+
+ checkSize: function() {
+ // checkSize() is called when the user has resized the browser window,
+ // but that doesn't affect this widget (or this widget's children)
+ // so it can be safely ignored...
+ // TODO: unless we are maximized. then we should resize ourself.
+ }
+ }
+);
+
+dojo.require("dojo.widget.Dialog");
+dojo.widget.defineWidget(
+ "dojo.widget.ModalFloatingPane",
+ [dojo.widget.FloatingPane, dojo.widget.ModalDialogBase],
+ {
+ windowState: "minimized",
+ displayCloseAction: true,
+ postCreate: function(){
+ dojo.widget.ModalDialogBase.prototype.postCreate.call(this);
+ dojo.widget.ModalFloatingPane.superclass.postCreate.call(this);
+ },
+ show: function(){
+ dojo.widget.ModalFloatingPane.superclass.show.apply(this, arguments);
+ dojo.widget.ModalDialogBase.prototype.show.call(this);
+ this.placeModalDialog();
+ //place the background div under this modal pane
+ this.shared.bg.style.zIndex = this.domNode.style.zIndex-1;
+ },
+ closeWindow: function(){
+ this.hide();
+ dojo.widget.ModalFloatingPane.superclass.closeWindow.apply(this, arguments);
+ }
+ }
+);
\ No newline at end of file
diff --git a/source/web/scripts/ajax/src/widget/GoogleMap.js b/source/web/scripts/ajax/src/widget/GoogleMap.js
new file mode 100644
index 0000000000..2b6589101c
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/GoogleMap.js
@@ -0,0 +1,198 @@
+dojo.provide("dojo.widget.GoogleMap");
+dojo.require("dojo.event.*");
+dojo.require("dojo.math");
+dojo.require("dojo.widget.*");
+dojo.require("dojo.uri.Uri");
+dojo.require("dojo.widget.HtmlWidget");
+
+(function(){
+ var gkey = djConfig["gMapKey"]||djConfig["googleMapKey"];
+
+ // the Google API key mechanism sucks. We're hardcoding here for love and affection but I don't like it.
+ var uri=new dojo.uri.Uri(window.location.href);
+ if(uri.host=="www.dojotoolkit.org"){
+ gkey="ABQIAAAACUNdgv_7FGOmUslbm9l6_hRqjp7ri2mNiOEYqetD3xnFHpt5rBSjszDd1sdufPyQKUTyCf_YxoIxvw";
+ }
+ else if(uri.host=="blog.dojotoolkit.org"){
+ gkey="ABQIAAAACUNdgv_7FGOmUslbm9l6_hSkep6Av1xaMhVn3yCLkorJeXeLARQ6fammI_P3qSGleTJhoI5_1JmP_Q";
+ }
+ else if(uri.host=="archive.dojotoolkit.org"){
+ gkey="ABQIAAAACUNdgv_7FGOmUslbm9l6_hTaQpDt0dyGLIHbXMPTzg1kWeAfwRTwZNyrUfbfxYE9yIvRivEjcXoDTg";
+ }
+ else if(uri.host=="dojotoolkit.org"){
+ gkey="ABQIAAAACUNdgv_7FGOmUslbm9l6_hSaOaO_TgJ5c3mtQFnk5JO2zD5dZBRZk-ieqVs7BORREYNzAERmcJoEjQ";
+ }
+
+ if(!dojo.hostenv.post_load_){
+ if(!gkey || gkey==""){
+ dojo.raise("dojo.widget.GoogleMap: The Google Map widget requires a proper API key in order to be used.");
+ }
+ var tag = "<scr"+"ipt src='http://maps.google.com/maps?file=api&v=2&key="+gkey+"'></scri"+"pt>";
+ if(!dj_global["GMap2"]){
+ document.write(tag);
+ }
+ }else{
+ dojo.debug("Cannot initialize Google Map system after the page has been loaded! Please either manually include the script block provided by Google in your page or require() the GoogleMap widget before onload has fired.");
+ }
+})();
+
+dojo.widget.defineWidget(
+ "dojo.widget.GoogleMap",
+ dojo.widget.HtmlWidget,
+ function(){
+ this.map=null;
+ this.geocoder=null;
+ this.data=[];
+ this.datasrc="";
+ this.controls=["largemap","scale","maptype"];
+ },
+{
+ templatePath:null,
+ templateCssPath:null,
+ isContainer: false,
+
+ _defaultPoint:{lat:39.10662, lng: -94.578209},
+
+ setControls:function(){
+ var methodmap={
+ largemap:GLargeMapControl,
+ smallmap:GSmallMapControl,
+ smallzoom:GSmallZoomControl,
+ scale:GScaleControl,
+ maptype:GMapTypeControl,
+ overview:GOverviewMapControl
+ };
+ for(var i=0; i<this.controls.length; i++){
+ this.map.addControl(new (methodmap[this.controls[i].toLowerCase()])());
+ }
+ },
+
+ findCenter:function(bounds){
+ if(this.data.length==1){
+ return (new GLatLng(this.data[0].lat, this.data[0].lng));
+ }
+ var clat=(bounds.getNorthEast().lat()+bounds.getSouthWest().lat())/2;
+ var clng=(bounds.getNorthEast().lng()+bounds.getSouthWest().lng())/2;
+ return (new GLatLng(clat,clng));
+ },
+
+ createPinpoint:function(pt,overlay){
+ var m=new GMarker(pt);
+ if(overlay){
+ GEvent.addListener(m,"click",function(){
+ m.openInfoWindowHtml("<div>"+overlay+"</div>");
+ });
+ }
+ return m;
+ },
+ plot:function(obj){
+ var p=new GLatLng(obj.lat,obj.lng);
+ var d=obj.description||null;
+ var m=this.createPinpoint(p,d);
+ this.map.addOverlay(m);
+ },
+ plotAddress:function(address){
+ var self=this;
+ this.geocoder.getLocations(address, function(response){
+ if(!response || response.Status.code != 200){
+ alert("The address \"" + address + "\" was not found.");
+ return;
+ }
+ var obj={
+ lat:response.Placemark[0].Point.coordinates[1],
+ lng:response.Placemark[0].Point.coordinates[0],
+ description:response.Placemark[0].address
+ };
+ self.data.push(obj);
+ self.render();
+ });
+ },
+
+ parse:function(table){
+ this.data=[];
+
+ // get the column indices
+ var h=table.getElementsByTagName("thead")[0];
+ if(!h){
+ return;
+ }
+
+ var a=[];
+ var cols=h.getElementsByTagName("td");
+ if(cols.length==0){
+ cols=h.getElementsByTagName("th");
+ }
+ for(var i=0; i<cols.length; i++){
+ var c=cols[i].innerHTML.toLowerCase();
+ if(c=="long") c="lng";
+ a.push(c);
+ }
+
+ // parse the data
+ var b=table.getElementsByTagName("tbody")[0];
+ if(!b){
+ return;
+ }
+ for(var i=0; i<b.childNodes.length; i++){
+ if(!(b.childNodes[i].nodeName&&b.childNodes[i].nodeName.toLowerCase()=="tr")){
+ continue;
+ }
+ var cells=b.childNodes[i].getElementsByTagName("td");
+ var o={};
+ for(var j=0; j<a.length; j++){
+ var col=a[j];
+ if(col=="lat"||col=="lng"){
+ o[col]=parseFloat(cells[j].innerHTML);
+ }else{
+ o[col]=cells[j].innerHTML;
+ }
+ }
+ this.data.push(o);
+ }
+ },
+ render:function(){
+ if(this.data.length==0){
+ this.map.setCenter(new GLatLng(this._defaultPoint.lat, this._defaultPoint.lng), 4);
+ return;
+ }
+
+ // remove all overlays
+ this.map.clearOverlays();
+
+ var bounds=new GLatLngBounds();
+ var d=this.data;
+ for(var i=0; i<d.length; i++){
+ bounds.extend(new GLatLng(d[i].lat,d[i].lng));
+ }
+ var zoom=Math.min((this.map.getBoundsZoomLevel(bounds)-1),14);
+ this.map.setCenter(this.findCenter(bounds), zoom);
+
+ for(var i=0; i<this.data.length; i++){
+ this.plot(this.data[i]);
+ }
+ },
+
+ initialize:function(args, frag){
+ if(this.datasrc){
+ this.parse(dojo.byId(this.datasrc));
+ }
+ else if(this.domNode.getElementsByTagName("table")[0]){
+ this.parse(this.domNode.getElementsByTagName("table")[0]);
+ }
+ },
+ postCreate:function(){
+ // clean the domNode before creating the map.
+ while(this.domNode.childNodes.length>0){
+ this.domNode.removeChild(this.domNode.childNodes[0]);
+ }
+ if(this.domNode.style.position!="absolute"){
+ this.domNode.style.position="relative";
+ }
+ this.map=new GMap2(this.domNode);
+ try{
+ this.geocoder=new GClientGeocoder();
+ }catch(ex){}
+ this.render();
+ this.setControls();
+ }
+});
diff --git a/source/web/scripts/ajax/src/widget/HslColorPicker.js b/source/web/scripts/ajax/src/widget/HslColorPicker.js
new file mode 100644
index 0000000000..c93af0a618
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/HslColorPicker.js
@@ -0,0 +1,129 @@
+dojo.provide("dojo.widget.svg.HslColorPicker");
+
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.HtmlWidget");
+dojo.require("dojo.widget.HslColorPicker");
+dojo.require("dojo.math");
+dojo.require("dojo.svg");
+dojo.require("dojo.graphics.color");
+dojo.require("dojo.graphics.color.hsl");
+
+dojo.widget.defineWidget(
+ "dojo.widget.svg.HslColorPicker",
+ dojo.widget.HtmlWidget,
+ function(){
+ dojo.debug("warning: the HslColorPicker is not a finished widget, and is not yet ready for general use");
+ this.filterObject = {};
+ },
+{
+ hue: "0",
+ saturation: "0",
+ light: "0",
+ storedColor: "#0054aa",
+
+ // widget props
+ templatePath: dojo.uri.dojoUri("src/widget/templates/HslColorPicker.svg"),
+ fillInTemplate: function() {
+ this.height = "131px";
+ this.svgDoc = this.hueNode.ownerDocument;
+ this.leftGradientColorNode = this.hueNode.ownerDocument.getElementById("leftGradientColor");
+ this.rightGradientColorNode = this.hueNode.ownerDocument.getElementById("rightGradientColor");
+ this.hueNode.setAttributeNS(dojo.dom.xmlns.xlink, "href", dojo.uri.dojoUri("src/widget/templates/images/hue.png"));
+ var hsl = dojo.graphics.color.hex2hsl(this.storedColor);
+ this.hue = hsl[0];
+ this.saturation = hsl[1];
+ this.light = hsl[2];
+ this.setSaturationStopColors();
+ //this.setHueSlider();
+ //this.setSaturationLightSlider();
+ },
+ setSaturationStopColors: function() {
+ //this.leftGradientStopColor = "rgb(" + dojo.graphics.color.hsl2rgb(this.hue, 20, 50).join(", ") + ")";
+ //this.rightGradientStopColor = "rgb(" + dojo.graphics.color.hsl2rgb(this.hue, 100, 50).join(", ") + ")";
+ //this.leftGradientStopColor = dojo.graphics.color.hsl2hex(this.hue, 20, 50);
+ //this.rightGradientStopColor = dojo.graphics.color.hsl2hex(this.hue, 100, 50);
+ this.leftGradientStopColor = dojo.graphics.color.rgb2hex(this.hsl2rgb(this.hue, 0, 50));
+ this.rightGradientStopColor = dojo.graphics.color.rgb2hex(this.hsl2rgb(this.hue, 100, 50));
+ this.leftGradientColorNode.setAttributeNS(null,'stop-color',this.leftGradientStopColor);
+ this.rightGradientColorNode.setAttributeNS(null,'stop-color',this.rightGradientStopColor);
+ },
+ setHue: function(hue) {
+ this.hue = hue;
+ },
+ setHueSlider: function() {
+ // FIXME: need to add some padding around the picker so you can see the slider at the top and bottom of the picker)
+ this.hueSliderNode.setAttribute("y", parseInt((this.hue/360) * parseInt(this.height) - 2) + "px" );
+ },
+ setSaturationLight: function(saturation, light) {
+ this.saturation = saturation;
+ this.light = light;
+ },
+ setSaturationLightSlider: function() {
+ // TODO
+ },
+ onHueClick: function(evt) {
+ // get the position that was clicked on the element
+ // FIXME: handle document scrolling, offset
+ var yPosition = parseInt(evt.clientY) - parseInt(evt.target.getAttribute("y"));
+ this.setHue( 360 - parseInt(yPosition*(360/parseInt(this.height))) );
+ this.setSaturationStopColors();
+ this.setStoredColor(dojo.graphics.color.hsl2hex(this.hue, this.saturation, this.light));
+ },
+ onHueDrag: function(evt) {
+ // TODO
+ },
+ onSaturationLightClick: function(evt) {
+ // get the position that was clicked on the element
+ // FIXME: handle document scrolling, offset
+ var xPosition = parseInt(evt.clientX) - parseInt(evt.target.getAttribute("y"));
+ var yPosition = parseInt(evt.clientY) - parseInt(evt.target.getAttribute("y"));
+ var saturation = parseInt(parseInt(xPosition)*(101/106));
+ var light = parseInt(parseInt(yPosition)*(101/106));
+ this.setSaturationLight(saturation, light);
+ this.setStoredColor(dojo.graphics.color.hsl2hex(this.hue, this.saturation, this.light));
+ },
+ onSaturationLightDrag: function(evt) {
+ // TODO
+ },
+ getStoredColor: function() {
+ return this.storedColor;
+ },
+ setStoredColor: function(rgbHexColor) {
+ this.storedColor = rgbHexColor;
+ dojo.event.topic.publish("/" + this.widgetId + "/setStoredColor", this.filterObject);
+ },
+ hsl2rgb: function(hue, saturation, light)
+ {
+ // hsl2rgb in dojo.graphics.color did not behave hte way I expected, so
+ // I'm using some old code I wrote until I figure out what the issue is
+ // first, check to see if saturation = 0
+ function rgb(q1,q2,hue) {
+ if (hue>360) hue=hue-360;
+ if (hue<0) hue=hue+360;
+ if (hue<60) return (q1+(q2-q1)*hue/60);
+ else if (hue<180) return(q2);
+ else if (hue<240) return(q1+(q2-q1)*(240-hue)/60);
+ else return(q1);
+ }
+ this.rgb = rgb
+
+ if (saturation==0) {
+ return [Math.round(light*255/100), Math.round(light*255/100), Math.round(light*255/100)];
+ } else {
+ light = light/100;
+ saturation = saturation/100;
+ // check to see if light > 0.5
+ if ((light)<0.5) {
+ var temp2 = (light)*(1.0+saturation)
+ } else {
+ var temp2 = (light+saturation-(light*saturation))
+ }
+ var temp1 = 2.0*light - temp2;
+ var rgbcolor = [];
+ rgbcolor[0] = Math.round(rgb(temp1,temp2,parseInt(hue)+120)*255);
+ rgbcolor[1] = Math.round(rgb(temp1,temp2,hue)*255);
+ rgbcolor[2] = Math.round(rgb(temp1,temp2,parseInt(hue)-120)*255);
+ return rgbcolor;
+ }
+ }
+});
diff --git a/source/web/scripts/ajax/src/widget/HtmlWidget.js b/source/web/scripts/ajax/src/widget/HtmlWidget.js
new file mode 100644
index 0000000000..a7fd91ffba
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/HtmlWidget.js
@@ -0,0 +1,154 @@
+dojo.provide("dojo.widget.HtmlWidget");
+dojo.require("dojo.widget.DomWidget");
+dojo.require("dojo.html.util");
+dojo.require("dojo.html.display");
+dojo.require("dojo.html.layout");
+dojo.require("dojo.lang.extras");
+dojo.require("dojo.lang.func");
+dojo.require("dojo.lfx.toggle");
+
+dojo.declare("dojo.widget.HtmlWidget", dojo.widget.DomWidget, {
+ widgetType: "HtmlWidget",
+
+ templateCssPath: null,
+ templatePath: null,
+
+ // for displaying/hiding widget
+ toggle: "plain",
+ toggleDuration: 150,
+
+ animationInProgress: false,
+
+ initialize: function(args, frag){
+ },
+
+ postMixInProperties: function(args, frag){
+ // now that we know the setting for toggle, get toggle object
+ // (default to plain toggler if user specified toggler not present)
+ this.toggleObj =
+ dojo.lfx.toggle[this.toggle.toLowerCase()] || dojo.lfx.toggle.plain;
+ },
+
+ getContainerHeight: function(){
+ // NOTE: container height must be returned as the INNER height
+ dojo.unimplemented("dojo.widget.HtmlWidget.getContainerHeight");
+ },
+
+ getContainerWidth: function(){
+ return this.parent.domNode.offsetWidth;
+ },
+
+ setNativeHeight: function(height){
+ var ch = this.getContainerHeight();
+ },
+
+ createNodesFromText: function(txt, wrap){
+ return dojo.html.createNodesFromText(txt, wrap);
+ },
+
+ destroyRendering: function(finalize){
+ try{
+ if(!finalize && this.domNode){
+ dojo.event.browser.clean(this.domNode);
+ }
+ this.domNode.parentNode.removeChild(this.domNode);
+ delete this.domNode;
+ }catch(e){ /* squelch! */ }
+ },
+
+ /////////////////////////////////////////////////////////
+ // Displaying/hiding the widget
+ /////////////////////////////////////////////////////////
+ isShowing: function(){
+ return dojo.html.isShowing(this.domNode);
+ },
+
+ toggleShowing: function(){
+ // dojo.html.toggleShowing(this.domNode);
+ if(this.isHidden){
+ this.show();
+ }else{
+ this.hide();
+ }
+ },
+
+ show: function(){
+ this.animationInProgress=true;
+ this.isHidden = false;
+ this.toggleObj.show(this.domNode, this.toggleDuration, null,
+ dojo.lang.hitch(this, this.onShow), this.explodeSrc);
+ },
+
+ // called after the show() animation has completed
+ onShow: function(){
+ this.animationInProgress=false;
+ this.checkSize();
+ },
+
+ hide: function(){
+ this.animationInProgress = true;
+ this.isHidden = true;
+ this.toggleObj.hide(this.domNode, this.toggleDuration, null,
+ dojo.lang.hitch(this, this.onHide), this.explodeSrc);
+ },
+
+ // called after the hide() animation has completed
+ onHide: function(){
+ this.animationInProgress=false;
+ },
+
+ //////////////////////////////////////////////////////////////////////////////
+ // Sizing related methods
+ // If the parent changes size then for each child it should call either
+ // - resizeTo(): size the child explicitly
+ // - or checkSize(): notify the child the the parent has changed size
+ //////////////////////////////////////////////////////////////////////////////
+
+ // Test if my size has changed.
+ // If width & height are specified then that's my new size; otherwise,
+ // query outerWidth/outerHeight of my domNode
+ _isResized: function(w, h){
+ // If I'm not being displayed then disregard (show() must
+ // check if the size has changed)
+ if(!this.isShowing()){ return false; }
+
+ // If my parent has been resized and I have style="height: 100%"
+ // or something similar then my size has changed too.
+ var wh = dojo.html.getMarginBox(this.domNode);
+ var width=w||wh.width;
+ var height=h||wh.height;
+ if(this.width == width && this.height == height){ return false; }
+
+ this.width=width;
+ this.height=height;
+ return true;
+ },
+
+ // Called when my parent has changed size, but my parent won't call resizeTo().
+ // This is useful if my size is height:100% or something similar.
+ // Also called whenever I am shown, because the first time I am shown I may need
+ // to do size calculations.
+ checkSize: function(){
+ if(!this._isResized()){ return; }
+ this.onResized();
+ },
+
+ // Explicitly set this widget's size (in pixels).
+ resizeTo: function(w, h){
+ if(!this._isResized(w,h)){ return; }
+ dojo.html.setMarginBox(this.domNode, { width: w, height: h });
+ this.onResized();
+ },
+
+ resizeSoon: function(){
+ if(this.isShowing()){
+ dojo.lang.setTimeout(this, this.onResized, 0);
+ }
+ },
+
+ // Called when my size has changed.
+ // Must notify children if their size has (possibly) changed
+ onResized: function(){
+ dojo.lang.forEach(this.children, function(child){ if (child["checkSize"]) child.checkSize(); });
+ }
+});
diff --git a/source/web/scripts/ajax/src/widget/InlineEditBox.js b/source/web/scripts/ajax/src/widget/InlineEditBox.js
new file mode 100644
index 0000000000..1fe73360af
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/InlineEditBox.js
@@ -0,0 +1,161 @@
+dojo.provide("dojo.widget.InlineEditBox");
+
+dojo.require("dojo.widget.*");
+dojo.require("dojo.lfx.*");
+dojo.require("dojo.graphics.color");
+dojo.require("dojo.string");
+dojo.require("dojo.html.*");
+dojo.require("dojo.html.layout");
+
+dojo.widget.defineWidget(
+ "dojo.widget.InlineEditBox",
+ dojo.widget.HtmlWidget,
+ function(){
+ // mutable objects need to be in constructor to give each instance its own copy
+ this.history = [];
+ },
+{
+ templatePath: dojo.uri.dojoUri("src/widget/templates/InlineEditBox.html"),
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/InlineEditBox.css"),
+
+ form: null,
+ editBox: null,
+ edit: null,
+ text: null,
+ textarea: null,
+ submitButton: null,
+ cancelButton: null,
+ mode: "text",
+
+ minWidth: 100, //px. minimum width of edit box
+ minHeight: 200, //px. minimum width of edit box, if it's a TA
+
+ editing: false,
+ textValue: "",
+ defaultText: "",
+ doFade: false,
+
+ onSave: function(newValue, oldValue){},
+ onUndo: function(value){},
+
+ postCreate: function(args, frag){
+ // put original node back in the document, and attach handlers
+ // which hide it and display the editor
+ this.editable = this.getFragNodeRef(frag);
+ dojo.html.insertAfter(this.editable, this.form);
+ dojo.event.connect(this.editable, "onmouseover", this, "mouseover");
+ dojo.event.connect(this.editable, "onmouseout", this, "mouseout");
+ dojo.event.connect(this.editable, "onclick", this, "beginEdit");
+
+ this.textValue = dojo.string.trim(this.editable.innerHTML);
+ if(dojo.string.trim(this.textValue).length == 0){
+ this.editable.innerHTML = this.defaultText;
+ }
+ },
+
+ mouseover: function(e){
+ if(!this.editing){
+ dojo.html.addClass(this.editable, "editableRegion");
+ if(this.mode == "textarea"){
+ dojo.html.addClass(this.editable, "editableTextareaRegion");
+ }
+ }
+ },
+
+ mouseout: function(e){
+ if(!this.editing){
+ dojo.html.removeClass(this.editable, "editableRegion");
+ dojo.html.removeClass(this.editable, "editableTextareaRegion");
+ }
+ },
+
+ // When user clicks the text, then start editing.
+ // Hide the text and display the form instead.
+ beginEdit: function(e){
+ if(this.editing){ return; }
+ this.mouseout();
+ this.editing = true;
+
+ // setup the form's <input> or <textarea> field, as specified by mode
+ var ee = this[this.mode.toLowerCase()];
+ ee.value = dojo.string.trim(this.textValue);
+ ee.style.fontSize = dojo.html.getStyle(this.editable, "font-size");
+ ee.style.fontWeight = dojo.html.getStyle(this.editable, "font-weight");
+ ee.style.fontStyle = dojo.html.getStyle(this.editable, "font-style");
+ var bb = dojo.html.getBorderBox(this.editable);
+ ee.style.width = Math.max(bb.width, this.minWidth) + "px";
+ if(this.mode.toLowerCase()=="textarea"){
+ ee.style.display = "block";
+ ee.style.height = Math.max(bb.height, this.minHeight) + "px";
+ } else {
+ ee.style.display = "";
+ }
+
+ // show the edit form and hide the read only version of the text
+ this.form.style.display = "";
+ this.editable.style.display = "none";
+
+ ee.focus();
+ ee.select();
+ this.submitButton.disabled = true;
+ },
+
+ saveEdit: function(e){
+ e.preventDefault();
+ e.stopPropagation();
+ var ee = this[this.mode.toLowerCase()];
+ if((this.textValue != ee.value)&&
+ (dojo.string.trim(ee.value) != "")){
+ this.doFade = true;
+ this.history.push(this.textValue);
+ this.onSave(ee.value, this.textValue);
+ this.textValue = ee.value;
+ this.editable.innerHTML = "";
+ var textNode = document.createTextNode( this.textValue );
+ this.editable.appendChild( textNode );
+ }else{
+ this.doFade = false;
+ }
+ this.finishEdit(e);
+ },
+
+ cancelEdit: function(e){
+ if(!this.editing){ return false; }
+ this.editing = false;
+ this.form.style.display="none";
+ this.editable.style.display = "";
+ return true;
+ },
+
+ finishEdit: function(e){
+ if(!this.cancelEdit(e)){ return; }
+ if(this.doFade) {
+ dojo.lfx.highlight(this.editable, dojo.graphics.color.hex2rgb("#ffc"), 700).play(300);
+ }
+ this.doFade = false;
+ },
+
+ setText: function(txt){
+ // sets the text without informing the server
+ var tt = dojo.string.trim(txt);
+ this.textValue = tt
+ this.editable.innerHTML = tt;
+ },
+
+ undo: function(){
+ if(this.history.length > 0){
+ var value = this.history.pop();
+ this.editable.innerHTML = value;
+ this.textValue = value;
+ this.onUndo(value);
+ }
+ },
+
+ checkForValueChange: function(){
+ var ee = this[this.mode.toLowerCase()];
+ if((this.textValue != ee.value)&&
+ (dojo.string.trim(ee.value) != "")){
+ this.submitButton.disabled = false;
+ }
+ }
+});
diff --git a/source/web/scripts/ajax/src/widget/LayoutContainer.js b/source/web/scripts/ajax/src/widget/LayoutContainer.js
new file mode 100644
index 0000000000..cbd4d0135d
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/LayoutContainer.js
@@ -0,0 +1,53 @@
+//
+// this widget provides Delphi-style panel layout semantics
+//
+
+dojo.provide("dojo.widget.LayoutContainer");
+
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.html.layout");
+
+dojo.widget.defineWidget(
+ "dojo.widget.LayoutContainer",
+ dojo.widget.HtmlWidget,
+{
+ isContainer: true,
+
+ layoutChildPriority: 'top-bottom',
+
+ postCreate: function(){
+ dojo.widget.html.layout(this.domNode, this.children, this.layoutChildPriority);
+ },
+
+ addChild: function(child, overrideContainerNode, pos, ref, insertIndex){
+ dojo.widget.LayoutContainer.superclass.addChild.call(this, child, overrideContainerNode, pos, ref, insertIndex);
+ dojo.widget.html.layout(this.domNode, this.children, this.layoutChildPriority);
+ },
+
+ removeChild: function(pane){
+ dojo.widget.LayoutContainer.superclass.removeChild.call(this,pane);
+ dojo.widget.html.layout(this.domNode, this.children, this.layoutChildPriority);
+ },
+
+ onResized: function(){
+ dojo.widget.html.layout(this.domNode, this.children, this.layoutChildPriority);
+ },
+
+ show: function(){
+ // If this node was created while display=="none" then it
+ // hasn't been laid out yet. Do that now.
+ this.domNode.style.display="";
+ this.checkSize();
+ this.domNode.style.display="none";
+ this.domNode.style.visibility="";
+
+ dojo.widget.LayoutContainer.superclass.show.call(this);
+ }
+});
+
+// This argument can be specified for the children of a LayoutContainer.
+// Since any widget can be specified as a LayoutContainer child, mix it
+// into the base widget class. (This is a hack, but it's effective.)
+dojo.lang.extend(dojo.widget.Widget, {
+ layoutAlign: 'none'
+});
diff --git a/source/web/scripts/ajax/src/widget/LinkPane.js b/source/web/scripts/ajax/src/widget/LinkPane.js
new file mode 100644
index 0000000000..ad0e4a6c9e
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/LinkPane.js
@@ -0,0 +1,31 @@
+//
+// a div that loads from a URL. (Similar to an iframe, but
+// it's in the same environment as the main window)
+//
+
+dojo.provide("dojo.widget.LinkPane");
+
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.ContentPane");
+dojo.require("dojo.html.style");
+
+dojo.widget.defineWidget(
+ "dojo.widget.LinkPane",
+ dojo.widget.ContentPane,
+{
+ // I'm using a template because the user may specify the input as
+ // <a href="foo.html">label</a>, in which case we need to get rid of the
+ // <a> because we don't want a link.
+ templateString: '<div class="dojoLinkPane"></div>',
+
+ fillInTemplate: function(args, frag){
+ var source = this.getFragNodeRef(frag);
+
+ // If user has specified node contents, they become the label
+ // (the link must be plain text)
+ this.label += source.innerHTML;
+
+ var source = this.getFragNodeRef(frag);
+ dojo.html.copyStyle(this.domNode, source);
+ }
+});
diff --git a/source/web/scripts/ajax/src/widget/Manager.js b/source/web/scripts/ajax/src/widget/Manager.js
new file mode 100644
index 0000000000..37a4554f86
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/Manager.js
@@ -0,0 +1,330 @@
+dojo.provide("dojo.widget.Manager");
+dojo.require("dojo.lang.array");
+dojo.require("dojo.lang.func");
+dojo.require("dojo.event.*");
+
+// Manager class
+dojo.widget.manager = new function(){
+ this.widgets = [];
+ this.widgetIds = [];
+
+ // map of widgetId-->widget for widgets without parents (top level widgets)
+ this.topWidgets = {};
+
+ var widgetTypeCtr = {};
+ var renderPrefixCache = [];
+
+ this.getUniqueId = function (widgetType) {
+ return widgetType + "_" + (widgetTypeCtr[widgetType] != undefined ?
+ ++widgetTypeCtr[widgetType] : widgetTypeCtr[widgetType] = 0);
+ }
+
+ this.add = function(widget){
+ //dojo.profile.start("dojo.widget.manager.add");
+ this.widgets.push(widget);
+ // Opera9 uses ID (caps)
+ if(!widget.extraArgs["id"]){
+ widget.extraArgs["id"] = widget.extraArgs["ID"];
+ }
+ // FIXME: the rest of this method is very slow!
+ if(widget.widgetId == ""){
+ if(widget["id"]){
+ widget.widgetId = widget["id"];
+ }else if(widget.extraArgs["id"]){
+ widget.widgetId = widget.extraArgs["id"];
+ }else{
+ widget.widgetId = this.getUniqueId(widget.widgetType);
+ }
+ }
+ if(this.widgetIds[widget.widgetId]){
+ dojo.debug("widget ID collision on ID: "+widget.widgetId);
+ }
+ this.widgetIds[widget.widgetId] = widget;
+ // Widget.destroy already calls removeById(), so we don't need to
+ // connect() it here
+ //dojo.profile.end("dojo.widget.manager.add");
+ }
+
+ this.destroyAll = function(){
+ for(var x=this.widgets.length-1; x>=0; x--){
+ try{
+ // this.widgets[x].destroyChildren();
+ this.widgets[x].destroy(true);
+ delete this.widgets[x];
+ }catch(e){ }
+ }
+ }
+
+ // FIXME: we should never allow removal of the root widget until all others
+ // are removed!
+ this.remove = function(widgetIndex){
+ if(dojo.lang.isNumber(widgetIndex)){
+ var tw = this.widgets[widgetIndex].widgetId;
+ delete this.widgetIds[tw];
+ this.widgets.splice(widgetIndex, 1);
+ }else{
+ this.removeById(widgetIndex);
+ }
+ }
+
+ // FIXME: suboptimal performance
+ this.removeById = function(id) {
+ if(!dojo.lang.isString(id)){
+ id = id["widgetId"];
+ if(!id){ dojo.debug("invalid widget or id passed to removeById"); return; }
+ }
+ for (var i=0; i<this.widgets.length; i++){
+ if(this.widgets[i].widgetId == id){
+ this.remove(i);
+ break;
+ }
+ }
+ }
+
+ this.getWidgetById = function(id){
+ if(dojo.lang.isString(id)){
+ return this.widgetIds[id];
+ }
+ return id;
+ }
+
+ this.getWidgetsByType = function(type){
+ var lt = type.toLowerCase();
+ var ret = [];
+ dojo.lang.forEach(this.widgets, function(x){
+ if(x.widgetType.toLowerCase() == lt){
+ ret.push(x);
+ }
+ });
+ return ret;
+ }
+
+ this.getWidgetsByFilter = function(unaryFunc, onlyOne){
+ var ret = [];
+ dojo.lang.every(this.widgets, function(x){
+ if(unaryFunc(x)){
+ ret.push(x);
+ if(onlyOne){return false;}
+ }
+ return true;
+ });
+ return (onlyOne ? ret[0] : ret);
+ }
+
+ this.getAllWidgets = function() {
+ return this.widgets.concat();
+ }
+
+ // added, trt 2006-01-20
+ this.getWidgetByNode = function(/* DOMNode */ node){
+ var w=this.getAllWidgets();
+ node = dojo.byId(node);
+ for(var i=0; i<w.length; i++){
+ if(w[i].domNode==node){
+ return w[i];
+ }
+ }
+ return null;
+ }
+
+ // shortcuts, baby
+ this.byId = this.getWidgetById;
+ this.byType = this.getWidgetsByType;
+ this.byFilter = this.getWidgetsByFilter;
+ this.byNode = this.getWidgetByNode;
+
+ // map of previousally discovered implementation names to constructors
+ var knownWidgetImplementations = {};
+
+ // support manually registered widget packages
+ var widgetPackages = ["dojo.widget"];
+ for (var i=0; i<widgetPackages.length; i++) {
+ // convenience for checking if a package exists (reverse lookup)
+ widgetPackages[widgetPackages[i]] = true;
+ }
+
+ this.registerWidgetPackage = function(pname) {
+ if(!widgetPackages[pname]){
+ widgetPackages[pname] = true;
+ widgetPackages.push(pname);
+ }
+ }
+
+ this.getWidgetPackageList = function() {
+ return dojo.lang.map(widgetPackages, function(elt) { return(elt!==true ? elt : undefined); });
+ }
+
+ this.getImplementation = function(widgetName, ctorObject, mixins, namespace){
+ // try and find a name for the widget
+ var impl = this.getImplementationName(widgetName, namespace);
+ if(impl){
+ // var tic = new Date();
+ var ret;
+ if(ctorObject){ret = new impl(ctor);}
+ else{ret = new impl();}
+ // dojo.debug(new Date() - tic);
+ return ret;
+ }
+ }
+
+ this.getImplementationName = function(widgetName, namespace){
+ /*
+ * This is the overly-simplistic implemention of getImplementation (har
+ * har). In the future, we are going to want something that allows more
+ * freedom of expression WRT to specifying different specializations of
+ * a widget.
+ *
+ * Additionally, this implementation treats widget names as case
+ * insensitive, which does not necessarialy mesh with the markup which
+ * can construct a widget.
+ */
+ if(!namespace){namespace="dojo";}
+ var lowerCaseWidgetName = widgetName.toLowerCase();
+
+ if(!knownWidgetImplementations[namespace]){knownWidgetImplementations[namespace]={};}
+
+ var impl = knownWidgetImplementations[namespace][lowerCaseWidgetName];
+ if(impl){
+ return impl;
+ }
+ var ns = dojo.getNamespace(namespace);
+ if(ns){ns.load(widgetName);}
+
+ // first store a list of the render prefixes we are capable of rendering
+ if(!renderPrefixCache.length){
+ for(var renderer in dojo.render){
+ if(dojo.render[renderer]["capable"] === true){
+ var prefixes = dojo.render[renderer].prefixes;
+ for(var i = 0; i < prefixes.length; i++){
+ renderPrefixCache.push(prefixes[i].toLowerCase());
+ }
+ }
+ }
+ // make sure we don't HAVE to prefix widget implementation names
+ // with anything to get them to render
+ renderPrefixCache.push("");
+ }
+
+ var nsSearchArr = null;
+
+ var deprWarningLogged=false;
+ for(var counter = 0; counter < 2; counter++){
+ // look for a rendering-context specific version of our widget name
+ for(var i = 0; i < widgetPackages.length; i++){
+ var widgetPackage = dojo.evalObjPath(widgetPackages[i]);
+ if(!widgetPackage) { continue; }
+ var pos = widgetPackages[i].indexOf(".");
+ if(pos > -1){
+ var n = widgetPackages[i].substring(0,pos);
+ if(n != namespace){
+ if(counter==0){continue;}
+ if(!deprWarningLogged){
+ deprWarningLogged = true;
+ dojo.deprecated('dojo.widget.Manager.getImplementationName', 'Wrong namespace ('+namespace+
+ ') specified. Developers should specify correct namespaces for all non-Dojo widgets', "0.5");
+ }
+ }
+ }
+
+ for (var j = 0; j < renderPrefixCache.length; j++) {
+ if (!widgetPackage[renderPrefixCache[j]]) { continue; }
+ for (var widgetClass in widgetPackage[renderPrefixCache[j]]) {
+ if (widgetClass.toLowerCase() != lowerCaseWidgetName) { continue; }
+ knownWidgetImplementations[namespace][lowerCaseWidgetName] =
+ widgetPackage[renderPrefixCache[j]][widgetClass];
+ return knownWidgetImplementations[namespace][lowerCaseWidgetName];
+ }
+ }
+
+ for (var j = 0; j < renderPrefixCache.length; j++) {
+ for (var widgetClass in widgetPackage) {
+ if (widgetClass.toLowerCase() != (renderPrefixCache[j] + lowerCaseWidgetName) &&
+ widgetClass.toLowerCase() != lowerCaseWidgetName) { continue; }
+
+ knownWidgetImplementations[namespace][lowerCaseWidgetName] =
+ widgetPackage[widgetClass];
+ return knownWidgetImplementations[namespace][lowerCaseWidgetName];
+ }
+ }
+ }
+ var newNs = dojo.findNamespaceForWidget(lowerCaseWidgetName);
+ if(newNs){
+ namespace = newNs.nsPrefix;
+ }
+ }
+
+ throw new Error('Could not locate "' + widgetName + '" class');
+ }
+
+ // FIXME: does it even belong in this name space?
+ // NOTE: this method is implemented by DomWidget.js since not all
+ // hostenv's would have an implementation.
+ /*this.getWidgetFromPrimitive = function(baseRenderType){
+ dojo.unimplemented("dojo.widget.manager.getWidgetFromPrimitive");
+ }
+
+ this.getWidgetFromEvent = function(nativeEvt){
+ dojo.unimplemented("dojo.widget.manager.getWidgetFromEvent");
+ }*/
+
+ // Catch window resize events and notify top level widgets
+ this.resizing=false;
+ this.onWindowResized = function(){
+ if(this.resizing){
+ return; // duplicate event
+ }
+ try{
+ this.resizing=true;
+ for(var id in this.topWidgets){
+ var child = this.topWidgets[id];
+ if(child.checkSize ){
+ child.checkSize();
+ }
+ }
+ }catch(e){
+ }finally{
+ this.resizing=false;
+ }
+ }
+ if(typeof window != "undefined") {
+ dojo.addOnLoad(this, 'onWindowResized'); // initial sizing
+ dojo.event.connect(window, 'onresize', this, 'onWindowResized'); // window resize
+ }
+
+ // FIXME: what else?
+};
+
+(function(){
+ var dw = dojo.widget;
+ var dwm = dw.manager;
+ var h = dojo.lang.curry(dojo.lang, "hitch", dwm);
+ var g = function(oldName, newName){
+ dw[(newName||oldName)] = h(oldName);
+ }
+ // copy the methods from the default manager (this) to the widget namespace
+ g("add", "addWidget");
+ g("destroyAll", "destroyAllWidgets");
+ g("remove", "removeWidget");
+ g("removeById", "removeWidgetById");
+ g("getWidgetById");
+ g("getWidgetById", "byId");
+ g("getWidgetsByType");
+ g("getWidgetsByFilter");
+ g("getWidgetsByType", "byType");
+ g("getWidgetsByFilter", "byFilter");
+ g("getWidgetByNode", "byNode");
+ dw.all = function(n){
+ var widgets = dwm.getAllWidgets.apply(dwm, arguments);
+ if(arguments.length > 0) {
+ return widgets[n];
+ }
+ return widgets;
+ }
+ g("registerWidgetPackage");
+ g("getImplementation", "getWidgetImplementation");
+ g("getImplementationName", "getWidgetImplementationName");
+
+ dw.widgets = dwm.widgets;
+ dw.widgetIds = dwm.widgetIds;
+ dw.root = dwm.root;
+})();
diff --git a/source/web/scripts/ajax/src/widget/Menu.js b/source/web/scripts/ajax/src/widget/Menu.js
new file mode 100644
index 0000000000..bb15a7cda6
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/Menu.js
@@ -0,0 +1,59 @@
+/*
+ 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.widget.Menu");
+dojo.provide("dojo.widget.DomMenu");
+
+dojo.deprecated("dojo.widget.Menu, dojo.widget.DomMenu", "use dojo.widget.Menu2", "0.4");
+
+dojo.require("dojo.widget.*");
+
+dojo.widget.tags.addParseTreeHandler("dojo:menu");
+
+/* Menu
+ *******/
+
+dojo.widget.Menu = function () {
+ dojo.widget.Menu.superclass.constructor.call(this);
+}
+dojo.inherits(dojo.widget.Menu, dojo.widget.Widget);
+
+dojo.lang.extend(dojo.widget.Menu, {
+ widgetType: "Menu",
+ isContainer: true,
+
+ items: [],
+ push: function(item){
+ dojo.connect.event(item, "onSelect", this, "onSelect");
+ this.items.push(item);
+ },
+ onSelect: function(){}
+});
+
+
+/* DomMenu
+ **********/
+
+dojo.widget.DomMenu = function(){
+ dojo.widget.DomMenu.superclass.constructor.call(this);
+}
+dojo.inherits(dojo.widget.DomMenu, dojo.widget.DomWidget);
+
+dojo.lang.extend(dojo.widget.DomMenu, {
+ widgetType: "Menu",
+ isContainer: true,
+
+ push: function (item) {
+ dojo.widget.Menu.call(this, item);
+ this.domNode.appendChild(item.domNode);
+ }
+});
+
+dojo.requireAfterIf("html", "dojo.widget.html.Menu");
diff --git a/source/web/scripts/ajax/src/widget/Menu2.js b/source/web/scripts/ajax/src/widget/Menu2.js
new file mode 100644
index 0000000000..5bb610dfa4
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/Menu2.js
@@ -0,0 +1,1047 @@
+dojo.provide("dojo.widget.PopupContainer");
+dojo.provide("dojo.widget.Menu2");
+dojo.provide("dojo.widget.PopupMenu2");
+dojo.provide("dojo.widget.MenuItem2");
+dojo.provide("dojo.widget.MenuBar2");
+
+dojo.require("dojo.html.style");
+dojo.require("dojo.html.layout");
+dojo.require("dojo.html.selection");
+dojo.require("dojo.html.iframe");
+dojo.require("dojo.event.*");
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.HtmlWidget");
+
+//PopupContainerBase is the mixin class which provide popup behaviors:
+//it can open in a given position x,y or around a given node.
+//In addition, it handles animation and IE bleed through workaround.
+//This class can not be used standalone: it should be mixed-in to a
+//dojo.widget.HtmlWidget. Use PopupContainer instead if you want a
+//a standalone popup widget
+dojo.declare(
+ "dojo.widget.PopupContainerBase",
+ null,
+ function(){
+ this.queueOnAnimationFinish = [];
+ },
+{
+ isContainer: true,
+ templateString: '<div dojoAttachPoint="containerNode" style="display:none;position:absolute;" class="dojoPopupContainer" tabindex="-1"></div>',
+ snarfChildDomOutput: true,
+
+ isShowingNow: false,
+
+ currentSubpopup: null,
+
+ beginZIndex: 1000,
+
+ parentPopup: null,
+ popupIndex: 0,
+
+ aroundBox: dojo.html.boxSizing.BORDER_BOX, //by default, popup around the BORDER box of the aroundNode in open()
+
+ processKey: function(evt){
+ return false;
+ },
+
+ //this function should be called in sub class where a custom
+ //templateString/templateStringPath is used (see Tooltip widget)
+ applyPopupBasicStyle: function(){
+ with(this.domNode.style){
+ display = 'none';
+ position = 'absolute';
+ }
+ },
+ /**
+ * Open the popup at position (x,y), relative to dojo.body()
+ * Or open(node, parent, explodeSrc, aroundOrient) to open
+ * around node
+ */
+ open: function(x, y, parent, explodeSrc, orient, padding){
+ if (this.isShowingNow){ return; }
+
+ // if I click right button and menu is opened, then it gets 2 commands: close -> open
+ // so close enables animation and next "open" is put to queue to occur at new location
+ if(this.animationInProgress){
+ this.queueOnAnimationFinish.push(this.open, arguments);
+ return;
+ }
+
+ var around = false, node, aroundOrient;
+ if(typeof x == 'object'){
+ node = x;
+ aroundOrient = explodeSrc;
+ explodeSrc = parent;
+ parent = y;
+ around = true;
+ }
+
+ // for unknown reasons even if the domNode is attached to the body in postCreate(),
+ // it's not attached here, so have to attach it here.
+ dojo.body().appendChild(this.domNode);
+
+ // if explodeSrc isn't specified then explode from my parent widget
+ explodeSrc = explodeSrc || parent["domNode"] || [];
+
+ //keep track of parent popup to decided whether this is a top level popup
+ var parentPopup = null;
+ this.isTopLevel = true;
+ while(parent){
+ if(parent !== this && (parent instanceof dojo.widget.PopupContainer || parent.applyPopupBasicStyle != undefined)){
+ parentPopup = parent;
+ this.isTopLevel = false;
+ parentPopup.setOpenedSubpopup(this);
+ break;
+ }
+ parent = parent.parent;
+ }
+
+ this.parentPopup = parentPopup;
+ this.popupIndex = parentPopup ? parentPopup.popupIndex + 1 : 1;
+
+ if(this.isTopLevel){
+ var button = explodeSrc instanceof Array ? null : explodeSrc;
+ dojo.widget.PopupManager.opened(this, button);
+ }
+
+ //convert explodeSrc from format [x, y] to
+ //{left: x, top: y, width: 0, height: 0} which is the new
+ //format required by dojo.html.toCoordinateObject
+ if(explodeSrc instanceof Array){
+ explodeSrc = {left: explodeSrc[0], top: explodeSrc[1], width: 0, height: 0};
+ }
+
+ // display temporarily, and move into position, then hide again
+ with(this.domNode.style){
+ display="";
+ zIndex = this.beginZIndex + this.popupIndex;
+ }
+
+ if(around){
+ this.move(node, padding, aroundOrient);
+ }else{
+ this.move(x, y, padding, orient);
+ }
+ this.domNode.style.display="none";
+
+ this.explodeSrc = explodeSrc;
+
+ // then use the user defined method to display it
+ this.show();
+
+ this.isShowingNow = true;
+ },
+
+ /* Summery: calculate where to place the popup
+ move(node, padding, aroundOrient) */
+ move: function(x, y, padding, orient){
+ var around = (typeof x == "object");
+ if(around){
+ var aroundOrient=padding;
+ var node=x;
+ padding=y;
+ if(!aroundOrient){ //By default, attempt to open above the aroundNode, or below
+ aroundOrient = {'BL': 'TL', 'TL': 'BL'};
+ }
+ dojo.html.placeOnScreenAroundElement(this.domNode, node, padding, this.aroundBox, aroundOrient);
+ }else{
+ if(!orient){ orient = 'TL,TR,BL,BR';}
+ dojo.html.placeOnScreen(this.domNode, x, y, padding, true, orient);
+ }
+ },
+
+ close: function(){
+ // If we are in the process of opening the menu and we are asked to close it
+ if(this.animationInProgress){
+ this.queueOnAnimationFinish.push(this.close, []);
+ return;
+ }
+
+ this.closeSubpopup();
+ this.hide();
+ if(this.bgIframe){
+ this.bgIframe.hide();
+ this.bgIframe.size({left: 0, top: 0, width: 0, height: 0});
+ }
+ if(this.isTopLevel){
+ dojo.widget.PopupManager.closed(this);
+ }
+ this.isShowingNow = false;
+ },
+
+ closeAll: function(){
+ if (this.parentPopup){
+ this.parentPopup.closeAll();
+ }else{
+ this.close();
+ }
+ },
+
+ //call this when a embedded popup is shown
+ setOpenedSubpopup: function(popup) {
+ this.currentSubpopup = popup;
+ },
+
+ closeSubpopup: function() {
+ if(this.currentSubpopup == null){ return; }
+
+ this.currentSubpopup.close();
+ this.currentSubpopup = null;
+ },
+
+ onShow: function() {
+ this.inherited('onShow');
+ // With some animation (wipe), after close, the size of the domnode is 0
+ // and next time when shown, the open() function can not determine
+ // the correct place to popup, so we store the opened size here and
+ // set it after close (in function onHide())
+ this.openedSize={w: this.domNode.style.width, h: this.domNode.style.height};
+ // prevent IE bleed through
+ if(dojo.render.html.ie){
+ if(!this.bgIframe){
+ this.bgIframe = new dojo.html.BackgroundIframe();
+ this.bgIframe.setZIndex(this.domNode);
+ }
+
+ this.bgIframe.size(this.domNode);
+ this.bgIframe.show();
+ }
+ this.processQueue();
+ },
+
+ // do events from queue
+ processQueue: function() {
+ if (!this.queueOnAnimationFinish.length) return;
+
+ var func = this.queueOnAnimationFinish.shift();
+ var args = this.queueOnAnimationFinish.shift();
+
+ func.apply(this, args);
+ },
+
+ onHide: function() {
+ dojo.widget.HtmlWidget.prototype.onHide.call(this);
+
+ //restore size of the domnode, see comment in
+ //function onShow()
+ if(this.openedSize){
+ with(this.domNode.style){
+ width=this.openedSize.w;
+ height=this.openedSize.h;
+ }
+ }
+
+ this.processQueue();
+ }
+});
+
+dojo.widget.defineWidget(
+ "dojo.widget.PopupContainer",
+ [dojo.widget.HtmlWidget, dojo.widget.PopupContainerBase], {});
+
+dojo.widget.defineWidget(
+ "dojo.widget.PopupMenu2",
+ dojo.widget.PopupContainer,
+ function(){
+ this.targetNodeIds = []; // fill this with nodeIds upon widget creation and it becomes context menu for those nodes
+
+ this.eventNames = {
+ open: ""
+ };
+ },
+{
+ templateCssString: "",
+ currentSubmenuTrigger: null,
+
+ eventNaming: "default",
+
+ templateString: '<table class="dojoPopupMenu2" border=0 cellspacing=0 cellpadding=0 style="display: none;"><tbody dojoAttachPoint="containerNode"></tbody></table>',
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/Menu2.css"),
+
+ submenuDelay: 500,
+ submenuOverlap: 5,
+ contextMenuForWindow: false,
+ openEvent: null,
+
+ _highlighted_option: null,
+
+ initialize: function(args, frag) {
+ if (this.eventNaming == "default") {
+ for (var eventName in this.eventNames) {
+ this.eventNames[eventName] = this.widgetId+"/"+eventName;
+ }
+ }
+ },
+
+ postCreate: function(){
+ if (this.contextMenuForWindow){
+ var doc = dojo.body();
+ this.bindDomNode(doc);
+ } else if ( this.targetNodeIds.length > 0 ){
+ dojo.lang.forEach(this.targetNodeIds, this.bindDomNode, this);
+ }
+
+ this.subscribeSubitemsOnOpen();
+ },
+
+ subscribeSubitemsOnOpen: function() {
+ var subItems = this.getChildrenOfType(dojo.widget.MenuItem2);
+
+ for(var i=0; i<subItems.length; i++) {
+ dojo.event.topic.subscribe(this.eventNames.open, subItems[i], "menuOpen")
+ }
+ },
+
+ // get open event for current menu
+ getTopOpenEvent: function() {
+ var menu = this;
+ while (menu.parentPopup){ menu = menu.parentPopup; }
+ return menu.openEvent;
+ },
+
+ // attach menu to given node
+ bindDomNode: function(node){
+ node = dojo.byId(node);
+
+ var win = dojo.html.getElementWindow(node);
+ if(dojo.html.isTag(node,'iframe') == 'iframe'){
+ win = dojo.html.iframeContentWindow(node);
+ node = dojo.withGlobal(win, dojo.body);
+ }
+ // fixes node so that it supports oncontextmenu if not natively supported, Konqueror, Opera more?
+ dojo.widget.Menu2.OperaAndKonqFixer.fixNode(node);
+
+ dojo.event.kwConnect({
+ srcObj: node,
+ srcFunc: "oncontextmenu",
+ targetObj: this,
+ targetFunc: "onOpen",
+ once: true
+ });
+
+ dojo.widget.PopupManager.registerWin(win);
+ },
+
+ // detach menu from given node
+ unBindDomNode: function(nodeName){
+ var node = dojo.byId(nodeName);
+ dojo.event.kwDisconnect({
+ srcObj: node,
+ srcFunc: "oncontextmenu",
+ targetObj: this,
+ targetFunc: "onOpen",
+ once: true
+ });
+
+ // cleans a fixed node, konqueror and opera
+ dojo.widget.Menu2.OperaAndKonqFixer.cleanNode(node);
+ },
+
+ moveToNext: function(evt){
+ this.highlightOption(1);
+ return true; //do not pass to parent menu
+ },
+
+ moveToPrevious: function(evt){
+ this.highlightOption(-1);
+ return true; //do not pass to parent menu
+ },
+
+ moveToParentMenu: function(evt){
+ if(this._highlighted_option && this.parentPopup){
+ //only process event in the focused menu
+ //and its immediate parentPopup to support
+ //MenuBar2
+ if(evt._menu2UpKeyProcessed){
+ return true; //do not pass to parent menu
+ }else{
+ this._highlighted_option.onUnhover();
+ this.closeSubpopup();
+ evt._menu2UpKeyProcessed = true;
+ }
+ }
+ return false;
+ },
+
+ moveToChildMenu: function(evt){
+ if(this._highlighted_option && this._highlighted_option.submenuId){
+ this._highlighted_option._onClick(true);
+ return true; //do not pass to parent menu
+ }
+ return false;
+ },
+
+ selectCurrentItem: function(evt){
+ if(this._highlighted_option){
+ this._highlighted_option._onClick();
+ return true;
+ }
+ return false;
+ },
+
+ //return true to stop the event being processed by the
+ //parent popupmenu
+ processKey: function(evt){
+ if(evt.ctrlKey || evt.altKey){ return false; }
+
+ var keyCode = evt.keyCode;
+ var rval = false;
+ var k = dojo.event.browser.keys;
+
+ // mozilla quirk
+ // space has no keyCode in mozilla
+ var keyCode = evt.keyCode;
+ if(keyCode==0 && evt.charCode==k.KEY_SPACE){
+ keyCode = k.KEY_SPACE;
+ }
+
+ switch(keyCode){
+ case k.KEY_DOWN_ARROW:
+ rval = this.moveToNext(evt);
+ break;
+ case k.KEY_UP_ARROW:
+ rval = this.moveToPrevious(evt);
+ break;
+ case k.KEY_RIGHT_ARROW:
+ rval = this.moveToChildMenu(evt);
+ break;
+ case k.KEY_LEFT_ARROW:
+ rval = this.moveToParentMenu(evt);
+ break;
+ case k.KEY_SPACE: //fall through
+ case k.KEY_ENTER:
+ if(rval = this.selectCurrentItem(evt)){
+ break;
+ }
+ //fall through
+ case k.KEY_ESCAPE:
+ dojo.widget.PopupManager.currentMenu.close();
+ rval = true;
+ break;
+ }
+
+ return rval;
+ },
+
+ findValidItem: function(dir, curItem){
+ if(curItem){
+ curItem = dir>0 ? curItem.getNextSibling() : curItem.getPreviousSibling();
+ }
+
+ for(var i=0; i < this.children.length; ++i){
+ if(!curItem){
+ curItem = dir>0 ? this.children[0] : this.children[this.children.length-1];
+ }
+ if(curItem.onHover){
+ return curItem;
+ }
+ curItem = dir>0 ? curItem.getNextSibling() : curItem.getPreviousSibling();
+ }
+ },
+
+ highlightOption: function(dir){
+ var item;
+ // || !this._highlighted_option.parentNode
+ if((!this._highlighted_option)){
+ item = this.findValidItem(dir);
+ }else{
+ item = this.findValidItem(dir, this._highlighted_option);
+ }
+ if(item){
+ if(this._highlighted_option) {
+ this._highlighted_option.onUnhover();
+ }
+ item.onHover();
+ dojo.html.scrollIntoView(item.domNode);
+ }
+ },
+
+ // User defined function to handle clicks on an item
+ onItemClick: function(item) {},
+
+ close: function(){
+ if(this.animationInProgress){
+ dojo.widget.PopupMenu2.superclass.close.call(this);
+ return;
+ }
+
+ if(this._highlighted_option){
+ this._highlighted_option.onUnhover();
+ }
+
+ dojo.widget.PopupMenu2.superclass.close.call(this);
+ },
+
+ //overwrite the default one
+ closeSubpopup: function(){
+ if (this.currentSubpopup == null){ return; }
+
+ this.currentSubpopup.close();
+ this.currentSubpopup = null;
+
+ this.currentSubmenuTrigger.is_open = false;
+ this.currentSubmenuTrigger.closedSubmenu();
+ this.currentSubmenuTrigger = null;
+ },
+
+ // open the menu to the right of the current menu item
+ openSubmenu: function(submenu, from_item){
+ var fromPos = dojo.html.getAbsolutePosition(from_item.domNode, true);
+ var our_w = dojo.html.getMarginBox(this.domNode).width;
+ var x = fromPos.x + our_w - this.submenuOverlap;
+ var y = fromPos.y;
+
+ //the following is set in open, so we do not need it
+ //this.currentSubpopup = submenu;
+ submenu.open(x, y, this, from_item.domNode);
+
+ this.currentSubmenuTrigger = from_item;
+ this.currentSubmenuTrigger.is_open = true;
+ },
+
+ onOpen: function(e){
+ this.openEvent = e;
+ var x = e.pageX, y = e.pageY;
+
+ var win = dojo.html.getElementWindow(e.target);
+ var iframe = win.frameElement;
+ if(iframe){
+ var cood = dojo.html.getAbsolutePosition(iframe, true);
+ x += cood.x - dojo.withGlobal(win, dojo.html.getScroll).left;
+ y += cood.y - dojo.withGlobal(win, dojo.html.getScroll).top;
+ }
+ this.open(x, y, null, [x, y]);
+
+ e.preventDefault();
+ e.stopPropagation();
+ }
+});
+
+dojo.widget.defineWidget(
+ "dojo.widget.MenuItem2",
+ dojo.widget.HtmlWidget,
+ function(){
+ this.eventNames = {
+ engage: ""
+ };
+ },
+{
+ // Make 4 columns
+ // icon, label, accelerator-key, and right-arrow indicating sub-menu
+ templateString:
+ '<tr class="dojoMenuItem2" dojoAttachEvent="onMouseOver: onHover; onMouseOut: onUnhover; onClick: _onClick;">'
+ +'<td><div class="dojoMenuItem2Icon" style="${this.iconStyle}"></div></td>'
+ +'<td class="dojoMenuItem2Label"><span><span>${this.caption}</span>${this.caption}</span></td>'
+ +'<td class="dojoMenuItem2Accel"><span><span>${this.accelKey}</span>${this.accelKey}</span></td>'
+ +'<td><div class="dojoMenuItem2Submenu" style="display:${this.arrowDisplay};"></div></td>'
+ +'</tr>',
+
+ //
+ // internal settings
+ //
+
+ is_hovering: false,
+ hover_timer: null,
+ is_open: false,
+ topPosition: 0,
+
+ //
+ // options
+ //
+
+ caption: 'Untitled',
+ accelKey: '',
+ iconSrc: '',
+ submenuId: '',
+ disabled: false,
+ eventNaming: "default",
+ highlightClass: 'dojoMenuItem2Hover',
+
+ postMixInProperties: function(){
+ this.iconStyle="";
+ if (this.iconSrc){
+ if ((this.iconSrc.toLowerCase().substring(this.iconSrc.length-4) == ".png") && (dojo.render.html.ie) && (!dojo.render.html.ie70)){
+ this.iconStyle="filter: progid:DXImageTransform.Microsoft.AlphaImageLoader(src='"+this.iconSrc+"', sizingMethod='image')";
+ }else{
+ this.iconStyle="background-image: url("+this.iconSrc+")";
+ }
+ }
+ this.arrowDisplay = this.submenuId ? 'block' : 'none';
+ },
+
+ fillInTemplate: function(){
+ dojo.html.disableSelection(this.domNode);
+
+ if (this.disabled){
+ this.setDisabled(true);
+ }
+
+ if (this.eventNaming == "default") {
+ for (var eventName in this.eventNames) {
+ this.eventNames[eventName] = this.widgetId+"/"+eventName;
+ }
+ }
+ },
+
+ onHover: function(){
+ //this is to prevent some annoying behavior when both mouse and keyboard are used
+ this.onUnhover();
+
+ if (this.is_hovering){ return; }
+ if (this.is_open){ return; }
+
+ if(this.parent._highlighted_option){
+ this.parent._highlighted_option.onUnhover();
+ }
+ this.parent.closeSubpopup();
+ this.parent._highlighted_option = this;
+ dojo.widget.PopupManager.setFocusedMenu(this.parent);
+
+ this.highlightItem();
+
+ if (this.is_hovering){ this.stopSubmenuTimer(); }
+ this.is_hovering = true;
+ this.startSubmenuTimer();
+ },
+
+ onUnhover: function(){
+ if(!this.is_open){ this.unhighlightItem(); }
+
+ this.is_hovering = false;
+
+ this.parent._highlighted_option = null;
+
+ if(this.parent.parentPopup){
+ dojo.widget.PopupManager.setFocusedMenu(this.parent.parentPopup);
+ }
+
+ this.stopSubmenuTimer();
+ },
+
+ // Internal function for clicks
+ _onClick: function(focus){
+ var displayingSubMenu = false;
+ if (this.disabled){ return false; }
+
+ if (this.submenuId){
+ if (!this.is_open){
+ this.stopSubmenuTimer();
+ this.openSubmenu();
+ }
+ displayingSubMenu = true;
+ }else{
+ this.parent.closeAll();
+ }
+
+ // for some browsers the onMouseOut doesn't get called (?), so call it manually
+ if(!displayingSubMenu){ //only onUnhover when no submenu is available
+ this.onUnhover();
+ }
+
+ // user defined handler for click
+ this.onClick();
+
+ dojo.event.topic.publish(this.eventNames.engage, this);
+
+ if(displayingSubMenu && focus){
+ dojo.widget.getWidgetById(this.submenuId).highlightOption(1);
+ }
+ return;
+ },
+
+ // User defined function to handle clicks
+ // this default function call the parent
+ // menu's onItemClick
+ onClick: function() {
+ this.parent.onItemClick(this);
+ },
+
+ highlightItem: function(){
+ dojo.html.addClass(this.domNode, this.highlightClass);
+ },
+
+ unhighlightItem: function(){
+ dojo.html.removeClass(this.domNode, this.highlightClass);
+ },
+
+ startSubmenuTimer: function(){
+ this.stopSubmenuTimer();
+
+ if (this.disabled){ return; }
+
+ var self = this;
+ var closure = function(){ return function(){ self.openSubmenu(); } }();
+
+ this.hover_timer = dojo.lang.setTimeout(closure, this.parent.submenuDelay);
+ },
+
+ stopSubmenuTimer: function(){
+ if (this.hover_timer){
+ dojo.lang.clearTimeout(this.hover_timer);
+ this.hover_timer = null;
+ }
+ },
+
+ openSubmenu: function(){
+ // first close any other open submenu
+ this.parent.closeSubpopup();
+
+ var submenu = dojo.widget.getWidgetById(this.submenuId);
+ if (submenu){
+ this.parent.openSubmenu(submenu, this);
+ }
+ },
+
+ closedSubmenu: function(){
+ this.onUnhover();
+ },
+
+ setDisabled: function(value){
+ this.disabled = value;
+
+ if (this.disabled){
+ dojo.html.addClass(this.domNode, 'dojoMenuItem2Disabled');
+ }else{
+ dojo.html.removeClass(this.domNode, 'dojoMenuItem2Disabled');
+ }
+ },
+
+ enable: function(){
+ this.setDisabled(false);
+ },
+
+ disable: function(){
+ this.setDisabled(true);
+ },
+
+ menuOpen: function(message) {
+ }
+
+});
+
+dojo.widget.defineWidget(
+ "dojo.widget.MenuSeparator2",
+ dojo.widget.HtmlWidget,
+{
+ templateString: '<tr class="dojoMenuSeparator2"><td colspan=4>'
+ +'<div class="dojoMenuSeparator2Top"></div>'
+ +'<div class="dojoMenuSeparator2Bottom"></div>'
+ +'</td></tr>',
+
+ postCreate: function(){
+ dojo.html.disableSelection(this.domNode);
+ }
+});
+
+//
+// the popup manager makes sure we don't have several popups
+// open at once. the root popup in an opening sequence calls
+// opened(). when a root menu closes it calls closed(). then
+// everything works. lovely.
+//
+
+dojo.widget.PopupManager = new function(){
+
+ this.currentMenu = null;
+ this.currentButton = null; // button that opened current menu (if any)
+ this.currentFocusMenu = null; // the (sub)menu which receives key events
+ this.focusNode = null;
+ this.registeredWindows = [];
+
+ //In Opera, only onkeypress works, while in IE, only onkeydown works
+ //In Moz, both work. so use onkeydown in IE, otherwise use onkeypress
+ //for keyevents (FIXME: safari/konqueror?)
+ this._keyEventName = dojo.doc().createEvent ? "onkeypress" : "onkeydown";
+
+ this.registerWin = function(win){
+ if(!win.__PopupManagerRegistered)
+ {
+ dojo.event.connect(win.document, 'onmousedown', this, 'onClick');
+ dojo.event.connect(win, "onscroll", this, "onClick");
+ dojo.event.connect(win.document, this._keyEventName, this, 'onKeyPress');
+ win.__PopupManagerRegistered = true;
+ this.registeredWindows.push(win);
+ }
+ };
+
+ /*
+ This function register all the iframes and the top window,
+ so that whereever the user clicks in the page, the popup
+ menu will be closed
+ In case you add an iframe after onload event, please call
+ dojo.widget.PopupManager.registerWin manually
+ */
+ this.registerAllWindows = function(targetWindow){
+ //starting from window.top, clicking everywhere in this page
+ //should close popup menus
+ if(!targetWindow) targetWindow = dojo.html.getDocumentWindow(window.top.document); //see comment below
+
+ this.registerWin(targetWindow);
+
+ for (var i = 0; i < targetWindow.frames.length; i++){
+ //do not remove dojo.html.getDocumentWindow, see comment in it
+ var win = dojo.html.getDocumentWindow(targetWindow.frames[i].document);
+ if(win){
+ this.registerAllWindows(win);
+ }
+ }
+ };
+
+ dojo.addOnLoad(this, "registerAllWindows");
+
+ this.closed = function(menu){
+ if (this.currentMenu == menu){
+ this.currentMenu = null;
+ this.currentButton = null;
+ this.currentFocusMenu = null;
+ }
+ };
+
+ this.opened = function(menu, button){
+ if (menu == this.currentMenu){ return; }
+
+ if (this.currentMenu){
+ this.currentMenu.close();
+ }
+
+ this.currentMenu = menu;
+ this.currentFocusMenu = menu;
+ this.currentButton = button;
+ };
+
+ this.setFocusedMenu = function(menu){
+ this.currentFocusMenu = menu;
+ };
+
+ this.onKeyPress = function(e){
+ if(!this.currentMenu || !this.currentMenu.isShowingNow){ return; }
+
+ var m = this.currentFocusMenu;
+ while (m){
+ if(m.processKey(e)){
+ e.preventDefault();
+ e.stopPropagation();
+ break;
+ }
+ m = m.parentPopup;
+ }
+ },
+
+ this.onClick = function(e){
+ if (!this.currentMenu){ return; }
+
+ var scrolloffset = dojo.html.getScroll().offset;
+
+ // starting from the base menu, perform a hit test
+ // and exit when one succeeds
+
+ var m = this.currentMenu;
+
+ while (m){
+ if(dojo.html.overElement(m.domNode, e) || dojo.html.isDescendantOf(e.target, m.domNode)){
+ return;
+ }
+ m = m.currentSubpopup;
+ }
+
+ // Also, if user clicked the button that opened this menu, then
+ // that button will send the menu a close() command, so this code
+ // shouldn't try to close the menu. Closing twice messes up animation.
+ if (this.currentButton && dojo.html.overElement(this.currentButton, e)){
+ return;
+ }
+
+ // the click didn't fall within the open menu tree
+ // so close it
+
+ this.currentMenu.close();
+ };
+}
+
+// ************************** make contextmenu work in konqueror and opera *********************
+dojo.widget.Menu2.OperaAndKonqFixer = new function(){
+ var implement = true;
+ var delfunc = false;
+
+ /** dom event check
+ *
+ * make a event and dispatch it and se if it calls function below,
+ * if it indeed is supported and we dont need to implement our own
+ */
+
+ // gets called if we have support for oncontextmenu
+ if (!dojo.lang.isFunction(dojo.doc().oncontextmenu)){
+ dojo.doc().oncontextmenu = function(){
+ implement = false;
+ delfunc = true;
+ }
+ }
+
+ if (dojo.doc().createEvent){ // moz, safari has contextmenu event, need to do livecheck on this env.
+ try {
+ var e = dojo.doc().createEvent("MouseEvents");
+ e.initMouseEvent("contextmenu", 1, 1, dojo.global(), 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, null);
+ dojo.doc().dispatchEvent(e);
+ } catch (e) {/* assume not supported */}
+ } else {
+ // IE no need to implement custom contextmenu
+ implement = false;
+ }
+
+ // clear this one if it wasn't there before
+ if (delfunc){
+ delete dojo.doc().oncontextmenu;
+ }
+ /***** end dom event check *****/
+
+
+ /**
+ * this fixes a dom node by attaching a custom oncontextmenu function that gets called when apropriate
+ * @param node a dom node
+ *
+ * no returns
+ */
+ this.fixNode = function(node){
+ if (implement){
+ // attach stub oncontextmenu function
+ if (!dojo.lang.isFunction(node.oncontextmenu)){
+ node.oncontextmenu = function(e){/*stub*/}
+ }
+
+ // attach control function for oncontextmenu
+ if (dojo.render.html.opera){
+ // opera
+ // listen to ctrl-click events
+ node._menufixer_opera = function(e){
+ if (e.ctrlKey){
+ this.oncontextmenu(e);
+ }
+ };
+
+ dojo.event.connect(node, "onclick", node, "_menufixer_opera");
+
+ } else {
+ // konqueror
+ // rightclick, listen to mousedown events
+ node._menufixer_konq = function(e){
+ if (e.button==2 ){
+ e.preventDefault(); // need to prevent browsers menu
+ this.oncontextmenu(e);
+ }
+ };
+
+ dojo.event.connect(node, "onmousedown", node, "_menufixer_konq");
+ }
+ }
+ }
+
+ /**
+ * this cleans up a fixed node, prevent memoryleak?
+ * @param node node to clean
+ *
+ * no returns
+ */
+ this.cleanNode = function(node){
+ if (implement){
+ // checks needed if we gets a non fixed node
+ if (node._menufixer_opera){
+ dojo.event.disconnect(node, "onclick", node, "_menufixer_opera");
+ delete node._menufixer_opera;
+ } else if(node._menufixer_konq){
+ dojo.event.disconnect(node, "onmousedown", node, "_menufixer_konq");
+ delete node._menufixer_konq;
+ }
+ if (node.oncontextmenu){
+ delete node.oncontextmenu;
+ }
+ }
+ }
+};
+
+dojo.widget.defineWidget(
+ "dojo.widget.MenuBar2",
+ dojo.widget.PopupMenu2,
+{
+ menuOverlap: 2,
+
+ templateString: '<div class="dojoMenuBar2"><table class="dojoMenuBar2Client"><tr dojoAttachPoint="containerNode"></tr></table></div>',
+
+ close: function(){
+ if(this._highlighted_option){
+ this._highlighted_option.onUnhover();
+ }
+
+ this.closeSubpopup();
+ },
+
+ processKey: function(evt){
+ if(evt.ctrlKey || evt.altKey){ return false; }
+
+ var keyCode = evt.keyCode;
+ var rval = false;
+ var k = dojo.event.browser.keys;
+
+ switch(keyCode){
+ case k.KEY_DOWN_ARROW:
+ rval = this.moveToChildMenu(evt);
+ break;
+ case k.KEY_UP_ARROW:
+ rval = this.moveToParentMenu(evt);
+ break;
+ case k.KEY_RIGHT_ARROW:
+ rval = this.moveToNext(evt);
+ break;
+ case k.KEY_LEFT_ARROW:
+ rval = this.moveToPrevious(evt);
+ break;
+ default:
+ rval = this.inherited("processKey", evt);
+ break;
+ }
+
+ return rval;
+ },
+
+ postCreate: function(){
+ this.inherited("postCreate");
+ dojo.widget.PopupManager.opened(this);
+ this.isShowingNow = true;
+ },
+
+ /*
+ * override PopupMenu2 to open the submenu below us rather than to our right
+ */
+ openSubmenu: function(submenu, from_item){
+ var fromPos = dojo.html.getAbsolutePosition(from_item.domNode, true);
+ var ourPos = dojo.html.getAbsolutePosition(this.domNode, true);
+ var our_h = dojo.html.getBorderBox(this.domNode).height;
+ var x = fromPos.x;
+ var y = ourPos.y + our_h - this.menuOverlap;
+
+ submenu.open(x, y, this, from_item.domNode);
+
+ this.currentSubmenuTrigger = from_item;
+ this.currentSubmenuTrigger.is_open = true;
+ }
+});
+
+dojo.widget.defineWidget(
+ "dojo.widget.MenuBarItem2",
+ dojo.widget.MenuItem2,
+{
+ templateString:
+ '<td class="dojoMenuBarItem2" dojoAttachEvent="onMouseOver: onHover; onMouseOut: onUnhover; onClick: _onClick;">'
+ +'<span><span>${this.caption}</span>${this.caption}</span>'
+ +'</td>',
+
+ highlightClass: 'dojoMenuBarItem2Hover',
+
+ setDisabled: function(value){
+ this.disabled = value;
+ if (this.disabled){
+ dojo.html.addClass(this.domNode, 'dojoMenuBarItem2Disabled');
+ }else{
+ dojo.html.removeClass(this.domNode, 'dojoMenuBarItem2Disabled');
+ }
+ }
+});
diff --git a/source/web/scripts/ajax/src/widget/MenuItem.js b/source/web/scripts/ajax/src/widget/MenuItem.js
new file mode 100644
index 0000000000..3c26ab7ac4
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/MenuItem.js
@@ -0,0 +1,47 @@
+/*
+ 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.widget.MenuItem");
+dojo.provide("dojo.widget.DomMenuItem");
+
+dojo.deprecated("dojo.widget.MenuItem, dojo.widget.DomMenuItem", "use dojo.widget.Menu2", "0.4");
+
+dojo.require("dojo.string");
+dojo.require("dojo.widget.*");
+
+dojo.widget.tags.addParseTreeHandler("dojo:MenuItem");
+
+/* MenuItem
+ ***********/
+
+dojo.widget.MenuItem = function(){
+ dojo.widget.MenuItem.superclass.constructor.call(this);
+}
+dojo.inherits(dojo.widget.MenuItem, dojo.widget.Widget);
+
+dojo.lang.extend(dojo.widget.MenuItem, {
+ widgetType: "MenuItem",
+ isContainer: true
+});
+
+
+/* DomMenuItem
+ **************/
+dojo.widget.DomMenuItem = function(){
+ dojo.widget.DomMenuItem.superclass.constructor.call(this);
+}
+dojo.inherits(dojo.widget.DomMenuItem, dojo.widget.DomWidget);
+
+dojo.lang.extend(dojo.widget.DomMenuItem, {
+ widgetType: "MenuItem"
+});
+
+dojo.requireAfterIf("html", "dojo.html");
+dojo.requireAfterIf("html", "dojo.widget.html.MenuItem");
diff --git a/source/web/scripts/ajax/src/widget/MonthlyCalendar.js b/source/web/scripts/ajax/src/widget/MonthlyCalendar.js
new file mode 100644
index 0000000000..f493c4ebe1
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/MonthlyCalendar.js
@@ -0,0 +1,173 @@
+dojo.provide("dojo.widget.MonthlyCalendar");
+dojo.require("dojo.date");
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.DatePicker");
+dojo.require("dojo.event.*");
+dojo.require("dojo.html.*");
+dojo.require("dojo.i18n.calendar.GregorianNames");
+
+dojo.widget.defineWidget(
+ "dojo.widget.MonthlyCalendar",
+ dojo.widget.DatePicker,
+ function(){
+ this.iCalendars = [];
+ },
+{
+ dayWidth: 'wide',
+
+ templatePath: dojo.uri.dojoUri("src/widget/templates/MonthlyCalendar.html"),
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/MonthlyCalendar.css"),
+
+ cache: function() {
+ },
+
+ addCalendar: function(/* dojo.iCalendar */ cal) {
+ dojo.debug("Adding Calendar");
+ this.iCalendars.push(cal);
+ dojo.debug("Starting init");
+ this.initUI();
+ dojo.debug("done init");
+ },
+
+ createDayContents: function(node,mydate) {
+ dojo.html.removeChildren(node);
+ node.appendChild(document.createTextNode(mydate.getDate()));
+ for(var x=0; x<this.iCalendars.length; x++) {
+ var evts = this.iCalendars[x].getEvents(mydate);
+ if ((dojo.lang.isArray(evts)) && (evts.length>0)) {
+ for(var y=0;y<evts.length;y++) {
+ var el = document.createElement("div");
+ dojo.html.addClass(el, "dojoMonthlyCalendarEvent");
+ el.appendChild(document.createTextNode(evts[y].summary.value));
+ el.width = dojo.html.getContentBox(node).width;
+ node.appendChild(el);
+ }
+ }
+ }
+ },
+
+ initUI: function() {
+ var dayLabels = dojo.i18n.calendar.GregorianNames.getNames('days', this.dayWidth, 'standAlone', this.lang);
+ var dayLabelNodes = this.dayLabelsRow.getElementsByTagName("td");
+ for(var i=0; i<7; i++) {
+ dayLabelNodes.item(i).innerHTML = dayLabels[i];
+ }
+
+ this.selectedIsUsed = false;
+ this.currentIsUsed = false;
+ var currentClassName = "";
+ var previousDate = new Date();
+ var calendarNodes = this.calendarDatesContainerNode.getElementsByTagName("td");
+ var currentCalendarNode;
+ // set hours of date such that there is no chance of rounding error due to
+ // time change in local time zones
+ previousDate.setHours(8);
+ var nextDate = new Date(this.firstSaturday.year, this.firstSaturday.month, this.firstSaturday.date, 8);
+ var lastDay = new Date(this.firstSaturday.year, this.firstSaturday.month, this.firstSaturday.date + 42, 8);
+
+ if (this.iCalendars.length > 0) {
+ for (var x=0; x<this.iCalendars.length;x++) {
+ this.iCalendars[x].preComputeRecurringEvents(lastDay);
+ }
+ }
+
+ if(this.firstSaturday.date < 7) {
+ // this means there are days to show from the previous month
+ var dayInWeek = 6;
+ for (var i=this.firstSaturday.date; i>0; i--) {
+ currentCalendarNode = calendarNodes.item(dayInWeek);
+ this.createDayContents(currentCalendarNode, nextDate);
+
+ dojo.html.setClass(currentCalendarNode, this.getDateClassName(nextDate, "current"));
+ dayInWeek--;
+ previousDate = nextDate;
+ nextDate = this.incrementDate(nextDate, false);
+ }
+ for(var i=dayInWeek; i>-1; i--) {
+ currentCalendarNode = calendarNodes.item(i);
+
+ this.createDayContents(currentCalendarNode, nextDate);
+
+ dojo.html.setClass(currentCalendarNode, this.getDateClassName(nextDate, "previous"));
+ previousDate = nextDate;
+ nextDate = this.incrementDate(nextDate, false);
+ }
+ } else {
+ nextDate.setDate(1);
+ for(var i=0; i<7; i++) {
+ currentCalendarNode = calendarNodes.item(i);
+ this.createDayContents(currentCalendarNode, nextDate);
+ dojo.html.setClass(currentCalendarNode, this.getDateClassName(nextDate, "current"));
+ previousDate = nextDate;
+ nextDate = this.incrementDate(nextDate, true);
+ }
+ }
+ previousDate.setDate(this.firstSaturday.date);
+ previousDate.setMonth(this.firstSaturday.month);
+ previousDate.setFullYear(this.firstSaturday.year);
+ nextDate = this.incrementDate(previousDate, true);
+ var count = 7;
+ currentCalendarNode = calendarNodes.item(count);
+ while((nextDate.getMonth() == previousDate.getMonth()) && (count<42)) {
+ this.createDayContents(currentCalendarNode, nextDate);
+ dojo.html.setClass(currentCalendarNode, this.getDateClassName(nextDate, "current"));
+ currentCalendarNode = calendarNodes.item(++count);
+ previousDate = nextDate;
+ nextDate = this.incrementDate(nextDate, true);
+ }
+
+ while(count < 42) {
+ this.createDayContents(currentCalendarNode, nextDate);
+ dojo.html.setClass(currentCalendarNode, this.getDateClassName(nextDate, "next"));
+ currentCalendarNode = calendarNodes.item(++count);
+ previousDate = nextDate;
+ nextDate = this.incrementDate(nextDate, true);
+ }
+ this.setMonthLabel(this.firstSaturday.month);
+ this.setYearLabels(this.firstSaturday.year);
+ }
+});
+
+dojo.widget.MonthlyCalendar.util= new function() {
+// this.months = dojo.date.months;
+// this.weekdays = dojo.date.days;
+
+ this.toRfcDate = function(jsDate) {
+ if(!jsDate) {
+ jsDate = this.today;
+ }
+ var year = jsDate.getFullYear();
+ var month = jsDate.getMonth() + 1;
+ if (month < 10) {
+ month = "0" + month.toString();
+ }
+ var date = jsDate.getDate();
+ if (date < 10) {
+ date = "0" + date.toString();
+ }
+ // because this is a date picker and not a time picker, we treat time
+ // as zero
+ return year + "-" + month + "-" + date + "T00:00:00+00:00";
+ }
+
+ this.fromRfcDate = function(rfcDate) {
+ var tempDate = rfcDate.split("-");
+ if(tempDate.length < 3) {
+ return new Date();
+ }
+ // fullYear, month, date
+ return new Date(parseInt(tempDate[0]), (parseInt(tempDate[1], 10) - 1), parseInt(tempDate[2].substr(0,2), 10));
+ }
+
+//Note: redundant with dojo.widget.DatePicker.util
+ this.initFirstSaturday = function(month, year) {
+ if(!month) {
+ month = this.date.getMonth();
+ }
+ if(!year) {
+ year = this.date.getFullYear();
+ }
+ var firstOfMonth = new Date(year, month, 1);
+ return {year: year, month: month, date: 7 - firstOfMonth.getDay()};
+ }
+}
diff --git a/source/web/scripts/ajax/src/widget/Parse.js b/source/web/scripts/ajax/src/widget/Parse.js
new file mode 100644
index 0000000000..15c1a3d55c
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/Parse.js
@@ -0,0 +1,355 @@
+dojo.provide("dojo.widget.Parse");
+
+dojo.require("dojo.widget.Manager");
+dojo.require("dojo.dom");
+dojo.require("dojo.namespace");
+
+dojo.widget.Parse = function(fragment){
+ this.propertySetsList = [];
+ this.fragment = fragment;
+
+ this.createComponents = function(frag, parentComp){
+ var comps = [];
+ var built = false;
+ // if we have items to parse/create at this level, do it!
+ try{
+ if((frag)&&(frag["tagName"])&&(frag!=frag["nodeRef"])){
+ var djTags = dojo.widget.tags;
+ // we split so that you can declare multiple
+ // non-destructive widgets from the same ctor node
+ var tna = String(frag["tagName"]).split(";");
+ for(var x=0; x<tna.length; x++){
+ var ltn = (tna[x].replace(/^\s+|\s+$/g, "")).toLowerCase();
+ var pos = ltn.indexOf(":");
+ var nsName = (pos > 0) ? ltn.substring(0,pos) : null;
+ //if we don't already have a tag registered for this widget, try to load it's
+ //namespace, if it has one
+ if(!djTags[ltn] && dojo.getNamespace && dojo.lang.isString(ltn) && pos>0){
+ var ns = dojo.getNamespace(nsName);
+ var tagName = ltn.substring(pos+1,ltn.length);
+ var domain = null;
+ var dojoDomain = frag[ltn]["dojoDomain"] || frag[ltn]["dojodomain"];
+ if(dojoDomain){
+ domain = dojoDomain[0].value;
+ }
+ if(ns){
+ ns.load(tagName, domain);
+ }
+
+ }
+
+ if(!djTags[ltn]){
+ dojo.deprecated('dojo.widget.Parse.createComponents', 'Widget not defined for namespace'+nsName+
+ ', so searching all namespaces. Developers should specify namespaces for all non-Dojo widgets', "0.5");
+
+ var newNs = dojo.findNamespaceForWidget(tagName);
+ if(newNs){
+ ltn = newNs.nsPrefix + ":" + (ltn.indexOf(":")> 0 ? ltn.substring(ltn.indexOf(":")+1) : ltn);
+ }
+ }
+
+ if(djTags[ltn]){
+ built = true;
+ frag.tagName = ltn;
+ var ret = djTags[ltn](frag, this, parentComp, frag["index"]);
+ comps.push(ret);
+ }else{
+ if(dojo.lang.isString(ltn) && nsName && dojo._namespaces[nsName]){
+ dojo.debug("no tag handler registered for type: ", ltn);
+ }
+ }
+ }
+ }
+ }catch(e){
+ dojo.debug("dojo.widget.Parse: error:", e);
+ // throw e;
+ // IE is such a bitch sometimes
+ }
+ // if there's a sub-frag, build widgets from that too
+ if(!built){
+ comps = comps.concat(this.createSubComponents(frag, parentComp));
+ }
+ return comps;
+ }
+
+ /* createSubComponents recurses over a raw JavaScript object structure,
+ and calls the corresponding handler for its normalized tagName if it exists
+ */
+ this.createSubComponents = function(fragment, parentComp){
+ var frag, comps = [];
+ for(var item in fragment){
+ frag = fragment[item];
+ if ((frag)&&(typeof frag == "object")&&(frag!=fragment.nodeRef)&&(frag!=fragment["tagName"])){
+ comps = comps.concat(this.createComponents(frag, parentComp));
+ }
+ }
+ return comps;
+ }
+
+ /* parsePropertySets checks the top level of a raw JavaScript object
+ structure for any propertySets. It stores an array of references to
+ propertySets that it finds.
+ */
+ this.parsePropertySets = function(fragment){
+ return [];
+ var propertySets = [];
+ for(var item in fragment){
+ if((fragment[item]["tagName"] == "dojo:propertyset")){
+ propertySets.push(fragment[item]);
+ }
+ }
+ // FIXME: should we store these propertySets somewhere for later retrieval
+ this.propertySetsList.push(propertySets);
+ return propertySets;
+ }
+
+ /* parseProperties checks a raw JavaScript object structure for
+ properties, and returns an array of properties that it finds.
+ */
+ this.parseProperties = function(fragment){
+ var properties = {};
+ for(var item in fragment){
+ // FIXME: need to check for undefined?
+ // case: its a tagName or nodeRef
+ if((fragment[item] == fragment["tagName"])||
+ (fragment[item] == fragment.nodeRef)){
+ // do nothing
+ }else{
+ if((fragment[item]["tagName"])&&
+ (dojo.widget.tags[fragment[item].tagName.toLowerCase()])){
+ // TODO: it isn't a property or property set, it's a fragment,
+ // so do something else
+ // FIXME: needs to be a better/stricter check
+ // TODO: handle xlink:href for external property sets
+ }else if((fragment[item][0])&&(fragment[item][0].value!="")&&(fragment[item][0].value!=null)){
+ try{
+ // FIXME: need to allow more than one provider
+ if(item.toLowerCase() == "dataprovider") {
+ var _this = this;
+ this.getDataProvider(_this, fragment[item][0].value);
+ properties.dataProvider = this.dataProvider;
+ }
+ properties[item] = fragment[item][0].value;
+ var nestedProperties = this.parseProperties(fragment[item]);
+ // FIXME: this kind of copying is expensive and inefficient!
+ for(var property in nestedProperties){
+ properties[property] = nestedProperties[property];
+ }
+ }catch(e){ dojo.debug(e); }
+ }
+ }
+ }
+ return properties;
+ }
+
+ /* getPropertySetById returns the propertySet that matches the provided id
+ */
+
+ this.getDataProvider = function(objRef, dataUrl){
+ // FIXME: this is currently sync. To make this async, we made need to move
+ //this step into the widget ctor, so that it is loaded when it is needed
+ // to populate the widget
+ dojo.io.bind({
+ url: dataUrl,
+ load: function(type, evaldObj){
+ if(type=="load"){
+ objRef.dataProvider = evaldObj;
+ }
+ },
+ mimetype: "text/javascript",
+ sync: true
+ });
+ }
+
+
+ this.getPropertySetById = function(propertySetId){
+ for(var x = 0; x < this.propertySetsList.length; x++){
+ if(propertySetId == this.propertySetsList[x]["id"][0].value){
+ return this.propertySetsList[x];
+ }
+ }
+ return "";
+ }
+
+ /* getPropertySetsByType returns the propertySet(s) that match(es) the
+ * provided componentClass
+ */
+ this.getPropertySetsByType = function(componentType){
+ var propertySets = [];
+ for(var x=0; x < this.propertySetsList.length; x++){
+ var cpl = this.propertySetsList[x];
+ var cpcc = cpl["componentClass"]||cpl["componentType"]||null;
+ var propertySetId = this.propertySetsList[x]["id"][0].value;
+ if((cpcc)&&(propertySetId == cpcc[0].value)){
+ propertySets.push(cpl);
+ }
+ }
+ return propertySets;
+ }
+
+ /* getPropertySets returns the propertySet for a given component fragment
+ */
+ this.getPropertySets = function(fragment){
+ var ppl = "dojo:propertyproviderlist";
+ var propertySets = [];
+ var tagname = fragment["tagName"];
+ if(fragment[ppl]){
+ var propertyProviderIds = fragment[ppl].value.split(" ");
+ // FIXME: should the propertyProviderList attribute contain #
+ // syntax for reference to ids or not?
+ // FIXME: need a better test to see if this is local or external
+ // FIXME: doesn't handle nested propertySets, or propertySets that
+ // just contain information about css documents, etc.
+ for(var propertySetId in propertyProviderIds){
+ if((propertySetId.indexOf("..")==-1)&&(propertySetId.indexOf("://")==-1)){
+ // get a reference to a propertySet within the current parsed structure
+ var propertySet = this.getPropertySetById(propertySetId);
+ if(propertySet != ""){
+ propertySets.push(propertySet);
+ }
+ }else{
+ // FIXME: add code to parse and return a propertySet from
+ // another document
+ // alex: is this even necessaray? Do we care? If so, why?
+ }
+ }
+ }
+ // we put the typed ones first so that the parsed ones override when
+ // iteration happens.
+ return (this.getPropertySetsByType(tagname)).concat(propertySets);
+ }
+
+ /*
+ nodeRef is the node to be replaced... in the future, we might want to add
+ an alternative way to specify an insertion point
+
+ componentName is the expected dojo widget name, i.e. Button of ContextMenu
+
+ properties is an object of name value pairs
+ namespace is the namespace of the widget. Defaults to "dojo"
+ */
+ this.createComponentFromScript = function(nodeRef, componentName, properties, namespace){
+ if(!namespace){ namespace = "dojo"; }
+ var ltn = namespace + ":" + componentName.toLowerCase();
+
+ var djTags = dojo.widget.tags;
+ //if we don't already have a tag registered for this widget, try to load it's
+ //namespace, if it has one
+ if(!djTags[ltn] && dojo.getNamespace && dojo.lang.isString(ltn)){
+ var ns = dojo.getNamespace(namespace);
+ if(ns){ns.load(componentName);}
+ }
+
+ if(!djTags[ltn]){
+ dojo.deprecated('dojo.widget.Parse.createComponentFromScript', 'Widget not defined for namespace'+
+ namespace +
+ ', so searching all namespaces. Developers should specify namespaces for all non-Dojo widgets', "0.5");
+
+ var newNs = dojo.findNamespaceForWidget(componentName.toLowerCase());
+ if(newNs){
+ var newLtn = newNs.nsPrefix + ":"+(ltn.indexOf(":")> 0 ? ltn.substring(ltn.indexOf(":")+1) : ltn);
+ properties[newLtn]=properties[ltn];
+ properties.namespace = newNs.nsPrefix;
+ ltn = newLtn;
+ }
+ }
+
+ if(djTags[ltn]){
+ properties.fastMixIn = true;
+ //dojo.profile.start("dojo.widget.tags - "+ltn);
+ //var ret = [dojo.widget.tags[ltn](properties, this, null, null, properties)];
+ var ret = [dojo.widget.buildWidgetFromParseTree(ltn, properties, this, null, null, properties)];
+ //dojo.profile.end("dojo.widget.tags - "+ltn);
+ return ret;
+ }else{
+ dojo.debug("no tag handler registered for type: ", ltn);
+ }
+
+ }
+}
+
+
+dojo.widget._parser_collection = {"dojo": new dojo.widget.Parse() };
+dojo.widget.getParser = function(name){
+ if(!name){ name = "dojo"; }
+ if(!this._parser_collection[name]){
+ this._parser_collection[name] = new dojo.widget.Parse();
+ }
+ return this._parser_collection[name];
+}
+
+/**
+ * Creates widget.
+ *
+ * @param name The name of the widget to create with optional namespace prefix,
+ * e.g."ns:widget", namespace defaults to "dojo".
+ * @param props Key-Value pairs of properties of the widget
+ * @param refNode If the position argument is specified, this node is used as
+ * a reference for inserting this node into a DOM tree; else
+ * the widget becomes the domNode
+ * @param position The position to insert this widget's node relative to the
+ * refNode argument
+ * @return The new Widget object
+ */
+
+dojo.widget.createWidget = function(name, props, refNode, position){
+
+ var isNode = false;
+ var isNameStr = (typeof name == "string");
+ if(isNameStr){
+ var pos = name.indexOf(":");
+ var namespace = (pos > -1) ? name.substring(0,pos) : "dojo";
+ if(pos > -1){ name = name.substring(pos+1); }
+ var lowerCaseName = name.toLowerCase();
+ var namespacedName = namespace+":" + lowerCaseName;
+ isNode = ( dojo.byId(name) && (!dojo.widget.tags[namespacedName]) );
+ }
+
+ if( (arguments.length == 1) && ((isNode)||(!isNameStr)) ){
+ // we got a DOM node
+ var xp = new dojo.xml.Parse();
+ // FIXME: we should try to find the parent!
+ var tn = (isNode) ? dojo.byId(name) : name;
+ return dojo.widget.getParser().createComponents(xp.parseElement(tn, null, true))[0];
+ }
+
+ function fromScript(placeKeeperNode, name, props, namespace){
+ props[namespacedName] = {
+ dojotype: [{value: lowerCaseName}],
+ nodeRef: placeKeeperNode,
+ fastMixIn: true
+ };
+ props.namespace = namespace;
+ return dojo.widget.getParser().createComponentFromScript(
+ placeKeeperNode, name, props, namespace);
+ }
+
+ props = props||{};
+ var notRef = false;
+ var tn = null;
+ var h = dojo.render.html.capable;
+ if(h){
+ tn = document.createElement("span");
+ }
+ if(!refNode){
+ notRef = true;
+ refNode = tn;
+ if(h){
+ dojo.body().appendChild(refNode);
+ }
+ }else if(position){
+ dojo.dom.insertAtPosition(tn, refNode, position);
+ }else{ // otherwise don't replace, but build in-place
+ tn = refNode;
+ }
+ var widgetArray = fromScript(tn, name.toLowerCase(), props, namespace);
+ if (!widgetArray || !widgetArray[0] || typeof widgetArray[0].widgetType == "undefined") {
+ throw new Error("createWidget: Creation of \"" + name + "\" widget failed.");
+ }
+ if (notRef) {
+ if (widgetArray[0].domNode.parentNode) {
+ widgetArray[0].domNode.parentNode.removeChild(widgetArray[0].domNode);
+ }
+ }
+ return widgetArray[0]; // just return the widget
+}
diff --git a/source/web/scripts/ajax/src/widget/PopUpButton.js b/source/web/scripts/ajax/src/widget/PopUpButton.js
new file mode 100644
index 0000000000..fddbad81af
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/PopUpButton.js
@@ -0,0 +1,192 @@
+/*
+ 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.widget.PopUpButton");
+dojo.provide("dojo.widget.DomPopUpButton");
+dojo.provide("dojo.widget.HtmlPopUpButton");
+
+dojo.deprecated("dojo.widget.PopUpButton, dojo.widget.DomPopUpButton, dojo.widget.HtmlPopUpButton", "use dojo.widget.DropDownButton", "0.4");
+
+//dojo.require("dojo.widget.Button");
+//dojo.require("dojo.widget.HtmlButton");
+
+dojo.require("dojo.widget.Menu");
+dojo.require("dojo.widget.MenuItem");
+
+dojo.require("dojo.html");
+
+dojo.widget.tags.addParseTreeHandler("dojo:PopUpButton");
+
+/* PopUpButton
+ **************/
+
+dojo.widget.PopUpButton = function () {
+ dojo.widget.PopUpButton.superclass.constructor.call(this);
+}
+dojo.inherits(dojo.widget.PopUpButton, dojo.widget.Widget);
+
+dojo.lang.extend(dojo.widget.PopUpButton, {
+ widgetType: "PopUpButton",
+
+ label: ""
+});
+
+
+/* DomPopUpButton
+ *****************/
+dojo.widget.DomPopUpButton = function(){
+ dojo.widget.DomPopUpButton.superclass.constructor.call(this);
+}
+dojo.inherits(dojo.widget.DomPopUpButton, dojo.widget.DomWidget);
+
+dojo.lang.extend(dojo.widget.DomPopUpButton, {
+ widgetType: dojo.widget.PopUpButton.prototype.widgetType
+});
+
+
+/* HtmlPopUpButton
+ ******************/
+
+dojo.widget.HtmlPopUpButton = function () {
+ dojo.widget.HtmlPopUpButton.superclass.constructor.call(this);
+}
+dojo.inherits(dojo.widget.HtmlPopUpButton, dojo.widget.HtmlWidget);
+
+dojo.lang.extend(dojo.widget.HtmlPopUpButton, {
+ widgetType: dojo.widget.PopUpButton.prototype.widgetType,
+ templateString: null,
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/PopUpButton.css"),
+
+ buildRendering: function (args, frag) {
+ dojo.style.insertCssFile(this.templateCssPath, null, true);
+
+ this.domNode = document.createElement("a");
+ this.domNode.className = "PopUpButton";
+ dojo.event.connect(this.domNode, "onmousedown", this, "onMouseDown");
+
+ // draw the arrow
+ var arrow = document.createElement("img");
+ arrow.src = dojo.uri.dojoUri("src/widget/templates/images/dropdownButtonsArrow.gif");
+ dojo.html.setClass(arrow, "downArrow");
+ this.domNode.appendChild(arrow);
+
+ this.menu = dojo.widget.fromScript("Menu");
+ dojo.html.addClass(this.menu.domNode, "PopUpButtonMenu");
+ dojo.event.connect(this.menu, "onSelect", this, "onSelect");
+
+ if (frag["dojo:" + this.widgetType.toLowerCase()].nodeRef) {
+ var node = frag["dojo:" + this.widgetType.toLowerCase()].nodeRef;
+ var options = node.getElementsByTagName("option");
+ for (var i = 0; i < options.length; i++) {
+ var properties = {
+ title: dojo.dom.textContent(options[i]),
+ value: options[i].value
+ }
+ this.addItem(dojo.widget.fromScript("MenuItem", properties));
+ }
+ }
+ },
+
+ addItem: function (item) {
+ // TODO: should be dojo.widget.MenuItem
+ if (item instanceof dojo.widget.html.MenuItem) {
+ this.menu.push(item);
+ } else {
+ // TODO: create one
+ var menuItem = dojo.widget.fromScript("MenuItem", {title: item});
+ this.menu.push(menuItem);
+ }
+ },
+
+
+/* Enabled utility methods
+ **************************/
+
+ _enabled: true,
+
+ isEnabled: function() { return this._enabled; },
+
+ setEnabled: function(enabled, force, preventEvent) {
+ enabled = Boolean(enabled);
+ if (force || this._enabled != enabled) {
+ this._enabled = enabled;
+ if (!preventEvent) {
+ this._fireEvent(this._enabled ? "onEnable" : "onDisable");
+ this._fireEvent("onChangeEnabled");
+ }
+ }
+
+ dojo.html[(this._enabled ? "add" : "remove")
+ + "Class"](this.domNode, "disabled");
+
+ return this._enabled;
+ },
+
+ enable: function(force, preventEvent) {
+ return this.setEnabled(true, force, preventEvent);
+ },
+
+ disable: function(force, preventEvent) {
+ return this.setEnabled(false, force, preventEvent);
+ },
+
+ toggleEnabled: function(force, preventEvent) {
+ return this.setEnabled(!this._enabled, force, preventEvent);
+ },
+
+
+/* Select utility methods
+ **************************/
+
+ onSelect: function (item, e) {
+ this.domNode.firstChild.nodeValue = item.title;
+ },
+
+ onMouseDown: function (e) {
+ if (!this._menuVisible) {
+ this._showMenu(e);
+ dojo.lang.setTimeout(dojo.event.connect, 1, document, "onmousedown", this, "_hideMenu");
+ }
+ },
+
+
+ _fireEvent: function(evt) {
+ if(typeof this[evt] == "function") {
+ var args = [this];
+ for(var i = 1; i < arguments.length; i++) {
+ args.push(arguments[i]);
+ }
+ this[evt].apply(this, args);
+ }
+ },
+
+
+ _showMenu: function (e) {
+ if (!this._enabled) { return; }
+ this._menuVisible = true;
+ with (dojo.html) {
+ var y = getAbsoluteY(this.domNode) + getInnerHeight(this.domNode);
+ var x = getAbsoluteX(this.domNode);
+ }
+
+ document.body.appendChild(this.menu.domNode);
+ with (this.menu.domNode.style) {
+ top = y + "px";
+ left = x + "px";
+ }
+ },
+
+ _hideMenu: function (e) {
+ this.menu.domNode.parentNode.removeChild(this.menu.domNode);
+ dojo.event.disconnect(document, "onmousedown", this, "_hideMenu");
+ this._menuVisible = false;
+ }
+
+});
diff --git a/source/web/scripts/ajax/src/widget/RemoteTabController.js b/source/web/scripts/ajax/src/widget/RemoteTabController.js
new file mode 100644
index 0000000000..c95c718f62
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/RemoteTabController.js
@@ -0,0 +1,171 @@
+dojo.provide("dojo.widget.RemoteTabController");
+
+//Summary
+//Remote Tab Controller widget. Can be located independently of a tab
+//container and control the selection of its tabs
+dojo.require("dojo.widget.*");
+dojo.require("dojo.event.*");
+
+dojo.widget.defineWidget(
+ "dojo.widget.RemoteTabController",
+ dojo.widget.HtmlWidget,
+ function() {
+ //summary
+ //Initialize Remote Tab Controller
+ // for passing in as a parameter
+ this.tabContainer = "";
+
+ // the reference to the tab container
+ this._tabContainer={};
+
+ //hash of tabs
+ this.tabs = {};
+
+ this.selectedTab="";
+
+ //override these classes to change the style
+ this["class"]="dojoRemoteTabController"; // alt syntax: "class" is a reserved word in JS
+ this.labelClass="dojoRemoteTab";
+ this.imageClass="dojoRemoteTabClose";
+ this.imageHoverClass="dojoRemoteTabCloseHover";
+ },
+ {
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/RemoteTabControl.css"),
+ templateString: '<div dojoAttachPoint="domNode" wairole="tablist"></div>',
+
+ postCreate: function() {
+ dojo.html.addClass(this.domNode, this["class"]); // "class" is a reserved word in JS
+ dojo.widget.wai.setAttr(this.domNode, "waiRole", "role", "tablist");
+
+ if (this.tabContainer) {
+ dojo.addOnLoad(dojo.lang.hitch(this, function() {
+ this.setTabContainer(dojo.widget.byId(this.tabContainer));
+ }));
+ }
+ },
+
+ setTabContainer: function(/* dojo.widget.TabContainer */ tabContainer) {
+ //summary
+ //Connect this Remote Tab Controller to an existing TabContainer
+ this._tabContainer = tabContainer;
+ this.setupTabs();
+
+ dojo.event.connect(this._tabContainer, "addChild", this, "setupTabs");
+ dojo.event.connect(this._tabContainer, "selectTab", this, "onTabSelected");
+ },
+
+ setupTabs: function() {
+ //summary
+ //Setup tab buttons for each of the TabContainers tabs
+
+ dojo.html.removeChildren(this.domNode);
+ dojo.lang.forEach(this._tabContainer.children, this.addTab, this);
+ },
+
+ onTabSelected: function(/* dojo.widget.TabPane */tab) {
+ //summary
+ //Do this when a tab gets selected
+ if (this.selectedTab.tab != tab.widgetId) {
+ dojo.html.removeClass(this.selectedTab.button, "current");
+ }
+
+ this.selectedTab = this.tabs[tab.widgetId];
+ dojo.html.addClass(this.selectedTab.button,"current");
+
+ },
+
+ addTab: function(/* dojo.widget.TabPane */tab) {
+ //summary
+ //Add a new button
+
+ // Create label
+ div = document.createElement("div");
+ dojo.html.addClass(div, this.labelClass);
+ var innerDiv = document.createElement("div");
+
+ // need inner span so focus rectangle is drawn properly
+ var titleSpan = document.createElement("span");
+ titleSpan.innerHTML = tab.label;
+ titleSpan.tabIndex="-1";
+
+ // set role on tab title
+ dojo.widget.wai.setAttr(titleSpan, "waiRole", "role", "tab");
+ innerDiv.appendChild(titleSpan);
+ dojo.html.disableSelection(titleSpan);
+
+ if(this._tabContainer.closeButton=="tab" || tab.tabCloseButton){
+ var img = document.createElement("span");
+ dojo.html.addClass(img, this.imageClass);
+ dojo.event.connect(img, "onclick", dojo.lang.hitch(this, function(evt){
+ this._runOnCloseTab(tab); dojo.event.browser.stopEvent(evt);
+ }));
+ dojo.event.connect(img, "onmouseover", dojo.lang.hitch(this, function(){
+ dojo.html.addClass(img, this.imageHoverClass);
+ }));
+ dojo.event.connect(img, "onmouseout", dojo.lang.hitch(this, function(){
+ dojo.html.removeClass(img, this.imageHoverClass);
+ }));
+ innerDiv.appendChild(img);
+ }
+
+ // connect to _runOnCloseTab in case the tab pane or
+ // another remote controller closes a tab
+ if(this._tabContainer.closeButton=="tab" || this._tabContainer.closeButton=="pane"){
+ dojo.event.connect(this._tabContainer, "_runOnCloseTab", dojo.lang.hitch(this, function(t){
+ this._runOnRemoteClose(t);
+ }));
+ }
+
+ div.appendChild(innerDiv);
+ div.tabTitle=titleSpan;
+ this.domNode.appendChild(div);
+
+ var tabObj = {"tab": tab, "button": div};
+
+ if (this._tabContainer.selectedTab == tab.widgetId || tab.selected) {
+ this.selectedTab = tabObj;
+ dojo.html.addClass(div, "current");
+ }
+
+ this.tabs[tab.widgetId] = tabObj;
+
+ dojo.event.connect(div, "onclick", dojo.lang.hitch(this._tabContainer, function() {
+ this.selectTab(tab);
+ }));
+
+ dojo.event.connect(div, "onkeydown", dojo.lang.hitch(this._tabContainer, function(evt) {
+ this.tabNavigation(evt, tab);
+ }));
+ },
+
+ _runOnCloseTab: function(tab){
+ var tabObj = this.tabs[tab.widgetId];
+ this.removeChild(tabObj);
+ this._tabContainer._runOnCloseTab(tab);
+ },
+
+ _runOnRemoteClose: function(tab){
+ var tabObj = this.tabs[tab.widgetId];
+ if(!tabObj.button){ return; }
+ this.removeChild(tabObj);
+ },
+
+ removeChild: function(tab){
+ // remove tab event handlers
+ dojo.event.disconnect(tab.button, "onclick", function(){ });
+ if(this._tabContainer.closeButton == "tab"){
+ var img = tab.button.lastChild.lastChild;
+ if(img){
+ dojo.html.removeClass(img, this.imageClass);
+ }
+ }
+
+ dojo.widget.RemoteTabController.superclass.removeChild.call(this, tab);
+
+ if(tab.domNode) { dojo.html.removeClass(tab.domNode, this.labelClass); }
+ this.domNode.removeChild(tab.button);
+ delete(tab.button);
+ }
+ },
+ "html"
+);
diff --git a/source/web/scripts/ajax/src/widget/ResizableTextarea.js b/source/web/scripts/ajax/src/widget/ResizableTextarea.js
new file mode 100644
index 0000000000..746df39e61
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/ResizableTextarea.js
@@ -0,0 +1,92 @@
+dojo.provide("dojo.widget.ResizableTextarea");
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.LayoutContainer");
+dojo.require("dojo.widget.ResizeHandle");
+
+dojo.widget.defineWidget(
+ "dojo.widget.ResizableTextarea",
+ dojo.widget.HtmlWidget,
+{
+ templatePath: dojo.uri.dojoUri("src/widget/templates/ResizableTextarea.html"),
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/ResizableTextarea.css"),
+ isContainer: false,
+ textAreaNode: null,
+ textAreaContainer: null,
+ textAreaContainerNode: null,
+ statusBar: null,
+ statusBarContainerNode: null,
+ statusLabelNode: null,
+ statusLabel: null,
+ rootLayoutNode: null,
+ resizeHandleNode: null,
+ resizeHandle: null,
+
+ fillInTemplate: function(args, frag){
+ this.textAreaNode = this.getFragNodeRef(frag).cloneNode(true);
+
+ // FIXME: Safari apparently needs this!
+ dojo.body().appendChild(this.domNode);
+
+ this.rootLayout = dojo.widget.createWidget(
+ "LayoutContainer",
+ {
+ minHeight: 50,
+ minWidth: 100
+ },
+ this.rootLayoutNode
+ );
+
+
+ this.textAreaContainer = dojo.widget.createWidget(
+ "LayoutContainer",
+ { layoutAlign: "client" },
+ this.textAreaContainerNode
+ );
+ this.rootLayout.addChild(this.textAreaContainer);
+
+ this.textAreaContainer.domNode.appendChild(this.textAreaNode);
+ with(this.textAreaNode.style){
+ width="100%";
+ height="100%";
+ }
+
+ this.statusBar = dojo.widget.createWidget(
+ "LayoutContainer",
+ {
+ layoutAlign: "bottom",
+ minHeight: 28
+ },
+ this.statusBarContainerNode
+ );
+ this.rootLayout.addChild(this.statusBar);
+
+ this.statusLabel = dojo.widget.createWidget(
+ "LayoutContainer",
+ {
+ layoutAlign: "client",
+ minWidth: 50
+ },
+ this.statusLabelNode
+ );
+ this.statusBar.addChild(this.statusLabel);
+
+ this.resizeHandle = dojo.widget.createWidget(
+ "ResizeHandle",
+ { targetElmId: this.rootLayout.widgetId },
+ this.resizeHandleNode
+ );
+ this.statusBar.addChild(this.resizeHandle);
+ // dojo.debug(this.rootLayout.widgetId);
+
+ // dojo.event.connect(this.resizeHandle, "beginSizing", this, "hideContent");
+ // dojo.event.connect(this.resizeHandle, "endSizing", this, "showContent");
+ },
+
+ hideContent: function(){
+ this.textAreaNode.style.display = "none";
+ },
+
+ showContent: function(){
+ this.textAreaNode.style.display = "";
+ }
+});
diff --git a/source/web/scripts/ajax/src/widget/ResizeHandle.js b/source/web/scripts/ajax/src/widget/ResizeHandle.js
new file mode 100644
index 0000000000..23764aace4
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/ResizeHandle.js
@@ -0,0 +1,93 @@
+dojo.provide("dojo.widget.ResizeHandle");
+
+dojo.require("dojo.widget.*");
+dojo.require("dojo.html.layout");
+dojo.require("dojo.event");
+
+dojo.widget.defineWidget(
+ "dojo.widget.ResizeHandle",
+ dojo.widget.HtmlWidget,
+{
+ isSizing: false,
+ startPoint: null,
+ startSize: null,
+ minSize: null,
+
+ targetElmId: '',
+
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/ResizeHandle.css"),
+ templateString: '<div class="dojoHtmlResizeHandle"><div></div></div>',
+
+ postCreate: function(){
+ dojo.event.connect(this.domNode, "onmousedown", this, "beginSizing");
+ },
+
+ beginSizing: function(e){
+ if (this.isSizing){ return false; }
+
+ // get the target dom node to adjust. targetElmId can refer to either a widget or a simple node
+ this.targetWidget = dojo.widget.byId(this.targetElmId);
+ this.targetDomNode = this.targetWidget ? this.targetWidget.domNode : dojo.byId(this.targetElmId);
+ if (!this.targetDomNode){ return; }
+
+ this.isSizing = true;
+ this.startPoint = {'x':e.clientX, 'y':e.clientY};
+ var mb = dojo.html.getMarginBox(this.targetDomNode);
+ this.startSize = {'w':mb.width, 'h':mb.height};
+
+ dojo.event.kwConnect({
+ srcObj: dojo.body(),
+ srcFunc: "onmousemove",
+ targetObj: this,
+ targetFunc: "changeSizing",
+ rate: 25
+ });
+ dojo.event.connect(dojo.body(), "onmouseup", this, "endSizing");
+
+ e.preventDefault();
+ },
+
+ changeSizing: function(e){
+ // On IE, if you move the mouse above/to the left of the object being resized,
+ // sometimes clientX/Y aren't set, apparently. Just ignore the event.
+ try{
+ if(!e.clientX || !e.clientY){ return; }
+ }catch(e){
+ // sometimes you get an exception accessing above fields...
+ return;
+ }
+ var dx = this.startPoint.x - e.clientX;
+ var dy = this.startPoint.y - e.clientY;
+
+ var newW = this.startSize.w - dx;
+ var newH = this.startSize.h - dy;
+
+ // minimum size check
+ if (this.minSize) {
+ var mb = dojo.html.getMarginBox(this.targetDomNode);
+ if (newW < this.minSize.w) {
+ newW = mb.width;
+ }
+ if (newH < this.minSize.h) {
+ newH = mb.height;
+ }
+ }
+
+ if(this.targetWidget){
+ this.targetWidget.resizeTo(newW, newH);
+ }else{
+ dojo.html.setMarginBox(this.targetDomNode, { width: newW, height: newH});
+ }
+
+ e.preventDefault();
+ },
+
+ endSizing: function(e){
+ dojo.event.disconnect(dojo.body(), "onmousemove", this, "changeSizing");
+ dojo.event.disconnect(dojo.body(), "onmouseup", this, "endSizing");
+
+ this.isSizing = false;
+ }
+
+
+});
diff --git a/source/web/scripts/ajax/src/widget/RichText.js b/source/web/scripts/ajax/src/widget/RichText.js
new file mode 100644
index 0000000000..924bd9a3eb
--- /dev/null
+++ b/source/web/scripts/ajax/src/widget/RichText.js
@@ -0,0 +1,1560 @@
+ /* -*- tab-width: 4 -*- */
+dojo.provide("dojo.widget.RichText");
+
+dojo.require("dojo.widget.*");
+dojo.require("dojo.html.*");
+dojo.require("dojo.html.layout");
+dojo.require("dojo.event.*");
+dojo.require("dojo.string.extras");
+
+// used to save content
+if(dojo.hostenv.post_load_){
+ (function(){
+ var savetextarea = dojo.doc().createElement('textarea');
+ savetextarea.id = "dojo.widget.RichText.savedContent";
+ savetextarea.style = "display:none;position:absolute;top:-100px;left:-100px;height:3px;width:3px;overflow:hidden;";
+ dojo.body().appendChild(savetextarea);
+ })();
+}else{
+ //dojo.body() is not available before onLoad is fired
+ try {
+ dojo.doc().write('<textarea id="dojo.widget.RichText.savedContent" ' +
+ 'style="display:none;position:absolute;top:-100px;left:-100px;height:3px;width:3px;overflow:hidden;"></textarea>');
+ }catch(e){ }
+}
+
+dojo.widget.defineWidget(
+ "dojo.widget.RichText",
+ dojo.widget.HtmlWidget,
+ {
+ /** whether to inherit the parent's width or simply use 100% */
+ inheritWidth: false,
+ focusOnLoad: true,
+
+ /**
+ * If a save name is specified the content is saved and restored if the
+ * editor is not properly closed after editing has started.
+ */
+ saveName: "",
+ _content: "",
+
+ /* set height to fix the editor at a specific height, with scrolling */
+ height: null,
+
+ /** The minimum height that the editor should have */
+ minHeight: "1em",
+
+ isClosed: true,
+ isLoaded: false,
+
+ /** whether to use the active-x object in IE */
+ useActiveX: false,
+
+ /*whether to use relative URLs for images - if this is enabled
+ images will be given absolute URLs when inside the editor but
+ will be changed to use relative URLs (to the current page) on save
+ */
+ relativeImageUrls: false,
+
+ _SEPARATOR: "@@**%%__RICHTEXTBOUNDRY__%%**@@",
+
+ /*
+ defaultContentCleaner: function(content){
+ if(!dojo.render.html.ie){
+ return content;
+ }
+
+ content = content.replace(/\x20/g, " ");
+ // alert(content);
+ return content;
+ },
+ */
+
+ /* Init
+ *******/
+
+ fillInTemplate: function(){
+ this.open();
+
+ // add the formatting functions
+ var funcs = ["queryCommandEnabled", "queryCommandState",
+ "queryCommandValue", "execCommand"];
+ for(var i = 0; i < funcs.length; i++){
+ dojo.event.connect("around", this, funcs[i], this, "_normalizeCommand");
+ }
+
+ // backwards compatibility, needs to be removed
+ dojo.event.connect(this, "onKeyPressed", this, "afterKeyPress");
+ dojo.event.connect(this, "onKeyPress", this, "keyPress");
+ dojo.event.connect(this, "onKeyDown", this, "keyDown");
+ dojo.event.connect(this, "onKeyUp", this, "keyUp");
+
+ // add default some key handlers
+ var ctrl = this.KEY_CTRL;
+ var exec = function (cmd, arg) {
+ return arguments.length == 1 ? function () { this.execCommand(cmd); } :
+ function () { this.execCommand(cmd, arg); }
+ }
+
+ this.addKeyHandler("b", ctrl, exec("bold"));
+ this.addKeyHandler("i", ctrl, exec("italic"));
+ this.addKeyHandler("u", ctrl, exec("underline"));
+ this.addKeyHandler("a", ctrl, exec("selectall"));
+ //this.addKeyHandler("k", ctrl, exec("createlink", ""));
+ //this.addKeyHandler("K", ctrl, exec("unlink"));
+ this.addKeyHandler("s", ctrl, function () { this.save(true); });
+
+ this.addKeyHandler("1", ctrl, exec("formatblock", "h1"));
+ this.addKeyHandler("2", ctrl, exec("formatblock", "h2"));
+ this.addKeyHandler("3", ctrl, exec("formatblock", "h3"));
+ this.addKeyHandler("4", ctrl, exec("formatblock", "h4"));
+
+ this.addKeyHandler("\\", ctrl, exec("insertunorderedlist"));
+ if(!dojo.render.html.ie){
+ this.addKeyHandler("Z", ctrl, exec("redo"));
+ }
+ },
+
+
+ events: ["onBlur", "onFocus", "onKeyPress", "onKeyDown", "onKeyUp", "onClick"],
+
+ /**
+ * Transforms the node referenced in this.domNode into a rich text editing
+ * node. This can result in the creation and replacement with an <iframe> if
+ * designMode is used, an <object> and active-x component if inside of IE or
+ * a reguler element if contentEditable is available.
+ */
+ open: function (element) {
+ var h = dojo.render.html;
+ dojo.event.topic.publish("dojo.widget.RichText::open", this);
+
+ if (!this.isClosed) { this.close(); }
+ this._content = "";
+ if((arguments.length == 1)&&(element["nodeName"])){ this.domNode = element; } // else unchanged
+
+ if( (this.domNode["nodeName"])&&
+ (this.domNode.nodeName.toLowerCase() == "textarea")){
+ this.textarea = this.domNode;
+ var html = dojo.string.trim(this.textarea.value);
+ if(html == ""){ html = " "; }
+ this.domNode = document.createElement("div");
+ var tmpFunc = dojo.lang.hitch(this, function(){
+ with(this.textarea.style){
+ display = "block";
+ position = "absolute";
+ width = "1px";
+ height = "1px";
+ border = margin = padding = "0px";
+ // border = "3px solid black";
+ left = top = "-50px";
+ // visiblity = "hidden";
+ if(h.ie){
+ overflow = "hidden";
+ }
+ }
+ });
+ if(h.ie){
+ setTimeout(tmpFunc, 10);
+ }else{
+ tmpFunc();
+ }
+ if(!h.safari){
+ // FIXME: VERY STRANGE safari 2.0.4 behavior here caused by
+ // moving the textarea. Often crashed the browser!!! Seems
+ // fixed on webkit nightlies.
+ dojo.html.insertBefore(this.domNode, this.textarea);
+ }
+ // this.domNode.innerHTML = html;
+
+ if(this.textarea.form){
+ dojo.event.connect(this.textarea.form, "onsubmit",
+ // FIXME: should we be calling close() here instead?
+ dojo.lang.hitch(this, function(){
+ this.textarea.value = this.getEditorContent();
+ })
+ );
+ }
+
+ // dojo plucks our original domNode from the document so we need
+ // to go back and put ourselves back in
+ var editor = this;
+ dojo.event.connect(this, "postCreate", function (){
+ dojo.html.insertAfter(editor.textarea, editor.domNode);
+ });
+ }else{
+ var html = this._preFilterContent(dojo.string.trim(this.domNode.innerHTML));
+ if(html == ""){ html = " "; }
+ }
+
+ var content = dojo.html.getContentBox(this.domNode);
+ this._oldHeight = content.height;
+ this._oldWidth = content.width;
+
+ this._firstChildContributingMargin = this._getContributingMargin(this.domNode, "top");
+ this._lastChildContributingMargin = this._getContributingMargin(this.domNode, "bottom");
+
+ this.savedContent = document.createElement("div");
+ while (this.domNode.hasChildNodes()) {
+ this.savedContent.appendChild(this.domNode.firstChild);
+ }
+
+ // If we're a list item we have to put in a blank line to force the
+ // bullet to nicely align at the top of text
+ if( (this.domNode["nodeName"])&&
+ (this.domNode.nodeName == "LI")){
+ this.domNode.innerHTML = " <br>";
+ }
+
+ if(this.saveName != ""){
+ var saveTextarea = document.getElementById("dojo.widget.RichText.savedContent");
+ if (saveTextarea.value != "") {
+ var datas = saveTextarea.value.split(this._SEPARATOR);
+ for (var i = 0; i < datas.length; i++) {
+ var data = datas[i].split(":");
+ if (data[0] == this.saveName) {
+ html = data[1];
+ datas.splice(i, 1);
+ break;
+ }
+ }
+ }
+ dojo.event.connect("before", window, "onunload", this, "_saveContent");
+ // dojo.event.connect(window, "onunload", this, "_saveContent");
+ }
+
+ if(h.ie70 && this.useActiveX){
+ dojo.debug("activeX in ie70 is not currently supported, useActiveX is ignored for now.");
+ this.useActiveX = false;
+ }
+ // Safari's selections go all out of whack if we do it inline,
+ // so for now IE is our only hero
+ //if (typeof document.body.contentEditable != "undefined") {
+ if (this.useActiveX && h.ie) { // active-x
+ this._drawObject(html);
+ // dojo.debug(this.object.document);
+ } else if (h.ie) { // contentEditable, easy
+ this.editNode = document.createElement("div");
+ with (this.editNode) {
+ contentEditable = true;
+ if(h.ie70){
+ if(this.height){
+ style.height = this.height;
+ }
+ if(this.minHeight){
+ style.minHeight = this.minHeight;
+ }
+ }else{
+ style["height"] = this.height ? this.height : this.minHeight;
+ }
+ }
+ this.window = window;
+ this.document = document;
+
+ // FIXME: setting contentEditable on switches this element to
+ // IE's hasLayout mode, triggering weird margin collapsing
+ // behavior. It's particularly bad if the element you're editing
+ // contains childnodes that don't have margin: defined in local
+ // css rules. It would be nice if it was possible to hack around
+ // this. Sadly _firstChildContributingMargin and
+ // _lastChildContributingMargin don't work on IE unless all
+ // elements have margins set in CSS :-(
+
+ this.domNode.appendChild(this.editNode);
+
+ //if the normal way fails, we try the hard way to get the list
+// this.editNode.style.display = "none";
+ if(!this._cacheLocalBlockFormatNames()){
+ //in the array below, ul can not come directly after ol, otherwise the queryCommandValue returns Normal for it
+ var formats = ['p', 'pre', 'address', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'ol', 'div', 'ul'];
+ var localhtml = "";
+ for(var i in formats){
+ if(formats[i].charAt(1) != 'l'){
+ localhtml += "<"+formats[i]+"><span>content</span></"+formats[i]+">";
+ }else{
+ localhtml += "<"+formats[i]+"><li>content</li></"+formats[i]+">";
+ }
+ }
+ //queryCommandValue returns empty if we hide editNode, so move it out of screen temporary
+ with(this.editNode.style){
+ position = "absolute";
+ left = "-2000px";
+ top = "-2000px";
+ }
+ this.editNode.innerHTML = localhtml;
+ var node = this.editNode.firstChild;
+ while(node){
+ dojo.html.selection.selectElement(node.firstChild);
+ var nativename = node.tagName.toLowerCase();
+ this._local2NativeFormatNames[nativename] = this.queryCommandValue("formatblock");
+ dojo.debug([nativename,this._local2NativeFormatNames[nativename]]);
+ this._native2LocalFormatNames[this._local2NativeFormatNames[nativename]] = nativename;
+ node = node.nextSibling;
+ }
+ with(this.editNode.style){
+ position = "";
+ left = "";
+ top = "";
+ }
+ }
+
+ this.editNode.innerHTML = html;
+ if(this.height){ this.editNode.style.overflowY="scroll"; }
+
+ dojo.lang.forEach(this.events, function(e){
+ dojo.event.connect(this.editNode, e.toLowerCase(), this, e);
+ }, this);
+
+ this.onLoad();
+ } else { // designMode in iframe
+ this._drawIframe(html);
+ }
+
+ // TODO: this is a guess at the default line-height, kinda works
+ if (this.domNode.nodeName == "LI") { this.domNode.lastChild.style.marginTop = "-1.2em"; }
+ dojo.html.addClass(this.domNode, "RichTextEditable");
+
+ this.isClosed = false;
+ },
+
+ _hasCollapseableMargin: function(element, side) {
+ // check if an element has padding or borders on the given side
+ // which would prevent it from collapsing margins
+ if (dojo.html.getPixelValue(element,
+ 'border-'+side+'-width',
+ false)) {
+ return false;
+ } else if (dojo.html.getPixelValue(element,
+ 'padding-'+side,
+ false)) {
+ return false;
+ } else {
+ return true;
+ }
+ },
+
+ _getContributingMargin: function(element, topOrBottom) {
+ // calculate how much margin this element and its first or last
+ // child are contributing to the total margin between this element
+ // and the adjacent node. CSS border collapsing makes this
+ // necessary.
+
+ if (topOrBottom == "top") {
+ var siblingAttr = "previousSibling";
+ var childSiblingAttr = "nextSibling";
+ var childAttr = "firstChild";
+ var marginProp = "margin-top";
+ var siblingMarginProp = "margin-bottom";
+ } else {
+ var siblingAttr = "nextSibling";
+ var childSiblingAttr = "previousSibling";
+ var childAttr = "lastChild";
+ var marginProp = "margin-bottom";
+ var siblingMarginProp = "margin-top";
+ }
+
+ var elementMargin = dojo.html.getPixelValue(element, marginProp, false);
+
+ function isSignificantNode(element) {
+ // see if an node is significant in the current context
+ // for calulating margins
+ return !(element.nodeType==3 && dojo.string.isBlank(element.data))
+ && dojo.html.getStyle(element, "display") != "none"
+ && !dojo.html.isPositionAbsolute(element);
+ }
+
+ // walk throuh first/last children to find total collapsed margin size
+ var childMargin = 0;
+ var child = element[childAttr];
+ while (child) {
+ // skip over insignificant elements (whitespace, etc)
+ while ((!isSignificantNode(child)) && child[childSiblingAttr]) {
+ child = child[childSiblingAttr];
+ }
+
+ childMargin = Math.max(childMargin, dojo.html.getPixelValue(child, marginProp, false));
+ // stop if we hit a bordered/padded element
+ if (!this._hasCollapseableMargin(child, topOrBottom)) break;
+ child = child[childAttr];
+ }
+
+ // if this element has a border, return full child margin immediately
+ // as there won't be any margin collapsing
+ if (!this._hasCollapseableMargin(element, topOrBottom)){ return parseInt(childMargin); }
+
+ // find margin supplied by nearest sibling
+ var contextMargin = 0;
+ var sibling = element[siblingAttr];
+ while (sibling) {
+ if (isSignificantNode(sibling)) {
+ contextMargin = dojo.html.getPixelValue(sibling,
+ siblingMarginProp,
+ false);
+ break;
+ }
+ sibling = sibling[siblingAttr];
+ }
+ if (!sibling) { // no sibling, look at parent's margin instead
+ contextMargin = dojo.html.getPixelValue(element.parentNode,
+ marginProp, false);
+ }
+
+ if (childMargin > elementMargin) {
+ return parseInt(Math.max((childMargin-elementMargin)-contextMargin, 0));
+ } else {
+ return 0;
+ }
+
+ },
+
+ /** Draws an iFrame using the existing one if one exists.
+ Used by Mozilla, Safari, and Opera */
+ _drawIframe: function (html) {
+
+ // detect firefox < 1.5, which has some iframe loading issues
+ var oldMoz = Boolean(dojo.render.html.moz && (
+ typeof window.XML == 'undefined'))
+
+ if (!this.iframe) {
+ var currentDomain = (new dojo.uri.Uri(document.location)).host;
+ this.iframe = document.createElement("iframe");
+ with (this.iframe) {
+ scrolling = this.height ? "auto" : "no";
+ style.border = "none";
+ style.lineHeight = "0"; // squash line height
+ style.verticalAlign = "bottom";
+ }
+ }
+ // opera likes this to be outside the with block
+ this.iframe.src = dojo.uri.dojoUri("src/widget/templates/richtextframe.html") + "#" + ((document.domain != currentDomain) ? document.domain : "");
+ this.iframe.width = this.inheritWidth ? this._oldWidth : "100%";
+ if (this.height) {
+ this.iframe.style.height = this.height;
+ } else {
+ var height = this._oldHeight;
+ if (this._hasCollapseableMargin(this.domNode, 'top')) {
+ height += this._firstChildContributingMargin;
+ }
+ if (this._hasCollapseableMargin(this.domNode, 'bottom')) {
+ height += this._lastChildContributingMargin;
+ }
+ this.iframe.height = height;
+ }
+
+ var tmpContent = document.createElement('div');
+ tmpContent.innerHTML = html;
+
+ // make relative image urls absolute
+ if (this.relativeImageUrls) {
+ var imgs = tmpContent.getElementsByTagName('img');
+ for (var i=0; i<imgs.length; i++) {
+ imgs[i].src = (new dojo.uri.Uri(window.location, imgs[i].src)).toString();
+ }
+ html = tmpContent.innerHTML;
+ }
+
+ // fix margins on tmpContent
+ var firstChild = dojo.html.firstElement(tmpContent);
+ var lastChild = dojo.html.lastElement(tmpContent);
+ if(firstChild){
+ firstChild.style.marginTop = this._firstChildContributingMargin+"px";
+ }
+ if(lastChild){
+ lastChild.style.marginBottom = this._lastChildContributingMargin+"px";
+ }
+
+ // show existing content behind iframe for now
+ tmpContent.style.position = "absolute";
+ this.domNode.appendChild(tmpContent);
+ this.domNode.appendChild(this.iframe);
+
+ var _iframeInitialized = false;
+
+ // now we wait for onload. Janky hack!
+ var ifrFunc = dojo.lang.hitch(this, function(){
+ if(!_iframeInitialized){
+ _iframeInitialized = true;
+ }else{ return; }
+ if(!this.editNode){
+ if(this.iframe.contentWindow){
+ this.window = this.iframe.contentWindow;
+ }else{
+ // for opera
+ this.window = this.iframe.contentDocument.window;
+ }
+ if(dojo.render.html.moz){
+ this.document = this.iframe.contentWindow.document
+ }else{
+ this.document = this.iframe.contentDocument;
+ }
+
+ // curry the getStyle function
+ var getStyle = (function (domNode) { return function (style) {
+ return dojo.html.getStyle(domNode, style);
+ }; })(this.domNode);
+
+ var font =
+ getStyle('font-weight') + " " +
+ getStyle('font-size') + " " +
+ getStyle('font-family');
+
+ // line height is tricky - applying a units value will mess things up.
+ // if we can't get a non-units value, bail out.
+ var lineHeight = "1.0";
+ var lineHeightStyle = dojo.html.getUnitValue(this.domNode, 'line-height');
+ if (lineHeightStyle.value && lineHeightStyle.units=="") {
+ lineHeight = lineHeightStyle.value;
+ }
+
+ dojo.html.insertCssText(
+ ' body,html { background: transparent; padding: 0; margin: 0; }\n' +
+ // TODO: left positioning will case contents to disappear out of view
+ // if it gets too wide for the visible area
+ ' body { top: 0; left: 0; right: 0;' +
+ (((this.height)||(dojo.render.html.opera)) ? '' : ' position: fixed; ') +
+ ' font: ' + font + ';\n' +
+ ' min-height: ' + this.minHeight + '; \n' +
+ ' line-height: ' + lineHeight + '} \n' +
+ ' p { margin: 1em 0 !important; }\n' +
+ ' body > *:first-child { padding-top: 0 !important; margin-top: ' + this._firstChildContributingMargin + 'px !important; }\n' + // FIXME: test firstChild nodeType
+ ' body > *:last-child { padding-bottom: 0 !important; margin-bottom: ' + this._lastChildContributingMargin + 'px !important; }\n' +
+ ' li > ul:-moz-first-node, li > ol:-moz-first-node { padding-top: 1.2em; }\n' +
+ ' li { min-height: 1.2em; }\n' +
+ //' p,ul,li { padding-top: 0; padding-bottom: 0; margin-top:0; margin-bottom: 0; }\n' +
+ '', this.document);
+
+ tmpContent.parentNode.removeChild(tmpContent);
+ this.document.body.innerHTML = html;
+ if(oldMoz){
+ this.document.designMode = "on";
+ }
+ this.onLoad();
+ }else{
+ tmpContent.parentNode.removeChild(tmpContent);
+ this.editNode.innerHTML = html;
+ this.onDisplayChanged();
+ }
+ });
+
+ if(this.editNode){
+ ifrFunc(); // iframe already exists, just set content
+ }else if(dojo.render.html.moz){
+ // FIXME: if we put this on a delay, we get a height of 20px.
+ // Otherwise we get the correctly specified minHeight value.
+ this.iframe.onload = function(){
+ setTimeout(ifrFunc, 250);
+ }
+ }else{ // new mozillas, opera, safari
+ this.iframe.onload = ifrFunc;
+ }
+ },
+
+ /** Draws an active x object, used by IE */
+ _drawObject: function (html) {
+ this.object = dojo.html.createExternalElement(dojo.doc(), "object");
+
+ with (this.object) {
+ classid = "clsid:2D360201-FFF5-11D1-8D03-00A0C959BC0A";
+ width = this.inheritWidth ? this._oldWidth : "100%";
+ style.height = this.height ? this.height : (this._oldHeight+"px");
+ Scrollbars = this.height ? true : false;
+ Appearance = this._activeX.appearance.flat;
+ }
+ this.domNode.appendChild(this.object);
+
+ this.object.attachEvent("DocumentComplete", dojo.lang.hitch(this, "onLoad"));
+ //DisplayChanged is fired too often even no change is made, so we ignore it
+ //and call onDisplayChanged manually in execCommand instead
+// this.object.attachEvent("DisplayChanged", dojo.lang.hitch(this, "onDisplayChanged"));
+
+ dojo.lang.forEach(this.events, function(e){
+ this.object.attachEvent(e.toLowerCase(), dojo.lang.hitch(this, e));
+ }, this);
+
+ this.object.DocumentHTML = '<!doctype HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">' +
+ '<html><title>' +
+ '' +
+ //'
' +
+ '
' + html + '