You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@myfaces.apache.org by ca...@apache.org on 2007/01/11 23:36:18 UTC
svn commit: r495409 [37/47] - in
/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource:
./ src/ src/animation/ src/cal/ src/charting/ src/charting/svg/
src/charting/vml/ src/collections/ src/crypto/ src/data/ src/data/...
Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Select.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Select.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Select.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Select.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,89 @@
+/*
+ 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.Select");
+
+dojo.require("dojo.widget.ComboBox");
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.html.stabile");
+
+dojo.widget.defineWidget(
+ "dojo.widget.Select",
+ dojo.widget.ComboBox,
+ {
+ /*
+ * summary
+ * Enhanced version of HTML's <select> tag.
+ *
+ * Similar features:
+ * - There is a drop down list of possible values.
+ * - You can only enter a value from the drop down list. (You can't enter an arbitrary value.)
+ * - The value submitted with the form is the hidden value (ex: CA),
+ * not the displayed value a.k.a. label (ex: California)
+ *
+ * Enhancements over plain HTML version:
+ * - If you type in some text then it will filter down the list of possible values in the drop down list.
+ * - List can be specified either as a static list or via a javascript function (that can get the list from a server)
+ */
+
+ // This value should not be changed by the user
+ forceValidOption: true,
+
+ setValue: function(value) {
+ // summary
+ // Sets the value of the combobox.
+ // TODO: this doesn't work correctly when a URL is specified, because we can't
+ // set the label automatically (based on the specified value)
+ this.comboBoxValue.value = value;
+ dojo.widget.html.stabile.setState(this.widgetId, this.getState(), true);
+ this.onValueChanged(value);
+ },
+
+ setLabel: function(value){
+ // summary
+ // FIXME, not sure what to do here!
+ // Users shouldn't call this function; they should be calling setValue() instead
+ this.comboBoxSelectionValue.value = value;
+ if (this.textInputNode.value != value) { // prevent mucking up of selection
+ this.textInputNode.value = value;
+ }
+ },
+
+ getLabel: function(){
+ // summary: returns current label
+ return this.comboBoxSelectionValue.value; // String
+ },
+
+ getState: function() {
+ // summary: returns current value and label
+ return {
+ value: this.getValue(),
+ label: this.getLabel()
+ }; // Object
+ },
+
+ onKeyUp: function(/*Event*/ evt){
+ // summary: internal function
+ this.setLabel(this.textInputNode.value);
+ },
+
+ setState: function(/*Object*/ state) {
+ // summary: internal function to set both value and label
+ this.setValue(state.value);
+ this.setLabel(state.label);
+ },
+
+ setAllValues: function(/*String*/ value1, /*String*/ value2){
+ // summary: internal function to set both value and label
+ this.setLabel(value1);
+ this.setValue(value2);
+ }
+ }
+);
Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Show.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Show.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Show.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Show.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,256 @@
+/*
+ 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.Show");
+
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.HtmlWidget");
+dojo.require("dojo.uri.Uri");
+dojo.require("dojo.event.*");
+dojo.require("dojo.lfx.*");
+dojo.require("dojo.math.curves");
+dojo.require("dojo.lang.common");
+dojo.require("dojo.lang.func");
+
+dojo.widget.defineWidget(
+ "dojo.widget.Show",
+ dojo.widget.HtmlWidget,
+ function(){
+ this._slides=[];
+ },
+ {
+ isContainer: true,
+ _slide: -1,
+
+ body: null,
+ nav: null,
+ hider: null,
+ select: null,
+ option: null,
+ inNav: false,
+ debugPane: null,
+ noClick: false,
+ templatePath: dojo.uri.dojoUri("src/widget/templates/Show.html"),
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/Show.css"),
+ fillInTemplate: function(args, frag){
+ if(args.debugPane){
+ var dp = this.debugPane = dojo.widget.byId(args.debugPane);
+ dp.hide();
+ dojo.event.connect(dp, "closeWindow", dojo.lang.hitch(this, function(){ this.debugPane = false; }));
+ }
+ var source = this.getFragNodeRef(frag);
+ this.sourceNode = dojo.body().appendChild(source.cloneNode(true));
+ for(var i = 0, child; child = this.sourceNode.childNodes[i]; i++){
+ if(child.tagName && child.getAttribute("dojotype").toLowerCase() == "showslide"){
+ child.className = "dojoShowPrintSlide";
+ child.innerHTML = "<h1>" + child.title + "</h1>" + child.innerHTML;
+ }
+ }
+ this.sourceNode.className = "dojoShowPrint";
+ this.sourceNode.style.display = "none";
+
+ dojo.event.connect(document, "onclick", this, "gotoSlideByEvent");
+ if(dojo.render.html.ie) {
+ dojo.event.connect(document,"onkeydown",this, "gotoSlideByEvent");
+ } else {
+ // while keydown works, keypress allows rapid successive key presses
+ // to be handled correctly
+ dojo.event.connect(document,"onkeypress",this, "gotoSlideByEvent");
+ }
+ dojo.event.connect(window, "onresize", this, "resizeWindow");
+ dojo.event.connect(this.nav, "onmousemove", this, "popUpNav");
+ },
+ postCreate: function(){
+ this._slides = [];
+ for(var i = 0, child; child = this.children[i]; i++){
+ if(child.widgetType == "ShowSlide"){
+ this._slides.push(child);
+ this.option.text = child.title+" ("+(i+1)+")";
+ this.option.parentNode.insertBefore(this.option.cloneNode(true), this.option);
+ }
+ }
+ this.option.parentNode.removeChild(this.option);
+ this.domNode.style.display = "block";
+ this.resizeWindow();
+
+ this.gotoSlide(0, true);
+
+ // check to see if we're initialized from a particular slide
+ dojo.addOnLoad(dojo.lang.hitch(this,
+ function(){
+ var th = window.location.hash;
+ if(th.length){
+ var parts = (""+window.location).split(this.widgetId+"_SlideNo_");
+ if(parts.length > 1){
+ setTimeout(dojo.lang.hitch(this, function(){
+ this.gotoSlide(parseInt(parts[1]), true);
+ }), 300);
+ }
+ }
+ })
+ );
+ },
+ gotoSlide: function(/*int*/ slide, /*Boolean*/preventSetHash){
+ if(slide == this._slide){
+ return;
+ }
+
+ if(!this._slides[slide]){
+ // slide: string
+ for(var i = 0, child; child = this._slides[i]; i++){
+ if(child.title == slide){
+ slide = i;
+ break;
+ }
+ }
+ }
+
+ if(!this._slides[slide]){
+ return;
+ }
+
+ if(this.debugPane){
+ if(this._slides[slide].debug){
+ this.debugPane.show();
+ }else{
+ this.debugPane.hide();
+ }
+ }
+
+ if(this._slide != -1){
+ while(this._slides[this._slide].previousAction()){}
+ }
+
+ if(!preventSetHash){
+ window.location.href = "#"+this.widgetId+"_SlideNo_"+slide;
+ }
+ if(this._slides[this._slide]){
+ this._slides[this._slide].hide();
+ }
+
+ this._slide = slide;
+ this.select.selectedIndex = slide;
+ var cn = this.contentNode;
+ while(cn.firstChild){ cn.removeChild(cn.firstChild); }
+ cn.appendChild(this._slides[slide].domNode);
+ this._slides[slide].show();
+ },
+ gotoSlideByEvent: function(/*Event*/ event){
+ var node = event.target;
+ var type = event.type;
+ if(type == "click"){
+ if(node.tagName == "OPTION" && node.parentNode == this.select){
+ this.gotoSlide(node.index);
+ }else if(node == this.select){
+ this.gotoSlide(node.selectedIndex);
+ }else{
+ this.nextSlide(event);
+ }
+ }else if (type=="keydown" || type=="keypress") {
+ var key = event.keyCode;
+ var ch = event.charCode;
+ if(key == 63234 || key == 37){
+ this.previousSlide(event);
+ }else if(key == 63235 || key == 39 || ch == 32){
+ this.nextSlide(event);
+ }
+ }
+ },
+ nextSlide: function(/*Event?*/ event){
+ if(!this.stopEvent(event)){
+ return false;
+ }
+ if(!this._slides[this._slide].nextAction(event)){
+ if((this._slide + 1) != this._slides.length){
+ this.gotoSlide(this._slide + 1);
+ return true; // boolean
+ }
+ return false; // boolean
+ }
+ },
+ previousSlide: function(/*Event?*/ event){
+ if(!this.stopEvent(event)){
+ return false;
+ }
+ if(!this._slides[this._slide].previousAction(event)){
+ if((this._slide - 1) != -1){
+ this.gotoSlide(this._slide - 1);
+ return true; // boolean
+ }
+ return false; // boolean
+ }
+ },
+
+ stopEvent: function(/*Event*/ ev){
+ if(!ev){
+ return true;
+ }
+
+ if (ev.type == "click" && (this._slides[this._slide].noClick || this.noClick)) {
+ return false;
+ }
+ var target = ev.target;
+ // Check to see if the target is below the show domNode
+ while(target != null){
+ if(target == this.domNode){
+ target = ev.target;
+ break;
+ }
+ target = target.parentNode;
+ }
+ // Now that we know it's below this widget's domNode, we bubble up until we get to our domNode
+ if(!dojo.dom.isDescendantOf(target, this.nav)){
+ while(target && target != this.domNode){
+ if(target.tagName == "A" || target.tagName == "INPUT" || target.tagName == "TEXTAREA" || target.tagName == "SELECT"){
+ return false;
+ }
+ if(typeof target.onclick == "function" || typeof target.onkeypress == "function"){
+ return false;
+ }
+ target = target.parentNode;
+ }
+ }
+
+ if(window.event){
+ ev.returnValue = false;
+ ev.cancelBubble = true;
+ }else{
+ ev.preventDefault();
+ ev.stopPropagation();
+ }
+
+ return true;
+ },
+ popUpNav: function(){
+ if(!this.inNav){
+ // dojo.widget.Show.node = this.nav;
+ dojo.lfx.propertyAnimation(this.nav, {
+ "height": { start: 5, end: 30 }
+ }, 250).play();
+ }
+ clearTimeout(this.inNav);
+ this.inNav = setTimeout(dojo.lang.hitch(this, "hideNav"), 2000);
+ },
+ hideNav: function(){
+ clearTimeout(this.inNav);
+ this.inNav = false;
+ // dojo.widget.Show.node = this.nav;
+ dojo.lfx.propertyAnimation(this.nav, {
+ "height": { start: 30, end: 5 }
+ }, 250).play();
+ },
+ resizeWindow: function(/*Event*/ ev){
+ dojo.body().style.height = "auto";
+ var h = Math.max(
+ document.documentElement.scrollHeight || dojo.body().scrollHeight,
+ dojo.html.getViewport().height);
+ dojo.body().style.height = h + "px";
+ }
+});
Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/ShowAction.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/ShowAction.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/ShowAction.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/ShowAction.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,30 @@
+/*
+ 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.ShowAction");
+dojo.require("dojo.widget.*");
+
+dojo.widget.defineWidget(
+ "dojo.widget.ShowAction",
+ dojo.widget.HtmlWidget,
+{
+ on: "",
+ action: "fade",
+ duration: 350,
+ from: "",
+ to: "",
+ auto: "false",
+ postMixInProperties: function(){
+ // fix for very strange Opera 9 bug
+ if(dojo.render.html.opera){
+ this.action = this.action.split("/").pop();
+ }
+ }
+});
Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/ShowSlide.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/ShowSlide.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/ShowSlide.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/ShowSlide.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,229 @@
+/*
+ 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.ShowSlide");
+
+dojo.require("dojo.widget.*");
+dojo.require("dojo.lang.common");
+dojo.require("dojo.widget.HtmlWidget");
+dojo.require("dojo.lfx.html");
+dojo.require("dojo.html.display");
+dojo.require("dojo.html.layout");
+dojo.require("dojo.animation.Animation");
+dojo.require("dojo.gfx.color");
+
+dojo.widget.defineWidget(
+ "dojo.widget.ShowSlide",
+ dojo.widget.HtmlWidget,
+{
+ title: "",
+ _action: -1,
+ isContainer: true,
+ _components: {},
+ _actions: [],
+
+ gotoAction: function(/*int*/ action){
+ this._action = action;
+ },
+ _nextAction: function(/*Event?*/ event){
+ if((this._action + 1) != this._actions.length){
+ ++this._action;
+ return true; // boolean
+ }
+ return false; // boolean
+ },
+ _previousAction: function(/*Event?*/ event){
+ if((this._action - 1) != -1){
+ --this._action;
+ return true; // boolean
+ }
+ return false; // boolean
+ },
+
+ htmlTitle: null,
+ debug: false,
+ noClick: false,
+ templatePath: dojo.uri.dojoUri("src/widget/templates/ShowSlide.html"),
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/ShowSlide.css"),
+ postCreate: function(){
+ this.htmlTitle.innerHTML = this.title;
+
+ var actions = this.getChildrenOfType("ShowAction", false);
+ var atypes = {};
+ dojo.lang.forEach(actions, function(act){ atypes[act.on] = true; });
+
+ this._components = {};
+ var cn = this.containerNode;
+ var nodes = dojo.render.html.ie ? cn.all : cn.getElementsByTagName('*');
+ dojo.lang.forEach(nodes, function(node){
+ var as = node.getAttribute("as");
+ if(as){
+ if(!this._components[as]){
+ this._components[as] = [];
+ }
+ this._components[as].push(node);
+ if(!atypes[as]){
+ var tmpAction = dojo.widget.createWidget("ShowAction", { on: as });
+ this.addChild(tmpAction);
+ atypes[as] = true;
+ }
+ }
+ }, this);
+
+ this._actions = [];
+ actions = this.getChildrenOfType("ShowAction", false);
+ dojo.lang.forEach(actions, function(child){
+ this._actions.push(child);
+ var components = this._components[child.on];
+ for(var j = 0, component; component = components[j]; j++){
+ if(child["action"] && (
+ (child.action != "remove")&&
+ (child.action != "fadeout")&&
+ (child.action != "wipeout")
+ ) ){
+ this.hideComponent(component);
+ }
+ }
+ }, this);
+ },
+
+ previousAction: function(/*Event?*/ event){
+ if(!this.parent.stopEvent(event)){
+ return false;
+ }
+
+ var action = this._actions[this._action];
+ if(!action){
+ return false;
+ }
+
+ var on = action.on;
+ while(action.on == on){
+ var components = this._components[on];
+ for(var i = 0, component; component = components[i]; i++){
+ if(
+ (action.action == "remove")||
+ (action.action == "fadeout")||
+ (action.action == "wipeout")
+ ){
+ if(component.style.display == "none"){
+ component.style.display = "";
+ component.style.visibility = "visible";
+ var exits = true;
+ }
+ dojo.html.setOpacity(component, 1);
+ }else if(action.action){
+ this.hideComponent(component);
+ }
+ }
+
+ --this._action;
+
+ if(exits){
+ return true;
+ }
+
+ if(action.auto == "true"){
+ on = this._actions[this._action].on;
+ }
+
+ action = this._actions[this._action];
+ if(!action){
+ return false;
+ }
+ }
+ return true;
+ },
+ hideComponent: function(/*Node*/ component){
+ component.style.visibility = "hidden";
+ component.style.backgroundColor = "transparent";
+ var parent = component.parentNode;
+ if((parent)&&(parent.tagName.toLowerCase() == "li")){
+ parent.oldType = parent.style.listStyleType;
+ parent.style.listStyleType = "none";
+ }
+ },
+ nextAction: function(/*Event?*/ event){
+ if(!this.parent.stopEvent(event)){
+ return false;
+ }
+
+ if(!this._nextAction(this)){
+ return false;
+ }
+
+ var action = this._actions[this._action];
+ if(!action){
+ return false;
+ }
+ var tmpAction = action["action"];
+
+ var components = this._components[action.on];
+ for(var i = 0, component; component = components[i]; i++){
+ if(tmpAction){
+ var duration = action.duration || 1000;
+ if((tmpAction == "fade")||(tmpAction == "fadeIn")){
+ dojo.html.setOpacity(component, 0);
+ dojo.lfx.html.fadeShow(component, duration).play(true);
+ }else if(tmpAction == "fadeout"){
+ dojo.lfx.html.fadeHide(component, duration).play(true);
+ }else if(tmpAction == "fly"){
+ var width = dojo.html.getMarginBox(component).width;
+ var position = dojo.html.getAbsolutePosition(component);
+ // alert(position);
+ component.style.position = "relative";
+ component.style.left = -(width + position.x) + "px";
+ dojo.lfx.html.slideBy(component, { top: 0, left: (width + position.x)}, duration, -1, this.callWith).play(true);
+ }else if((tmpAction == "wipe")||(tmpAction == "wipein")){
+ dojo.lfx.html.wipeIn(component, duration).play();
+ }else if(tmpAction == "wipeout"){
+ dojo.lfx.html.wipeOut(component, duration).play();
+ }else if(tmpAction == "color"){
+ var from = new dojo.gfx.color.Color(action.from).toRgb();
+ var to = new dojo.gfx.color.Color(action.to).toRgb();
+ var anim = new dojo.animation.Animation(new dojo.math.curves.Line(from, to), duration, 0);
+ var node = component;
+ dojo.event.connect(anim, "onAnimate", function(e) {
+ node.style.color = "rgb(" + e.coordsAsInts().join(",") + ")";
+ });
+ anim.play(true);
+ }else if(tmpAction == "bgcolor"){
+ dojo.lfx.html.unhighlight(component, action.to, duration).play();
+ }else if(tmpAction == "remove"){
+ component.style.display = "none";
+ }
+
+ if(tmpAction == "hide"){
+ component.style.visibility = "hidden";
+ }else{
+ component.style.visibility = "visible";
+ }
+ }
+ }
+
+ action = this._actions[this._action + 1];
+ if(action && action.auto == "true"){
+ this.nextAction();
+ }
+
+ return true;
+ },
+ callWith: function(/*Node*/ node){
+ if(!node){ return; }
+ if(dojo.lang.isArray(node)){
+ dojo.lang.forEach(node, arguments.callee);
+ return;
+ }
+ var parent = node.parentNode;
+ if((parent)&&(parent.tagName.toLowerCase() == "li")){
+ parent.style.listStyleType = parent.oldType;
+ }
+ }
+});
Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/SlideShow.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/SlideShow.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/SlideShow.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/SlideShow.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,174 @@
+/*
+ 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.SlideShow");
+
+dojo.require("dojo.event.*");
+dojo.require("dojo.widget.*");
+dojo.require("dojo.lfx.*");
+dojo.require("dojo.html.display");
+
+
+dojo.widget.defineWidget(
+ "dojo.widget.SlideShow",
+ dojo.widget.HtmlWidget,
+ {
+ /*
+ summary
+ Takes a bunch of pictures and displays them one by one, like a slide show.
+ Usage
+ <img dojoType="SlideShow"
+ imgUrls="images/1.jpg;images/2.jpg;images/3.jpg;images/4.jpg;images/5.jpg;images/6.jpg"
+ imgUrlBase="/foo/bar/images/"
+ transitionInterval="700"
+ delay="7000"
+ src="images/1.jpg"
+ imgWidth="400" imgHeight="300" />
+ */
+
+ templatePath: dojo.uri.dojoUri("src/widget/templates/SlideShow.html"),
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/SlideShow.css"),
+
+ // imgUrls: String[]
+ // List of images to use
+ // Ex: "1.jpg;2.jpg;3.jpg"
+ imgUrls: [],
+
+ // imgUrlBase: String
+ // Path prefix to prepend to each file specified in imgUrls
+ // Ex: "/foo/bar/images/"
+ imgUrlBase: "",
+
+ // delay: Integer
+ // Number of milliseconds to display each image
+ delay: 4000,
+
+ // transitionInterval: Integer
+ // Number of milliseconds to transition between pictures
+ transitionInterval: 2000,
+
+ // imgWidth: Integer
+ // Width of image in pixels
+ imgWidth: 800,
+
+ // imgHeight: Integer
+ // Height of image in pixels
+ imgHeight: 600,
+
+ // preventCache: Boolean
+ // If true, download the image every time, rather than using cached version in browser
+ preventCache: false,
+
+ // stopped: Boolean
+ // is Animation paused?
+ stopped: false,
+
+ ////// Properties
+ _urlsIdx: 0, // where in the images we are
+ _background: "img2", // what's in the bg
+ _foreground: "img1", // what's in the fg
+ fadeAnim: null, // references our animation
+
+ ///////// our DOM nodes
+ startStopButton: null,
+ img1: null,
+ img2: null,
+
+ postMixInProperties: function(){
+ this.width = this.imgWidth + "px";
+ this.height = this.imgHeight + "px";
+ },
+
+ fillInTemplate: function(){
+ // safari will cache the images and not fire an image onload event if
+ // there are only two images in the slideshow
+ if(dojo.render.html.safari && this.imgUrls.length == 2) {
+ this.preventCache = true;
+ }
+ dojo.html.setOpacity(this.img1, 0.9999);
+ dojo.html.setOpacity(this.img2, 0.9999);
+ if(this.imgUrls.length>1){
+ this.img2.src = this.imgUrlBase+this.imgUrls[this._urlsIdx++] + this._getUrlSuffix();
+ this._endTransition();
+ }else{
+ this.img1.src = this.imgUrlBase+this.imgUrls[this._urlsIdx++] + this._getUrlSuffix();
+ }
+ },
+
+ _getUrlSuffix: function() {
+ if(this.preventCache) {
+ return "?ts=" + (new Date()).getTime();
+ } else {
+ return "";
+ }
+ },
+
+ togglePaused: function(){
+ // summary: pauses or restarts the slideshow
+ if(this.stopped){
+ this.stopped = false;
+ this._backgroundImageLoaded();
+ this.startStopButton.value= "pause";
+ }else{
+ this.stopped = true;
+ this.startStopButton.value= "play";
+ }
+ },
+
+ _backgroundImageLoaded: function(){
+ // start fading out the _foreground image
+ if(this.stopped){ return; }
+
+ // actually start the fadeOut effect
+ // NOTE: if we wanted to use other transition types, we'd set them up
+ // here as well
+ if(this.fadeAnim) {
+ this.fadeAnim.stop();
+ }
+ this.fadeAnim = dojo.lfx.fadeOut(this[this._foreground],
+ this.transitionInterval, null);
+ dojo.event.connect(this.fadeAnim,"onEnd",this,"_endTransition");
+ this.fadeAnim.play();
+ },
+
+ _endTransition: function(){
+ // move the _foreground image to the _background
+ with(this[this._background].style){ zIndex = parseInt(zIndex)+1; }
+ with(this[this._foreground].style){ zIndex = parseInt(zIndex)-1; }
+
+ // fg/bg book-keeping
+ var tmp = this._foreground;
+ this._foreground = this._background;
+ this._background = tmp;
+ // keep on truckin
+ this._loadNextImage();
+ },
+
+ _loadNextImage: function(){
+ // summary
+ // after specified delay,
+ // load a new image in that container, and call _backgroundImageLoaded()
+ // when it finishes loading
+ dojo.event.kwConnect({
+ srcObj: this[this._background],
+ srcFunc: "onload",
+ adviceObj: this,
+ adviceFunc: "_backgroundImageLoaded",
+ once: true, // kill old connections
+ delay: this.delay
+ });
+ dojo.html.setOpacity(this[this._background], 1.0);
+ this[this._background].src = this.imgUrlBase+this.imgUrls[this._urlsIdx++];
+ if(this._urlsIdx>(this.imgUrls.length-1)){
+ this._urlsIdx = 0;
+ }
+ }
+ }
+);
Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Slider.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Slider.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Slider.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Slider.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,927 @@
+/*
+ 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.Slider");
+
+// load dependencies
+dojo.require("dojo.event.*");
+dojo.require("dojo.dnd.*");
+// dojo.dnd.* doesn't include this package, because it's not in __package__.js
+dojo.require("dojo.dnd.HtmlDragMove");
+dojo.require("dojo.widget.*");
+dojo.require("dojo.html.layout");
+
+
+dojo.widget.defineWidget (
+ "dojo.widget.Slider",
+ dojo.widget.HtmlWidget,
+ {
+ // summary
+ // Slider Widget.
+ //
+ // The slider widget comes in three forms:
+ // 1. Base Slider widget which supports movement in x and y dimensions
+ // 2. Vertical Slider (SliderVertical) widget which supports movement
+ // only in the y dimension.
+ // 3. Horizontal Slider (SliderHorizontal) widget which supports movement
+ // only in the x dimension.
+ //
+ // The key objects in the widget are:
+ // - a container div which displays a bar in the background (Slider object)
+ // - a handle inside the container div, which represents the value
+ // (sliderHandle DOM node)
+ // - the object which moves the handle (_handleMove is of type
+ // SliderDragMoveSource)
+ //
+ // The values for the slider are calculated by grouping pixels together,
+ // based on the number of values to be represented by the slider.
+ // The number of pixels in a group is called the _valueSize
+ // e.g. if slider is 150 pixels long, and is representing the values
+ // 0,1,...10 then pixels are grouped into lots of 15 (_valueSize), where:
+ // value 0 maps to pixels 0 - 7
+ // 1 8 - 22
+ // 2 23 - 37 etc.
+ // The accuracy of the slider is limited to the number of pixels
+ // (i.e tiles > pixels will result in the slider not being able to
+ // represent some values).
+
+ // minimumX: Number
+ // minimum value to be represented by slider in the horizontal direction
+ minimumX: 0,
+
+ // minimumY: Number
+ // minimum value to be represented by slider in the vertical direction
+ minimumY: 0,
+
+ // maximumX: Number
+ // maximum value to be represented by slider in the horizontal direction
+ maximumX: 10,
+
+ // maximumY: Number
+ // maximum value to be represented by slider in the vertical direction
+ maximumY: 10,
+
+ // snapValuesX: Number
+ // number of values to be represented by slider in the horizontal direction
+ // =0 means no snapping
+ snapValuesX: 0,
+
+ // snapValuesY: Number
+ // number of values to be represented by slider in the vertical direction
+ // =0 means no snapping
+ snapValuesY: 0,
+
+ // should the handle snap to the grid or remain where it was dragged to?
+ // FIXME: snapToGrid=false is logically in conflict with setting snapValuesX and snapValuesY
+ _snapToGrid: true,
+
+ // isEnableX: Boolean
+ // enables (disables) sliding in the horizontal direction
+ isEnableX: true,
+
+ // isEnableY: Boolean
+ // enables (disables) sliding in the vertical direction
+ isEnableY: true,
+
+ // value size (pixels) in the x dimension
+ _valueSizeX: 0.0,
+ // value size (pixels) in the y dimension
+ _valueSizeY: 0.0,
+ // left most edge of constraining container (pixels) in the X dimension
+ _minX: 0,
+ // top most edge of constraining container (pixels) in the Y dimension
+ _minY: 0,
+ // constrained slider size (pixels) in the x dimension
+ _constraintWidth: 0,
+ // constrained slider size (pixels) in the y dimension
+ _constraintHeight: 0,
+ // progress image right clip value (pixels) in the X dimension
+ _clipLeft: 0,
+ // progress image left clip value (pixels) in the X dimension
+ _clipRight: 0,
+ // progress image top clip value (pixels) in the Y dimension
+ _clipTop: 0,
+ // progress image bottom clip value (pixels) in the Y dimension
+ _clipBottom: 0,
+ // half the size of the slider handle (pixels) in the X dimension
+ _clipXdelta: 0,
+ // half the size of the slider handle (pixels) in the Y dimension
+ _clipYdelta: 0,
+
+ // initialValueX: Number
+ // initial value in the x dimension
+ initialValueX: 0,
+
+ // initialValueY: Number
+ // initial value in the y dimension
+ initialValueY: 0,
+
+ // flipX: Boolean
+ // values decrease in the X dimension
+ flipX: false,
+
+ // flipY: Boolean
+ // values decrease in the Y dimension
+ flipY: false,
+
+ // clickSelect: Boolean
+ // enables (disables) the user to click on the slider to set the position
+ clickSelect: true,
+
+ // activeDrag: Boolean
+ // disables (enables) the value to change while you are dragging, or just after drag finishes
+ activeDrag: false,
+
+ templateCssPath: dojo.uri.dojoUri ("src/widget/templates/Slider.css"),
+ templatePath: dojo.uri.dojoUri ("src/widget/templates/Slider.html"),
+
+ // This is set to true when a drag is started, so that it is not confused
+ // with a click
+ _isDragInProgress: false,
+
+ // default user style attributes
+
+ // bottomButtonSrc: String
+ // down arrow graphic URL
+ bottomButtonSrc: dojo.uri.dojoUri("src/widget/templates/images/slider_down_arrow.png"),
+
+ // topButtonSrc: String
+ // up arrow graphic URL
+ topButtonSrc: dojo.uri.dojoUri("src/widget/templates/images/slider_up_arrow.png"),
+
+ // leftButtonSrc: String
+ // left arrow graphic URL
+ leftButtonSrc: dojo.uri.dojoUri("src/widget/templates/images/slider_left_arrow.png"),
+
+ // rightButtonSrc: String
+ // right arrow graphic URL
+ rightButtonSrc: dojo.uri.dojoUri("src/widget/templates/images/slider_right_arrow.png"),
+
+ // backgroundSrc: String
+ // slider background graphic URL
+ backgroundSrc: dojo.uri.dojoUri("src/widget/templates/images/blank.gif"),
+
+ // progressBackgroundSrc: String
+ // slider background graphic URL to overlay the normal background to show progress
+ progressBackgroundSrc: dojo.uri.dojoUri("src/widget/templates/images/blank.gif"),
+
+ // backgroundSize: String
+ // sizing style attributes for the background image
+ backgroundSize: "width:200px;height:200px;",
+
+ // backgroundStyle: String
+ // style attributes (other than sizing) for the background image
+ backgroundStyle: "",
+
+ // buttonStyleX: String
+ // style attributes for the left and right arrow images
+ buttonStyleX: "",
+
+ // buttonStyleY: String
+ // style attributes for the up and down arrow images
+ buttonStyleY: "",
+
+ // handleStyle: String
+ // style attributes for the moveable slider image
+ handleStyle: "",
+
+ // handleSrc: String
+ // moveable slider graphic URL
+ handleSrc: dojo.uri.dojoUri("src/widget/templates/images/slider-button.png"),
+
+ // showButtons: Boolean
+ // show (don't show) the arrow buttons
+ showButtons: true,
+
+ _eventCount: 0,
+ _typamaticTimer: null,
+ _typamaticFunction: null,
+
+ // defaultTimeout: Number
+ // number of milliseconds before a held key or button becomes typematic
+ defaultTimeout: 500,
+
+ // timeoutChangeRate: Number
+ // fraction of time used to change the typematic timer between events
+ // 1.0 means that each typematic event fires at defaultTimeout intervals
+ // < 1.0 means that each typematic event fires at an increasing faster rate
+ timeoutChangeRate: 0.90,
+
+ _currentTimeout: this.defaultTimeout,
+
+ // does the keyboard related stuff
+ _handleKeyEvents: function(/*Event*/ evt){
+ if(!evt.key){ return; }
+
+ if(!evt.ctrlKey && !evt.altKey){
+ switch(evt.key){
+ case evt.KEY_LEFT_ARROW:
+ dojo.event.browser.stopEvent(evt);
+ this._leftButtonPressed(evt);
+ return;
+ case evt.KEY_RIGHT_ARROW:
+ dojo.event.browser.stopEvent(evt);
+ this._rightButtonPressed(evt);
+ return;
+ case evt.KEY_DOWN_ARROW:
+ dojo.event.browser.stopEvent(evt);
+ this._bottomButtonPressed(evt);
+ return;
+ case evt.KEY_UP_ARROW:
+ dojo.event.browser.stopEvent(evt);
+ this._topButtonPressed(evt);
+ return;
+ }
+ }
+ this._eventCount++;
+
+ },
+
+ _pressButton: function(/*DomNode*/ buttonNode){
+ buttonNode.className = buttonNode.className.replace("Outset","Inset");
+ },
+
+ _releaseButton: function(/*DomNode*/ buttonNode){
+ buttonNode.className = buttonNode.className.replace("Inset","Outset");
+ },
+
+ _buttonPressed: function(/*Event*/ evt, /*DomNode*/ buttonNode){
+ this._setFocus();
+ if(typeof evt == "object"){
+ if(this._typamaticTimer != null){
+ if(this._typamaticNode == buttonNode){
+ return;
+ }
+ clearTimeout(this._typamaticTimer);
+ }
+ this._buttonReleased(null);
+ this._eventCount++;
+ this._typamaticTimer = null;
+ this._currentTimeout = this.defaultTimeout;
+ dojo.event.browser.stopEvent(evt);
+ }else if (evt != this._eventCount){
+ this._buttonReleased(null);
+ return false;
+ }
+ if (buttonNode == this.leftButtonNode && this.isEnableX){
+ this._snapX(dojo.html.getPixelValue (this.sliderHandleNode,"left") - this._valueSizeX);
+ }
+ else if (buttonNode == this.rightButtonNode && this.isEnableX){
+ this._snapX(dojo.html.getPixelValue (this.sliderHandleNode,"left") + this._valueSizeX);
+ }
+ else if (buttonNode == this.topButtonNode && this.isEnableY){
+ this._snapY(dojo.html.getPixelValue (this.sliderHandleNode,"top") - this._valueSizeY);
+ }
+ else if (buttonNode == this.bottomButtonNode && this.isEnableY){
+ this._snapY(dojo.html.getPixelValue (this.sliderHandleNode,"top") + this._valueSizeY);
+ }
+ else {
+ return false;
+ }
+ this._pressButton(buttonNode);
+ this.notifyListeners();
+ this._typamaticNode = buttonNode;
+ this._typamaticTimer = dojo.lang.setTimeout(this, "_buttonPressed", this._currentTimeout, this._eventCount, buttonNode);
+ this._currentTimeout = Math.round(this._currentTimeout * this.timeoutChangeRate);
+ return false;
+ },
+
+ _bottomButtonPressed: function(/*Event*/ evt){
+ return this._buttonPressed(evt,this.bottomButtonNode);
+ },
+
+ // IE sends these events when rapid clicking, mimic an extra single click
+ _bottomButtonDoubleClicked: function(/*Event*/ evt){
+ var rc = this._bottomButtonPressed(evt);
+ dojo.lang.setTimeout( this, "_buttonReleased", 50, null);
+ return rc;
+ },
+
+ _topButtonPressed: function(/*Event*/ evt){
+ return this._buttonPressed(evt,this.topButtonNode);
+ },
+
+ // IE sends these events when rapid clicking, mimic an extra single click
+ _topButtonDoubleClicked: function(/*Event*/ evt){
+ var rc = this._topButtonPressed(evt);
+ dojo.lang.setTimeout( this, "_buttonReleased", 50, null);
+ return rc;
+ },
+
+ _leftButtonPressed: function(/*Event*/ evt){
+ return this._buttonPressed(evt,this.leftButtonNode);
+ },
+
+ // IE sends these events when rapid clicking, mimic an extra single click
+ _leftButtonDoubleClicked: function(/*Event*/ evt){
+ var rc = this._leftButtonPressed(evt);
+ dojo.lang.setTimeout( this, "_buttonReleased", 50, null);
+ return rc;
+ },
+
+ _rightButtonPressed: function(/*Event*/ evt){
+ return this._buttonPressed(evt,this.rightButtonNode);
+ },
+
+ // IE sends these events when rapid clicking, mimic an extra single click
+ _rightButtonDoubleClicked: function(/*Event*/ evt){
+ var rc = this._rightButtonPressed(evt);
+ dojo.lang.setTimeout( this, "_buttonReleased", 50, null);
+ return rc;
+ },
+
+ _buttonReleased: function(/*Event*/ evt){
+ if(typeof evt == "object" && evt != null && typeof evt.keyCode != "undefined" && evt.keyCode != null){
+ var keyCode = evt.keyCode;
+
+ switch(keyCode){
+ case evt.KEY_LEFT_ARROW:
+ case evt.KEY_RIGHT_ARROW:
+ case evt.KEY_DOWN_ARROW:
+ case evt.KEY_UP_ARROW:
+ dojo.event.browser.stopEvent(evt);
+ break;
+ }
+ }
+ this._releaseButton(this.topButtonNode);
+ this._releaseButton(this.bottomButtonNode);
+ this._releaseButton(this.leftButtonNode);
+ this._releaseButton(this.rightButtonNode);
+ this._eventCount++;
+ if(this._typamaticTimer != null){
+ clearTimeout(this._typamaticTimer);
+ }
+ this._typamaticTimer = null;
+ this._currentTimeout = this.defaultTimeout;
+ },
+
+ _mouseWheeled: function(/*Event*/ evt){
+ var scrollAmount = 0;
+ if(typeof evt.wheelDelta == 'number'){ // IE
+ scrollAmount = evt.wheelDelta;
+ }else if (typeof evt.detail == 'number'){ // Mozilla+Firefox
+ scrollAmount = -evt.detail;
+ }
+ if (this.isEnableY){
+ if(scrollAmount > 0){
+ this._topButtonPressed(evt);
+ this._buttonReleased(evt);
+ }else if (scrollAmount < 0){
+ this._bottomButtonPressed(evt);
+ this._buttonReleased(evt);
+ }
+ } else if (this.isEnableX){
+ if(scrollAmount > 0){
+ this._rightButtonPressed(evt);
+ this._buttonReleased(evt);
+ }else if (scrollAmount < 0){
+ this._leftButtonPressed(evt);
+ this._buttonReleased(evt);
+ }
+ }
+ },
+
+ _discardEvent: function(/*Event*/ evt){
+ dojo.event.browser.stopEvent(evt);
+ },
+
+ _setFocus: function(){
+ if (this.focusNode.focus){
+ this.focusNode.focus();
+ }
+ },
+
+ // This function is called when the template is loaded
+ fillInTemplate: function (/*Object*/ args, /*Object*/ frag)
+ {
+ var source = this.getFragNodeRef(frag);
+ dojo.html.copyStyle(this.domNode, source);
+ // the user's style for the widget might include border and padding
+ // unfortunately, border isn't supported for inline elements
+ // so I get to fake everyone out by setting the border and padding
+ // of the outer table cells
+ var padding = this.domNode.style.padding;
+ if (dojo.lang.isString(padding) && padding != "" && padding != "0px" && padding != "0px 0px 0px 0px"){
+ this.topBorderNode.style.padding =
+ this.bottomBorderNode.style.padding = padding;
+ this.topBorderNode.style.paddingBottom = "0px";
+ this.bottomBorderNode.style.paddingTop = "0px";
+ this.rightBorderNode.style.paddingRight = this.domNode.style.paddingRight;
+ this.leftBorderNode.style.paddingLeft= this.domNode.style.paddingLeft;
+ this.domNode.style.padding = "0px 0px 0px 0px";
+ }
+ var borderWidth = this.domNode.style.borderWidth;
+ if (dojo.lang.isString(borderWidth) && borderWidth != "" && borderWidth != "0px" && borderWidth != "0px 0px 0px 0px"){
+ this.topBorderNode.style.borderStyle =
+ this.rightBorderNode.style.borderStyle =
+ this.bottomBorderNode.style.borderStyle =
+ this.leftBorderNode.style.borderStyle =
+ this.domNode.style.borderStyle;
+ this.topBorderNode.style.borderColor =
+ this.rightBorderNode.style.borderColor =
+ this.bottomBorderNode.style.borderColor =
+ this.leftBorderNode.style.borderColor =
+ this.domNode.style.borderColor;
+ this.topBorderNode.style.borderWidth =
+ this.bottomBorderNode.style.borderWidth = borderWidth;
+ this.topBorderNode.style.borderBottomWidth = "0px";
+ this.bottomBorderNode.style.borderTopWidth = "0px";
+ this.rightBorderNode.style.borderRightWidth = this.domNode.style.borderRightWidth;
+ this.leftBorderNode.style.borderLeftWidth = this.domNode.style.borderLeftWidth;
+ this.domNode.style.borderWidth = "0px 0px 0px 0px";
+ }
+
+ // dojo.debug ("fillInTemplate - className = " + this.domNode.className);
+
+ // setup drag-n-drop for the sliderHandle
+ this._handleMove = new dojo.widget._SliderDragMoveSource (this.sliderHandleNode);
+ this._handleMove.setParent (this);
+
+ if (this.clickSelect){
+ dojo.event.connect (this.constrainingContainerNode, "onmousedown", this, "_onClick");
+ }
+
+ if (this.isEnableX){
+ this.setValueX (!isNaN(this.initialValueX) ? this.initialValueX : (!isNaN(this.minimumX) ? this.minimumX : 0));
+ }
+ if (!this.isEnableX || !this.showButtons){
+ this.rightButtonNode.style.width = "1px"; // allow the border to show
+ this.rightButtonNode.style.visibility = "hidden";
+ this.leftButtonNode.style.width = "1px"; // allow the border to show
+ this.leftButtonNode.style.visibility = "hidden";
+ }
+ if (this.isEnableY){
+ this.setValueY (!isNaN(this.initialValueY) ? this.initialValueY : (!isNaN(this.minimumY) ? this.minimumY : 0));
+ }
+ if (!this.isEnableY || !this.showButtons){
+ this.bottomButtonNode.style.width = "1px"; // allow the border to show
+ this.bottomButtonNode.style.visibility = "hidden";
+ this.topButtonNode.style.width = "1px"; // allow the border to show
+ this.topButtonNode.style.visibility = "hidden";
+ }
+ if(this.focusNode.addEventListener){
+ // dojo.event.connect() doesn't seem to work with DOMMouseScroll
+ this.focusNode.addEventListener('DOMMouseScroll', dojo.lang.hitch(this, "_mouseWheeled"), false); // Mozilla + Firefox + Netscape
+ }
+ },
+
+ // move the X value to the closest allowable value
+ _snapX: function(/*Number*/ x){
+ if (x < 0){ x = 0; }
+ else if (x > this._constraintWidth){ x = this._constraintWidth; }
+ else {
+ var selectedValue = Math.round (x / this._valueSizeX);
+ x = Math.round (selectedValue * this._valueSizeX);
+ }
+ this.sliderHandleNode.style.left = x + "px";
+ if (this.flipX){
+ this._clipLeft = x + this._clipXdelta;
+ } else {
+ this._clipRight = x + this._clipXdelta;
+ }
+ this.progressBackgroundNode.style.clip = "rect("+this._clipTop+"px,"+this._clipRight+"px,"+this._clipBottom+"px,"+this._clipLeft+"px)";
+ },
+
+ // compute _valueSizeX & _constraintWidth & default snapValuesX
+ _calc_valueSizeX: function (){
+ var constrainingCtrBox = dojo.html.getContentBox(this.constrainingContainerNode);
+ var sliderHandleBox = dojo.html.getContentBox(this.sliderHandleNode);
+ if (isNaN(constrainingCtrBox.width) || isNaN(sliderHandleBox.width) || constrainingCtrBox.width <= 0 || sliderHandleBox.width <= 0){
+ return false;
+ }
+
+ this._constraintWidth = constrainingCtrBox.width
+ + dojo.html.getPadding(this.constrainingContainerNode).width
+ - sliderHandleBox.width;
+
+ if (this.flipX){
+ this._clipLeft = this._clipRight = constrainingCtrBox.width;
+ } else {
+ this._clipLeft = this._clipRight = 0;
+ }
+ this._clipXdelta = sliderHandleBox.width >> 1;
+ if (!this.isEnableY){
+ this._clipTop = 0;
+ this._clipBottom = constrainingCtrBox.height;
+ }
+
+ if (this._constraintWidth <= 0){ return false; }
+ if (this.snapValuesX == 0){
+ this.snapValuesX = this._constraintWidth + 1;
+ }
+
+ this._valueSizeX = this._constraintWidth / (this.snapValuesX - 1);
+ return true;
+ },
+
+ // summary
+ // move the handle horizontally to the specified value
+ setValueX: function (/*Number*/ value){
+ if (0.0 == this._valueSizeX){
+ if (this._calc_valueSizeX () == false){
+ dojo.lang.setTimeout(this, "setValueX", 100, value);
+ return;
+ }
+ }
+ if (isNaN(value)){
+ value = 0;
+ }
+ if (value > this.maximumX){
+ value = this.maximumX;
+ }
+ else if (value < this.minimumX){
+ value = this.minimumX;
+ }
+ var pixelPercent = (value-this.minimumX) / (this.maximumX-this.minimumX);
+ if (this.flipX){
+ pixelPercent = 1.0 - pixelPercent;
+ }
+ this._snapX (pixelPercent * this._constraintWidth);
+ this.notifyListeners();
+ },
+
+
+ // summary
+ // return the X value that the matches the position of the handle
+ getValueX: function (){
+ var pixelPercent = dojo.html.getPixelValue (this.sliderHandleNode,"left") / this._constraintWidth;
+ if (this.flipX){
+ pixelPercent = 1.0 - pixelPercent;
+ }
+ return Math.round (pixelPercent * (this.snapValuesX-1)) * ((this.maximumX-this.minimumX) / (this.snapValuesX-1)) + this.minimumX;
+ },
+
+ // move the Y value to the closest allowable value
+ _snapY: function (/*Number*/ y){
+ if (y < 0){ y = 0; }
+ else if (y > this._constraintHeight){ y = this._constraintHeight; }
+ else {
+ var selectedValue = Math.round (y / this._valueSizeY);
+ y = Math.round (selectedValue * this._valueSizeY);
+ }
+ this.sliderHandleNode.style.top = y + "px";
+ if (this.flipY){
+ this._clipTop = y + this._clipYdelta;
+ } else {
+ this._clipBottom = y + this._clipYdelta;
+ }
+ this.progressBackgroundNode.style.clip = "rect("+this._clipTop+"px,"+this._clipRight+"px,"+this._clipBottom+"px,"+this._clipLeft+"px)";
+ },
+ // compute _valueSizeY & _constraintHeight & default snapValuesY
+ _calc_valueSizeY: function (){
+ var constrainingCtrBox = dojo.html.getContentBox(this.constrainingContainerNode);
+ var sliderHandleBox = dojo.html.getContentBox(this.sliderHandleNode);
+ if (isNaN(constrainingCtrBox.height) || isNaN(sliderHandleBox.height) || constrainingCtrBox.height <= 0 || sliderHandleBox.height <= 0){
+ return false;
+ }
+
+ this._constraintHeight = constrainingCtrBox.height
+ + dojo.html.getPadding(this.constrainingContainerNode).height
+ - sliderHandleBox.height;
+
+ if (this.flipY){
+ this._clipTop = this._clipBottom = constrainingCtrBox.height;
+ } else {
+ this._clipTop = this._clipBottom = 0;
+ }
+ this._clipYdelta = sliderHandleBox.height >> 1;
+ if (!this.isEnableX){
+ this._clipLeft = 0;
+ this._clipRight = constrainingCtrBox.width;
+ }
+
+ if (this._constraintHeight <= 0){ return false; }
+ if (this.snapValuesY == 0){
+ this.snapValuesY = this._constraintHeight + 1;
+ }
+
+ this._valueSizeY = this._constraintHeight / (this.snapValuesY - 1);
+ return true;
+ },
+
+ // summary
+ // move the handle vertically to the specified value
+ setValueY: function (/*Number*/ value){
+ if (0.0 == this._valueSizeY){
+ if (this._calc_valueSizeY () == false){
+ dojo.lang.setTimeout(this, "setValueY", 100, value);
+ return;
+ }
+ }
+ if (isNaN(value)){
+ value = 0;
+ }
+ if (value > this.maximumY){
+ value = this.maximumY;
+ }
+ else if (value < this.minimumY){
+ value = this.minimumY;
+ }
+ var pixelPercent = (value-this.minimumY) / (this.maximumY-this.minimumY);
+ if (this.flipY){
+ pixelPercent = 1.0 - pixelPercent;
+ }
+ this._snapY (pixelPercent * this._constraintHeight);
+ this.notifyListeners();
+ },
+
+ // summary
+ // return the Y value that the matches the position of the handle
+ getValueY: function (){
+ var pixelPercent = dojo.html.getPixelValue (this.sliderHandleNode,"top") / this._constraintHeight;
+ if (this.flipY){
+ pixelPercent = 1.0 - pixelPercent;
+ }
+ return Math.round (pixelPercent * (this.snapValuesY-1)) * ((this.maximumY-this.minimumY) / (this.snapValuesY-1)) + this.minimumY;
+ },
+
+ // set the position of the handle
+ _onClick: function(/*Event*/ evt){
+ if (this._isDragInProgress){
+ return;
+ }
+
+ var parent = dojo.html.getAbsolutePosition(this.constrainingContainerNode, true, dojo.html.boxSizing.MARGIN_BOX);
+ var content = dojo.html.getContentBox(this._handleMove.domNode);
+ if (this.isEnableX){
+ var x = evt.pageX - parent.x - (content.width >> 1);
+ this._snapX(x);
+ }
+ if (this.isEnableY){
+ var y = evt.pageY - parent.y - (content.height >> 1);
+ this._snapY(y);
+ }
+ this.notifyListeners();
+ },
+
+ // summary
+ // method to invoke user's onValueChanged method
+ notifyListeners: function(){
+ this.onValueChanged(this.getValueX(), this.getValueY());
+ },
+
+ // summary
+ // empty method to be overridden by user
+ onValueChanged: function(/*Number*/ x, /*Number*/ y){
+ }
+ }
+);
+
+
+
+dojo.widget.defineWidget (
+ "dojo.widget.SliderHorizontal",
+ dojo.widget.Slider,
+ {
+ // summary
+ // the horizontal slider widget subclass
+
+ isEnableX: true,
+ isEnableY: false,
+
+ // initialValue: Number
+ // sets initialValueX.
+ // TODO: should be called "value". Also, common attributes between SliderHorizontal/SliderVertical
+ // should be consolidated to Slider1D base class
+ initialValue: "",
+
+ // snapValues: Number
+ // sets snapValuesX
+ snapValues: "",
+
+ // minimum: Number
+ // sets minimumX
+ minimum: "",
+
+ // maximum: Number
+ // sets maximumX
+ maximum: "",
+
+ // buttonStyle: String
+ // sets buttonStyleX
+ buttonStyle: "",
+
+ backgroundSize: "height:10px;width:200px;",
+ backgroundSrc: dojo.uri.dojoUri("src/widget/templates/images/slider-bg.gif"),
+
+ // flip: Boolean
+ // sets flipX
+ flip: false,
+
+ postMixInProperties: function(){
+ dojo.widget.SliderHorizontal.superclass.postMixInProperties.apply(this, arguments);
+ if (!isNaN(parseFloat(this.initialValue))){
+ this.initialValueX = parseFloat(this.initialValue);
+ }
+ if (!isNaN(parseFloat(this.minimum))){
+ this.minimumX = parseFloat(this.minimum);
+ }
+ if (!isNaN(parseFloat(this.maximum))){
+ this.maximumX = parseFloat(this.maximum);
+ }
+ if (!isNaN(parseInt(this.snapValues))){
+ this.snapValuesX = parseInt(this.snapValues);
+ }
+ if (dojo.lang.isString(this.buttonStyle) && this.buttonStyle != ""){
+ this.buttonStyleX = this.buttonStyle;
+ }
+ if (dojo.lang.isBoolean(this.flip)){
+ this.flipX = this.flip;
+ }
+ },
+
+ notifyListeners: function(){
+ this.onValueChanged(this.getValueX());
+ },
+
+ // summary
+ // wrapper for getValueX()
+ getValue: function (){
+ return this.getValueX ();
+ },
+
+ // summary
+ // wrapper for setValueX()
+ setValue: function (/*Number*/ value){
+ this.setValueX (value);
+ },
+
+ onValueChanged: function(/*Number*/ value){
+ }
+ }
+);
+
+
+/* ------------------------------------------------------------------------- */
+
+
+dojo.widget.defineWidget (
+ "dojo.widget.SliderVertical",
+ dojo.widget.Slider,
+ {
+ // summary
+ // the vertical slider widget subclass
+
+ isEnableX: false,
+ isEnableY: true,
+
+ // initialValue: Number
+ // sets initialValueY
+ initialValue: "",
+
+ // snapValues: Number
+ // sets snapValuesY
+ snapValues: "",
+
+ // minimum: Number
+ // sets minimumY
+ minimum: "",
+
+ // Number
+ // maximum: sets maximumY
+ maximum: "",
+
+ // buttonStyle: String
+ // sets buttonStyleY
+ buttonStyle: "",
+
+ backgroundSize: "width:10px;height:200px;",
+ backgroundSrc: dojo.uri.dojoUri("src/widget/templates/images/slider-bg-vert.gif"),
+
+ // flip: Boolean
+ // sets flipY
+ flip: false,
+
+ postMixInProperties: function(){
+ dojo.widget.SliderVertical.superclass.postMixInProperties.apply(this, arguments);
+ if (!isNaN(parseFloat(this.initialValue))){
+ this.initialValueY = parseFloat(this.initialValue);
+ }
+ if (!isNaN(parseFloat(this.minimum))){
+ this.minimumY = parseFloat(this.minimum);
+ }
+ if (!isNaN(parseFloat(this.maximum))){
+ this.maximumY = parseFloat(this.maximum);
+ }
+ if (!isNaN(parseInt(this.snapValues))){
+ this.snapValuesY = parseInt(this.snapValues);
+ }
+ if (dojo.lang.isString(this.buttonStyle) && this.buttonStyle != ""){
+ this.buttonStyleY = this.buttonStyle;
+ }
+ if (dojo.lang.isBoolean(this.flip)){
+ this.flipY = this.flip;
+ }
+ },
+
+ notifyListeners: function(){
+ this.onValueChanged(this.getValueY());
+ },
+
+ // summary
+ // wrapper for getValueY()
+ getValue: function (){
+ return this.getValueY ();
+ },
+
+ // summary
+ // wrapper for setValueY()
+ setValue: function (/*Number*/ value){
+ this.setValueY (value);
+ },
+
+ onValueChanged: function(/*Number*/ value){
+ }
+ }
+);
+
+
+/* ------------------------------------------------------------------------- */
+
+
+/**
+ * This class extends the HtmlDragMoveSource class to provide
+ * features for the slider handle.
+ */
+dojo.declare (
+ "dojo.widget._SliderDragMoveSource",
+ dojo.dnd.HtmlDragMoveSource,
+{
+ slider: null,
+
+ /** Setup the handle for drag
+ * Extends dojo.dnd.HtmlDragMoveSource by creating a SliderDragMoveSource */
+ onDragStart: function(/*Event*/ evt){
+ this.slider._isDragInProgress = true;
+ var dragObj = this.createDragMoveObject ();
+
+ this.slider.notifyListeners();
+ return dragObj;
+ },
+
+ onDragEnd: function(/*Event*/ evt){
+ this.slider._isDragInProgress = false;
+ this.slider.notifyListeners();
+ },
+
+ createDragMoveObject: function (){
+ //dojo.debug ("SliderDragMoveSource#createDragMoveObject - " + this.slider);
+ var dragObj = new dojo.widget._SliderDragMoveObject (this.dragObject, this.type);
+ dragObj.slider = this.slider;
+
+ // this code copied from dojo.dnd.HtmlDragSource#onDragStart
+ if (this.dragClass){
+ dragObj.dragClass = this.dragClass;
+ }
+
+ return dragObj;
+ },
+
+
+ setParent: function (/*Widget*/ slider){
+ this.slider = slider;
+ }
+});
+
+
+/* ------------------------------------------------------------------------- */
+
+
+/**
+ * This class extends the HtmlDragMoveObject class to provide
+ * features for the slider handle.
+ */
+dojo.declare (
+ "dojo.widget._SliderDragMoveObject",
+ dojo.dnd.HtmlDragMoveObject,
+{
+ // reference to dojo.widget.Slider
+ slider: null,
+
+ /** Moves the node to follow the mouse.
+ * Extends functon HtmlDragObject by adding functionality to snap handle
+ * to a discrete value */
+ onDragMove: function(/*Event*/ evt){
+ this.updateDragOffset ();
+
+ if (this.slider.isEnableX){
+ var x = this.dragOffset.x + evt.pageX;
+ this.slider._snapX(x);
+ }
+
+ if (this.slider.isEnableY){
+ var y = this.dragOffset.y + evt.pageY;
+ this.slider._snapY(y);
+ }
+ if(this.slider.activeDrag){
+ this.slider.notifyListeners();
+ }
+ }
+});
Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/SortableTable.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/SortableTable.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/SortableTable.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/SortableTable.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,615 @@
+/*
+ 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.SortableTable");
+
+dojo.deprecated("SortableTable will be removed in favor of FilteringTable.", "0.5");
+
+dojo.require("dojo.lang.common");
+dojo.require("dojo.date.format");
+dojo.require("dojo.html.*");
+dojo.require("dojo.html.selection");
+dojo.require("dojo.html.util");
+dojo.require("dojo.html.style");
+dojo.require("dojo.event.*");
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.HtmlWidget");
+
+dojo.widget.defineWidget(
+ "dojo.widget.SortableTable",
+ dojo.widget.HtmlWidget,
+ function(){
+ this.data=[];
+ this.selected=[]; // always an array to handle multiple selections.
+ this.columns=[];
+ },
+ {
+ // custom properties
+ enableMultipleSelect: false,
+ maximumNumberOfSelections: 0, // 0 for unlimited, is the default.
+ enableAlternateRows: false,
+ minRows: 0, // 0 means ignore.
+ defaultDateFormat: "%D",
+ sortIndex: 0, // index of the column sorted on, first is the default.
+ sortDirection: 0, // 0==asc, 1==desc
+ valueField: "Id", // if a JSON structure is parsed and there is a field of this name,
+ // a value attribute will be added to the row (tr value="{Id}")
+
+ headClass: "",
+ tbodyClass: "",
+ headerClass: "",
+ headerSortUpClass: "selected",
+ headerSortDownClass: "selected",
+ rowClass: "",
+ rowAlternateClass: "alt",
+ rowSelectedClass: "selected",
+ columnSelected: "sorted-column",
+
+ isContainer: false,
+ templatePath:null,
+ templateCssPath:null,
+
+ getTypeFromString:function(/* string */ s){
+ // summary
+ // Find the constructor that matches param s by searching through the entire object tree.
+ 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; // function
+ },
+ compare:function(/* object */ o1, /* object */ o2){
+ // summary
+ // Compare two objects using a shallow property compare
+ for(var p in o1){
+ if(!(p in o2)) return false; // boolean
+ if(o1[p].valueOf()!=o2[p].valueOf()) return false; // boolean
+ }
+ return true; // boolean
+ },
+ isSelected:function(/* object */ o){
+ // summary
+ // checked to see if the passed object is in the current selection.
+ for(var i=0;i<this.selected.length;i++){
+ if(this.compare(this.selected[i],o)){
+ return true; // boolean
+ }
+ }
+ return false; // boolean
+ },
+ removeFromSelected:function(/* object */ o){
+ // summary
+ // remove the passed object from the current selection.
+ var idx=-1;
+ for(var i=0;i<this.selected.length;i++){
+ if(this.compare(this.selected[i],o)){
+ idx=i;
+ break;
+ }
+ }
+ if(idx>=0){
+ this.selected.splice(idx,1);
+ }
+ },
+ getSelection:function(){
+ // summary
+ // return the array of currently selected objects (JSON format)
+ return this.selected; // array
+ },
+ getValue:function(){
+ // summary
+ // return a comma-delimited list of selected valueFields.
+ var a=[];
+ for(var i=0;i<this.selected.length;i++){
+ if (this.selected[i][this.valueField]){
+ a.push(this.selected[i][this.valueField]);
+ }
+ }
+ return a.join(); // string
+ },
+ reset:function(){
+ // summary
+ // completely resets the internal representations.
+ this.columns=[];
+ this.data=[];
+ this.resetSelections(this.domNode.getElementsByTagName("tbody")[0]);
+ },
+ resetSelections:function(/* HTMLTableBodyElement */ body){
+ this.selected=[];
+ var idx=0;
+ var rows=body.getElementsByTagName("tr");
+ for(var i=0; i<rows.length; i++){
+ if(rows[i].parentNode==body){
+ rows[i].removeAttribute("selected");
+ if(this.enableAlternateRows&&idx%2==1){
+ rows[i].className=this.rowAlternateClass;
+ }else{
+ rows[i].className="";
+ }
+ idx++;
+ }
+ }
+ },
+
+ getObjectFromRow:function(/* HTMLTableRowElement */ row){
+ // summary
+ // creates a JSON object based on the passed row
+ var cells=row.getElementsByTagName("td");
+ var o={};
+ for(var i=0; i<this.columns.length;i++){
+ if(this.columns[i].sortType=="__markup__"){
+ // FIXME: should we parse this instead? Because if the user may not get back the markup they put in...
+ o[this.columns[i].getField()]=cells[i].innerHTML;
+ }else{
+ var text=dojo.html.renderedTextContent(cells[i]);
+ var val=text;
+ if (this.columns[i].getType() != String){
+ var val=new (this.columns[i].getType())(text);
+ }
+ o[this.columns[i].getField()]=val;
+ }
+ }
+ if(dojo.html.hasAttribute(row,"value")){
+ o[this.valueField]=dojo.html.getAttribute(row,"value");
+ }
+ return o; // object
+ },
+ setSelectionByRow:function(/* HTMLTableElementRow */ row){
+ // summary
+ // create the selection object based on the passed row, makes sure it's unique.
+ // note that you need to call render manually (because of multi-select operations)
+ var o=this.getObjectFromRow(row);
+ var b=false;
+ for(var i=0;i<this.selected.length;i++){
+ if(this.compare(this.selected[i], o)){
+ b=true;
+ break;
+ }
+ }
+ if(!b){
+ this.selected.push(o);
+ }
+ },
+
+ parseColumns:function(/* HTMLTableHeadElement */ node){
+ // summary
+ // parses the passed element to create column objects
+ this.reset();
+ var row=node.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={
+ field:null,
+ format:null,
+ noSort:false,
+ sortType:"String",
+ dataType:String,
+ sortFunction:null,
+ label:null,
+ align:"left",
+ valign:"middle",
+ getField:function(){ return this.field||this.label; },
+ getType:function(){ return this.dataType; }
+ };
+ // 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");
+ }
+
+ // sorting features.
+ 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");
+ }
+ 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");
+ 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]);
+ 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")){
+ this.sortIndex=i;
+ var dir=dojo.html.getAttribute(cells[i], "sort");
+ if(!isNaN(parseInt(dir))){
+ dir=parseInt(dir);
+ this.sortDirection=(dir!=0)?1:0;
+ }else{
+ this.sortDirection=(dir.toLowerCase()=="desc")?1:0;
+ }
+ }
+ }
+ },
+
+ parseData:function(/* array */ data){
+ // summary
+ // Parse the passed JSON data structure, and cast based on columns.
+ this.data=[];
+ this.selected=[];
+ for(var i=0; i<data.length; i++){
+ var o={}; // new data object.
+ for(var j=0; j<this.columns.length; j++){
+ var field=this.columns[j].getField();
+ if(this.columns[j].sortType=="__markup__"){
+ o[field]=String(data[i][field]);
+ }else{
+ var type=this.columns[j].getType();
+ var val=data[i][field];
+ var t=this.columns[j].sortType.toLowerCase();
+ if(type == String) {
+ o[field]=val;
+ } else {
+ if(val!=null){
+ o[field]=new type(val);
+ }else{
+ o[field]=new type(); // let it use the default.
+ }
+ }
+ }
+ }
+ // check for the valueField if not already parsed.
+ if(data[i][this.valueField]&&!o[this.valueField]){
+ o[this.valueField]=data[i][this.valueField];
+ }
+ this.data.push(o);
+ }
+ },
+
+ parseDataFromTable:function(/* HTMLTableBodyElement */ tbody){
+ // summary
+ // parses the data in the tbody of a table to create a set of objects.
+ // Will add objects to this.selected if an attribute 'selected="true"' is present on the row.
+ this.data=[];
+ this.selected=[];
+ var rows=tbody.getElementsByTagName("tr");
+ for(var i=0; i<rows.length; i++){
+ if(dojo.html.getAttribute(rows[i],"ignoreIfParsed")=="true"){
+ continue;
+ }
+ var o={}; // new data object.
+ var cells=rows[i].getElementsByTagName("td");
+ for(var j=0; j<this.columns.length; j++){
+ var field=this.columns[j].getField();
+ if(this.columns[j].sortType=="__markup__"){
+ // FIXME: parse this?
+ o[field]=cells[j].innerHTML;
+ }else{
+ var type=this.columns[j].getType();
+ var val=dojo.html.renderedTextContent(cells[j]); // should be the same index as the column.
+ if(type == String){
+ o[field]=val;
+ } else {
+ if (val!=null){
+ o[field]=new type(val);
+ } else {
+ o[field]=new type(); // let it use the default.
+ }
+ }
+ }
+ }
+ if(dojo.html.hasAttribute(rows[i],"value")&&!o[this.valueField]){
+ o[this.valueField]=dojo.html.getAttribute(rows[i],"value");
+ }
+ // FIXME: add code to preserve row attributes in __metadata__ field?
+ this.data.push(o);
+
+ // add it to the selections if selected="true" is present.
+ if(dojo.html.getAttribute(rows[i],"selected")=="true"){
+ this.selected.push(o);
+ }
+ }
+ },
+
+ showSelections:function(){
+ var body=this.domNode.getElementsByTagName("tbody")[0];
+ var rows=body.getElementsByTagName("tr");
+ var idx=0;
+ for(var i=0; i<rows.length; i++){
+ if(rows[i].parentNode==body){
+ if(dojo.html.getAttribute(rows[i],"selected")=="true"){
+ rows[i].className=this.rowSelectedClass;
+ } else {
+ if(this.enableAlternateRows&&idx%2==1){
+ rows[i].className=this.rowAlternateClass;
+ }else{
+ rows[i].className="";
+ }
+ }
+ idx++;
+ }
+ }
+ },
+ render:function(bDontPreserve){
+ // summary
+ // renders the table to the browser
+ var data=[];
+ var body=this.domNode.getElementsByTagName("tbody")[0];
+
+ if(!bDontPreserve){
+ // rebuild data and selection
+ this.parseDataFromTable(body);
+ }
+
+ // clone this.data for sorting purposes.
+ for(var i=0; i<this.data.length; i++){
+ data.push(this.data[i]);
+ }
+
+ var col=this.columns[this.sortIndex];
+ if(!col.noSort){
+ var field=col.getField();
+ if(col.sortFunction){
+ var sort=col.sortFunction;
+ }else{
+ var sort=function(a,b){
+ if (a[field]>b[field]) return 1;
+ if (a[field]<b[field]) return -1;
+ return 0;
+ }
+ }
+ data.sort(sort);
+ if(this.sortDirection!=0) data.reverse();
+ }
+
+ // build the table and pop it in.
+ while(body.childNodes.length>0) body.removeChild(body.childNodes[0]);
+ for(var i=0; i<data.length;i++){
+ var row=document.createElement("tr");
+ dojo.html.disableSelection(row);
+ if (data[i][this.valueField]){
+ row.setAttribute("value",data[i][this.valueField]);
+ }
+ if(this.isSelected(data[i])){
+ row.className=this.rowSelectedClass;
+ row.setAttribute("selected","true");
+ } else {
+ if(this.enableAlternateRows&&i%2==1){
+ row.className=this.rowAlternateClass;
+ }
+ }
+ 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);
+ if(this.sortIndex==j){
+ cell.className=this.columnSelected;
+ }
+ if(this.columns[j].sortType=="__markup__"){
+ cell.innerHTML=data[i][this.columns[j].getField()];
+ for(var k=0; k<cell.childNodes.length; k++){
+ var node=cell.childNodes[k];
+ if(node&&node.nodeType==dojo.html.ELEMENT_NODE){
+ dojo.html.disableSelection(node);
+ }
+ }
+ }else{
+ if(this.columns[j].getType()==Date){
+ var format=this.defaultDateFormat;
+ if(this.columns[j].format) format=this.columns[j].format;
+ cell.appendChild(document.createTextNode(dojo.date.strftime(data[i][this.columns[j].getField()], format)));
+ }else{
+ cell.appendChild(document.createTextNode(data[i][this.columns[j].getField()]));
+ }
+ }
+ row.appendChild(cell);
+ }
+ body.appendChild(row);
+ dojo.event.connect(row, "onclick", this, "onUISelect");
+ }
+
+ // if minRows exist.
+ var minRows=parseInt(this.minRows);
+ if (!isNaN(minRows) && minRows>0 && data.length<minRows){
+ var mod=0;
+ if(data.length%2==0) mod=1;
+ var nRows=minRows-data.length;
+ for(var i=0; i<nRows; i++){
+ var row=document.createElement("tr");
+ row.setAttribute("ignoreIfParsed","true");
+ if(this.enableAlternateRows&&i%2==mod){
+ row.className=this.rowAlternateClass;
+ }
+ for(var j=0;j<this.columns.length;j++){
+ var cell=document.createElement("td");
+ cell.appendChild(document.createTextNode("\u00A0"));
+ row.appendChild(cell);
+ }
+ body.appendChild(row);
+ }
+ }
+ },
+
+ // the following the user can override.
+ onSelect:function(/* DomEvent */ e){
+ // summary
+ // empty function for the user to attach code to, fired by onUISelect
+ },
+ onUISelect:function(/* DomEvent */ e){
+ // summary
+ // fired when a user selects a row
+ var row=dojo.html.getParentByType(e.target,"tr");
+ var body=dojo.html.getParentByType(row,"tbody");
+ if(this.enableMultipleSelect){
+ if(e.metaKey||e.ctrlKey){
+ if(this.isSelected(this.getObjectFromRow(row))){
+ this.removeFromSelected(this.getObjectFromRow(row));
+ row.removeAttribute("selected");
+ }else{
+ // push onto the selection stack.
+ this.setSelectionByRow(row);
+ row.setAttribute("selected","true");
+ }
+ }else if(e.shiftKey){
+ // the tricky one. We need to figure out the *last* selected row above,
+ // and select all the rows in between.
+ var startRow;
+ var rows=body.getElementsByTagName("tr");
+ // if there's a selection above, we go with that first.
+ for(var i=0;i<rows.length;i++){
+ if(rows[i].parentNode==body){
+ if(rows[i]==row) break;
+ if(dojo.html.getAttribute(rows[i],"selected")=="true"){
+ startRow=rows[i];
+ }
+ }
+ }
+ // if there isn't a selection above, we continue with a selection below.
+ if(!startRow){
+ startRow=row;
+ for(;i<rows.length;i++){
+ if(dojo.html.getAttribute(rows[i],"selected")=="true"){
+ row=rows[i];
+ break;
+ }
+ }
+ }
+ this.resetSelections(body);
+ if(startRow==row){
+ // this is the only selection
+ row.setAttribute("selected","true");
+ this.setSelectionByRow(row);
+ }else{
+ var doSelect=false;
+ for(var i=0; i<rows.length; i++){
+ if(rows[i].parentNode==body){
+ rows[i].removeAttribute("selected");
+ if(rows[i]==startRow){
+ doSelect=true;
+ }
+ if(doSelect){
+ this.setSelectionByRow(rows[i]);
+ rows[i].setAttribute("selected","true");
+ }
+ if(rows[i]==row){
+ doSelect=false;
+ }
+ }
+ }
+ }
+ }else{
+ // reset the selection
+ this.resetSelections(body);
+ row.setAttribute("selected","true");
+ this.setSelectionByRow(row);
+ }
+ }else{
+ // reset the data selection and go.
+ this.resetSelections(body);
+ row.setAttribute("selected","true");
+ this.setSelectionByRow(row);
+ }
+ this.showSelections();
+ this.onSelect(e);
+ e.stopPropagation();
+ e.preventDefault();
+ },
+ onHeaderClick:function(/* DomEvent */ e){
+ // summary
+ // Main handler function for each header column click.
+ 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++){
+ if(headers[i]==header){
+ if(i!=oldIndex){
+ // new col.
+ this.sortIndex=i;
+ this.sortDirection=0;
+ headers[i].className=this.headerSortDownClass
+ }else{
+ this.sortDirection=(oldDirection==0)?1:0;
+ if(this.sortDirection==0){
+ headers[i].className=this.headerSortDownClass;
+ }else{
+ headers[i].className=this.headerSortUpClass;
+ }
+ }
+ }else{
+ // reset the header class.
+ headers[i].className=this.headerClass;
+ }
+ }
+ this.render();
+ },
+
+ postCreate:function(){
+ // summary
+ // overridden from HtmlWidget, initializes and renders the widget.
+ var thead=this.domNode.getElementsByTagName("thead")[0];
+ if(this.headClass.length>0){
+ thead.className=this.headClass;
+ }
+
+ // disable selections
+ dojo.html.disableSelection(this.domNode);
+
+ // parse the columns.
+ this.parseColumns(thead);
+
+ // attach header handlers.
+ var header="td";
+ if(thead.getElementsByTagName(header).length==0) header="th";
+ var headers=thead.getElementsByTagName(header);
+ for(var i=0; i<headers.length; i++){
+ if(!this.columns[i].noSort){
+ dojo.event.connect(headers[i], "onclick", this, "onHeaderClick");
+ }
+ if(this.sortIndex==i){
+ if(this.sortDirection==0){
+ headers[i].className=this.headerSortDownClass;
+ }else{
+ headers[i].className=this.headerSortUpClass;
+ }
+ }
+ }
+
+ // parse the tbody element and re-render it.
+ var tbody=this.domNode.getElementsByTagName("tbody")[0];
+ if (this.tbodyClass.length>0) {
+ tbody.className=this.tbodyClass;
+ }
+
+ this.parseDataFromTable(tbody);
+ this.render(true);
+ }
+ }
+);