You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@myfaces.apache.org by we...@apache.org on 2006/01/27 00:58:20 UTC
svn commit: r372668 [12/16] - in
/myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource:
./ src/ src/alg/ src/animation/ src/collections/ src/crypto/ src/data/
src/dnd/ src/event/ src/flash/ src/flash/flash6/ sr...
Added: myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/FisheyeList.js
URL: http://svn.apache.org/viewcvs/myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/FisheyeList.js?rev=372668&view=auto
==============================================================================
--- myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/FisheyeList.js (added)
+++ myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/FisheyeList.js Thu Jan 26 15:56:50 2006
@@ -0,0 +1,742 @@
+/*
+ Copyright (c) 2004-2005, 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.FisheyeList");
+dojo.provide("dojo.widget.html.FisheyeList");
+dojo.provide("dojo.widget.html.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.widget.Container");
+dojo.require("dojo.dom");
+dojo.require("dojo.html");
+dojo.require("dojo.style");
+dojo.require("dojo.event");
+
+dojo.widget.tags.addParseTreeHandler("dojo:FisheyeList");
+dojo.widget.tags.addParseTreeHandler("dojo:FisheyeListItem");
+
+dojo.widget.html.FisheyeList = function(){
+ dojo.widget.html.Container.call(this);
+}
+dojo.inherits(dojo.widget.html.FisheyeList, dojo.widget.html.Container);
+
+dojo.lang.extend(dojo.widget.html.FisheyeList, {
+
+ templateString: '<div class="dojoHtmlFisheyeListBar"></div>',
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/HtmlFisheyeList.css"),
+ widgetType: "FisheyeList",
+
+ EDGE: {
+ CENTER: 0,
+ LEFT: 1,
+ RIGHT: 2,
+ TOP: 3,
+ BOTTOM: 4
+ },
+
+ 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.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();
+
+ //
+ // 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");
+ },
+
+ onBodyOut: function(e){
+ // clicking over an object inside of body causes this event to fire; ignore that case
+ if( dojo.html.overElement(dojo.html.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) {
+ var p = this.getCursorPos(e);
+
+ if ((p.x >= this.hitX1) && (p.x <= this.hitX2) &&
+ (p.y >= this.hitY1) && (p.y <= this.hitY2)){
+ if( !this.isOver ){
+ this.setActive(e);
+ }
+ this.onGridMouseMove(p.x-this.hitX1, p.y-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 labelW = dojo.style.getOuterWidth(itm.lblNode);
+ var labelH = dojo.style.getOuterHeight(itm.lblNode);
+
+ if (this.labelEdge == this.EDGE.TOP){
+ x = Math.round((itm.sizeW / 2) - (labelW / 2));
+ y = -labelH;
+ }
+
+ if (this.labelEdge == this.EDGE.BOTTOM){
+ x = Math.round((itm.sizeW / 2) - (labelW / 2));
+ y = itm.sizeH;
+ }
+
+ if (this.labelEdge == this.EDGE.LEFT){
+ x = -labelW;
+ y = Math.round((itm.sizeH / 2) - (labelH / 2));
+ }
+
+ if (this.labelEdge == this.EDGE.RIGHT){
+ x = itm.sizeW;
+ y = Math.round((itm.sizeH / 2) - (labelH / 2));
+ }
+
+ itm.lblNode.style.left = x + 'px';
+ itm.lblNode.style.top = y + 'px';
+ },
+
+ getCursorPos: function(e){
+ return {
+ 'x': e.pageX || e.clientX + dojo.html.body().scrollLeft,
+ 'y': e.pageY || e.clientY + dojo.html.body().scrollTop
+ };
+ },
+
+ calcHitGrid: function(){
+
+ var pos = dojo.style.getAbsolutePosition(this.domNode);
+
+ 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);
+ }
+ }
+
+});
+
+dojo.widget.html.FisheyeListItem = function(){
+ dojo.widget.HtmlWidget.call(this);
+}
+dojo.inherits(dojo.widget.html.FisheyeListItem, dojo.widget.HtmlWidget);
+
+dojo.lang.extend(dojo.widget.html.FisheyeListItem, {
+ widgetType: "FisheyeListItem",
+
+ // 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)){
+ 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() {
+ }
+});
+
Added: myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/FloatingPane.js
URL: http://svn.apache.org/viewcvs/myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/FloatingPane.js?rev=372668&view=auto
==============================================================================
--- myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/FloatingPane.js (added)
+++ myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/FloatingPane.js Thu Jan 26 15:56:50 2006
@@ -0,0 +1,528 @@
+/*
+ Copyright (c) 2004-2005, 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.FloatingPane");
+dojo.provide("dojo.widget.html.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.style");
+dojo.require("dojo.dom");
+dojo.require("dojo.widget.ContentPane");
+dojo.require("dojo.widget.LayoutPane");
+dojo.require("dojo.dnd.HtmlDragMove");
+dojo.require("dojo.dnd.HtmlDragMoveSource");
+dojo.require("dojo.dnd.HtmlDragMoveObject");
+
+dojo.widget.html.FloatingPane = function(){
+ dojo.widget.html.LayoutPane.call(this);
+}
+
+dojo.inherits(dojo.widget.html.FloatingPane, dojo.widget.html.LayoutPane);
+
+dojo.lang.extend(dojo.widget.html.FloatingPane, {
+ widgetType: "FloatingPane",
+
+ // Constructor arguments
+ title: '',
+ iconSrc: '',
+ hasShadow: false,
+ constrainToContainer: false,
+ taskBarId: "",
+ resizable: true, // note: if specified, user must include ResizeHandle
+ overflow: "",
+
+ resizable: false,
+ titleBarDisplay: "fancy",
+ titleHeight: 22, // workaround to CSS loading race condition bug
+
+ href: "",
+ extractContent: true,
+ parseContent: true,
+ cacheContent: true,
+
+ // FloatingPane supports 3 modes for the client area (the part below the title bar)
+ // default - client area is a ContentPane, that can hold
+ // either inlined data and/or data downloaded from a URL
+ // layout - the client area is a layout pane
+ // none - the user specifies a single widget which becomes the content pane
+ contentWrapper: "default",
+
+ containerNode: null,
+ domNode: null,
+ clientPane: null,
+ dragBar: null,
+
+ windowState: "normal",
+ displayCloseAction: false,
+
+ maxTaskBarConnectAttempts: 5,
+ taskBarConnectAttempts: 0,
+
+ minimizeIcon: dojo.uri.dojoUri("src/widget/templates/images/floatingPaneMinimize.gif"),
+ maximizeIcon: dojo.uri.dojoUri("src/widget/templates/images/floatingPaneMaximize.gif"),
+ restoreIcon: dojo.uri.dojoUri("src/widget/templates/images/floatingPaneRestore.gif"),
+ closeIcon: dojo.uri.dojoUri("src/widget/templates/images/floatingPaneClose.gif"),
+ titleBarBackground: dojo.uri.dojoUri("src/widget/templates/images/titlebar-bg.jpg"),
+
+ shadowPng: dojo.uri.dojoUri("src/widget/templates/images/shadow"),
+ shadowThickness: 8,
+ shadowOffset: 15,
+
+ templateString: '<div></div>',
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/HtmlFloatingPane.css"),
+
+ initialized: false,
+
+ addChild: function(child, overrideContainerNode, pos, ref, insertIndex) {
+ this.clientPane.addChild(child, overrideContainerNode, pos, ref, insertIndex);
+ },
+
+ // make a widget container to hold all the contents of the floating pane (other than the
+ // title and the resize bar at the bottom)
+ _makeClientPane: function(clientDiv){
+ var args = {
+ layoutAlign: "client",
+ id:this.widgetId+"_client",
+ href: this.href,
+ cacheContent: this.cacheContent,
+ extractContent: this.extractContent,
+ parseContent: this.parseContent
+ };
+ var pane = this._createPane(this.contentWrapper=="layout"?"LayoutPane":"ContentPane", clientDiv, args);
+ return pane;
+ },
+
+ fillInTemplate: function(args, frag){
+ var source = this.getFragNodeRef(frag);
+
+ // Copy style info and id from input node to output node
+ this.domNode.style.cssText = source.style.cssText;
+ dojo.html.addClass(this.domNode, dojo.html.getClass(source));
+ dojo.html.addClass(this.domNode, "dojoFloatingPane");
+ this.domNode.style.position="absolute";
+ this.domNode.id = source.id;
+ if(dojo.render.html.safari){
+ dojo.html.body().appendChild(this.domNode);
+ }
+
+ // make client pane wrapper to hold the contents of this floating pane
+ if(this.contentWrapper!="none"){
+ var clientDiv = document.createElement('div');
+ dojo.dom.moveChildren(source, clientDiv, 0);
+ this.clientPane = this._makeClientPane(clientDiv);
+ }
+
+ if (this.titleBarDisplay != "none") {
+ // this is our chrome
+ var chromeDiv = document.createElement('div');
+ dojo.html.addClass(chromeDiv, 'dojoFloatingPaneDragbar');
+ chromeDiv.style.height=this.titleHeight+"px"; // workaround CSS loading race condition bug
+
+ this.dragBar = this._createPane("LayoutPane", chromeDiv, {layoutAlign: 'top', id:this.widgetId+"_chrome"});
+ dojo.html.disableSelection(this.dragBar.domNode);
+
+ if( this.titleBarDisplay == "fancy"){
+ // image background to get gradient
+ var img = document.createElement('img');
+ img.src = this.titleBarBackground;
+ dojo.html.addClass(img, 'dojoFloatingPaneDragbarBackground');
+ var backgroundPane = dojo.widget.createWidget("ContentPane", {layoutAlign:"flood", id:this.widgetId+"_titleBackground"}, img);
+ this.dragBar.addChild(backgroundPane);
+ }
+
+ //Title Bar
+ var titleBar = document.createElement('div');
+ dojo.html.addClass(titleBar, "dojoFloatingPaneTitleBar");
+ dojo.html.disableSelection(titleBar);
+
+ //TitleBarActions
+ var titleBarActions = document.createElement('div');
+ dojo.html.addClass(titleBarActions, "dojoFloatingPaneActions");
+
+ //Title Icon
+ if(this.iconSrc!=""){
+ var titleIcon = document.createElement('img');
+ dojo.html.addClass(titleIcon,"dojoTitleBarIcon");
+ titleIcon.src = this.iconSrc;
+ titleBar.appendChild(titleIcon);
+ }
+
+ //Title text
+ var titleText = document.createTextNode(this.title)
+ titleBar.appendChild(titleText);
+
+ if (this.resizable) {
+
+ //FloatingPane Action Minimize
+ this.minimizeAction = document.createElement("img");
+ dojo.html.addClass(this.minimizeAction, "dojoFloatingPaneActionItem");
+ this.minimizeAction.src = this.minimizeIcon;
+ titleBarActions.appendChild(this.minimizeAction);
+ dojo.event.connect(this.minimizeAction, 'onclick', this, 'minimizeWindow');
+
+ //FloatingPane Action Restore
+ this.restoreAction = document.createElement("img");
+ dojo.html.addClass(this.restoreAction, "dojoFloatingPaneActionItem");
+ this.restoreAction.src = this.restoreIcon;
+ titleBarActions.appendChild(this.restoreAction);
+ dojo.event.connect(this.restoreAction, 'onclick', this, 'restoreWindow');
+
+ if (this.windowState != "normal") {
+ this.restoreAction.style.display="inline";
+ } else {
+ this.restoreAction.style.display="none";
+ }
+
+ //FloatingPane Action Maximize
+ this.maximizeAction = document.createElement("img");
+ dojo.html.addClass(this.maximizeAction, "dojoFloatingPaneActionItem");
+ this.maximizeAction.src = this.maximizeIcon;
+ titleBarActions.appendChild(this.maximizeAction);
+ dojo.event.connect(this.maximizeAction, 'onclick', this, 'maximizeWindow');
+
+ if (this.windowState != "maximized") {
+ this.maximizeAction.style.display="inline";
+ } else {
+ this.maximizeAction.style.display="none";
+ }
+
+ }
+
+ if (this.displayCloseAction) {
+ //FloatingPane Action Close
+ var closeAction= document.createElement("img");
+ dojo.html.addClass(closeAction, "dojoFloatingPaneActionItem");
+ closeAction.src = this.closeIcon;
+ titleBarActions.appendChild(closeAction);
+ dojo.event.connect(closeAction, 'onclick', this, 'closeWindow');
+ }
+
+
+ chromeDiv.appendChild(titleBar);
+ chromeDiv.appendChild(titleBarActions);
+ }
+
+ if ( this.resizable ) {
+ // add the resize handle
+ var resizeDiv = document.createElement('div');
+ dojo.html.addClass(resizeDiv, "dojoFloatingPaneResizebar");
+ dojo.html.disableSelection(resizeDiv);
+ var rh = dojo.widget.createWidget("ResizeHandle", {targetElmId: this.widgetId, id:this.widgetId+"_resize"});
+ this.resizePane = this._createPane("ContentPane", resizeDiv, {layoutAlign: "bottom"});
+ this.resizePane.addChild(rh);
+ }
+
+ // add a drop shadow
+ this._makeShadow();
+
+ dojo.event.connect(this.domNode, 'onmousedown', this, 'onMouseDown');
+
+ // Prevent IE bleed-through problem
+ this.bgIframe = new dojo.html.BackgroundIframe();
+ if( this.bgIframe.iframe ){
+ this.domNode.appendChild(this.bgIframe.iframe);
+ }
+ if ( this.isVisible() ) {
+ this.bgIframe.show();
+ };
+
+ if( this.taskBarId ){
+ this.taskBarSetup();
+ }
+
+ if (dojo.hostenv.post_load_) {
+ this.setInitialWindowState();
+ } else {
+ dojo.addOnLoad(this, "setInitialWindowState");
+ }
+ if(dojo.render.html.safari){
+ dojo.html.body().removeChild(this.domNode);
+ }
+
+ dojo.widget.html.FloatingPane.superclass.postCreate.call(this, args, frag);
+ },
+
+ postCreate: function(args, frag){
+ // Make the client pane. It will either be the widget specified by the user,
+ // or a wrapper widget
+ if(this.contentWrapper=="none"){
+ // the user has specified a single widget which will become our content
+ this.clientPane = this.children[0];
+ this.domNode.appendChild(this.clientPane.domNode);
+ }else{
+ // move our 'children' into the client pane
+ // we already moved the domnodes, but now we need to move the 'children'
+ var kids = this.children.concat();
+ this.children = [];
+
+ for(var i=0; i<kids.length; i++){
+ if (kids[i].ownerPane == this){
+ this.children.push(kids[i]);
+ }else{
+ if(this.contentWrapper=="layout"){
+ this.clientPane.addChild(kids[i]);
+ }else{
+ this.clientPane.children.push(kids[i]);
+ }
+ }
+ }
+ }
+ dojo.html.addClass(this.clientPane.domNode, 'dojoFloatingPaneClient');
+ this.clientPane.layoutAlign="client";
+ this.clientPane.ownerPane=this;
+ if (this.overflow != "") {
+ this.clientPane.domNode.style.overflow=this.overflow;
+ }
+
+ if (this.titleBarDisplay != "none") {
+ var drag = new dojo.dnd.HtmlDragMoveSource(this.domNode);
+
+ if (this.constrainToContainer) {
+ drag.constrainTo();
+ }
+
+ drag.setDragHandle(this.dragBar.domNode);
+ }
+
+ this.initialized=true;
+ },
+
+ _makeShadow: function(){
+ if ( this.hasShadow ) {
+ // make all the pieces of the shadow, and position/size them as much
+ // as possible (but a lot of the coordinates are set in sizeShadow
+ this.shadow={};
+ var x1 = -1 * this.shadowThickness;
+ var y0 = this.shadowOffset;
+ var y1 = this.shadowOffset + this.shadowThickness;
+ this._makeShadowPiece("ul", "top", y0, "left", x1);
+ this._makeShadowPiece("l", "top", y1, "left", x1, "scale");
+ this._makeShadowPiece("ur", "top", y0, "left", 0);
+ this._makeShadowPiece("r", "top", y1, "left", 0, "scale");
+ this._makeShadowPiece("bl", "top", 0, "left", x1);
+ this._makeShadowPiece("b", "top", 0, "left", 0, "crop");
+ this._makeShadowPiece("br", "top", 0, "left", 0);
+ }
+ },
+
+ _makeShadowPiece: function(name, vertAttach, vertCoord, horzAttach, horzCoord, sizing){
+ var img;
+ var url = this.shadowPng + name.toUpperCase() + ".png";
+ if(dojo.render.html.ie){
+ img=document.createElement("div");
+ img.style.filter="progid:DXImageTransform.Microsoft.AlphaImageLoader(src='"+url+"'"+
+ (sizing?", sizingMethod='"+sizing+"'":"") + ")";
+ }else{
+ img=document.createElement("img");
+ img.src=url;
+ }
+ img.style.position="absolute";
+ img.style[vertAttach]=vertCoord+"px";
+ img.style[horzAttach]=horzCoord+"px";
+ img.style.width=this.shadowThickness+"px";
+ img.style.height=this.shadowThickness+"px";
+ this.shadow[name]=img;
+ this.domNode.appendChild(img);
+ },
+
+ _sizeShadow: function(width, height){
+ if ( this.shadow ) {
+ var sideHeight = height - (this.shadowOffset+this.shadowThickness+1);
+ this.shadow.l.style.height = sideHeight+"px";
+ this.shadow.r.style.height = sideHeight+"px";
+ this.shadow.b.style.width = (width-1)+"px";
+ this.shadow.bl.style.top = (height-1)+"px";
+ this.shadow.b.style.top = (height-1)+"px";
+ this.shadow.br.style.top = (height-1)+"px";
+ this.shadow.ur.style.left = (width-1)+"px";
+ this.shadow.r.style.left = (width-1)+"px";
+ this.shadow.br.style.left = (width-1)+"px";
+ }
+ },
+
+ maximizeWindow: function(evt) {
+ this.previousWidth= this.domNode.style.width;
+ this.previousHeight= this.domNode.style.height;
+ this.previousLeft = this.domNode.style.left;
+ this.previousTop = this.domNode.style.top;
+
+ this.domNode.style.left =
+ dojo.style.getPixelValue(this.domNode.parentNode, "padding-left", true) + "px";
+ this.domNode.style.top =
+ dojo.style.getPixelValue(this.domNode.parentNode, "padding-top", true) + "px";
+
+ if ((this.domNode.parentNode.nodeName.toLowerCase() == 'body')) {
+ dojo.style.setOuterWidth(this.domNode, dojo.html.getViewportWidth()-dojo.style.getPaddingWidth(dojo.html.body()));
+ dojo.style.setOuterHeight(this.domNode, dojo.html.getViewportHeight()-dojo.style.getPaddingHeight(dojo.html.body()));
+ } else {
+ dojo.style.setOuterWidth(this.domNode, dojo.style.getContentWidth(this.domNode.parentNode));
+ dojo.style.setOuterHeight(this.domNode, dojo.style.getContentHeight(this.domNode.parentNode));
+ }
+ this.maximizeAction.style.display="none";
+ this.restoreAction.style.display="inline";
+ this.windowState="maximized";
+ this.onResized();
+ },
+
+ minimizeWindow: function(evt) {
+ this.hide();
+ if (this.resizable) {
+ this.maximizeAction.style.display="inline";
+ this.restoreAction.style.display="inline";
+ }
+
+ this.windowState = "minimized";
+ },
+
+ restoreWindow: function(evt) {
+ if (this.previousWidth && this.previousHeight && this.previousLeft && this.previousTop) {
+ this.domNode.style.width = this.previousWidth;
+ this.domNode.style.height = this.previousHeight;
+ this.domNode.style.left = this.previousLeft;
+ this.domNode.style.top = this.previousTop;
+ dojo.widget.html.FloatingPane.superclass.onResized.call(this);
+ }
+
+ if (this.widgetState != "maximized") {
+ this.show();
+ }
+
+ if (this.resizable) {
+ this.maximizeAction.style.display="inline";
+ this.restoreAction.style.display="none";
+ }
+
+ this.bringToTop();
+ this.windowState="normal";
+ },
+
+ closeWindow: function(evt) {
+ this.destroy();
+ },
+
+ onMouseDown: function(evt) {
+ this.bringToTop();
+ },
+
+ bringToTop: function() {
+ var floatingPaneStartingZ = 100;
+ var floatingPanes= dojo.widget.manager.getWidgetsByType("FloatingPane");
+ var windows = []
+ var y=0;
+ 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);
+
+ for (x=0; x<windows.length;x++) {
+ windows[x].domNode.style.zIndex = floatingPaneStartingZ + x;
+ }
+ },
+
+ setInitialWindowState: function() {
+ if (this.windowState == "maximized") {
+ this.maximizeWindow();
+ this.show();
+ this.bringToTop();
+ return;
+ }
+
+ if (this.windowState=="normal") {
+ dojo.lang.setTimeout(this, this.onResized, 50);
+ this.show();
+ this.bringToTop();
+ 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);
+ },
+
+ onResized: function(){
+ if( !this.isVisible() ){ return; }
+ var newHeight = dojo.style.getInnerHeight(this.domNode);
+ var newWidth = dojo.style.getInnerWidth(this.domNode);
+
+ //if ( newWidth != this.width || newHeight != this.height ) {
+ this.width = newWidth;
+ this.height = newHeight;
+ this._sizeShadow(newWidth, newHeight);
+ dojo.widget.html.FloatingPane.superclass.onResized.call(this);
+ //}
+
+ // bgIframe is a child of this.domNode, so position should be relative to [0,0]
+ if(this.bgIframe){
+ this.bgIframe.size([0, 0, newWidth, newHeight]);
+ }
+ },
+
+ hide: function(){
+ dojo.widget.html.FloatingPane.superclass.hide.call(this);
+ if(this.bgIframe){
+ this.bgIframe.hide();
+ }
+ },
+
+ show: function(){
+ dojo.widget.html.FloatingPane.superclass.show.call(this);
+ if(this.bgIframe){
+ this.bgIframe.show();
+ }
+ },
+
+ _createPane: function(type, node, args){
+ var pane = dojo.widget.createWidget(type, args, node);
+ dojo.widget.html.FloatingPane.superclass.addChild.call(this,pane);
+ pane.ownerPane=this;
+ return pane;
+ },
+
+ setUrl: function(url){
+ this.clientPane.setUrl(url);
+ },
+
+ setContent: function(str){
+ this.clientPane.setContent(str);
+ }
+});
+
+dojo.widget.tags.addParseTreeHandler("dojo:FloatingPane");
Added: myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/HslColorPicker.js
URL: http://svn.apache.org/viewcvs/myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/HslColorPicker.js?rev=372668&view=auto
==============================================================================
--- myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/HslColorPicker.js (added)
+++ myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/HslColorPicker.js Thu Jan 26 15:56:50 2006
@@ -0,0 +1,25 @@
+/*
+ Copyright (c) 2004-2005, 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.HslColorPicker");
+
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.Widget");
+dojo.require("dojo.graphics.color");
+dojo.widget.tags.addParseTreeHandler("dojo:hslcolorpicker");
+
+dojo.requireAfterIf(dojo.render.svg.support.builtin, "dojo.widget.svg.HslColorPicker");
+
+dojo.widget.HslColorPicker=function(){
+ dojo.widget.Widget.call(this);
+ this.widgetType = "HslColorPicker";
+ this.isContainer = false;
+}
+dojo.inherits(dojo.widget.HslColorPicker, dojo.widget.Widget);
Added: myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/HtmlWidget.js
URL: http://svn.apache.org/viewcvs/myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/HtmlWidget.js?rev=372668&view=auto
==============================================================================
--- myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/HtmlWidget.js (added)
+++ myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/HtmlWidget.js Thu Jan 26 15:56:50 2006
@@ -0,0 +1,226 @@
+/*
+ Copyright (c) 2004-2005, 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.HtmlWidget");
+dojo.require("dojo.widget.DomWidget");
+dojo.require("dojo.html");
+dojo.require("dojo.string");
+
+dojo.widget.HtmlWidget = function(args){
+ // mixin inheritance
+ dojo.widget.DomWidget.call(this);
+}
+
+dojo.inherits(dojo.widget.HtmlWidget, dojo.widget.DomWidget);
+
+dojo.lang.extend(dojo.widget.HtmlWidget, {
+ widgetType: "HtmlWidget",
+
+ templateCssPath: null,
+ templatePath: null,
+ allowResizeX: true,
+ allowResizeY: true,
+
+ resizeGhost: null,
+ initialResizeCoords: 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, define show()&hide()
+ dojo.lang.mixin(this,
+ dojo.widget.HtmlWidget.Toggle[dojo.string.capitalize(this.toggle)] ||
+ dojo.widget.HtmlWidget.Toggle.Plain);
+ },
+
+ getContainerHeight: function(){
+ // NOTE: container height must be returned as the INNER height
+ dj_unimplemented("dojo.widget.HtmlWidget.getContainerHeight");
+ },
+
+ getContainerWidth: function(){
+ return this.parent.domNode.offsetWidth;
+ },
+
+ setNativeHeight: function(height){
+ var ch = this.getContainerHeight();
+ },
+
+ startResize: function(coords){
+ // get the left and top offset of our dom node
+ coords.offsetLeft = dojo.html.totalOffsetLeft(this.domNode);
+ coords.offsetTop = dojo.html.totalOffsetTop(this.domNode);
+ coords.innerWidth = dojo.html.getInnerWidth(this.domNode);
+ coords.innerHeight = dojo.html.getInnerHeight(this.domNode);
+ if(!this.resizeGhost){
+ this.resizeGhost = document.createElement("div");
+ var rg = this.resizeGhost;
+ rg.style.position = "absolute";
+ rg.style.backgroundColor = "white";
+ rg.style.border = "1px solid black";
+ dojo.html.setOpacity(rg, 0.3);
+ dojo.html.body().appendChild(rg);
+ }
+ with(this.resizeGhost.style){
+ left = coords.offsetLeft + "px";
+ top = coords.offsetTop + "px";
+ }
+ this.initialResizeCoords = coords;
+ this.resizeGhost.style.display = "";
+ this.updateResize(coords, true);
+ },
+
+ updateResize: function(coords, override){
+ var dx = coords.x-this.initialResizeCoords.x;
+ var dy = coords.y-this.initialResizeCoords.y;
+ with(this.resizeGhost.style){
+ if((this.allowResizeX)||(override)){
+ width = this.initialResizeCoords.innerWidth + dx + "px";
+ }
+ if((this.allowResizeY)||(override)){
+ height = this.initialResizeCoords.innerHeight + dy + "px";
+ }
+ }
+ },
+
+ endResize: function(coords){
+ // FIXME: need to actually change the size of the widget!
+ var dx = coords.x-this.initialResizeCoords.x;
+ var dy = coords.y-this.initialResizeCoords.y;
+ with(this.domNode.style){
+ if(this.allowResizeX){
+ width = this.initialResizeCoords.innerWidth + dx + "px";
+ }
+ if(this.allowResizeY){
+ height = this.initialResizeCoords.innerHeight + dy + "px";
+ }
+ }
+ this.resizeGhost.style.display = "none";
+ },
+
+ resizeSoon: function(){
+ if ( this.isVisible() ) {
+ dojo.lang.setTimeout(this, this.onResized, 0);
+ }
+ },
+
+ createNodesFromText: function(txt, wrap){
+ return dojo.html.createNodesFromText(txt, wrap);
+ },
+
+ _old_buildFromTemplate: dojo.widget.DomWidget.prototype.buildFromTemplate,
+
+ buildFromTemplate: function(args, frag){
+ if(dojo.widget.DomWidget.templates[this.widgetType]){
+ var ot = dojo.widget.DomWidget.templates[this.widgetType];
+ dojo.widget.DomWidget.templates[this.widgetType] = {};
+ }
+ if(args["templatecsspath"]){
+ args["templateCssPath"] = args["templatecsspath"];
+ }
+ if(args["templatepath"]){
+ args["templatePath"] = args["templatepath"];
+ }
+ dojo.widget.buildFromTemplate(this, args["templatePath"], args["templateCssPath"]);
+ this._old_buildFromTemplate(args, frag);
+ dojo.widget.DomWidget.templates[this.widgetType] = ot;
+ },
+
+ destroyRendering: function(finalize){
+ try{
+ var tempNode = this.domNode.parentNode.removeChild(this.domNode);
+ if(!finalize){
+ dojo.event.browser.clean(tempNode);
+ }
+ delete tempNode;
+ }catch(e){ /* squelch! */ }
+ },
+
+ // Displaying/hiding the widget
+
+ isVisible: function(){
+ return dojo.html.isVisible(this.domNode);
+ },
+ doToggle: function(){
+ this.isVisible() ? this.hide() : this.show();
+ },
+ show: function(){
+ this.animationInProgress=true;
+ this.showMe();
+ },
+ onShow: function(){
+ this.animationInProgress=false;
+ },
+ hide: function(){
+ this.animationInProgress=true;
+ this.hideMe();
+ },
+ onHide: function(){
+ this.animationInProgress=false;
+ }
+});
+
+
+/****
+ Strategies for displaying/hiding widget
+*****/
+
+dojo.widget.HtmlWidget.Toggle={}
+
+dojo.widget.HtmlWidget.Toggle.Plain = {
+ showMe: function(){
+ dojo.html.show(this.domNode);
+ if(dojo.lang.isFunction(this.onShow)){ this.onShow(); }
+ },
+
+ hideMe: function(){
+ dojo.html.hide(this.domNode);
+ if(dojo.lang.isFunction(this.onHide)){ this.onHide(); }
+ }
+}
+
+dojo.widget.HtmlWidget.Toggle.Fade = {
+ showMe: function(){
+ dojo.fx.html.fadeShow(this.domNode, this.toggleDuration, dojo.lang.hitch(this, this.onShow));
+ },
+
+ hideMe: function(){
+ dojo.fx.html.fadeHide(this.domNode, this.toggleDuration, dojo.lang.hitch(this, this.onHide));
+ }
+}
+
+dojo.widget.HtmlWidget.Toggle.Wipe = {
+ showMe: function(){
+ dojo.fx.html.wipeIn(this.domNode, this.toggleDuration, dojo.lang.hitch(this, this.onShow));
+ },
+
+ hideMe: function(){
+ dojo.fx.html.wipeOut(this.domNode, this.toggleDuration, dojo.lang.hitch(this, this.onHide));
+ }
+}
+
+dojo.widget.HtmlWidget.Toggle.Explode = {
+ showMe: function(){
+ dojo.fx.html.explode(this.explodeSrc, this.domNode, this.toggleDuration,
+ dojo.lang.hitch(this, this.onShow));
+ },
+
+ hideMe: function(){
+ dojo.fx.html.implode(this.domNode, this.explodeSrc, this.toggleDuration,
+ dojo.lang.hitch(this, this.onHide));
+ }
+}
Added: myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/InlineEditBox.js
URL: http://svn.apache.org/viewcvs/myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/InlineEditBox.js?rev=372668&view=auto
==============================================================================
--- myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/InlineEditBox.js (added)
+++ myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/InlineEditBox.js Thu Jan 26 15:56:50 2006
@@ -0,0 +1,196 @@
+/*
+ Copyright (c) 2004-2005, 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.InlineEditBox");
+dojo.provide("dojo.widget.html.InlineEditBox");
+
+dojo.require("dojo.widget.*");
+dojo.require("dojo.fx.*");
+dojo.require("dojo.graphics.color");
+dojo.require("dojo.string");
+dojo.require("dojo.style");
+dojo.require("dojo.html");
+
+dojo.widget.tags.addParseTreeHandler("dojo:inlineeditbox");
+
+dojo.widget.html.InlineEditBox = function(){
+ dojo.widget.HtmlWidget.call(this);
+ // mutable objects need to be in constructor to give each instance its own copy
+ this.history = [];
+ this.storage = document.createElement("span");
+}
+
+dojo.inherits(dojo.widget.html.InlineEditBox, dojo.widget.HtmlWidget);
+
+dojo.lang.extend(dojo.widget.html.InlineEditBox, {
+ templatePath: dojo.uri.dojoUri("src/widget/templates/HtmlInlineEditBox.html"),
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/HtmlInlineEditBox.css"),
+ widgetType: "InlineEditBox",
+
+ 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){},
+
+ // overwrite buildRendering so we don't clobber our list
+ buildRendering: function(args, frag){
+ this.nodeRef = frag["dojo:"+this.widgetType.toLowerCase()]["nodeRef"];
+ var node = this.nodeRef;
+ if(node.normalize){ node.normalize(); }
+
+ dojo.widget.buildAndAttachTemplate(this);
+
+ this.editable = document.createElement("span");
+ // this.editable.appendChild(node.firstChild);
+ while(node.firstChild){
+ this.editable.appendChild(node.firstChild);
+ }
+ // this.textValue = this.editable.firstChild.nodeValue;
+ this.textValue = dojo.string.trim(this.editable.innerHTML);
+ if(dojo.string.trim(this.textValue).length == 0){
+ this.editable.innerHTML = this.defaultText;
+ }
+ /*
+ if(node.hasChildNodes()) {
+ node.insertBefore(this.editable, node.firstChild);
+ } else {
+ }
+ */
+ node.appendChild(this.editable);
+
+ // delay to try and show up before stylesheet
+ var _this = this;
+ setTimeout(function(){
+ _this.editable.appendChild(_this.edit);
+ }, 30);
+
+ 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.fillInTemplate(args, frag);
+ },
+
+ 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((e)&&(e.target != this.domNode)){ return; }
+ if(!this.editing){
+ dojo.html.removeClass(this.editable, "editableRegion");
+ dojo.html.removeClass(this.editable, "editableTextareaRegion");
+ }
+ },
+
+ beginEdit: function(e){
+ if(this.editing){ return; }
+ this.mouseout();
+ this.editing = true;
+
+ var ee = this[this.mode.toLowerCase()];
+
+ ee.style.display = "";
+ ee.value = dojo.string.trim(this.textValue);
+ ee.style.fontSize = dojo.style.getStyle(this.editable, "font-size");
+ ee.style.fontWeight = dojo.style.getStyle(this.editable, "font-weight");
+ ee.style.fontStyle = dojo.style.getStyle(this.editable, "font-style");
+ //this.text.style.fontFamily = dojo.dom.getStyle(this.editable, "font-family");
+
+ ee.style.width = Math.max(dojo.html.getInnerWidth(this.editable), this.minWidth) + "px";
+ // ee.style.width = "100%";
+
+ if(this.mode.toLowerCase()=="textarea"){
+ ee.style.display = "block";
+ ee.style.height = Math.max(dojo.html.getInnerHeight(this.editable), this.minHeight) + "px";
+ }
+ this.editable.style.display = "none";
+ this.nodeRef.appendChild(this.form);
+ 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 = this.textValue;
+ }else{
+ this.doFade = false;
+ }
+ this.finishEdit(e);
+ },
+
+ cancelEdit: function(e){
+ if(!this.editing){ return false; }
+ this.editing = false;
+ this.nodeRef.removeChild(this.form);
+ this.editable.style.display = "";
+ return true;
+ },
+
+ finishEdit: function(e){
+ if(!this.cancelEdit(e)){ return; }
+ if(this.doFade) {
+ dojo.fx.highlight(this.editable, dojo.graphics.color.hex2rgb("#ffc"), 700, 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;
+ }
+ }
+});
Added: myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/LayoutPane.js
URL: http://svn.apache.org/viewcvs/myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/LayoutPane.js?rev=372668&view=auto
==============================================================================
--- myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/LayoutPane.js (added)
+++ myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/LayoutPane.js Thu Jan 26 15:56:50 2006
@@ -0,0 +1,17 @@
+/*
+ Copyright (c) 2004-2005, 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.LayoutPane");
+
+dojo.require("dojo.widget.*");
+dojo.requireAfterIf("html", "dojo.widget.html.LayoutPane");
+dojo.widget.tags.addParseTreeHandler("dojo:LayoutPane");
+
+// NOTE: there's no stub file for this widget
Added: myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/LinkPane.js
URL: http://svn.apache.org/viewcvs/myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/LinkPane.js?rev=372668&view=auto
==============================================================================
--- myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/LinkPane.js (added)
+++ myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/LinkPane.js Thu Jan 26 15:56:50 2006
@@ -0,0 +1,17 @@
+/*
+ Copyright (c) 2004-2005, 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.LinkPane");
+
+dojo.require("dojo.widget.*");
+dojo.requireAfterIf("html", "dojo.widget.html.LinkPane");
+dojo.widget.tags.addParseTreeHandler("dojo:LinkPane");
+
+// NOTE: there's no stub file for this widget
Added: myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Manager.js
URL: http://svn.apache.org/viewcvs/myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Manager.js?rev=372668&view=auto
==============================================================================
--- myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Manager.js (added)
+++ myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Manager.js Thu Jan 26 15:56:50 2006
@@ -0,0 +1,279 @@
+/*
+ Copyright (c) 2004-2005, 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.Manager");
+dojo.require("dojo.lang");
+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);
+ // 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){
+ var tw = this.widgets[widgetIndex].widgetId;
+ delete this.widgetIds[tw];
+ this.widgets.splice(widgetIndex, 1);
+ }
+
+ // FIXME: suboptimal performance
+ this.removeById = function(id) {
+ for (var i=0; i<this.widgets.length; i++){
+ if(this.widgets[i].widgetId == id){
+ this.remove(i);
+ break;
+ }
+ }
+ }
+
+ this.getWidgetById = function(id){
+ return this.widgetIds[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.getWidgetsOfType = function (id) {
+ dj_deprecated("getWidgetsOfType is depecrecated, use getWidgetsByType");
+ return dojo.widget.manager.getWidgetsByType(id);
+ }
+
+ this.getWidgetsByFilter = function(unaryFunc){
+ var ret = [];
+ dojo.lang.forEach(this.widgets, function(x){
+ if(unaryFunc(x)){
+ ret.push(x);
+ }
+ });
+ return ret;
+ }
+
+ this.getAllWidgets = function() {
+ return this.widgets.concat();
+ }
+
+ // shortcuts, baby
+ this.byId = this.getWidgetById;
+ this.byType = this.getWidgetsByType;
+ this.byFilter = this.getWidgetsByFilter;
+
+ // map of previousally discovered implementation names to constructors
+ var knownWidgetImplementations = {};
+
+ // support manually registered widget packages
+ var widgetPackages = ["dojo.widget", "dojo.webui.widgets"];
+ 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){
+ // try and find a name for the widget
+ var impl = this.getImplementationName(widgetName);
+ if(impl){
+ // var tic = new Date();
+ var ret = new impl(ctorObject);
+ // dojo.debug(new Date() - tic);
+ return ret;
+ }
+ }
+
+ this.getImplementationName = function(widgetName){
+ /*
+ * 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.
+ */
+
+ var lowerCaseWidgetName = widgetName.toLowerCase();
+
+ var impl = knownWidgetImplementations[lowerCaseWidgetName];
+ if(impl){
+ return impl;
+ }
+
+ // 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("");
+ }
+
+ // 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; }
+
+ 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[lowerCaseWidgetName] =
+ widgetPackage[renderPrefixCache[j]][widgetClass];
+ return knownWidgetImplementations[lowerCaseWidgetName];
+ }
+ }
+
+ for (var j = 0; j < renderPrefixCache.length; j++) {
+ for (var widgetClass in widgetPackage) {
+ if (widgetClass.toLowerCase() !=
+ (renderPrefixCache[j] + lowerCaseWidgetName)) { continue; }
+
+ knownWidgetImplementations[lowerCaseWidgetName] =
+ widgetPackage[widgetClass];
+ return knownWidgetImplementations[lowerCaseWidgetName];
+ }
+ }
+ }
+
+ 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){
+ dj_unimplemented("dojo.widget.manager.getWidgetFromPrimitive");
+ }
+
+ this.getWidgetFromEvent = function(nativeEvt){
+ dj_unimplemented("dojo.widget.manager.getWidgetFromEvent");
+ }*/
+
+ // Catch window resize events and notify top level widgets
+ this.resizing=false;
+ this.onResized = function() {
+ if(this.resizing){
+ return; // duplicate event
+ }
+ try {
+ this.resizing=true;
+ for(var id in this.topWidgets) {
+ var child = this.topWidgets[id];
+ //dojo.debug("root resizing child " + child.widgetId);
+ if ( child.onResized ) {
+ child.onResized();
+ }
+ }
+ } finally {
+ this.resizing=false;
+ }
+ }
+ if(typeof window != "undefined") {
+ dojo.addOnLoad(this, 'onResized'); // initial sizing
+ dojo.event.connect(window, 'onresize', this, 'onResized'); // window resize
+ }
+
+ // FIXME: what else?
+}
+
+// copy the methods from the default manager (this) to the widget namespace
+dojo.widget.getUniqueId = function () { return dojo.widget.manager.getUniqueId.apply(dojo.widget.manager, arguments); }
+dojo.widget.addWidget = function () { return dojo.widget.manager.add.apply(dojo.widget.manager, arguments); }
+dojo.widget.destroyAllWidgets = function () { return dojo.widget.manager.destroyAll.apply(dojo.widget.manager, arguments); }
+dojo.widget.removeWidget = function () { return dojo.widget.manager.remove.apply(dojo.widget.manager, arguments); }
+dojo.widget.removeWidgetById = function () { return dojo.widget.manager.removeById.apply(dojo.widget.manager, arguments); }
+dojo.widget.getWidgetById = function () { return dojo.widget.manager.getWidgetById.apply(dojo.widget.manager, arguments); }
+dojo.widget.getWidgetsByType = function () { return dojo.widget.manager.getWidgetsByType.apply(dojo.widget.manager, arguments); }
+dojo.widget.getWidgetsByFilter = function () { return dojo.widget.manager.getWidgetsByFilter.apply(dojo.widget.manager, arguments); }
+dojo.widget.byId = function () { return dojo.widget.manager.getWidgetById.apply(dojo.widget.manager, arguments); }
+dojo.widget.byType = function () { return dojo.widget.manager.getWidgetsByType.apply(dojo.widget.manager, arguments); }
+dojo.widget.byFilter = function () { return dojo.widget.manager.getWidgetsByFilter.apply(dojo.widget.manager, arguments); }
+dojo.widget.all = function (n) {
+ var widgets = dojo.widget.manager.getAllWidgets.apply(dojo.widget.manager, arguments);
+ if(arguments.length > 0) {
+ return widgets[n];
+ }
+ return widgets;
+}
+dojo.widget.registerWidgetPackage = function () { return dojo.widget.manager.registerWidgetPackage.apply(dojo.widget.manager, arguments); }
+dojo.widget.getWidgetImplementation = function () { return dojo.widget.manager.getImplementation.apply(dojo.widget.manager, arguments); }
+dojo.widget.getWidgetImplementationName = function () { return dojo.widget.manager.getImplementationName.apply(dojo.widget.manager, arguments); }
+
+dojo.widget.widgets = dojo.widget.manager.widgets;
+dojo.widget.widgetIds = dojo.widget.manager.widgetIds;
+dojo.widget.root = dojo.widget.manager.root;
Added: myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Menu.js
URL: http://svn.apache.org/viewcvs/myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Menu.js?rev=372668&view=auto
==============================================================================
--- myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Menu.js (added)
+++ myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Menu.js Thu Jan 26 15:56:50 2006
@@ -0,0 +1,59 @@
+/*
+ Copyright (c) 2004-2005, 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");
Added: myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Menu2.js
URL: http://svn.apache.org/viewcvs/myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Menu2.js?rev=372668&view=auto
==============================================================================
--- myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Menu2.js (added)
+++ myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Menu2.js Thu Jan 26 15:56:50 2006
@@ -0,0 +1,703 @@
+/*
+ Copyright (c) 2004-2005, 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.Menu2");
+dojo.provide("dojo.widget.html.Menu2");
+dojo.provide("dojo.widget.PopupMenu2");
+dojo.provide("dojo.widget.MenuItem2");
+
+dojo.require("dojo.html");
+dojo.require("dojo.style");
+dojo.require("dojo.event.*");
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.HtmlWidget");
+
+
+dojo.widget.PopupMenu2 = function(){
+ dojo.widget.HtmlWidget.call(this);
+ this.items = []; // unused???
+ this.targetNodeIds = []; // fill this with nodeIds upon widget creation and it becomes context menu for those nodes
+ this.queueOnAnimationFinish = [];
+}
+
+dojo.inherits(dojo.widget.PopupMenu2, dojo.widget.HtmlWidget);
+
+dojo.lang.extend(dojo.widget.PopupMenu2, {
+ widgetType: "PopupMenu2",
+ isContainer: true,
+
+ snarfChildDomOutput: true,
+
+ currentSubmenu: null,
+ currentSubmenuTrigger: null,
+ parentMenu: null,
+ isShowing: false,
+ menuX: 0,
+ menuY: 0,
+ menuWidth: 0,
+ menuHeight: 0,
+ menuIndex: 0,
+
+ domNode: null,
+ containerNode: null,
+
+ templateString: '<div><div dojoAttachPoint="containerNode"></div></div>',
+ templateCssPath: dojo.uri.dojoUri("src/widget/templates/HtmlMenu2.css"),
+
+ itemHeight: 18,
+ iconGap: 1,
+ accelGap: 10,
+ submenuGap: 2,
+ finalGap: 5,
+ submenuIconSize: 4,
+ separatorHeight: 9,
+ submenuDelay: 500,
+ submenuOverlap: 5,
+ contextMenuForWindow: false,
+ openEvent: null,
+
+ submenuIconSrc: dojo.uri.dojoUri("src/widget/templates/images/submenu_off.gif").toString(),
+ submenuIconOnSrc: dojo.uri.dojoUri("src/widget/templates/images/submenu_on.gif").toString(),
+
+ postCreate: function(){
+
+ dojo.html.addClass(this.domNode, 'dojoPopupMenu2');
+ dojo.html.addClass(this.containerNode, 'dojoPopupMenu2Client');
+
+ this.domNode.style.left = '-9999px'
+ this.domNode.style.top = '-9999px'
+
+ if (this.contextMenuForWindow){
+ var doc = document.documentElement || dojo.html.body();
+ dojo.event.connect(doc, "oncontextmenu", this, "onOpen");
+ } else if ( this.targetNodeIds.length > 0 ){
+ for(var i=0; i<this.targetNodeIds.length; i++){
+ this.bindDomNode(this.targetNodeIds[i]);
+ }
+ }
+
+ this.layoutMenuSoon();
+ },
+
+ // get open event for current menu
+ getTopOpenEvent: function() {
+ var menu = this;
+ while (menu.parent){ menu = menu.parent; }
+ return menu.openEvent;
+ },
+
+ // attach menu to given node
+ bindDomNode: function(node){
+ dojo.event.connect(dojo.byId(node), "oncontextmenu", this, "onOpen");
+ },
+
+ // detach menu from given node
+ unBindDomNode: function(node){
+ dojo.event.kwDisconnect({
+ srcObj: dojo.byId(node),
+ srcFunc: "oncontextmenu",
+ targetObj: this,
+ targetFunc: "onOpen",
+ once: true
+ });
+ },
+
+ layoutMenuSoon: function(){
+
+ dojo.lang.setTimeout(this, "layoutMenu", 0);
+ },
+
+ layoutMenu: function(){
+
+ // determine menu width
+
+ var max_label_w = 0;
+ var max_accel_w = 0;
+
+ for(var i=0; i<this.children.length; i++){
+
+ if (this.children[i].getLabelWidth){
+
+ max_label_w = Math.max(max_label_w, this.children[i].getLabelWidth());
+ }
+
+ if (dojo.lang.isFunction(this.children[i].getAccelWidth)){
+
+ max_accel_w = Math.max(max_accel_w, this.children[i].getAccelWidth());
+ }
+ }
+
+ if( isNaN(max_label_w) || isNaN(max_accel_w) ){
+ // Browser needs some more time to calculate sizes
+ this.layoutMenuSoon();
+ return;
+ }
+
+ var clientLeft = dojo.style.getPixelValue(this.domNode, "padding-left", true) + dojo.style.getPixelValue(this.containerNode, "padding-left", true);
+ var clientTop = dojo.style.getPixelValue(this.domNode, "padding-top", true) + dojo.style.getPixelValue(this.containerNode, "padding-top", true);
+
+ if( isNaN(clientLeft) || isNaN(clientTop) ){
+ // Browser needs some more time to calculate sizes
+ this.layoutMenuSoon();
+ return;
+ }
+
+ var y = clientTop;
+ var max_item_width = 0;
+
+ for(var i=0; i<this.children.length; i++){
+
+ var ch = this.children[i];
+
+ ch.layoutItem(max_label_w, max_accel_w);
+
+ ch.topPosition = y;
+
+ y += dojo.style.getOuterHeight(ch.domNode);
+ max_item_width = Math.max(max_item_width, dojo.style.getOuterWidth(ch.domNode));
+ }
+
+ dojo.style.setContentWidth(this.containerNode, max_item_width);
+ dojo.style.setContentHeight(this.containerNode, y-clientTop);
+
+ dojo.style.setContentWidth(this.domNode, dojo.style.getOuterWidth(this.containerNode));
+ dojo.style.setContentHeight(this.domNode, dojo.style.getOuterHeight(this.containerNode));
+
+ this.menuWidth = dojo.style.getOuterWidth(this.domNode);
+ this.menuHeight = dojo.style.getOuterHeight(this.domNode);
+ },
+
+ open: function(x, y, parentMenu, explodeSrc){
+
+ // NOTE: alex:
+ // this couldn't have possibly worked. this.open wound up calling
+ // this.close, which called open...etc..
+ if (this.isShowing){ /* this.close(); */ return; }
+
+ if ( !parentMenu ) {
+ // record whenever a top level menu is opened
+ dojo.widget.html.Menu2Manager.opened(this, explodeSrc);
+ }
+
+ //dojo.debug("open called for animation "+this.animationInProgress)
+
+ // 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 viewport = dojo.html.getViewportSize();
+ var scrolloffset = dojo.html.getScrollOffset();
+
+ var clientRect = {
+ 'left' : scrolloffset[0],
+ 'right' : scrolloffset[0] + viewport[0],
+ 'top' : scrolloffset[1],
+ 'bottom': scrolloffset[1] + viewport[1]
+ };
+
+ if (parentMenu){
+ // submenu is opening
+
+ if (x + this.menuWidth > clientRect.right){ x = x - (this.menuWidth + parentMenu.menuWidth - (2 * this.submenuOverlap)); }
+
+ if (y + this.menuHeight > clientRect.bottom){ y = y -
+ (this.menuHeight - (this.itemHeight + 5)); } // TODO: why 5?
+
+ }else{
+ // top level menu is opening
+ x+=scrolloffset[0];
+ y+=scrolloffset[1];
+ explodeSrc[0] += scrolloffset[0];
+ explodeSrc[1] += scrolloffset[1];
+
+ if (x < clientRect.left){ x = clientRect.left; }
+ if (x + this.menuWidth > clientRect.right){ x = x - this.menuWidth; }
+
+ if (y < clientRect.top){ y = clientRect.top; }
+ if (y + this.menuHeight > clientRect.bottom){ y = y - this.menuHeight; }
+ }
+
+ this.parentMenu = parentMenu;
+ this.explodeSrc = explodeSrc;
+ this.menuIndex = parentMenu ? parentMenu.menuIndex + 1 : 1;
+
+ this.menuX = x;
+ this.menuY = y;
+
+ // move the menu into position but make it invisible
+ // (because when menus are initially constructed they are visible but off-screen)
+ this.domNode.style.zIndex = 10 + this.menuIndex;
+ this.domNode.style.left = x + 'px';
+ this.domNode.style.top = y + 'px';
+ this.domNode.style.display='none';
+ this.domNode.style.position='absolute';
+
+ // then use the user defined method to display it
+ this.show();
+
+ this.isShowing = true;
+ },
+
+ close: function(){
+ // If we are in the process of opening the menu and we are asked to close it,
+ // we should really cancel the current animation, but for simplicity we will
+ // just ignore the request
+ if(this.animationInProgress){
+ this.queueOnAnimationFinish.push(this.close, []);
+ return;
+ }
+
+ this.closeSubmenu();
+ this.hide();
+ this.isShowing = false;
+ dojo.widget.html.Menu2Manager.closed(this);
+ },
+
+ onShow: function() {
+ dojo.widget.HtmlWidget.prototype.onShow.call(this);
+ 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);
+
+ this.processQueue();
+ },
+
+
+ closeAll: function(){
+
+ if (this.parentMenu){
+ this.parentMenu.closeAll();
+ }else{
+ this.close();
+ }
+ },
+
+ closeSubmenu: function(){
+ if (this.currentSubmenu == null){ return; }
+
+ this.currentSubmenu.close();
+ this.currentSubmenu = null;
+
+ this.currentSubmenuTrigger.is_open = false;
+ this.currentSubmenuTrigger.closedSubmenu();
+ this.currentSubmenuTrigger = null;
+ },
+
+ openSubmenu: function(submenu, from_item){
+
+ var our_x = dojo.style.getPixelValue(this.domNode, 'left');
+ var our_y = dojo.style.getPixelValue(this.domNode, 'top');
+ var our_w = dojo.style.getOuterWidth(this.domNode);
+ var item_y = from_item.topPosition;
+
+ var x = our_x + our_w - this.submenuOverlap;
+ var y = our_y + item_y;
+
+ this.currentSubmenu = submenu;
+ this.currentSubmenu.open(x, y, this, from_item.domNode);
+
+ this.currentSubmenuTrigger = from_item;
+ this.currentSubmenuTrigger.is_open = true;
+ },
+
+ onOpen: function(e){
+ this.openEvent = e;
+
+ //dojo.debugShallow(e);
+ this.open(e.clientX, e.clientY, null, [e.clientX, e.clientY]);
+
+ if(e["preventDefault"]){
+ e.preventDefault();
+ }
+ },
+
+ isPointInMenu: function(x, y){
+
+ if (x < this.menuX){ return 0; }
+ if (x > this.menuX + this.menuWidth){ return 0; }
+
+ if (y < this.menuY){ return 0; }
+ if (y > this.menuY + this.menuHeight){ return 0; }
+
+ return 1;
+ }
+});
+
+
+dojo.widget.MenuItem2 = function(){
+ dojo.widget.HtmlWidget.call(this);
+}
+
+dojo.inherits(dojo.widget.MenuItem2, dojo.widget.HtmlWidget);
+
+dojo.lang.extend(dojo.widget.MenuItem2, {
+ widgetType: "MenuItem2",
+ templateString:
+ '<div class="dojoMenuItem2">'
+ +'<div dojoAttachPoint="iconNode" class="dojoMenuItem2Icon"></div>'
+ +'<span dojoAttachPoint="labelNode" class="dojoMenuItem2Label"><span><span></span></span></span>'
+ +'<span dojoAttachPoint="accelNode" class="dojoMenuItem2Accel"><span><span></span></span></span>'
+ +'<div dojoAttachPoint="submenuNode" class="dojoMenuItem2Submenu"></div>'
+ +'<div dojoAttachPoint="targetNode" class="dojoMenuItem2Target" dojoAttachEvent="onMouseOver: onHover; onMouseOut: onUnhover; onClick;"> </div>'
+ +'</div>',
+
+ //
+ // nodes
+ //
+
+ domNode: null,
+ iconNode: null,
+ labelNode: null,
+ accelNode: null,
+ submenuNode: null,
+ targetNode: null,
+
+ //
+ // internal settings
+ //
+
+ is_hovering: false,
+ hover_timer: null,
+ is_open: false,
+ topPosition: 0,
+ is_disabled: false,
+
+ //
+ // options
+ //
+
+ caption: 'Untitled',
+ accelKey: '',
+ iconSrc: '',
+ submenuId: '',
+ isDisabled: false,
+
+
+ postCreate: function(){
+
+ dojo.html.disableSelection(this.domNode);
+
+ if (this.isDisabled){
+ this.setDisabled(true);
+ }
+
+ this.labelNode.childNodes[0].appendChild(document.createTextNode(this.caption));
+ this.accelNode.childNodes[0].appendChild(document.createTextNode(this.accelKey));
+
+ this.labelShadowNode = this.labelNode.childNodes[0].childNodes[0];
+ this.accelShadowNode = this.accelNode.childNodes[0].childNodes[0];
+
+ this.labelShadowNode.appendChild(document.createTextNode(this.caption));
+ this.accelShadowNode.appendChild(document.createTextNode(this.accelKey));
+ },
+
+ layoutItem: function(label_w, accel_w){
+
+ var x_label = this.parent.itemHeight + this.parent.iconGap;
+ var x_accel = x_label + label_w + this.parent.accelGap;
+ var x_submu = x_accel + accel_w + this.parent.submenuGap;
+ var total_w = x_submu + this.parent.submenuIconSize + this.parent.finalGap;
+
+
+ this.iconNode.style.left = '0px';
+ this.iconNode.style.top = '0px';
+
+
+ if (this.iconSrc){
+
+ if ((this.iconSrc.toLowerCase().substring(this.iconSrc.length-4) == ".png") && (dojo.render.html.ie)){
+
+ this.iconNode.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='"+this.iconSrc+"', sizingMethod='image')";
+ this.iconNode.style.backgroundImage = '';
+ }else{
+ this.iconNode.style.backgroundImage = 'url('+this.iconSrc+')';
+ }
+ }else{
+ this.iconNode.style.backgroundImage = '';
+ }
+
+ dojo.style.setOuterWidth(this.iconNode, this.parent.itemHeight);
+ dojo.style.setOuterHeight(this.iconNode, this.parent.itemHeight);
+
+ dojo.style.setOuterHeight(this.labelNode, this.parent.itemHeight);
+ dojo.style.setOuterHeight(this.accelNode, this.parent.itemHeight);
+
+ dojo.style.setContentWidth(this.domNode, total_w);
+ dojo.style.setContentHeight(this.domNode, this.parent.itemHeight);
+
+ this.labelNode.style.left = x_label + 'px';
+ this.accelNode.style.left = x_accel + 'px';
+ this.submenuNode.style.left = x_submu + 'px';
+
+ dojo.style.setOuterWidth(this.submenuNode, this.parent.submenuIconSize);
+ dojo.style.setOuterHeight(this.submenuNode, this.parent.itemHeight);
+
+ this.submenuNode.style.display = this.submenuId ? 'block' : 'none';
+ this.submenuNode.style.backgroundImage = 'url('+this.parent.submenuIconSrc+')';
+
+ dojo.style.setOuterWidth(this.targetNode, total_w);
+ dojo.style.setOuterHeight(this.targetNode, this.parent.itemHeight);
+ },
+
+ onHover: function(){
+
+ if (this.is_hovering){ return; }
+ if (this.is_open){ return; }
+
+ this.parent.closeSubmenu();
+ this.highlightItem();
+
+ if (this.is_hovering){ this.stopSubmenuTimer(); }
+ this.is_hovering = 1;
+ this.startSubmenuTimer();
+ },
+
+ onUnhover: function(){
+
+ if (!this.is_open){ this.unhighlightItem(); }
+
+ this.is_hovering = 0;
+ this.stopSubmenuTimer();
+ },
+
+ onClick: function(){
+
+ if (this.is_disabled){ return; }
+
+ if (this.submenuId){
+
+ if (!this.is_open){
+ this.stopSubmenuTimer();
+ this.openSubmenu();
+ }
+
+ }else{
+
+ this.parent.closeAll();
+ }
+ },
+
+ highlightItem: function(){
+
+ dojo.html.addClass(this.domNode, 'dojoMenuItem2Hover');
+ this.submenuNode.style.backgroundImage = 'url('+this.parent.submenuIconOnSrc+')';
+ },
+
+ unhighlightItem: function(){
+
+ dojo.html.removeClass(this.domNode, 'dojoMenuItem2Hover');
+ this.submenuNode.style.backgroundImage = 'url('+this.parent.submenuIconSrc+')';
+ },
+
+ startSubmenuTimer: function(){
+ this.stopSubmenuTimer();
+
+ if (this.is_disabled){ return; }
+
+ var self = this;
+ var closure = function(){ return function(){ self.openSubmenu(); } }();
+
+ this.hover_timer = window.setTimeout(closure, this.parent.submenuDelay);
+ },
+
+ stopSubmenuTimer: function(){
+ if (this.hover_timer){
+ window.clearTimeout(this.hover_timer);
+ this.hover_timer = null;
+ }
+ },
+
+ openSubmenu: function(){
+ // first close any other open submenu
+ this.parent.closeSubmenu();
+
+ var submenu = dojo.widget.getWidgetById(this.submenuId);
+ if (submenu){
+
+ this.parent.openSubmenu(submenu, this);
+ }
+
+ //dojo.debug('open submenu for item '+this.widgetId);
+ },
+
+ closedSubmenu: function(){
+
+ this.onUnhover();
+ },
+
+ setDisabled: function(value){
+
+ if (value == this.is_disabled){ return; }
+
+ this.is_disabled = value;
+
+ if (this.is_disabled){
+ dojo.html.addClass(this.domNode, 'dojoMenuItem2Disabled');
+ }else{
+ dojo.html.removeClass(this.domNode, 'dojoMenuItem2Disabled');
+ }
+ },
+
+ getLabelWidth: function(){
+
+ var node = this.labelNode.childNodes[0];
+
+ return dojo.style.getOuterWidth(node);
+ },
+
+ getAccelWidth: function(){
+
+ var node = this.accelNode.childNodes[0];
+
+ return dojo.style.getOuterWidth(node);
+ }
+});
+
+
+dojo.widget.MenuSeparator2 = function(){
+ dojo.widget.HtmlWidget.call(this);
+}
+
+dojo.inherits(dojo.widget.MenuSeparator2, dojo.widget.HtmlWidget);
+
+dojo.lang.extend(dojo.widget.MenuSeparator2, {
+ widgetType: "MenuSeparator2",
+
+ domNode: null,
+ topNode: null,
+ bottomNode: null,
+
+ templateString: '<div>'
+ +'<div dojoAttachPoint="topNode"></div>'
+ +'<div dojoAttachPoint="bottomNode"></div>'
+ +'</div>',
+
+ postCreate: function(){
+
+ dojo.html.addClass(this.domNode, 'dojoMenuSeparator2');
+ dojo.html.addClass(this.topNode, 'dojoMenuSeparator2Top');
+ dojo.html.addClass(this.bottomNode, 'dojoMenuSeparator2Bottom');
+
+ dojo.html.disableSelection(this.domNode);
+
+ this.layoutItem();
+ },
+
+ layoutItem: function(label_w, accel_w){
+
+ var full_width = this.parent.itemHeight
+ + this.parent.iconGap
+ + label_w
+ + this.parent.accelGap
+ + accel_w
+ + this.parent.submenuGap
+ + this.parent.submenuIconSize
+ + this.parent.finalGap;
+
+ if (isNaN(full_width)){ return; }
+
+ dojo.style.setContentHeight(this.domNode, this.parent.separatorHeight);
+ dojo.style.setContentWidth(this.domNode, full_width);
+ }
+});
+
+//
+// the menu manager makes sure we don't have several menus
+// open at once. the root menu in an opening sequence calls
+// opened(). when a root menu closes it calls closed(). then
+// everything works. lovely.
+//
+
+dojo.widget.html.Menu2Manager = new function(){
+
+ this.currentMenu = null;
+ this.currentButton = null; // button that opened current menu (if any)
+ this.focusNode = null;
+
+ dojo.event.connect(document, 'onmousedown', this, 'onClick');
+ dojo.event.connect(window, "onscroll", this, "onClick");
+
+ this.closed = function(menu){
+ if (this.currentMenu == menu){
+ this.currentMenu = null;
+ this.currentButton = null;
+ }
+ };
+
+ this.opened = function(menu, button){
+ if (menu == this.currentMenu){ return; }
+
+ if (this.currentMenu){
+ this.currentMenu.close();
+ }
+
+ this.currentMenu = menu;
+ this.currentButton = button;
+ };
+
+ this.onClick = function(e){
+
+ if (!this.currentMenu){ return; }
+
+ var scrolloffset = dojo.html.getScrollOffset();
+
+ var x = e.clientX + scrolloffset[0];
+ var y = e.clientY + scrolloffset[1];
+
+ var m = this.currentMenu;
+
+ // starting from the base menu, perform a hit test
+ // and exit when one succeeds
+
+ while (m){
+
+ if (m.isPointInMenu(x, y)){
+
+ return;
+ }
+
+ m = m.currentSubmenu;
+ }
+
+ // 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 it a tag
+dojo.widget.tags.addParseTreeHandler("dojo:PopupMenu2");
+dojo.widget.tags.addParseTreeHandler("dojo:MenuItem2");
+dojo.widget.tags.addParseTreeHandler("dojo:MenuSeparator2");
+
Added: myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/MenuItem.js
URL: http://svn.apache.org/viewcvs/myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/MenuItem.js?rev=372668&view=auto
==============================================================================
--- myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/MenuItem.js (added)
+++ myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/MenuItem.js Thu Jan 26 15:56:50 2006
@@ -0,0 +1,47 @@
+/*
+ Copyright (c) 2004-2005, 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");