svn commit: r495409 [31/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/...

[ca...@apache.org]

Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,534 @@
+/*
+	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
+*/
+
+/* TODO:
+ * - font selector
+ * - test, bug fix, more features :)
+*/
+dojo.provide("dojo.widget.Editor");
+dojo.deprecated("dojo.widget.Editor", "is replaced by dojo.widget.Editor2", "0.5");
+
+dojo.require("dojo.io.*");
+dojo.require("dojo.widget.*");
+dojo.require("dojo.widget.Toolbar");
+dojo.require("dojo.widget.RichText");
+dojo.require("dojo.widget.ColorPalette");
+dojo.require("dojo.string.extras");
+
+dojo.widget.tags.addParseTreeHandler("dojo:Editor");
+
+dojo.widget.Editor = function() {
+	dojo.widget.HtmlWidget.call(this);
+	this.contentFilters = [];
+	this._toolbars = [];
+}
+dojo.inherits(dojo.widget.Editor, dojo.widget.HtmlWidget);
+
+dojo.widget.Editor.itemGroups = {
+	textGroup: ["bold", "italic", "underline", "strikethrough"],
+	blockGroup: ["formatBlock", "fontName", "fontSize"],
+	justifyGroup: ["justifyleft", "justifycenter", "justifyright"],
+	commandGroup: ["save", "cancel"],
+	colorGroup: ["forecolor", "hilitecolor"],
+	listGroup: ["insertorderedlist", "insertunorderedlist"],
+	indentGroup: ["outdent", "indent"],
+	linkGroup: ["createlink", "insertimage", "inserthorizontalrule"]
+};
+
+dojo.widget.Editor.formatBlockValues = {
+	"Normal": "p",
+	"Main heading": "h2",
+	"Sub heading": "h3",
+	"Sub sub heading": "h4",
+	"Preformatted": "pre"
+};
+
+dojo.widget.Editor.fontNameValues = {
+	"Arial": "Arial, Helvetica, sans-serif",
+	"Verdana": "Verdana, sans-serif",
+	"Times New Roman": "Times New Roman, serif",
+	"Courier": "Courier New, monospace"
+};
+
+dojo.widget.Editor.fontSizeValues = {
+	"1 (8 pt)" : "1",
+	"2 (10 pt)": "2",
+	"3 (12 pt)": "3",
+	"4 (14 pt)": "4",
+	"5 (18 pt)": "5",
+	"6 (24 pt)": "6",
+	"7 (36 pt)": "7"
+};
+
+dojo.widget.Editor.defaultItems = [
+	"commandGroup", "|", "blockGroup", "|", "textGroup", "|", "colorGroup", "|", "justifyGroup", "|", "listGroup", "indentGroup", "|", "linkGroup"
+];
+
+// ones we support by default without asking the RichText component
+// NOTE: you shouldn't put buttons like bold, italic, etc in here
+dojo.widget.Editor.supportedCommands = ["save", "cancel", "|", "-", "/", " "];
+
+dojo.lang.extend(dojo.widget.Editor, {
+	widgetType: "Editor",
+
+	saveUrl: "",
+	saveMethod: "post",
+	saveArgName: "editorContent",
+	closeOnSave: false,
+	items: dojo.widget.Editor.defaultItems,
+	formatBlockItems: dojo.lang.shallowCopy(dojo.widget.Editor.formatBlockValues),
+	fontNameItems: dojo.lang.shallowCopy(dojo.widget.Editor.fontNameValues),
+	fontSizeItems: dojo.lang.shallowCopy(dojo.widget.Editor.fontSizeValues),
+
+	// used to get the properties of an item if it is given as a string
+	getItemProperties: function(name) {
+		var props = {};
+		switch(name.toLowerCase()) {
+			case "bold":
+			case "italic":
+			case "underline":
+			case "strikethrough":
+				props.toggleItem = true;
+				break;
+
+			case "justifygroup":
+				props.defaultButton = "justifyleft";
+				props.preventDeselect = true;
+				props.buttonGroup = true;
+				break;
+
+			case "listgroup":
+				props.buttonGroup = true;
+				break;
+
+			case "save":
+			case "cancel":
+				props.label = dojo.string.capitalize(name);
+				break;
+
+			case "forecolor":
+			case "hilitecolor":
+				props.name = name;
+				props.toggleItem = true; // FIXME: they aren't exactly toggle items
+				props.icon = this.getCommandImage(name);
+				break;
+
+			case "formatblock":
+				props.name = "formatBlock";
+				props.values = this.formatBlockItems;
+				break;
+
+			case "fontname":
+				props.name = "fontName";
+				props.values = this.fontNameItems;
+
+			case "fontsize":
+				props.name = "fontSize";
+				props.values = this.fontSizeItems;
+		}
+		return props;
+	},
+
+	validateItems: true, // set to false to add items, regardless of support
+	focusOnLoad: true,
+	minHeight: "1em",
+
+	_richText: null, // RichText widget
+	_richTextType: "RichText",
+
+	_toolbarContainer: null, // ToolbarContainer widget
+	_toolbarContainerType: "ToolbarContainer",
+
+	_toolbars: [],
+	_toolbarType: "Toolbar",
+
+	_toolbarItemType: "ToolbarItem",
+
+	buildRendering: function(args, frag) {
+		// get the node from args/frag
+		var node = frag["dojo:"+this.widgetType.toLowerCase()]["nodeRef"];
+		var trt = dojo.widget.createWidget(this._richTextType, {
+			focusOnLoad: this.focusOnLoad,
+			minHeight: this.minHeight
+		}, node)
+		var _this = this;
+		// this appears to fix a weird timing bug on Safari
+		setTimeout(function(){
+			_this.setRichText(trt);
+
+			_this.initToolbar();
+
+			_this.fillInTemplate(args, frag);
+		}, 0);
+	},
+
+	setRichText: function(richText) {
+		if(this._richText && this._richText == richText) {
+			dojo.debug("Already set the richText to this richText!");
+			return;
+		}
+
+		if(this._richText && !this._richText.isClosed) {
+			dojo.debug("You are switching richTexts yet you haven't closed the current one. Losing reference!");
+		}
+		this._richText = richText;
+		dojo.event.connect(this._richText, "close", this, "onClose");
+		dojo.event.connect(this._richText, "onLoad", this, "onLoad");
+		dojo.event.connect(this._richText, "onDisplayChanged", this, "updateToolbar");
+		if(this._toolbarContainer) {
+			this._toolbarContainer.enable();
+			this.updateToolbar(true);
+		}
+	},
+
+	initToolbar: function() {
+		// var tic = new Date();
+		if(this._toolbarContainer) { return; } // only create it once
+		this._toolbarContainer = dojo.widget.createWidget(this._toolbarContainerType);
+		var tb = this.addToolbar();
+		var last = true;
+		for(var i = 0; i < this.items.length; i++) {
+			if(this.items[i] == "\n") { // new row
+				tb = this.addToolbar();
+			} else {
+				if((this.items[i] == "|")&&(!last)){
+					last = true;
+				}else{
+					last = this.addItem(this.items[i], tb);
+				}
+			}
+		}
+		this.insertToolbar(this._toolbarContainer.domNode, this._richText.domNode);
+		// alert(new Date - tic);
+	},
+
+	// allow people to override this so they can make their own placement logic
+	insertToolbar: function(tbNode, richTextNode) {
+		dojo.html.insertBefore(tbNode, richTextNode);
+		//dojo.html.insertBefore(this._toolbarContainer.domNode, this._richText.domNode);
+	},
+
+	addToolbar: function(toolbar) {
+		this.initToolbar();
+		if(!(toolbar instanceof dojo.widget.Toolbar)) {
+			toolbar = dojo.widget.createWidget(this._toolbarType);
+		}
+		this._toolbarContainer.addChild(toolbar);
+		this._toolbars.push(toolbar);
+		return toolbar;
+	},
+
+	addItem: function(item, tb, dontValidate) {
+		if(!tb) { tb = this._toolbars[0]; }
+		var cmd = ((item)&&(!dojo.lang.isUndefined(item["getValue"]))) ?  cmd = item["getValue"](): item;
+
+		var groups = dojo.widget.Editor.itemGroups;
+		if(item instanceof dojo.widget.ToolbarItem) {
+			tb.addChild(item);
+		} else if(groups[cmd]) {
+			var group = groups[cmd];
+			var worked = true;
+			if(cmd == "justifyGroup" || cmd == "listGroup") {
+				var btnGroup = [cmd];
+				for(var i = 0 ; i < group.length; i++) {
+					if(dontValidate || this.isSupportedCommand(group[i])) {
+						btnGroup.push(this.getCommandImage(group[i]));
+					}else{
+						worked = false;
+					}
+				}
+				if(btnGroup.length){
+					/*
+					// the addChild interface is assinine. Work around it.
+					var tprops = this.getItemProperties(cmd);
+					var tmpGroup = dojo.widget.createWidget("ToolbarButtonGroup", tprops);
+					dojo.debug(btnGroup);
+					dojo.event.connect(tmpGroup, "onClick", this, "_action");
+					dojo.event.connect(tmpGroup, "onChangeSelect", this, "_action");
+					*/
+					var btn = tb.addChild(btnGroup, null, this.getItemProperties(cmd));
+					dojo.event.connect(btn, "onClick", this, "_action");
+					dojo.event.connect(btn, "onChangeSelect", this, "_action");
+				}
+				return worked;
+			} else {
+				for(var i = 0; i < group.length; i++) {
+					if(!this.addItem(group[i], tb)){
+						worked = false;
+					}
+				}
+				return worked;
+			}
+		} else {
+			if((!dontValidate)&&(!this.isSupportedCommand(cmd))){
+				return false;
+			}
+			if(dontValidate || this.isSupportedCommand(cmd)) {
+				cmd = cmd.toLowerCase();
+				if(cmd == "formatblock") {
+					var select = dojo.widget.createWidget("ToolbarSelect", {
+						name: "formatBlock",
+						values: this.formatBlockItems
+					});
+					tb.addChild(select);
+					var _this = this;
+					dojo.event.connect(select, "onSetValue", function(item, value) {
+						_this.onAction("formatBlock", value);
+					});
+				} else if(cmd == "fontname") {
+					var select = dojo.widget.createWidget("ToolbarSelect", {
+						name: "fontName",
+						values: this.fontNameItems
+					});
+					tb.addChild(select);
+					dojo.event.connect(select, "onSetValue", dojo.lang.hitch(this, function(item, value) {
+						this.onAction("fontName", value);
+					}));
+				} else if(cmd == "fontsize") {
+					var select = dojo.widget.createWidget("ToolbarSelect", {
+						name: "fontSize",
+						values: this.fontSizeItems
+					});
+					tb.addChild(select);
+					dojo.event.connect(select, "onSetValue", dojo.lang.hitch(this, function(item, value) {
+						this.onAction("fontSize", value);
+					}));
+				} else if(dojo.lang.inArray(cmd, ["forecolor", "hilitecolor"])) {
+					var btn = tb.addChild(dojo.widget.createWidget("ToolbarColorDialog", this.getItemProperties(cmd)));
+					dojo.event.connect(btn, "onSetValue", this, "_setValue");
+				} else {
+					var btn = tb.addChild(this.getCommandImage(cmd), null, this.getItemProperties(cmd));
+					if(cmd == "save"){
+						dojo.event.connect(btn, "onClick", this, "_save");
+					}else if(cmd == "cancel"){
+						dojo.event.connect(btn, "onClick", this, "_close");
+					} else {
+						dojo.event.connect(btn, "onClick", this, "_action");
+						dojo.event.connect(btn, "onChangeSelect", this, "_action");
+					}
+				}
+			}
+		}
+		return true;
+	},
+
+	enableToolbar: function() {
+		if(this._toolbarContainer) {
+			this._toolbarContainer.domNode.style.display = "";
+			this._toolbarContainer.enable();
+		}
+	},
+
+	disableToolbar: function(hide){
+		if(hide){
+			if(this._toolbarContainer){
+				this._toolbarContainer.domNode.style.display = "none";
+			}
+		}else{
+			if(this._toolbarContainer){
+				this._toolbarContainer.disable();
+			}
+		}
+	},
+
+	_updateToolbarLastRan: null,
+	_updateToolbarTimer: null,
+	_updateToolbarFrequency: 500,
+
+	updateToolbar: function(force) {
+		if(!this._toolbarContainer) { return; }
+
+		// keeps the toolbar from updating too frequently
+		// TODO: generalize this functionality?
+		var diff = new Date() - this._updateToolbarLastRan;
+		if(!force && this._updateToolbarLastRan && (diff < this._updateToolbarFrequency)) {
+			clearTimeout(this._updateToolbarTimer);
+			var _this = this;
+			this._updateToolbarTimer = setTimeout(function() {
+				_this.updateToolbar();
+			}, this._updateToolbarFrequency/2);
+			return;
+		} else {
+			this._updateToolbarLastRan = new Date();
+		}
+		// end frequency checker
+
+		var items = this._toolbarContainer.getItems();
+		for(var i = 0; i < items.length; i++) {
+			var item = items[i];
+			if(item instanceof dojo.widget.ToolbarSeparator) { continue; }
+			var cmd = item._name;
+			if (cmd == "save" || cmd == "cancel") { continue; }
+			else if(cmd == "justifyGroup") {
+				try {
+					if(!this._richText.queryCommandEnabled("justifyleft")) {
+						item.disable(false, true);
+					} else {
+						item.enable(false, true);
+						var jitems = item.getItems();
+						for(var j = 0; j < jitems.length; j++) {
+							var name = jitems[j]._name;
+							var value = this._richText.queryCommandValue(name);
+							if(typeof value == "boolean" && value) {
+								value = name;
+								break;
+							} else if(typeof value == "string") {
+								value = "justify"+value;
+							} else {
+								value = null;
+							}
+						}
+						if(!value) { value = "justifyleft"; } // TODO: query actual style
+						item.setValue(value, false, true);
+					}
+				} catch(err) {}
+			} else if(cmd == "listGroup") {
+				var litems = item.getItems();
+				for(var j = 0; j < litems.length; j++) {
+					this.updateItem(litems[j]);
+				}
+			} else {
+				this.updateItem(item);
+			}
+		}
+	},
+
+	updateItem: function(item) {
+		try {
+			var cmd = item._name;
+			var enabled = this._richText.queryCommandEnabled(cmd);
+			item.setEnabled(enabled, false, true);
+
+			var active = this._richText.queryCommandState(cmd);
+			if(active && cmd == "underline") {
+				// don't activate underlining if we are on a link
+				active = !this._richText.queryCommandEnabled("unlink");
+			}
+			item.setSelected(active, false, true);
+			return true;
+		} catch(err) {
+			return false;
+		}
+	},
+
+	supportedCommands: dojo.widget.Editor.supportedCommands.concat(),
+
+	isSupportedCommand: function(cmd) {
+		// FIXME: how do we check for ActiveX?
+		var yes = dojo.lang.inArray(cmd, this.supportedCommands);
+		if(!yes) {
+			try {
+				var richText = this._richText || dojo.widget.HtmlRichText.prototype;
+				yes = richText.queryCommandAvailable(cmd);
+			} catch(E) {}
+		}
+		return yes;
+	},
+
+	getCommandImage: function(cmd) {
+		if(cmd == "|") {
+			return cmd;
+		} else {
+			return dojo.uri.dojoUri("src/widget/templates/buttons/" + cmd + ".gif");
+		}
+	},
+
+	_action: function(e) {
+		this._fire("onAction", e.getValue());
+	},
+
+	_setValue: function(a, b) {
+		this._fire("onAction", a.getValue(), b);
+	},
+
+	_save: function(e){
+		// FIXME: how should this behave when there's a larger form in play?
+		if(!this._richText.isClosed){
+			if(this.saveUrl.length){
+				var content = {};
+				content[this.saveArgName] = this.getHtml();
+				dojo.io.bind({
+					method: this.saveMethod,
+					url: this.saveUrl,
+					content: content
+				});
+			}else{
+				dojo.debug("please set a saveUrl for the editor");
+			}
+			if(this.closeOnSave){
+				this._richText.close(e.getName().toLowerCase() == "save");
+			}
+		}
+	},
+
+	_close: function(e) {
+		if(!this._richText.isClosed) {
+			this._richText.close(e.getName().toLowerCase() == "save");
+		}
+	},
+
+	onAction: function(cmd, value) {
+		switch(cmd) {
+			case "createlink":
+				if(!(value = prompt("Please enter the URL of the link:", "http://"))) {
+					return;
+				}
+				break;
+			case "insertimage":
+				if(!(value = prompt("Please enter the URL of the image:", "http://"))) {
+					return;
+				}
+				break;
+		}
+		this._richText.execCommand(cmd, value);
+	},
+
+	fillInTemplate: function(args, frag) {
+		// dojo.event.connect(this, "onResized", this._richText, "onResized");
+	},
+
+	_fire: function(eventName) {
+		if(dojo.lang.isFunction(this[eventName])) {
+			var args = [];
+			if(arguments.length == 1) {
+				args.push(this);
+			} else {
+				for(var i = 1; i < arguments.length; i++) {
+					args.push(arguments[i]);
+				}
+			}
+			this[eventName].apply(this, args);
+		}
+	},
+
+	getHtml: function(){
+		this._richText.contentFilters = this._richText.contentFilters.concat(this.contentFilters);
+		return this._richText.getEditorContent();
+	},
+
+	getEditorContent: function(){
+		return this.getHtml();
+	},
+
+	onClose: function(save, hide){
+		this.disableToolbar(hide);
+		if(save) {
+			this._fire("onSave");
+		} else {
+			this._fire("onCancel");
+		}
+	},
+
+	// events baby!
+	onLoad: function(){},
+	onSave: function(){},
+	onCancel: function(){}
+});
+

Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,809 @@
+/*
+	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.Editor2");
+
+dojo.require("dojo.io.*");
+dojo.require("dojo.widget.RichText");
+dojo.require("dojo.widget.Editor2Toolbar");
+
+dojo.widget.Editor2Manager = new dojo.widget.HandlerManager;
+dojo.lang.mixin(dojo.widget.Editor2Manager,
+{
+	// summary: Manager of current focused Editor2 Instance and available editor2 commands
+
+	_currentInstance: null,
+
+	// commandState: Object: state a command may be in
+	commandState: {Disabled: 0, Latched: 1, Enabled: 2},
+
+	getCurrentInstance: function(){
+		// summary: Return the current focused Editor2 instance
+		return this._currentInstance;
+	},
+	setCurrentInstance: function(/*Widget*/inst){
+		// summary: Set current focused Editor2 instance
+		this._currentInstance = inst;
+	},
+	getCommand: function(/*dojo.widget.Editor2*/editor,/*String*/name){
+		// summary: Return Editor2 command with the given name
+		// name: name of the command (case insensitive)
+		var oCommand;
+		name = name.toLowerCase();
+		for(var i=0;i<this._registeredHandlers.length;i++){
+			oCommand = this._registeredHandlers[i](editor, name);
+			if(oCommand){
+				return oCommand;
+			}
+		}
+		switch(name){
+			case 'htmltoggle':
+				//Editor2 natively provide the htmltoggle functionalitity
+				//and it is treated as a builtin command
+				oCommand = new dojo.widget.Editor2BrowserCommand(editor, name);
+				break;
+			case 'formatblock':
+				oCommand = new dojo.widget.Editor2FormatBlockCommand(editor, name);
+				break;
+			case 'anchor':
+				oCommand = new dojo.widget.Editor2Command(editor, name);
+				break;
+
+			//dialog command
+			case 'createlink':
+				oCommand = new dojo.widget.Editor2DialogCommand(editor, name,
+						{contentFile: "dojo.widget.Editor2Plugin.CreateLinkDialog",
+							contentClass: "Editor2CreateLinkDialog",
+							title: "Insert/Edit Link", width: "300px", height: "200px"});
+				break;
+			case 'insertimage':
+				oCommand = new dojo.widget.Editor2DialogCommand(editor, name,
+						{contentFile: "dojo.widget.Editor2Plugin.InsertImageDialog",
+							contentClass: "Editor2InsertImageDialog",
+							title: "Insert/Edit Image", width: "400px", height: "270px"});
+				break;
+			// By default we assume that it is a builtin simple command.
+			default:
+				var curtInst = this.getCurrentInstance();
+				if((curtInst && curtInst.queryCommandAvailable(name)) ||
+					(!curtInst && dojo.widget.Editor2.prototype.queryCommandAvailable(name))){
+					oCommand = new dojo.widget.Editor2BrowserCommand(editor, name);
+				}else{
+					dojo.debug("dojo.widget.Editor2Manager.getCommand: Unknown command "+name);
+					return;
+				}
+		}
+		return oCommand;
+	},
+	destroy: function(){
+		// summary: Cleaning up. This is called automatically on page unload.
+		this._currentInstance = null;
+		dojo.widget.HandlerManager.prototype.destroy.call(this);
+	}
+});
+
+dojo.addOnUnload(dojo.widget.Editor2Manager, "destroy");
+
+dojo.lang.declare("dojo.widget.Editor2Command",null,
+	function(editor,name){
+		// summary:
+		//		dojo.widget.Editor2Command is the base class for all commands in Editor2
+
+		this._editor = editor;
+		this._updateTime = 0;
+		this._name = name;
+	},
+{
+		_text: 'Unknown',
+		execute: function(para){
+			// summary: Execute the command. should be implemented in subclass
+			// description: this function should be re-implemented in subclass
+			dojo.unimplemented("dojo.widget.Editor2Command.execute");
+		},
+		getText: function(){
+			// summary: return the text name of this command
+			return this._text;
+		},
+		getState: function(){
+			// summary:
+			//		Return the state of the command. The default behavior is
+			//		to always return Enabled
+			return dojo.widget.Editor2Manager.commandState.Enabled;
+		},
+		destroy: function(){
+			// summary: Destructor
+		}
+	}
+);
+
+dojo.widget.Editor2BrowserCommandNames={
+			'bold': 'Bold',
+			'copy': 'Copy',
+			'cut': 'Cut',
+			'Delete': 'Delete',
+			'indent': 'Indent',
+			'inserthorizontalrule': 'Horizental Rule',
+			'insertorderedlist': 'Numbered List',
+			'insertunorderedlist': 'Bullet List',
+			'italic': 'Italic',
+			'justifycenter': 'Align Center',
+			'justifyfull': 'Justify',
+			'justifyleft': 'Align Left',
+			'justifyright': 'Align Right',
+			'outdent': 'Outdent',
+			'paste': 'Paste',
+			'redo': 'Redo',
+			'removeformat': 'Remove Format',
+			'selectall': 'Select All',
+			'strikethrough': 'Strikethrough',
+			'subscript': 'Subscript',
+			'superscript': 'Superscript',
+			'underline': 'Underline',
+			'undo': 'Undo',
+			'unlink': 'Remove Link',
+			'createlink': 'Create Link',
+			'insertimage': 'Insert Image',
+			'htmltoggle': 'HTML Source',
+			'forecolor': 'Foreground Color',
+			'hilitecolor': 'Background Color',
+			'plainformatblock': 'Paragraph Style',
+			'formatblock': 'Paragraph Style',
+			'fontsize': 'Font Size',
+			'fontname': 'Font Name'//,
+//			'inserttable': 'Insert Table',
+//			'insertcell':
+//			'insertcol':
+//			'insertrow':
+//			'deletecells':
+//			'deletecols':
+//			'deleterows':
+//			'mergecells':
+//			'splitcell':
+//			'inserthtml':
+//			'blockdirltr':
+//			'blockdirrtl':
+//			'dirltr':
+//			'dirrtl':
+//			'inlinedirltr':
+//			'inlinedirrtl':
+}
+
+dojo.lang.declare("dojo.widget.Editor2BrowserCommand", dojo.widget.Editor2Command, 
+	function(editor,name){
+		// summary:
+		//		dojo.widget.Editor2BrowserCommand is the base class for all the browser built
+		//		in commands
+
+		var text = dojo.widget.Editor2BrowserCommandNames[name.toLowerCase()];
+		if(text){
+			this._text = text;
+		}
+	},
+{
+		execute: function(para){
+			this._editor.execCommand(this._name, para);
+		},
+		getState: function(){
+			if(this._editor._lastStateTimestamp > this._updateTime || this._state == undefined){
+				this._updateTime = this._editor._lastStateTimestamp;
+				try{
+					if(this._editor.queryCommandEnabled(this._name)){
+						if(this._editor.queryCommandState(this._name)){
+							this._state = dojo.widget.Editor2Manager.commandState.Latched;
+						}else{
+							this._state = dojo.widget.Editor2Manager.commandState.Enabled;
+						}
+					}else{
+						this._state = dojo.widget.Editor2Manager.commandState.Disabled;
+					}
+				}catch (e) {
+					//dojo.debug("exception when getting state for command "+this._name+": "+e);
+					this._state = dojo.widget.Editor2Manager.commandState.Enabled;
+				}
+			}
+			return this._state;
+		},
+		getValue: function(){
+			try{
+				return this._editor.queryCommandValue(this._name);
+			}catch(e){}
+		}
+	}
+);
+
+dojo.lang.declare("dojo.widget.Editor2FormatBlockCommand", dojo.widget.Editor2BrowserCommand, {
+		/* In none-ActiveX mode under IE, <p> and no <p> text can not be distinguished
+		getCurrentValue: function(){
+			var curInst = dojo.widget.Editor2Manager.getCurrentInstance();
+			if(!curInst){ return ''; }
+
+			var h = dojo.render.html;
+
+			// safari f's us for selection primitives
+			if(h.safari){ return ''; }
+
+			var selectedNode = (h.ie) ? curInst.document.selection.createRange().parentElement() : curInst.window.getSelection().anchorNode;
+			// make sure we actuall have an element
+			while((selectedNode)&&(selectedNode.nodeType != 1)){
+				selectedNode = selectedNode.parentNode;
+			}
+			if(!selectedNode){ return ''; }
+
+			var formats = ["p", "pre", "h1", "h2", "h3", "h4", "h5", "h6", "address"];
+			// gotta run some specialized updates for the various
+			// formatting options
+			var type = formats[dojo.lang.find(formats, selectedNode.nodeName.toLowerCase())];
+			while((selectedNode!=curInst.editNode)&&(!type)){
+				selectedNode = selectedNode.parentNode;
+				if(!selectedNode){ break; }
+				type = formats[dojo.lang.find(formats, selectedNode.nodeName.toLowerCase())];
+			}
+			if(!type){
+				type = "";
+			}
+			return type;
+		}*/
+	}
+);
+
+dojo.require("dojo.widget.FloatingPane");
+dojo.widget.defineWidget(
+	"dojo.widget.Editor2Dialog",
+	[dojo.widget.HtmlWidget, dojo.widget.FloatingPaneBase, dojo.widget.ModalDialogBase],
+	{
+		// summary:
+		//		Provides a Dialog which can be modal or normal for the Editor2.
+
+		templatePath: dojo.uri.dojoUri("src/widget/templates/Editor2/EditorDialog.html"),
+
+		// modal: Boolean: Whether this is a modal dialog. True by default.
+		modal: true,
+
+//		refreshOnShow: true, //for debug for now
+
+		// width: String: Width of the dialog. None by default.
+		width: "",
+
+		// height: String: Height of the dialog. None by default.
+		height: "",
+
+		// windowState: String: startup state of the dialog
+		windowState: "minimized",
+
+		displayCloseAction: true,
+
+		// contentFile: String
+		//	TODO
+		contentFile: "",
+		
+		// contentClass: String
+		//	TODO
+		contentClass: "",
+
+		fillInTemplate: function(args, frag){
+			this.fillInFloatingPaneTemplate(args, frag);
+			dojo.widget.Editor2Dialog.superclass.fillInTemplate.call(this, args, frag);
+		},
+		postCreate: function(){
+			if(this.contentFile){
+				dojo.require(this.contentFile);
+			}
+			if(this.modal){
+				dojo.widget.ModalDialogBase.prototype.postCreate.call(this);
+			}else{
+				with(this.domNode.style) {
+					zIndex = 999;
+					display = "none";
+				}
+			}
+			dojo.widget.FloatingPaneBase.prototype.postCreate.apply(this, arguments);
+			dojo.widget.Editor2Dialog.superclass.postCreate.call(this);
+			if(this.width && this.height){
+				with(this.domNode.style){
+					width = this.width;
+					height = this.height;
+				}
+			}
+		},
+		createContent: function(){
+			if(!this.contentWidget && this.contentClass){
+				this.contentWidget = dojo.widget.createWidget(this.contentClass);
+				this.addChild(this.contentWidget);
+			}
+		},
+		show: function(){
+			if(!this.contentWidget){
+				//buggy IE: if the dialog is hidden, the button widgets
+				//in the dialog can not be shown, so show it temporary (as the
+				//dialog may decide not to show it in loadContent() later)
+				dojo.widget.Editor2Dialog.superclass.show.apply(this, arguments);
+				this.createContent();
+				dojo.widget.Editor2Dialog.superclass.hide.call(this);
+			}
+
+			if(!this.contentWidget || !this.contentWidget.loadContent()){
+				return;
+			}
+			this.showFloatingPane();
+			dojo.widget.Editor2Dialog.superclass.show.apply(this, arguments);
+			if(this.modal){
+				this.showModalDialog();
+			}
+			if(this.modal){
+				//place the background div under this modal pane
+				this.bg.style.zIndex = this.domNode.style.zIndex-1;
+			}
+		},
+		onShow: function(){
+			dojo.widget.Editor2Dialog.superclass.onShow.call(this);
+			this.onFloatingPaneShow();
+		},
+		closeWindow: function(){
+			this.hide();
+			dojo.widget.Editor2Dialog.superclass.closeWindow.apply(this, arguments);
+		},
+		hide: function(){
+			if(this.modal){
+				this.hideModalDialog();
+			}
+			dojo.widget.Editor2Dialog.superclass.hide.call(this);
+		},
+		//modified from ModalDialogBase.checkSize to call _sizeBackground conditionally
+		checkSize: function(){
+			if(this.isShowing()){
+				if(this.modal){
+					this._sizeBackground();
+				}
+				this.placeModalDialog();
+				this.onResized();
+			}
+		}
+	}
+);
+
+dojo.widget.defineWidget(
+	"dojo.widget.Editor2DialogContent",
+	dojo.widget.HtmlWidget,
+{
+	// summary:
+	//		dojo.widget.Editor2DialogContent is the actual content of a Editor2Dialog.
+	//		This class should be subclassed to provide the content.
+
+	widgetsInTemplate: true,
+
+	loadContent:function(){
+		// summary: Load the content. Called by Editor2Dialog when first shown
+		return true;
+	},
+	cancel: function(){
+		// summary: Default handler when cancel button is clicked.
+		this.parent.hide();
+	}
+});
+
+dojo.lang.declare("dojo.widget.Editor2DialogCommand", dojo.widget.Editor2BrowserCommand,
+	function(editor, name, dialogParas){
+		// summary:
+		//		Provides an easy way to popup a dialog when
+		//		the command is executed.
+		this.dialogParas = dialogParas;
+	},
+{
+	execute: function(){
+		if(!this.dialog){
+			if(!this.dialogParas.contentFile || !this.dialogParas.contentClass){
+				alert("contentFile and contentClass should be set for dojo.widget.Editor2DialogCommand.dialogParas!");
+				return;
+			}
+			this.dialog = dojo.widget.createWidget("Editor2Dialog", this.dialogParas);
+
+			dojo.body().appendChild(this.dialog.domNode);
+
+			dojo.event.connect(this, "destroy", this.dialog, "destroy");
+		}
+		this.dialog.show();
+	},
+	getText: function(){
+		return this.dialogParas.title || dojo.widget.Editor2DialogCommand.superclass.getText.call(this);
+	}
+});
+
+dojo.widget.Editor2ToolbarGroups = {
+	// summary: keeping track of all available share toolbar groups
+};
+
+dojo.widget.defineWidget(
+	"dojo.widget.Editor2",
+	dojo.widget.RichText,
+	function(){
+		this._loadedCommands={};
+	},
+	{
+		// summary:
+		//		dojo.widget.Editor2 is the WYSIWYG editor in dojo with toolbar. It supports a plugin
+		//		framework which can be used to extend the functionalities of the editor, such as
+		//		adding a context menu, table operation etc.
+		// description:
+		//		Plugins are available using dojo's require syntax. Please find available built-in plugins
+		//		under src/widget/Editor2Plugin.
+
+//		// saveUrl: String: url to which save action should send content to
+//		saveUrl: "",
+//		// saveMethod: String: HTTP method for save (post or get)
+//		saveMethod: "post",
+//		saveArgName: "editorContent",
+//		closeOnSave: false,
+
+		// toolbarAlwaysVisible: Boolean: Whether the toolbar should scroll to keep it in the view
+		toolbarAlwaysVisible: false,
+
+//		htmlEditing: false,
+
+		toolbarWidget: null,
+		scrollInterval: null,
+
+		// toolbarTemplatePath: dojo.uri.Uri
+		//		to specify the template file for the toolbar
+		toolbarTemplatePath: dojo.uri.dojoUri("src/widget/templates/EditorToolbarOneline.html"),
+
+		// toolbarTemplateCssPath: dojo.uri.Uri
+		//		to specify the css file for the toolbar
+		toolbarTemplateCssPath: null,
+
+		// toolbarPlaceHolder: String
+		//		element id to specify where to attach the toolbar
+		toolbarPlaceHolder: '',
+
+//		toolbarTemplatePath: dojo.uri.dojoUri("src/widget/templates/Editor2/EditorToolbarFCKStyle.html"),
+//		toolbarTemplateCssPath: dojo.uri.dojoUri("src/widget/templates/Editor2/FCKDefault/EditorToolbarFCKStyle.css"),
+
+		_inSourceMode: false,
+		_htmlEditNode: null,
+
+		// toolbarGroup: String: 
+		//		This instance of editor will share the same toolbar with other editor with the same toolbarGroup. 
+		//		By default, toolbarGroup is empty and standalone toolbar is used for this instance.
+		toolbarGroup: '',
+
+		// shareToolbar: Boolean: Whether to share toolbar with other instances of Editor2. Deprecated in favor of toolbarGroup
+		shareToolbar: false,
+
+		// contextMenuGroupSet: String: specify which context menu set should be used for this instance. Include ContextMenu plugin to use this
+		contextMenuGroupSet: '',
+
+		editorOnLoad: function(){
+			// summary:
+			//		Create toolbar and other initialization routines. This is called after
+			//		the finish of the loading of document in the editing element
+//			dojo.profile.start("dojo.widget.Editor2::editorOnLoad");
+
+			dojo.event.topic.publish("dojo.widget.Editor2::preLoadingToolbar", this);
+			if(this.toolbarAlwaysVisible){
+				dojo.require("dojo.widget.Editor2Plugin.AlwaysShowToolbar");
+			}
+
+			if(this.toolbarWidget){
+				this.toolbarWidget.show();
+				//re-add the toolbar to the new domNode (caused by open() on another element)
+				dojo.html.insertBefore(this.toolbarWidget.domNode, this.domNode.firstChild);
+			}else{
+				if(this.shareToolbar){
+					dojo.deprecated("Editor2:shareToolbar is deprecated in favor of toolbarGroup", "0.5");
+					this.toolbarGroup = 'defaultDojoToolbarGroup';
+				}
+				if(this.toolbarGroup){
+					if(dojo.widget.Editor2ToolbarGroups[this.toolbarGroup]){
+						this.toolbarWidget = dojo.widget.Editor2ToolbarGroups[this.toolbarGroup];
+					}
+				}
+				if(!this.toolbarWidget){
+						var tbOpts = {shareGroup: this.toolbarGroup, parent: this};
+						tbOpts.templatePath = this.toolbarTemplatePath;
+						if(this.toolbarTemplateCssPath){
+							tbOpts.templateCssPath = this.toolbarTemplateCssPath;
+						}
+						if(this.toolbarPlaceHolder){
+							this.toolbarWidget = dojo.widget.createWidget("Editor2Toolbar", tbOpts, dojo.byId(this.toolbarPlaceHolder), "after");
+						}else{
+							this.toolbarWidget = dojo.widget.createWidget("Editor2Toolbar", tbOpts, this.domNode.firstChild, "before");
+						}
+						if(this.toolbarGroup){
+							dojo.widget.Editor2ToolbarGroups[this.toolbarGroup] = this.toolbarWidget;
+						}
+						dojo.event.connect(this, "close", this.toolbarWidget, "hide");
+	
+						this.toolbarLoaded();
+				}
+			}
+
+			dojo.event.topic.registerPublisher("Editor2.clobberFocus", this, "clobberFocus");
+			dojo.event.topic.subscribe("Editor2.clobberFocus", this, "setBlur");
+
+			dojo.event.topic.publish("dojo.widget.Editor2::onLoad", this);
+//			dojo.profile.end("dojo.widget.Editor2::editorOnLoad");
+		},
+
+		//event for plugins to use
+		toolbarLoaded: function(){
+			// summary:
+			//		Fired when the toolbar for this editor is created.
+			//		This event is for plugins to use
+		},
+
+		//TODO: provide a query mechanism about loaded plugins?
+		registerLoadedPlugin: function(/*Object*/obj){
+			// summary: Register a plugin which is loaded for this instance
+			if(!this.loadedPlugins){
+				this.loadedPlugins = [];
+			}
+			this.loadedPlugins.push(obj);
+		},
+		unregisterLoadedPlugin: function(/*Object*/obj){
+			// summary: Delete a loaded plugin for this instance
+			for(var i in this.loadedPlugins){
+				if(this.loadedPlugins[i] === obj){
+					delete this.loadedPlugins[i];
+					return;
+				}
+			}
+			dojo.debug("dojo.widget.Editor2.unregisterLoadedPlugin: unknow plugin object: "+obj);
+		},
+
+		//overload the original ones to provide extra commands
+		execCommand: function(/*String*/command, argument){
+			switch(command.toLowerCase()){
+				case 'htmltoggle':
+					this.toggleHtmlEditing();
+					break;
+				default:
+					dojo.widget.Editor2.superclass.execCommand.apply(this, arguments);
+			}
+		},
+		queryCommandEnabled: function(/*String*/command, argument){
+			switch(command.toLowerCase()){
+				case 'htmltoggle':
+					return true;
+				default:
+					if(this._inSourceMode){ return false;}
+					return dojo.widget.Editor2.superclass.queryCommandEnabled.apply(this, arguments);
+			}
+		},
+		queryCommandState: function(/*String*/command, argument){
+			switch(command.toLowerCase()){
+				case 'htmltoggle':
+					return this._inSourceMode;
+				default:
+					return dojo.widget.Editor2.superclass.queryCommandState.apply(this, arguments);
+			}
+		},
+
+		onClick: function(/*Event*/e){
+			dojo.widget.Editor2.superclass.onClick.call(this, e);
+			//if Popup is used, call dojo.widget.PopupManager.onClick
+			//manually when click in the editing area to close all
+			//open popups (dropdowns)
+			if(dojo.widget.PopupManager){
+				if(!e){ //IE
+					e = this.window.event;
+				}
+				dojo.widget.PopupManager.onClick(e);
+			}
+		},
+
+		clobberFocus: function(){
+			// summary: stub to signal other instances to clobber focus
+		},
+		toggleHtmlEditing: function(){
+			// summary: toggle between WYSIWYG mode and HTML source mode
+			if(this===dojo.widget.Editor2Manager.getCurrentInstance()){
+				if(!this._inSourceMode){
+					var html = this.getEditorContent();
+					this._inSourceMode = true;
+
+					if(!this._htmlEditNode){
+						this._htmlEditNode = dojo.doc().createElement("textarea");
+						dojo.html.insertAfter(this._htmlEditNode, this.editorObject);
+					}
+
+					this._htmlEditNode.style.display = "";
+					this._htmlEditNode.style.width = "100%";
+					this._htmlEditNode.style.height = dojo.html.getBorderBox(this.editNode).height+"px";
+					this._htmlEditNode.value = html;
+
+					//activeX object (IE) doesn't like to be hidden, so move it outside of screen instead
+					with(this.editorObject.style){
+						position = "absolute";
+						left = "-2000px";
+						top = "-2000px";
+					}
+				}else{
+					this._inSourceMode = false;
+
+					//In IE activeX mode, if _htmlEditNode is focused,
+					//when toggling, an error would occur, so unfocus it
+					this._htmlEditNode.blur();
+
+					with(this.editorObject.style){
+						position = "";
+						left = "";
+						top = "";
+					}
+					var html = this._htmlEditNode.value;
+
+					dojo.lang.setTimeout(this, "replaceEditorContent", 1, html);
+					this._htmlEditNode.style.display = "none";
+					this.focus();
+				}
+				this.onDisplayChanged(null, true);
+			}
+		},
+
+		setFocus: function(){
+			// summary: focus is set on this instance
+//			dojo.debug("setFocus: start "+this.widgetId);
+			if(dojo.widget.Editor2Manager.getCurrentInstance() === this){ return; }
+
+			this.clobberFocus();
+//			dojo.debug("setFocus:", this);
+			dojo.widget.Editor2Manager.setCurrentInstance(this);
+		},
+
+		setBlur: function(){
+			// summary: focus on this instance is lost
+//			 dojo.debug("setBlur:", this);
+			//dojo.event.disconnect(this.toolbarWidget, "exec", this, "execCommand");
+		},
+
+		saveSelection: function(){
+			// summary: save the current selection for restoring it
+			this._bookmark = null;
+			this._bookmark = dojo.withGlobal(this.window, dojo.html.selection.getBookmark);
+		},
+		restoreSelection: function(){
+			// summary: restore the last saved selection
+			if(this._bookmark){
+				this.focus(); //require for none-activeX IE
+				dojo.withGlobal(this.window, "moveToBookmark", dojo.html.selection, [this._bookmark]);
+				this._bookmark = null;
+			}else{
+				dojo.debug("restoreSelection: no saved selection is found!");
+			}
+		},
+
+		_updateToolbarLastRan: null,
+		_updateToolbarTimer: null,
+		_updateToolbarFrequency: 500,
+
+		updateToolbar: function(/*Boolean*/force){
+			// summary: update the associated toolbar of this Editor2
+			if((!this.isLoaded)||(!this.toolbarWidget)){ return; }
+
+			// keeps the toolbar from updating too frequently
+			// TODO: generalize this functionality?
+			var diff = new Date() - this._updateToolbarLastRan;
+			if( (!force)&&(this._updateToolbarLastRan)&&
+				((diff < this._updateToolbarFrequency)) ){
+
+				clearTimeout(this._updateToolbarTimer);
+				var _this = this;
+				this._updateToolbarTimer = setTimeout(function() {
+					_this.updateToolbar();
+				}, this._updateToolbarFrequency/2);
+				return;
+
+			}else{
+				this._updateToolbarLastRan = new Date();
+			}
+			// end frequency checker
+
+			//IE has the habit of generating events even when this editor is blurred, prevent this
+			if(dojo.widget.Editor2Manager.getCurrentInstance() !== this){ return; }
+
+			this.toolbarWidget.update();
+		},
+
+		destroy: function(/*Boolean*/finalize){
+			this._htmlEditNode = null;
+			dojo.event.disconnect(this, "close", this.toolbarWidget, "hide");
+			if(!finalize){
+				this.toolbarWidget.destroy();
+			}
+			dojo.widget.Editor2.superclass.destroy.call(this);
+		},
+
+		_lastStateTimestamp: 0,
+		onDisplayChanged: function(/*Object*/e, /*Boolean*/forceUpdate){
+			this._lastStateTimestamp = (new Date()).getTime();
+			dojo.widget.Editor2.superclass.onDisplayChanged.call(this,e);
+			this.updateToolbar(forceUpdate);
+		},
+
+		onLoad: function(){
+			try{
+				dojo.widget.Editor2.superclass.onLoad.call(this);
+			}catch(e){ // FIXME: debug why this is throwing errors in IE!
+				dojo.debug(e);
+			}
+			this.editorOnLoad();
+		},
+
+		onFocus: function(){
+			dojo.widget.Editor2.superclass.onFocus.call(this);
+			this.setFocus();
+		},
+
+		//overload to support source editing mode
+		getEditorContent: function(){
+			if(this._inSourceMode){
+				return this._htmlEditNode.value;
+			}
+			return dojo.widget.Editor2.superclass.getEditorContent.call(this);
+		},
+
+		replaceEditorContent: function(html){
+			if(this._inSourceMode){
+				this._htmlEditNode.value = html;
+				return;
+			}
+			dojo.widget.Editor2.superclass.replaceEditorContent.apply(this,arguments);
+		},
+		getCommand: function(/*String*/name){
+			// summary: return a command associated with this instance of editor
+			if(this._loadedCommands[name]){
+				return this._loadedCommands[name];
+			}
+			var cmd = dojo.widget.Editor2Manager.getCommand(this, name);
+			this._loadedCommands[name] = cmd;
+			return cmd;
+		},
+		// Array: Commands shortcuts. Each element can has up to 3 fields:
+		//		1. String: the name of the command
+		//		2. String Optional: the char for shortcut key, by default the first char from the command name is used
+		//		3. Int Optional: specify the modifier of the shortcut, by default ctrl is used
+		shortcuts: [['bold'],['italic'],['underline'],['selectall','a'],['insertunorderedlist','\\']],
+		setupDefaultShortcuts: function(){
+			// summary: setup default shortcuts using Editor2 commands
+			var exec = function(cmd){ return function(){ cmd.execute(); } };
+//			if(!dojo.render.html.ie){
+//				this.shortcuts.push(['redo','Z']);
+//			}
+			var self = this;
+			dojo.lang.forEach(this.shortcuts, function(item){
+				var cmd = self.getCommand(item[0]);
+				if(cmd){
+					self.addKeyHandler(item[1]?item[1]:item[0].charAt(0), item[2]==undefined?self.KEY_CTRL:item[2], exec(cmd));
+				}
+			});
+//			this.addKeyHandler("s", ctrl, function () { this.save(true); });
+		}
+		/*,
+		// FIXME: probably not needed any more with new design, but need to verify
+		_save: function(e){
+			// FIXME: how should this behave when there's a larger form in play?
+			if(!this.isClosed){
+				dojo.debug("save attempt");
+				if(this.saveUrl.length){
+					var content = {};
+					content[this.saveArgName] = this.getEditorContent();
+					dojo.io.bind({
+						method: this.saveMethod,
+						url: this.saveUrl,
+						content: content
+					});
+				}else{
+					dojo.debug("please set a saveUrl for the editor");
+				}
+				if(this.closeOnSave){
+					this.close(e.getName().toLowerCase() == "save");
+				}
+			}
+		}*/
+	}
+);
\ No newline at end of file

Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/AlwaysShowToolbar.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/AlwaysShowToolbar.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/AlwaysShowToolbar.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/AlwaysShowToolbar.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,145 @@
+/*
+	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.Editor2Plugin.AlwaysShowToolbar");
+
+//dojo.widget.Editor2Manager.registerPerInstancePlugin("dojo.widget.Editor2Plugin.AlwaysShowToolbar");
+
+dojo.event.topic.subscribe("dojo.widget.Editor2::onLoad", function(editor){
+	if(editor.toolbarAlwaysVisible){
+		var p = new dojo.widget.Editor2Plugin.AlwaysShowToolbar(editor);
+	}
+});
+dojo.declare("dojo.widget.Editor2Plugin.AlwaysShowToolbar", null,
+	function(editor){
+		this.editor = editor;
+		this.editor.registerLoadedPlugin(this);
+		this.setup();
+	},
+	{
+	_scrollSetUp: false,
+	_fixEnabled: false,
+	_scrollThreshold: false,
+	_handleScroll: true,
+
+	setup: function(){
+		var tdn = this.editor.toolbarWidget;
+		if(!tdn.tbBgIframe){
+			tdn.tbBgIframe = new dojo.html.BackgroundIframe(tdn.domNode);
+			tdn.tbBgIframe.onResized();
+		}
+		this.scrollInterval = setInterval(dojo.lang.hitch(this, "globalOnScrollHandler"), 100);
+
+		dojo.event.connect("before", this.editor.toolbarWidget, "destroy", this, "destroy");
+	},
+
+	globalOnScrollHandler: function(){
+		var isIE = dojo.render.html.ie;
+		if(!this._handleScroll){ return; }
+		var dh = dojo.html;
+		var tdn = this.editor.toolbarWidget.domNode;
+		var db = dojo.body();
+
+		if(!this._scrollSetUp){
+			this._scrollSetUp = true;
+			var editorWidth =  dh.getMarginBox(this.editor.domNode).width; 
+			this._scrollThreshold = dh.abs(tdn, true).y;
+			// dojo.debug("threshold:", this._scrollThreshold);
+			if((isIE)&&(db)&&(dh.getStyle(db, "background-image")=="none")){
+				with(db.style){
+					backgroundImage = "url(" + dojo.uri.dojoUri("src/widget/templates/images/blank.gif") + ")";
+					backgroundAttachment = "fixed";
+				}
+			}
+		}
+
+		var scrollPos = (window["pageYOffset"]) ? window["pageYOffset"] : (document["documentElement"]||document["body"]).scrollTop;
+
+		// FIXME: need to have top and bottom thresholds so toolbar doesn't keep scrolling past the bottom
+		if(scrollPos > this._scrollThreshold){
+			// dojo.debug(scrollPos);
+			if(!this._fixEnabled){
+				var tdnbox = dojo.html.getMarginBox(tdn);
+				this.editor.editorObject.style.marginTop = tdnbox.height+"px";
+
+				if(isIE){
+					// FIXME: should we just use setBehvior() here instead?
+					tdn.style.left = dojo.html.abs(tdn, dojo.html.boxSizing.MARGIN_BOX).x;
+					if(tdn.previousSibling){
+						this._IEOriginalPos = ['after',tdn.previousSibling];
+					}else if(tdn.nextSibling){
+						this._IEOriginalPos = ['before',tdn.nextSibling];
+					}else{
+						this._IEOriginalPos = ['',tdn.parentNode];
+					}
+					dojo.body().appendChild(tdn);
+
+					dojo.html.addClass(tdn, "IEFixedToolbar");
+				}else{
+					with(tdn.style){
+						position = "fixed";
+						top = "0px";
+					}
+				}
+
+				tdn.style.width = tdnbox.width + "px";
+				tdn.style.zIndex = 1000;
+				this._fixEnabled = true;
+			}
+			// if we're showing the floating toolbar, make sure that if
+			// we've scrolled past the bottom of the editor that we hide
+			// the toolbar for this instance of the editor.
+
+			// TODO: when we get multiple editor toolbar support working
+			// correctly, ensure that we check this against the scroll
+			// position of the bottom-most editor instance.
+			if(!dojo.render.html.safari){
+				// safari reports a bunch of things incorrectly here
+				var eHeight = (this.height) ? parseInt(this.editor.height) : this.editor._lastHeight;
+				if(scrollPos > (this._scrollThreshold+eHeight)){
+					tdn.style.display = "none";
+				}else{
+					tdn.style.display = "";
+				}
+			}
+		}else if(this._fixEnabled){
+			(this.editor.object || this.editor.iframe).style.marginTop = null;
+			with(tdn.style){
+				position = "";
+				top = "";
+				zIndex = "";
+				display = "";
+			}
+			if(isIE){
+				tdn.style.left = "";
+				dojo.html.removeClass(tdn, "IEFixedToolbar");
+				if(this._IEOriginalPos){
+					dojo.html.insertAtPosition(tdn, this._IEOriginalPos[1], this._IEOriginalPos[0]);
+					this._IEOriginalPos = null;
+				}else{
+					dojo.html.insertBefore(tdn, this.editor.object||this.editor.iframe);
+				}
+			}
+			tdn.style.width = "";
+			this._fixEnabled = false;
+		}
+	},
+
+	destroy: function(){
+		this._IEOriginalPos = null;
+		this._handleScroll = false;
+		clearInterval(this.scrollInterval);
+		this.editor.unregisterLoadedPlugin(this);
+
+		if(dojo.render.html.ie){
+			dojo.html.removeClass(this.editor.toolbarWidget.domNode, "IEFixedToolbar");
+		}
+	}
+});
\ No newline at end of file

Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/ContextMenu.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/ContextMenu.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/ContextMenu.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/ContextMenu.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,278 @@
+/*
+	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.Editor2Plugin.ContextMenu");
+
+// summary: dojo.widget.Editor2Plugin.ContextMenu provides context menu for Editor2 widget
+// description:
+//		This plugin should be dojo.required-ed before all other plugins which
+//		support contextmenu, otherwise the menu for that plugin won't be shown
+//		For each Editor2, what will appear in its context menu can be set by changing
+//		Editor2.contextMenuGroupSet property (by default it is empty, which means use the
+//		default contextMenu). A contextMenuGroupSet has to be registered by calling
+//		dojo.widget.Editor2Plugin.ContextMenuManager.registerGroupSet()
+//		All Editor2 with the same contextMenuGroupSet will share the same ContextMenu
+
+dojo.require("dojo.widget.Menu2");
+
+dojo.event.topic.subscribe("dojo.widget.Editor2::onLoad", function(editor){
+	dojo.widget.Editor2Plugin.ContextMenuManager.getContextMenu(editor);
+//	var p = new dojo.widget.Editor2Plugin.ContextMenu();
+});
+
+dojo.widget.Editor2Plugin.ContextMenuManager = {
+	menuGroups: ['Generic', 'Link', 'Anchor', 'Image', 'List', 'Table'],
+	_contextMenuGroupSets: {},
+	_registeredGroups: {},
+	_menus: {},
+	registerGroup: function(name, handler){
+		if(this._registeredGroups[name]){
+			alert("dojo.widget.Editor2Plugin.ContextMenuManager.registerGroup: menu group "+name+"is already registered. Ignored.");
+			return;
+		}
+		this._registeredGroups[name] = handler;
+	},
+	removeGroup: function(name){
+		delete this._registeredGroups[name];
+	},
+	getGroup: function(name, contextmenuplugin){
+		if(this._registeredGroups[name]){
+			var item = this._registeredGroups[name](name, contextmenuplugin);
+			if(item){
+				return item;
+			}
+		}
+		switch(name){
+			case 'Generic':
+			case 'Link':
+			case 'Image':
+				return new dojo.widget.Editor2Plugin[name+"ContextMenuGroup"](contextmenuplugin);
+			//TODO
+			case 'Anchor':
+			case 'List':
+		}
+	},
+	registerGroupSet: function(/*String*/name, /*Array*/set){
+		// summary: register a group set
+		// name: name of the group set
+		// set: an array of groups, such as ['Generic','Link']
+		this._contextMenuGroupSets[name] = set;
+	},
+	removeGroupSet: function(name){
+		var set = this._contextMenuGroupSets[name];
+		delete this._contextMenuGroupSets[name];
+		return set;
+	},
+	getContextMenu: function(editor){
+		var set = editor.contextMenuGroupSet || 'defaultDojoEditor2MenuGroupSet';
+		if(this._menus[set]){
+			this._menus[set].bindEditor(editor);
+			return this._menus[set];
+		}
+
+		var gs = (editor.contextMenuGroupSet && this._contextMenuGroupSets[editor.contextMenuGroupSet]) || this.menuGroups;
+		var menu = new dojo.widget.Editor2Plugin.ContextMenu(editor, gs);
+		this._menus[set] = menu;
+		return menu;
+	}
+};
+
+dojo.declare("dojo.widget.Editor2Plugin.ContextMenu", null,
+	function(editor, gs){
+		this.groups = [];
+		this.separators = [];
+		this.editor = editor;
+		this.editor.registerLoadedPlugin(this);
+		this.contextMenu = dojo.widget.createWidget("PopupMenu2", {});
+		dojo.body().appendChild(this.contextMenu.domNode);
+		this.bindEditor(this.editor);
+
+		dojo.event.connect(this.contextMenu, "aboutToShow", this, "aboutToShow");
+		dojo.event.connect(this.editor, "destroy", this, "destroy");
+
+		this.setup(gs);
+	},
+	{
+	bindEditor: function(editor){
+		this.contextMenu.bindDomNode(editor.document.body);
+	},
+	setup: function(gs){
+		for(var i in gs){
+			var g = dojo.widget.Editor2Plugin.ContextMenuManager.getGroup(gs[i], this);
+			if(g){
+				this.groups.push(g);
+			}
+		}
+	},
+	aboutToShow: function(){
+		var first = true;
+		for(var i in this.groups){
+			if(i>0 && this.separators.length != this.groups.length-1){
+				this.separators.push(dojo.widget.createWidget("MenuSeparator2", {}));
+				this.contextMenu.addChild(this.separators[this.separators.length-1]);
+			}
+			if(this.groups[i].refresh()){
+				if(i>0){
+					if(first){
+						this.separators[i-1].hide();
+					}else{
+						this.separators[i-1].show();
+					}
+				}
+				if(first){ first = false; }
+			}else{
+				if(i>0){
+					this.separators[i-1].hide();
+				}
+			}
+		}
+	},
+	destroy: function(){
+		this.editor.unregisterLoadedPlugin(this);
+		delete this.groups;
+		delete this.separators;
+		this.contextMenu.destroy();
+		delete this.contextMenu;
+	}
+});
+
+dojo.widget.defineWidget(
+	"dojo.widget.Editor2ContextMenuItem",
+	dojo.widget.MenuItem2,
+{
+	command: '',
+	buildRendering: function(){
+		var curInst = dojo.widget.Editor2Manager.getCurrentInstance();
+		this.caption = curInst.getCommand(this.command).getText();
+
+		dojo.widget.Editor2ContextMenuItem.superclass.buildRendering.apply(this, arguments);
+	},
+	onClick: function(){
+		var curInst = dojo.widget.Editor2Manager.getCurrentInstance();
+		if(curInst){
+			var _command = curInst.getCommand(this.command);
+			if(_command){
+				_command.execute();
+			}
+		}
+	},
+	refresh: function(){
+		var curInst = dojo.widget.Editor2Manager.getCurrentInstance();
+		if(curInst){
+			var _command = curInst.getCommand(this.command);
+			if(_command){
+				if(_command.getState() == dojo.widget.Editor2Manager.commandState.Disabled){
+					this.disable();
+					return false;
+				}else{
+					this.enable();
+					return true;
+				}
+			}
+		}
+	},
+	//improve performance by skipping animation
+	hide: function(){
+		this.domNode.style.display = "none";
+	},
+	show: function(){
+		this.domNode.style.display = "";
+	}
+});
+dojo.declare("dojo.widget.Editor2Plugin.SimpleContextMenuGroup", null,
+	function(contextmenuplugin){
+		this.contextMenu = contextmenuplugin.contextMenu;
+		this.items = [];
+
+		dojo.event.connect(contextmenuplugin, "destroy", this, "destroy");
+	},
+	{
+	refresh: function(){
+		if(!this.items.length){
+			this.createItems();
+			for(var i in this.items){
+				this.contextMenu.addChild(this.items[i]);
+			}
+		}
+
+		return this.checkVisibility();
+	},
+	destroy: function(){
+		this.contextmenu = null;
+		delete this.items;
+		delete this.contextMenu;
+	},
+	//implement this to fill in the menu items
+	createItems: function(){	},
+
+	//overload this to show/hide items
+	checkVisibility: function(){
+		var show = false;
+		for(var i in this.items){
+			show = show || this.items[i].refresh();
+		}
+		var action = show ? "show" : "hide";
+		for(var i in this.items){
+			this.items[i][action]();
+		}
+		return show;
+	}
+});
+dojo.declare("dojo.widget.Editor2Plugin.GenericContextMenuGroup",
+	dojo.widget.Editor2Plugin.SimpleContextMenuGroup,
+{
+	createItems: function(){
+		this.items.push(dojo.widget.createWidget("Editor2ContextMenuItem", {command: "cut", iconClass: "dojoE2TBIcon dojoE2TBIcon_Cut"}));
+		this.items.push(dojo.widget.createWidget("Editor2ContextMenuItem", {command: "copy", iconClass: "dojoE2TBIcon dojoE2TBIcon_Copy"}));
+		this.items.push(dojo.widget.createWidget("Editor2ContextMenuItem", {command: "paste", iconClass: "dojoE2TBIcon dojoE2TBIcon_Paste"}));
+	}
+});
+dojo.declare("dojo.widget.Editor2Plugin.LinkContextMenuGroup",
+	dojo.widget.Editor2Plugin.SimpleContextMenuGroup,
+{
+	createItems: function(){
+		this.items.push(dojo.widget.createWidget("Editor2ContextMenuItem", {command: 'createlink', iconClass: "dojoE2TBIcon dojoE2TBIcon_Link"}));
+		this.items.push(dojo.widget.createWidget("Editor2ContextMenuItem", {command: 'unlink', iconClass: "dojoE2TBIcon dojoE2TBIcon_UnLink"}));
+	},
+	checkVisibility: function(){
+		var show = this.items[1].refresh();
+		if(show){
+			this.items[0].refresh();
+			for(var i in this.items){
+				this.items[i].show();
+			}
+		}else{
+			for(var i in this.items){
+				this.items[i].hide();
+			}
+		}
+
+		return show;
+	}
+});
+dojo.declare("dojo.widget.Editor2Plugin.ImageContextMenuGroup",
+	dojo.widget.Editor2Plugin.SimpleContextMenuGroup,
+{
+	createItems: function(){
+		this.items.push(dojo.widget.createWidget("Editor2ContextMenuItem", {command: 'insertimage', iconClass: "dojoE2TBIcon dojoE2TBIcon_Image"}));
+	},
+	checkVisibility: function(){
+		var curInst = dojo.widget.Editor2Manager.getCurrentInstance();
+		var img = dojo.withGlobal(curInst.window, "getSelectedElement", dojo.html.selection);
+
+		if(img && img.tagName.toLowerCase() == 'img'){
+			this.items[0].show();
+			return true;
+		}else{
+			this.items[0].hide();
+			return false;
+		}
+	}
+});
\ No newline at end of file

Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/CreateLinkDialog.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/CreateLinkDialog.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/CreateLinkDialog.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/CreateLinkDialog.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,78 @@
+/*
+	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.Editor2Plugin.CreateLinkDialog");
+
+dojo.widget.defineWidget(
+	"dojo.widget.Editor2CreateLinkDialog",
+	dojo.widget.Editor2DialogContent,
+{
+	templatePath: dojo.uri.dojoUri("src/widget/templates/Editor2/Dialog/createlink.html"),
+
+	editableAttributes: ['href', 'target', 'class'],
+	loadContent: function(){
+		var curInst = dojo.widget.Editor2Manager.getCurrentInstance();
+
+		curInst.saveSelection(); //save selection (none-activeX IE)
+
+		this.linkNode = dojo.withGlobal(curInst.window, "getAncestorElement", dojo.html.selection, ['a']);
+		var linkAttributes = {};
+		this.extraAttribText = "";
+		if(this.linkNode){
+			var attrs = this.linkNode.attributes;
+			for(var i=0; i<attrs.length; i++) {
+				if(dojo.lang.find(this.editableAttributes, attrs[i].name.toLowerCase())>-1){
+					linkAttributes[attrs[i].name] = attrs[i].value;
+				}else{
+					//IE lists all attributes, even default ones, filter them
+					if(attrs[i].specified == undefined || attrs[i].specified){
+						this.extraAttribText += attrs[i].name + '="'+attrs[i].value+'" ';
+					}
+				}
+			}
+		}else{
+			var html = dojo.withGlobal(curInst.window, "getSelectedText", dojo.html.selection);
+			if(html == null || html.length == 0){
+				alert("Please select some text to create a link.");
+				return false;//do not show the dialog
+			}
+		}
+
+		for(var i=0; i<this.editableAttributes.length; ++i){
+			name = this.editableAttributes[i];
+			this["link_"+name].value = (linkAttributes[name] == undefined) ? "" : linkAttributes[name] ;
+		}
+		return true;
+	},
+	ok: function(){
+		var curInst = dojo.widget.Editor2Manager.getCurrentInstance();
+		curInst.restoreSelection(); //restore previous selection, required for none-activeX IE
+
+		if(!this.linkNode){
+			var html = dojo.withGlobal(curInst.window, "getSelectedHtml", dojo.html.selection);
+		}else{
+			var html = this.linkNode.innerHTML;
+			dojo.withGlobal(curInst.window, "selectElement", dojo.html.selection, [this.linkNode]);
+		}
+
+		var attstr='';
+		for(var i=0; i<this.editableAttributes.length; ++i){
+			name = this.editableAttributes[i];
+			var value = this["link_"+name].value;
+			if(value.length > 0){
+				attstr += name + '="'+value+'" ';
+			}
+		}
+
+		curInst.execCommand('inserthtml', '<a '+attstr+this.extraAttribText+'>'+html+'</a>');
+
+		this.cancel();
+	}
+});
\ No newline at end of file

Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/FindReplace.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/FindReplace.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/FindReplace.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/FindReplace.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,84 @@
+/*
+	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.Editor2Plugin.FindReplace");
+
+dojo.require("dojo.widget.Editor2");
+
+//TODO replace, better GUI
+
+dojo.declare("dojo.widget.Editor2Plugin.FindCommand", dojo.widget.Editor2DialogCommand,{
+	SearchOption: {
+		CaseSensitive: 4,
+		SearchBackwards: 64,
+		WholeWord: 2,
+		WrapSearch: 128
+	},
+	find: function(text, option){
+		this._editor.focus();
+		if(window.find){ //moz
+			this._editor.window.find(text, 
+				option & this.SearchOption.CaseSensitive ? true : false,
+				option & this.SearchOption.SearchBackwards ? true : false,
+				option & this.SearchOption.WrapSearch ? true : false,
+				option & this.SearchOption.WholeWord ? true : false
+				);
+		}else if(dojo.body().createTextRange){ //IE
+			var range = this._editor.document.body.createTextRange();
+			var found = range.findText(text, (option&this.SearchOption.SearchBackwards)?1:-1, option );
+			if(found){
+				range.scrollIntoView() ;
+				range.select() ;
+			}else{
+				alert("Can not find "+text+" in the document");
+			}
+		}else{
+			alert("No idea how to search in this browser. Please submit patch if you know.");
+		}
+	},
+	getText: function(){
+		return 'Find';
+	}
+});
+
+dojo.widget.Editor2Plugin.FindReplace ={
+	getCommand: function(editor, name){
+		var name = name.toLowerCase();
+		var command;
+		if(name == 'find'){
+			command = new dojo.widget.Editor2Plugin.FindCommand(editor, 'find', 
+				{contentFile: "dojo.widget.Editor2Plugin.FindReplaceDialog", 
+				contentClass: "Editor2FindDialog",
+				title: "Find", width: "350px", height: "150px", modal: false});
+		}else if(name == 'replace') {
+			command = new dojo.widget.Editor2DialogCommand(editor, 'replace', 
+				{contentFile: "dojo.widget.Editor2Plugin.FindReplaceDialog", 
+				contentClass: "Editor2ReplaceDialog",
+				href: dojo.uri.dojoUri("src/widget/templates/Editor2/Dialog/replace.html"), 
+				title: "Replace", width: "350px", height: "200px", modal: false});
+		}
+	
+		return command;
+	},
+	getToolbarItem: function(name){
+		var name = name.toLowerCase();
+	
+		var item;
+		if(name == 'replace'){
+			item = new dojo.widget.Editor2ToolbarButton('Replace');
+		}else if(name == 'find') {
+			item = new dojo.widget.Editor2ToolbarButton('Find');
+		}
+	
+		return item;
+	}
+}
+dojo.widget.Editor2Manager.registerHandler(dojo.widget.Editor2Plugin.FindReplace.getCommand);
+dojo.widget.Editor2ToolbarItemManager.registerHandler(dojo.widget.Editor2Plugin.FindReplace.getToolbarItem);
\ No newline at end of file

Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/FindReplaceDialog.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/FindReplaceDialog.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/FindReplaceDialog.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/FindReplaceDialog.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,50 @@
+/*
+	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.Editor2Plugin.FindReplaceDialog");
+
+dojo.widget.defineWidget(
+	"dojo.widget.Editor2FindDialog",
+	dojo.widget.Editor2DialogContent,
+{
+	templatePath: dojo.uri.dojoUri("src/widget/templates/Editor2/Dialog/find.html"),
+
+	find: function(){
+		var curInst = dojo.widget.Editor2Manager.getCurrentInstance();
+		var findcmd = curInst.getCommand('find');
+		var option = 0;
+	
+		if(this["find_option_casesens"].checked){
+			option |= findcmd.SearchOption.CaseSensitive;
+		}
+		if(this["find_option_backwards"].checked){
+			option |= findcmd.SearchOption.SearchBackwards;
+		}
+	
+		if(this["find_option_wholeword"].checked){
+			option |= findcmd.SearchOption.WholeWord;
+		}
+		findcmd.find(this["find_text"].value, option);
+	}
+});
+
+dojo.widget.defineWidget(
+	"dojo.widget.Editor2ReplaceDialog",
+	dojo.widget.Editor2DialogContent,
+{
+	templatePath: dojo.uri.dojoUri("src/widget/templates/Editor2/Dialog/replace.html"),
+
+	replace: function(){
+		alert("not implemented yet");
+	},
+	replaceAll: function(){
+		alert("not implemented yet");
+	}
+});
\ No newline at end of file

Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/InsertImageDialog.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/InsertImageDialog.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/InsertImageDialog.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/InsertImageDialog.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,64 @@
+/*
+	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.Editor2Plugin.InsertImageDialog");
+
+dojo.widget.defineWidget(
+	"dojo.widget.Editor2InsertImageDialog",
+	dojo.widget.Editor2DialogContent,
+{
+	templatePath: dojo.uri.dojoUri("src/widget/templates/Editor2/Dialog/insertimage.html"),
+
+	editableAttributes: ['src', 'alt', 'width', 'height', 'hspace', 'vspace', 'border', 'align'],
+	loadContent: function(){
+		var curInst = dojo.widget.Editor2Manager.getCurrentInstance();
+		this.imageNode = dojo.withGlobal(curInst.window, "getSelectedElement", dojo.html.selection);
+		if(!this.imageNode){
+			this.imageNode = dojo.withGlobal(curInst.window, "getAncestorElement", dojo.html.selection, ['img']);
+		}
+		var imageAttributes = {};
+		this.extraAttribText = "";
+		if(this.imageNode){
+			var attrs = this.imageNode.attributes;
+			for(var i=0; i<attrs.length; i++) {
+				if(dojo.lang.find(this.editableAttributes, attrs[i].name.toLowerCase())>-1){
+					imageAttributes[attrs[i].name] = attrs[i].value;
+				}else{
+					this.extraAttribText += attrs[i].name + '="'+attrs[i].value+'" ';
+				}
+			}
+		}
+		for(var i=0; i<this.editableAttributes.length; ++i){
+			name = this.editableAttributes[i];
+			this["image_"+name].value = (imageAttributes[name] == undefined) ? "" : imageAttributes[name] ;
+		}
+		return true;
+	},
+	ok: function(){
+		var curInst = dojo.widget.Editor2Manager.getCurrentInstance();
+		var insertcmd = curInst.getCommand('inserthtml');
+		var option = 0;
+
+		var attstr='';
+		for(var i=0; i<this.editableAttributes.length; ++i){
+			name = this.editableAttributes[i];
+			var value = this["image_"+name].value;
+			if(value.length > 0){
+				attstr += name + '="'+value+'" ';
+			}
+		}
+		if(this.imageNode){
+			dojo.withGlobal(curInst.window, "selectElement", dojo.html.selection, [this.imageNode]);
+		}
+		insertcmd.execute('<img '+attstr+this.extraAttribText+'/>');
+
+		this.cancel();
+	}
+});
\ No newline at end of file

Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/InsertTableDialog.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/InsertTableDialog.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/InsertTableDialog.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/InsertTableDialog.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,149 @@
+/*
+	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.Editor2Plugin.InsertTableDialog");
+
+dojo.widget.defineWidget(
+	"dojo.widget.Editor2InsertTableDialog",
+	dojo.widget.Editor2DialogContent,
+{
+	templatePath: dojo.uri.dojoUri("src/widget/templates/Editor2/Dialog/inserttable.html"),
+
+	editableAttributes: ['summary', 'height', 'cellspacing', 'cellpadding', 'border', 'align'],
+
+	loadContent: function(){
+		var curInst = dojo.widget.Editor2Manager.getCurrentInstance();
+		curInst.saveSelection(); //save selection (none-activeX IE)
+		this.tableNode = dojo.withGlobal(curInst.window, "getSelectedElement", dojo.html.selection);
+		if(!this.tableNode || this.tableNode.tagName.toLowerCase() != 'table'){
+			this.tableNode = dojo.withGlobal(curInst.window, "getAncestorElement", dojo.html.selection, ['table']);
+		}
+
+		var tableAttributes = {};
+		this.extraAttribText = "";
+		if(this.tableNode){
+			this["table_rows"].value = this.tableNode.rows.length;
+			this["table_rows"].disabled = true;
+			this["table_cols"].value = this.tableNode.rows[0].cells.length;
+			this["table_cols"].disabled = true;
+
+			if (this.tableNode.caption){
+				this["table_caption"].value = this.tableNode.caption.innerHTML;
+			}else{
+				this["table_caption"].value = "";
+			}
+
+			var width = this.tableNode.style.width || this.tableNode.width;
+			if(width){
+				this["table_width"].value = parseInt(width);
+				if (width.indexOf('%') > -1){
+					this["table_widthtype"].value = "percent";
+				}else{
+					this["table_widthtype"].value = "pixels";
+				}
+			}else{
+				this["table_width"].value = "100";
+			}
+
+			var height = this.tableNode.style.height || this.tableNode.height;
+			if(height){
+				this["table_height"].value = parseInt(width);
+			}else{
+				this["table_height"].value = "";
+			}
+
+			var attrs = this.tableNode.attributes;
+			for(var i=0; i<attrs.length; i++) {
+				if(dojo.lang.find(this.editableAttributes, attrs[i].name.toLowerCase())>-1){
+					tableAttributes[attrs[i].name] = attrs[i].value;
+				}else{
+					this.extraAttribText += attrs[i].name + '="'+attrs[i].value+'" ';
+				}
+			}
+		}else{
+			this["table_rows"].value = 3;
+			this["table_rows"].disabled = false;
+			this["table_cols"].value = 2;
+			this["table_cols"].disabled = false;
+			this["table_width"].value = 100;
+			this["table_widthtype"].value = "percent";
+			this["table_height"].value = "";
+		}
+
+		for(var i=0; i<this.editableAttributes.length; ++i){
+			name = this.editableAttributes[i];
+			this["table_"+name].value = (tableAttributes[name] == undefined) ? "" : tableAttributes[name];
+			if(name == 'height' && tableAttributes[name] != undefined){
+				this["table_"+name].value = tableAttributes[name];
+			}
+		}
+		return true;
+	},
+	ok: function(){
+		var curInst = dojo.widget.Editor2Manager.getCurrentInstance();
+		var args = {};
+
+		args['rows'] = this["table_rows"].value;
+		args['cols'] = this["table_cols"].value;
+		args['caption'] = this["table_caption"].value;
+		args["tableattrs"] = "";
+		if(this["table_widthtype"].value == "percent"){
+			args["tableattrs"] += 'width="'+this["table_width"].value +'%" ';
+		}else{
+			args["tableattrs"] += 'width="'+this["table_width"].value +'px" ';
+		}
+		for(var i=0; i<this.editableAttributes.length; ++i){
+			var name = this.editableAttributes[i];
+			var value = this["table_"+name].value;
+			if(value.length > 0){
+				args["tableattrs"] += name + '="'+value+'" ';
+			}
+		}
+
+		if(!args["tableattrs"]){
+			args["tableattrs"] = "";
+		}
+
+		//show the border in IE by applying a custom class
+		if(dojo.render.html.ie && !this["table_border"].value){
+			args["tableattrs"] += 'class="dojoShowIETableBorders" ';
+		}
+
+		var html = "<table "+args["tableattrs"]+">";
+		if(args['caption']){
+			html += "<caption>"+args["caption"]+"</caption>";
+		}
+		var outertbody = "<tbody>";
+		if(this.tableNode){
+			//retain the content
+			var tbody = this.tableNode.getElementsByTagName("tbody")[0];
+			outertbody = tbody.outerHTML;
+			if(!outertbody){
+				var cnode = tbody.cloneNode(true);
+				var tmpnode = tbody.ownerDocument.createElement("div");
+				tmpnode.appendChild(cnode);
+				outertbody = tmpnode.innerHTML;
+			}
+			//TODO: save current selection and restore it later
+			dojo.withGlobal(curInst.window, "selectElement", dojo.html.selection, [this.tableNode]);
+		}else{
+			var cols = "<tr>";
+			for (var i = 0; i < +args.cols; i++) { cols += "<td></td>"; }
+			cols += "</tr>";
+			for (var i = 0; i < args.rows; i++) { outertbody += cols; }
+			outertbody += "</tbody>";
+		}
+		html += outertbody+"</table>";
+		curInst.restoreSelection(); //restore previous selection, required for none-activeX IE
+		curInst.execCommand("inserthtml", html);
+
+		this.cancel();
+	}
+});
\ No newline at end of file

Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/SimpleSignalCommands.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/SimpleSignalCommands.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/SimpleSignalCommands.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/SimpleSignalCommands.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,74 @@
+/*
+	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
+*/
+
+/*
+ * This plugin adds save() and insertImage() to Editor2 widget, and two commands for each
+ * of them. When the corresponding button is clicked in the toolbar, the added function in the
+ * Editor2 widget is called. This mimics the original Editor2 behavior. If you want to have other
+ * signals on the Editor2 widget, add them to dojo.widget.Editor2Plugin.SimpleSignalCommands.signals
+ * NOTE: Please consider writing your own Editor2 plugin rather than using this backward compatible
+ * plugin
+ * ATTENTION: This plugin overwrites the new built-in insertImage dialog. (If this is not desired, set
+ * dojo.widget.Editor2Plugin.SimpleSignalCommands.signals to not contain insertImage)
+ */
+
+//uncomment this line to add save only (do not overwrite the new built-in insertImage dialog
+//this line should present before require dojo.widget.Editor2Plugin.SimpleSignalCommands
+//dojo.widget.Editor2Plugin['SimpleSignalCommands'] = {signals: ['save']};
+
+dojo.provide("dojo.widget.Editor2Plugin.SimpleSignalCommands");
+
+dojo.require("dojo.widget.Editor2");
+
+dojo.declare("dojo.widget.Editor2Plugin.SimpleSignalCommand", dojo.widget.Editor2Command,
+	function(editor, name){
+		if(dojo.widget.Editor2.prototype[name] == undefined){
+			dojo.widget.Editor2.prototype[name] = function(){ /*dojo.debug("Editor2::"+name);*/ };
+		}
+	},
+{
+	execute: function(){
+		this._editor[this._name]();
+	}
+});
+
+if(dojo.widget.Editor2Plugin['SimpleSignalCommands']){
+	dojo.widget.Editor2Plugin['_SimpleSignalCommands']=dojo.widget.Editor2Plugin['SimpleSignalCommands'];
+}
+
+dojo.widget.Editor2Plugin.SimpleSignalCommands = {
+	signals: ['save', 'insertImage'],
+	Handler: function(name){
+		if(name.toLowerCase() == 'save'){
+			return new dojo.widget.Editor2ToolbarButton('Save');
+		}else if(name.toLowerCase() == 'insertimage'){
+			return new dojo.widget.Editor2ToolbarButton('InsertImage');
+		}
+	},
+	getCommand: function(editor, name){
+		var signal;
+		dojo.lang.every(this.signals,function(s){
+			if(s.toLowerCase() == name.toLowerCase()){
+				signal = s;
+				return false;
+			}
+			return true;
+		});
+		if(signal){
+			return new dojo.widget.Editor2Plugin.SimpleSignalCommand(editor, signal);
+		}
+	}
+};
+
+if(dojo.widget.Editor2Plugin['_SimpleSignalCommands']){
+	dojo.lang.mixin(dojo.widget.Editor2Plugin.SimpleSignalCommands, dojo.widget.Editor2Plugin['_SimpleSignalCommands']);
+}
+dojo.widget.Editor2Manager.registerHandler(dojo.widget.Editor2Plugin.SimpleSignalCommands, 'getCommand');
+dojo.widget.Editor2ToolbarItemManager.registerHandler(dojo.widget.Editor2Plugin.SimpleSignalCommands.Handler);
\ No newline at end of file

Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/TableOperation.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/TableOperation.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/TableOperation.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/TableOperation.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,159 @@
+/*
+	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.Editor2Plugin.TableOperation");
+
+dojo.require("dojo.widget.Editor2");
+
+//subscribe to dojo.widget.RichText::init, not onLoad because after onLoad
+//the stylesheets for the editing areas are already applied and the prefilters
+//are executed, so we have to insert our own trick before that point
+dojo.event.topic.subscribe("dojo.widget.RichText::init", function(editor){
+	if(dojo.render.html.ie){
+		//add/remove a class to a table with border=0 to show the border when loading/saving
+		editor.contentDomPreFilters.push(dojo.widget.Editor2Plugin.TableOperation.showIETableBorder);
+		editor.contentDomPostFilters.push(dojo.widget.Editor2Plugin.TableOperation.removeIEFakeClass);
+	}
+	//create a toggletableborder command for this editor so that tables without border can be seen
+	editor.getCommand("toggletableborder");
+});
+
+dojo.lang.declare("dojo.widget.Editor2Plugin.deleteTableCommand", dojo.widget.Editor2Command,
+{
+	execute: function(){
+		var table = dojo.withGlobal(this._editor.window, "getAncestorElement", dojo.html.selection, ['table']);
+		if(table){
+			dojo.withGlobal(this._editor.window, "selectElement", dojo.html.selection, [table]);
+			this._editor.execCommand("inserthtml", " "); //Moz does not like an empty string, so a space here instead
+		}
+	},
+	getState: function(){
+		if(this._editor._lastStateTimestamp > this._updateTime || this._state == undefined){
+			this._updateTime = this._editor._lastStateTimestamp;
+			var table = dojo.withGlobal(this._editor.window, "hasAncestorElement", dojo.html.selection, ['table']);
+			this._state = table ? dojo.widget.Editor2Manager.commandState.Enabled : dojo.widget.Editor2Manager.commandState.Disabled;
+		}
+		return this._state;
+	},
+	getText: function(){
+		return 'Delete Table';
+	}
+});
+
+dojo.lang.declare("dojo.widget.Editor2Plugin.toggleTableBorderCommand", dojo.widget.Editor2Command,
+	function(){
+		this._showTableBorder = false;
+		dojo.event.connect(this._editor, "editorOnLoad", this, 'execute');
+	},
+{
+	execute: function(){
+		if(this._showTableBorder){
+			this._showTableBorder = false;
+			if(dojo.render.html.moz){
+				this._editor.removeStyleSheet(dojo.uri.dojoUri("src/widget/templates/Editor2/showtableborder_gecko.css"));
+			}else if(dojo.render.html.ie){
+				this._editor.removeStyleSheet(dojo.uri.dojoUri("src/widget/templates/Editor2/showtableborder_ie.css"));
+			}
+		}else{
+			this._showTableBorder = true;
+			if(dojo.render.html.moz){
+				this._editor.addStyleSheet(dojo.uri.dojoUri("src/widget/templates/Editor2/showtableborder_gecko.css"));
+			}else if(dojo.render.html.ie){
+				this._editor.addStyleSheet(dojo.uri.dojoUri("src/widget/templates/Editor2/showtableborder_ie.css"));
+			}
+		}
+		
+	},
+	getText: function(){
+		return 'Toggle Table Border';
+	},
+	getState: function(){
+		return this._showTableBorder ? dojo.widget.Editor2Manager.commandState.Latched : dojo.widget.Editor2Manager.commandState.Enabled;
+	}
+});
+
+dojo.widget.Editor2Plugin.TableOperation = {
+	getCommand: function(editor, name){
+		switch(name.toLowerCase()){
+			case 'toggletableborder':
+				return new dojo.widget.Editor2Plugin.toggleTableBorderCommand(editor, name);
+			case 'inserttable':
+				return new dojo.widget.Editor2DialogCommand(editor, 'inserttable',
+					{contentFile: "dojo.widget.Editor2Plugin.InsertTableDialog",
+					contentClass: "Editor2InsertTableDialog",
+					title: "Insert/Edit Table", width: "450px", height: "250px"})
+			case 'deletetable':
+				return new dojo.widget.Editor2Plugin.deleteTableCommand(editor, name);
+		}
+	},
+	getToolbarItem: function(name){
+		var name = name.toLowerCase();
+
+		var item;
+		switch(name){
+			case 'inserttable':
+			case 'toggletableborder':
+				item = new dojo.widget.Editor2ToolbarButton(name);
+		}
+
+		return item;
+	},
+	getContextMenuGroup: function(name, contextmenuplugin){
+		return new dojo.widget.Editor2Plugin.TableContextMenuGroup(contextmenuplugin);
+	},
+	showIETableBorder: function(dom){
+		var tables = dom.getElementsByTagName('table');
+		dojo.lang.forEach(tables, function(t){
+			dojo.html.addClass(t, "dojoShowIETableBorders");
+		});
+		return dom;
+	},
+	removeIEFakeClass: function(dom){
+		var tables = dom.getElementsByTagName('table');
+		dojo.lang.forEach(tables, function(t){
+			dojo.html.removeClass(t, "dojoShowIETableBorders");
+		});
+		return dom;
+	}
+}
+
+//register commands: toggletableborder, inserttable, deletetable
+dojo.widget.Editor2Manager.registerHandler(dojo.widget.Editor2Plugin.TableOperation.getCommand);
+
+//register toggletableborder and inserttable as toolbar item
+dojo.widget.Editor2ToolbarItemManager.registerHandler(dojo.widget.Editor2Plugin.TableOperation.getToolbarItem);
+
+//add context menu support if dojo.widget.Editor2Plugin.ContextMenu is included before this plugin
+if(dojo.widget.Editor2Plugin.ContextMenuManager){
+	dojo.widget.Editor2Plugin.ContextMenuManager.registerGroup('Table', dojo.widget.Editor2Plugin.TableOperation.getContextMenuGroup);
+
+	dojo.declare("dojo.widget.Editor2Plugin.TableContextMenuGroup",
+		dojo.widget.Editor2Plugin.SimpleContextMenuGroup,
+	{
+		createItems: function(){
+			this.items.push(dojo.widget.createWidget("Editor2ContextMenuItem", {caption: "Delete Table", command: 'deletetable'}));
+			this.items.push(dojo.widget.createWidget("Editor2ContextMenuItem", {caption: "Table Property", command: 'inserttable', iconClass: "TB_Button_Icon TB_Button_Table"}));
+		},
+		checkVisibility: function(){
+			var curInst = dojo.widget.Editor2Manager.getCurrentInstance();
+			var table = dojo.withGlobal(curInst.window, "hasAncestorElement", dojo.html.selection, ['table']);
+
+			if(dojo.withGlobal(curInst.window, "hasAncestorElement", dojo.html.selection, ['table'])){
+				this.items[0].show();
+				this.items[1].show();
+				return true;
+			}else{
+				this.items[0].hide();
+				this.items[1].hide();
+				return false;
+			}
+		}
+	});
+}
\ No newline at end of file

Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/ToolbarDndSupport.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/ToolbarDndSupport.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/ToolbarDndSupport.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/widget/Editor2Plugin/ToolbarDndSupport.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,68 @@
+/*
+	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
+*/
+
+/*TODO:
+ * Add a command to toggle DnD support for a toolbar
+ * Save/restore order of toolbar/item
+ */
+dojo.provide("dojo.widget.Editor2Plugin.ToolbarDndSupport");
+dojo.require("dojo.dnd.*");
+
+dojo.event.topic.subscribe("dojo.widget.Editor2::preLoadingToolbar", function(editor){
+	dojo.dnd.dragManager.nestedTargets = true;
+	var p = new dojo.widget.Editor2Plugin.ToolbarDndSupport(editor);
+});
+
+dojo.declare("dojo.widget.Editor2Plugin.ToolbarDndSupport", null,{
+	lookForClass: "dojoEditorToolbarDnd TB_ToolbarSet TB_Toolbar",
+	initializer: function(editor){
+		this.editor = editor;
+		dojo.event.connect(this.editor, "toolbarLoaded", this, "setup");
+		this.editor.registerLoadedPlugin(this);
+	},
+
+	setup: function(){
+		dojo.event.disconnect(this.editor, "toolbarLoaded", this, "setup");
+		var tbw = this.editor.toolbarWidget;
+		dojo.event.connect("before", tbw, "destroy", this, "destroy");
+
+		var nodes = dojo.html.getElementsByClass(this.lookForClass, tbw.domNode, null, dojo.html.classMatchType.ContainsAny);
+		if(!nodes){
+			dojo.debug("dojo.widget.Editor2Plugin.ToolbarDndSupport: No dom node with class in "+this.lookForClass);
+			return;
+		}
+		for(var i=0; i<nodes.length; i++){
+			var node = nodes[i];
+			var droptarget = node.getAttribute("dojoETDropTarget");
+			if(droptarget){
+				(new dojo.dnd.HtmlDropTarget(node, [droptarget+tbw.widgetId])).vertical = true;
+			}
+			var dragsource = node.getAttribute("dojoETDragSource");
+			if(dragsource){
+				new dojo.dnd.HtmlDragSource(node, dragsource+tbw.widgetId);
+			}
+		}
+	},
+
+	destroy: function(){
+		this.editor.unregisterLoadedPlugin(this);
+	}
+});
+
+//let's have a command to enable DnD
+/*dojo.declare("dojo.widget.Editor2Plugin.ToolbarDndCommand", dojo.widget.Editor2Command,{
+	execute: function(text, option){
+		var curInst = dojo.widget.Editor2Manager.getCurrentInstance();
+		if(curInst){
+		}
+	},
+	getState: function(){	
+	}
+});*/
\ No newline at end of file