');
html = html.replace(/( | )<\/p>/g, '');
html = html.replace(/');
html = html.replace(/ <\/p>/gi, '');
//Fix last BR
html = html.replace(/$/, '');
//Fix last BR in P
html = html.replace(/<\/p>/g, '
');
if (this.browser.ie) {
html = html.replace(/ /g, '\t');
}
return html;
},
/**
* @method post_filter_linebreaks
* @param String html The HTML to filter
* @param String markup The markup type to filter to
* @description HTML Pre Filter
* @return String
*/
post_filter_linebreaks: function(html, markup) {
if (markup == 'xhtml') {
html = html.replace(//g, '/g, 'Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event cleanHTML
* @description Event is fired after the cleanHTML method is called.
* @type YAHOO.util.CustomEvent
*/
/**
* @event afterRender
* @description Event is fired after the render process finishes. See Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event editorContentLoaded
* @description Event is fired after the editor iframe's document fully loads and fires it's onload event. From here you can start injecting your own things into the document. See Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event beforeNodeChange
* @description Event fires at the beginning of the nodeChange process. See Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event afterNodeChange
* @description Event fires at the end of the nodeChange process. See Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event beforeExecCommand
* @description Event fires at the beginning of the execCommand process. See Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event afterExecCommand
* @description Event fires at the end of the execCommand process. See Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event editorMouseUp
* @param {Event} ev The DOM Event that occured
* @description Passed through HTML Event. See Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event editorMouseDown
* @param {Event} ev The DOM Event that occured
* @description Passed through HTML Event. See Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event editorDoubleClick
* @param {Event} ev The DOM Event that occured
* @description Passed through HTML Event. See Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event editorClick
* @param {Event} ev The DOM Event that occured
* @description Passed through HTML Event. See Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event editorKeyUp
* @param {Event} ev The DOM Event that occured
* @description Passed through HTML Event. See Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event editorKeyPress
* @param {Event} ev The DOM Event that occured
* @description Passed through HTML Event. See Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event editorKeyDown
* @param {Event} ev The DOM Event that occured
* @description Passed through HTML Event. See Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event beforeEditorMouseUp
* @param {Event} ev The DOM Event that occured
* @description Fires before editor event, returning false will stop the internal processing.
* @type YAHOO.util.CustomEvent
*/
/**
* @event beforeEditorMouseDown
* @param {Event} ev The DOM Event that occured
* @description Fires before editor event, returning false will stop the internal processing.
* @type YAHOO.util.CustomEvent
*/
/**
* @event beforeEditorDoubleClick
* @param {Event} ev The DOM Event that occured
* @description Fires before editor event, returning false will stop the internal processing.
* @type YAHOO.util.CustomEvent
*/
/**
* @event beforeEditorClick
* @param {Event} ev The DOM Event that occured
* @description Fires before editor event, returning false will stop the internal processing.
* @type YAHOO.util.CustomEvent
*/
/**
* @event beforeEditorKeyUp
* @param {Event} ev The DOM Event that occured
* @description Fires before editor event, returning false will stop the internal processing.
* @type YAHOO.util.CustomEvent
*/
/**
* @event beforeEditorKeyPress
* @param {Event} ev The DOM Event that occured
* @description Fires before editor event, returning false will stop the internal processing.
* @type YAHOO.util.CustomEvent
*/
/**
* @event beforeEditorKeyDown
* @param {Event} ev The DOM Event that occured
* @description Fires before editor event, returning false will stop the internal processing.
* @type YAHOO.util.CustomEvent
*/
/**
* @description Singleton object used to track the open window objects and panels across the various open editors
* @class EditorInfo
* @static
*/
YAHOO.widget.EditorInfo = {
/**
* @private
* @property _instances
* @description A reference to all editors on the page.
* @type Object
*/
_instances: {},
/**
* @private
* @property blankImage
* @description A reference to the blankImage url
* @type String
*/
blankImage: '',
/**
* @private
* @property window
* @description A reference to the currently open window object in any editor on the page.
* @type Object YAHOO.widget.EditorWindow
*/
window: {},
/**
* @private
* @property panel
* @description A reference to the currently open panel in any editor on the page.
* @type Object YAHOO.widget.Overlay
*/
panel: null,
/**
* @method getEditorById
* @description Returns a reference to the Editor object associated with the given textarea
* @param {String/HTMLElement} id The id or reference of the textarea to return the Editor instance of
* @return Object YAHOO.widget.Editor
*/
getEditorById: function(id) {
if (!YAHOO.lang.isString(id)) {
//Not a string, assume a node Reference
id = id.id;
}
if (this._instances[id]) {
return this._instances[id];
}
return false;
},
/**
* @method toString
* @description Returns a string representing the EditorInfo.
* @return {String}
*/
toString: function() {
var len = 0;
for (var i in this._instances) {
if (Lang.hasOwnProperty(this._instances, i)) {
len++;
}
}
return 'Editor Info (' + len + ' registered intance' + ((len > 1) ? 's' : '') + ')';
}
};
})();
/**
* @module editor
* @description The Rich Text Editor is a UI control that replaces a standard HTML textarea; it allows for the rich formatting of text content, including common structural treatments like lists, formatting treatments like bold and italic text, and drag-and-drop inclusion and sizing of images. The Rich Text Editor's toolbar is extensible via a plugin architecture so that advanced implementations can achieve a high degree of customization.
* @namespace YAHOO.widget
* @requires yahoo, dom, element, event, container_core, simpleeditor
* @optional dragdrop, animation, menu, button
* @beta
*/
(function() {
var Dom = YAHOO.util.Dom,
Event = YAHOO.util.Event,
Lang = YAHOO.lang,
Toolbar = YAHOO.widget.Toolbar;
/**
* The Rich Text Editor is a UI control that replaces a standard HTML textarea; it allows for the rich formatting of text content, including common structural treatments like lists, formatting treatments like bold and italic text, and drag-and-drop inclusion and sizing of images. The Rich Text Editor's toolbar is extensible via a plugin architecture so that advanced implementations can achieve a high degree of customization.
* @constructor
* @class Editor
* @extends YAHOO.widget.SimpleEditor
* @param {String/HTMLElement} el The textarea element to turn into an editor.
* @param {Object} attrs Object liternal containing configuration parameters.
*/
YAHOO.widget.Editor = function(el, attrs) {
YAHOO.widget.Editor.superclass.constructor.call(this, el, attrs);
};
YAHOO.extend(YAHOO.widget.Editor, YAHOO.widget.SimpleEditor, {
/**
* @private
* @property _undoCache
* @description An Array hash of the Undo Levels.
* @type Array
*/
_undoCache: null,
/**
* @private
* @property _undoLevel
* @description The index of the current undo state.
* @type Number
*/
_undoLevel: null,
/**
* @private
* @method _hasUndoLevel
* @description Checks to see if we have an undo level available
* @return Boolean
*/
_hasUndoLevel: function() {
return (this._undoCache.length && this._undoLevel);
},
/**
* @private
* @method _undoNodeChange
* @description nodeChange listener for undo processing
*/
_undoNodeChange: function() {
var undo_button = this.toolbar.getButtonByValue('undo'),
redo_button = this.toolbar.getButtonByValue('redo');
if (undo_button && redo_button) {
if (this._hasUndoLevel()) {
this.toolbar.enableButton(undo_button);
}
if (this._undoLevel < this._undoCache.length) {
this.toolbar.enableButton(redo_button);
}
}
},
/**
* @private
* @method _checkUndo
* @description Prunes the undo cache when it reaches the maxUndo config
*/
_checkUndo: function() {
var len = this._undoCache.length,
tmp = [];
if (len >= this.get('maxUndo')) {
for (var i = (len - this.get('maxUndo')); i < len; i++) {
tmp.push(this._undoCache[i]);
}
this._undoCache = tmp;
}
},
/**
* @private
* @method _putUndo
* @description Puts the content of the Editor into the _undoCache.
* //TODO Convert the hash to a series of TEXTAREAS to store state in.
* @param {String} str The content of the Editor
*/
_putUndo: function(str) {
this._undoCache.push(str);
},
/**
* @private
* @method _getUndo
* @description Get's a level from the undo cache.
* @param {Number} index The index of the undo level we want to get.
* @return {String}
*/
_getUndo: function(index) {
return this._undoCache[index];
},
/**
* @private
* @method _storeUndo
* @description Method to call when you want to store an undo state. Currently called from nodeChange and _handleKeyUp
*/
_storeUndo: function() {
if (this._lastCommand === 'undo' || this._lastCommand === 'redo') {
return false;
}
if (!this._undoCache) {
this._undoCache = [];
}
this._checkUndo();
var str = this.getEditorHTML();
var last = this._undoCache[this._undoCache.length - 1];
if (last) {
if (str !== last) {
this._putUndo(str);
}
} else {
this._putUndo(str);
}
this._undoLevel = this._undoCache.length;
this._undoNodeChange();
},
/**
* @property STR_BEFORE_EDITOR
* @description The accessibility string for the element before the iFrame
* @type String
*/
STR_BEFORE_EDITOR: 'This text field can contain stylized text and graphics. To cycle through all formatting options, use the keyboard shortcut Control + Shift + T to place focus on the toolbar and navigate between option heading names. Common formatting keyboard shortcuts: Control Shift B sets text to bold Control Shift I sets text to italic Control Shift U underlines text Control Shift [ aligns text left Control Shift | centers text Control Shift ] aligns text right Control Shift L adds an HTML link To exit this text editor use the keyboard shortcut Control + Shift + ESC. Note: To move this image just highlight it, cut, and paste where ever you\'d like.Note: This image/link points to a file on your computer and will not be accessible to others on the internet.this.CLASS_HIDDEN
* @default
.yui-hidden font, .yui-hidden strong, .yui-hidden b, .yui-hidden em, .yui-hidden i, .yui-hidden u, .yui-hidden div, .yui-hidden p, .yui-hidden span, .yui-hidden img, .yui-hidden ul, .yui-hidden ol, .yui-hidden li, .yui-hidden table {
border: 1px dotted #ccc;
}
.yui-hidden .yui-non {
border: none;
}
.yui-hidden img {
padding: 2px;
} ' + this.STR_LINK_URL + ': ' + this.STR_LINK_TITLE + ': ' + this.STR_IMAGE_URL + ': ' + this.STR_IMAGE_TITLE + ': ' + this.STR_LINK_URL + ': ' + this.STR_IMAGE_SIZE + ': ';
/*
var orgSize = '';
if ((height != oheight) || (width != owidth)) {
orgSize = '' + this.STR_IMAGE_ORIG_SIZE + ' ';
}
*/
hw.innerHTML += ''+bSizeStr+' ');
this._updateMenuChecked('bordersize', bsize, tbar);
var bt_button = tbar.getButtonByValue('bordertype');
bt_button.set('label', 'YAHOO.widget.Overlay }
*/
_renderPanel: function() {
var panel = new YAHOO.widget.Overlay(this.get('id') + this.EDITOR_PANEL_ID, {
width: '300px',
iframe: true,
visible: false,
underlay: 'none',
draggable: false,
close: false
});
this.set('panel', panel);
this.get('panel').setBody('---');
this.get('panel').setHeader(' ');
this.get('panel').setFooter(' ');
var body = document.createElement('div');
body.className = this.CLASS_PREFIX + '-body-cont';
for (var b in this.browser) {
if (this.browser[b]) {
Dom.addClass(body, b);
break;
}
}
Dom.addClass(body, ((YAHOO.widget.Button && (this._defaultToolbar.buttonType == 'advanced')) ? 'good-button' : 'no-button'));
var _note = document.createElement('h3');
_note.className = 'yui-editor-skipheader';
_note.innerHTML = this.STR_CLOSE_WINDOW_NOTE;
body.appendChild(_note);
var form = document.createElement('form');
form.setAttribute('method', 'GET');
panel.editor_form = form;
Event.on(form, 'submit', function(ev) {
Event.stopEvent(ev);
}, this, true);
body.appendChild(form);
var _close = document.createElement('span');
_close.innerHTML = 'X';
_close.title = this.STR_CLOSE_WINDOW;
_close.className = 'close';
Event.on(_close, 'click', this.closeWindow, this, true);
var _knob = document.createElement('span');
_knob.innerHTML = '^';
_knob.className = 'knob';
panel.editor_knob = _knob;
var _header = document.createElement('h3');
panel.editor_header = _header;
_header.innerHTML = 'YAHOO.widget.EditorWindow } win A YAHOO.widget.EditorWindow instance
* @description Opens a new "window/panel"
*/
openWindow: function(win) {
var self = this;
window.setTimeout(function() {
self.toolbar.set('disabled', true); //Disable the toolbar when an editor window is open..
}, 10);
Event.on(document, 'keydown', this._closeWindow, this, true);
if (this.currentWindow) {
this.closeWindow();
}
var xy = Dom.getXY(this.currentElement[0]),
elXY = Dom.getXY(this.get('iframe').get('element')),
panel = this.get('panel'),
newXY = [(xy[0] + elXY[0] - 20), (xy[1] + elXY[1] + 10)],
wWidth = (parseInt(win.attrs.width, 10) / 2),
align = 'center',
body = null;
this.fireEvent('beforeOpenWindow', { type: 'beforeOpenWindow', win: win, panel: panel });
var form = panel.editor_form;
var wins = this._windows;
for (var b in wins) {
if (Lang.hasOwnProperty(wins, b)) {
if (wins[b] && wins[b].body) {
if (b == win.name) {
Dom.setStyle(wins[b].body, 'display', 'block');
} else {
Dom.setStyle(wins[b].body, 'display', 'none');
}
}
}
}
if (this._windows[win.name].body) {
Dom.setStyle(this._windows[win.name].body, 'display', 'block');
form.appendChild(this._windows[win.name].body);
} else {
if (Lang.isObject(win.body)) { //Assume it's a reference
form.appendChild(win.body);
} else { //Assume it's a string
var _tmp = document.createElement('div');
_tmp.innerHTML = win.body;
form.appendChild(_tmp);
}
}
panel.editor_header.firstChild.innerHTML = win.header;
if (win.footer !== null) {
panel.setFooter(win.footer);
Dom.addClass(panel.footer, 'open');
} else {
Dom.removeClass(panel.footer, 'open');
}
panel.cfg.setProperty('width', win.attrs.width);
this.currentWindow = win;
this.moveWindow(true);
panel.show();
this.fireEvent('afterOpenWindow', { type: 'afterOpenWindow', win: win, panel: panel });
},
/**
* @method moveWindow
* @param {Boolean} force Boolean to tell it to move but not use any animation (Usually done the first time the window is loaded.)
* @description Realign the window with the currentElement and reposition the knob above the panel.
*/
moveWindow: function(force) {
if (!this.currentWindow) {
return false;
}
var win = this.currentWindow,
xy = Dom.getXY(this.currentElement[0]),
elXY = Dom.getXY(this.get('iframe').get('element')),
panel = this.get('panel'),
//newXY = [(xy[0] + elXY[0] - 20), (xy[1] + elXY[1] + 10)],
newXY = [(xy[0] + elXY[0]), (xy[1] + elXY[1])],
wWidth = (parseInt(win.attrs.width, 10) / 2),
align = 'center',
orgXY = panel.cfg.getProperty('xy') || [0,0],
_knob = panel.editor_knob,
xDiff = 0,
yDiff = 0,
anim = false;
newXY[0] = ((newXY[0] - wWidth) + 20);
//Account for the Scroll bars in a scrolled editor window.
newXY[0] = newXY[0] - Dom.getDocumentScrollLeft(this._getDoc());
newXY[1] = newXY[1] - Dom.getDocumentScrollTop(this._getDoc());
if (this._isElement(this.currentElement[0], 'img')) {
if (this.currentElement[0].src.indexOf(this.get('blankimage')) != -1) {
newXY[0] = (newXY[0] + (75 / 2)); //Placeholder size
newXY[1] = (newXY[1] + 75); //Placeholder sizea
} else {
var w = parseInt(this.currentElement[0].width, 10);
var h = parseInt(this.currentElement[0].height, 10);
newXY[0] = (newXY[0] + (w / 2));
newXY[1] = (newXY[1] + h);
}
newXY[1] = newXY[1] + 15;
} else {
var fs = Dom.getStyle(this.currentElement[0], 'fontSize');
if (fs && fs.indexOf && fs.indexOf('px') != -1) {
newXY[1] = newXY[1] + parseInt(Dom.getStyle(this.currentElement[0], 'fontSize'), 10) + 5;
} else {
newXY[1] = newXY[1] + 20;
}
}
if (newXY[0] < elXY[0]) {
newXY[0] = elXY[0] + 5;
align = 'left';
}
if ((newXY[0] + (wWidth * 2)) > (elXY[0] + parseInt(this.get('iframe').get('element').clientWidth, 10))) {
newXY[0] = ((elXY[0] + parseInt(this.get('iframe').get('element').clientWidth, 10)) - (wWidth * 2) - 5);
align = 'right';
}
try {
xDiff = (newXY[0] - orgXY[0]);
yDiff = (newXY[1] - orgXY[1]);
} catch (e) {}
if (this.get('autoHeight') === false) {
var iTop = elXY[1] + parseInt(this.get('height'), 10);
var iLeft = elXY[0] + parseInt(this.get('width'), 10);
if (newXY[1] > iTop) {
newXY[1] = iTop;
}
if (newXY[0] > iLeft) {
newXY[0] = (iLeft / 2);
}
}
//Convert negative numbers to positive so we can get the difference in distance
xDiff = ((xDiff < 0) ? (xDiff * -1) : xDiff);
yDiff = ((yDiff < 0) ? (yDiff * -1) : yDiff);
if (((xDiff > 10) || (yDiff > 10)) || force) { //Only move the window if it's supposed to move more than 10px or force was passed (new window)
var _knobLeft = 0,
elW = 0;
if (this.currentElement[0].width) {
elW = (parseInt(this.currentElement[0].width, 10) / 2);
}
var leftOffset = xy[0] + elXY[0] + elW;
_knobLeft = leftOffset - newXY[0];
//Check to see if the knob will go off either side & reposition it
if (_knobLeft > (parseInt(win.attrs.width, 10) - 1)) {
_knobLeft = ((parseInt(win.attrs.width, 10) - 30) - 1);
} else if (_knobLeft < 40) {
_knobLeft = 1;
}
if (isNaN(_knobLeft)) {
_knobLeft = 1;
}
if (force) {
if (_knob) {
_knob.style.left = _knobLeft + 'px';
}
//Removed Animation from a forced move..
panel.cfg.setProperty('xy', newXY);
} else {
if (this.get('animate')) {
anim = new YAHOO.util.Anim(panel.element, {}, 0.5, YAHOO.util.Easing.easeOut);
anim.attributes = {
top: {
to: newXY[1]
},
left: {
to: newXY[0]
}
};
anim.onComplete.subscribe(function() {
panel.cfg.setProperty('xy', newXY);
});
//We have to animate the iframe shim at the same time as the panel or we get scrollbar bleed ..
var iframeAnim = new YAHOO.util.Anim(panel.iframe, anim.attributes, 0.5, YAHOO.util.Easing.easeOut);
var _knobAnim = new YAHOO.util.Anim(_knob, {
left: {
to: _knobLeft
}
}, 0.6, YAHOO.util.Easing.easeOut);
anim.animate();
iframeAnim.animate();
_knobAnim.animate();
} else {
_knob.style.left = _knobLeft + 'px';
panel.cfg.setProperty('xy', newXY);
}
}
}
},
/**
* @private
* @method _closeWindow
* @description Close the currently open EditorWindow with the Escape key.
* @param {Event} ev The keypress Event that we are trapping
*/
_closeWindow: function(ev) {
//if ((ev.charCode == 87) && ev.shiftKey && ev.ctrlKey) {
if (this._checkKey(this._keyMap.CLOSE_WINDOW, ev)) {
if (this.currentWindow) {
this.closeWindow();
}
}
},
/**
* @method closeWindow
* @description Close the currently open EditorWindow.
*/
closeWindow: function(keepOpen) {
//YAHOO.widget.EditorInfo.window = {};
this.fireEvent('window' + this.currentWindow.name + 'Close', { type: 'window' + this.currentWindow.name + 'Close', win: this.currentWindow, el: this.currentElement[0] });
this.fireEvent('closeWindow', { type: 'closeWindow', win: this.currentWindow });
this.currentWindow = null;
this.get('panel').hide();
this.get('panel').cfg.setProperty('xy', [-900,-900]);
this.get('panel').syncIframe(); //Needed to move the iframe with the hidden panel
this.unsubscribeAll('afterExecCommand');
this.toolbar.set('disabled', false); //enable the toolbar now that the window is closed
this.toolbar.resetAllButtons();
this._focusWindow();
Event.removeListener(document, 'keydown', this._closeWindow);
},
/* {{{ Command Overrides - These commands are only over written when we are using the advanced version */
/**
* @method cmd_undo
* @description Pulls an item from the Undo stack and updates the Editor
* @param value Value passed from the execCommand method
*/
cmd_undo: function(value) {
if (this._hasUndoLevel()) {
if (!this._undoLevel) {
this._undoLevel = this._undoCache.length;
}
this._undoLevel = (this._undoLevel - 1);
if (this._undoCache[this._undoLevel]) {
var html = this._getUndo(this._undoLevel);
this.setEditorHTML(html);
} else {
this._undoLevel = null;
this.toolbar.disableButton('undo');
}
}
return [false];
},
/**
* @method cmd_redo
* @description Pulls an item from the Undo stack and updates the Editor
* @param value Value passed from the execCommand method
*/
cmd_redo: function(value) {
this._undoLevel = this._undoLevel + 1;
if (this._undoLevel >= this._undoCache.length) {
this._undoLevel = this._undoCache.length;
}
if (this._undoCache[this._undoLevel]) {
var html = this._getUndo(this._undoLevel);
this.setEditorHTML(html);
} else {
this.toolbar.disableButton('redo');
}
return [false];
},
/**
* @method cmd_heading
* @param value Value passed from the execCommand method
* @description This is an execCommand override method. It is called from execCommand when the execCommand('heading') is used.
*/
cmd_heading: function(value) {
var exec = true,
el = null,
action = 'heading',
_sel = this._getSelection(),
_selEl = this._getSelectedElement();
if (_selEl) {
_sel = _selEl;
}
if (this.browser.ie) {
action = 'formatblock';
}
if (value == 'none') {
if ((_sel && _sel.tagName && (_sel.tagName.toLowerCase().substring(0,1) == 'h')) || (_sel && _sel.parentNode && _sel.parentNode.tagName && (_sel.parentNode.tagName.toLowerCase().substring(0,1) == 'h'))) {
if (_sel.parentNode.tagName.toLowerCase().substring(0,1) == 'h') {
_sel = _sel.parentNode;
}
if (this._isElement(_sel, 'html')) {
return [false];
}
el = this._swapEl(_selEl, 'span', function(el) {
el.className = 'yui-non';
});
this._selectNode(el);
this.currentElement[0] = el;
}
exec = false;
} else {
if (this._isElement(_selEl, 'h1') || this._isElement(_selEl, 'h2') || this._isElement(_selEl, 'h3') || this._isElement(_selEl, 'h4') || this._isElement(_selEl, 'h5') || this._isElement(_selEl, 'h6')) {
el = this._swapEl(_selEl, value);
this._selectNode(el);
this.currentElement[0] = el;
} else {
this._createCurrentElement(value);
this._selectNode(this.currentElement[0]);
}
exec = false;
}
return [exec, action];
},
/**
* @method cmd_hiddenelements
* @param value Value passed from the execCommand method
* @description This is an execCommand override method. It is called from execCommand when the execCommand('hiddenelements') is used.
*/
cmd_hiddenelements: function(value) {
if (this._showingHiddenElements) {
//Don't auto highlight the hidden button
this._lastButton = null;
this._showingHiddenElements = false;
this.toolbar.deselectButton('hiddenelements');
Dom.removeClass(this._getDoc().body, this.CLASS_HIDDEN);
} else {
this._showingHiddenElements = true;
Dom.addClass(this._getDoc().body, this.CLASS_HIDDEN);
this.toolbar.selectButton('hiddenelements');
}
return [false];
},
/**
* @method cmd_removeformat
* @param value Value passed from the execCommand method
* @description This is an execCommand override method. It is called from execCommand when the execCommand('removeformat') is used.
*/
cmd_removeformat: function(value) {
var exec = true;
/**
* @knownissue Remove Format issue
* @browser Safari 2.x
* @description There is an issue here with Safari, that it may not always remove the format of the item that is selected.
* Due to the way that Safari 2.x handles ranges, it is very difficult to determine what the selection holds.
* So here we are making the best possible guess and acting on it.
*/
if (this.browser.webkit && !this._getDoc().queryCommandEnabled('removeformat')) {
var _txt = this._getSelection()+'';
this._createCurrentElement('span');
this.currentElement[0].className = 'yui-non';
this.currentElement[0].innerHTML = _txt;
for (var i = 1; i < this.currentElement.length; i++) {
this.currentElement[i].parentNode.removeChild(this.currentElement[i]);
}
/*
this._createCurrentElement('span');
YAHOO.util.Dom.addClass(this.currentElement[0], 'yui-non');
var re= /<\S[^><]*>/g;
var str = this.currentElement[0].innerHTML.replace(re, '');
var _txt = this._getDoc().createTextNode(str);
this.currentElement[0].parentNode.parentNode.replaceChild(_txt, this.currentElement[0].parentNode);
*/
exec = false;
}
return [exec];
},
/**
* @method cmd_script
* @param action action passed from the execCommand method
* @param value Value passed from the execCommand method
* @description This is a combined execCommand override method. It is called from the cmd_superscript and cmd_subscript methods.
*/
cmd_script: function(action, value) {
var exec = true, tag = action.toLowerCase().substring(0, 3),
_span = null, _selEl = this._getSelectedElement();
if (this.browser.webkit) {
if (this._isElement(_selEl, tag)) {
_span = this._swapEl(this.currentElement[0], 'span', function(el) {
el.className = 'yui-non';
});
this._selectNode(_span);
} else {
this._createCurrentElement(tag);
var _sub = this._swapEl(this.currentElement[0], tag);
this._selectNode(_sub);
this.currentElement[0] = _sub;
}
exec = false;
}
return exec;
},
/**
* @method cmd_superscript
* @param value Value passed from the execCommand method
* @description This is an execCommand override method. It is called from execCommand when the execCommand('superscript') is used.
*/
cmd_superscript: function(value) {
return [this.cmd_script('superscript', value)];
},
/**
* @method cmd_subscript
* @param value Value passed from the execCommand method
* @description This is an execCommand override method. It is called from execCommand when the execCommand('subscript') is used.
*/
cmd_subscript: function(value) {
return [this.cmd_script('subscript', value)];
},
/**
* @method cmd_indent
* @param value Value passed from the execCommand method
* @description This is an execCommand override method. It is called from execCommand when the execCommand('indent') is used.
*/
cmd_indent: function(value) {
var exec = true, selEl = this._getSelectedElement(), _bq = null;
//if (this.browser.webkit || this.browser.ie || this.browser.gecko) {
//if (this.browser.webkit || this.browser.ie) {
if (this.browser.ie) {
if (this._isElement(selEl, 'blockquote')) {
_bq = this._getDoc().createElement('blockquote');
_bq.innerHTML = selEl.innerHTML;
selEl.innerHTML = '';
selEl.appendChild(_bq);
this._selectNode(_bq);
} else {
_bq = this._getDoc().createElement('blockquote');
var html = this._getRange().htmlText;
_bq.innerHTML = html;
this._createCurrentElement('blockquote');
/*
for (var i = 0; i < this.currentElement.length; i++) {
_bq = this._getDoc().createElement('blockquote');
_bq.innerHTML = this.currentElement[i].innerHTML;
this.currentElement[i].parentNode.replaceChild(_bq, this.currentElement[i]);
this.currentElement[i] = _bq;
}
*/
this.currentElement[0].parentNode.replaceChild(_bq, this.currentElement[0]);
this.currentElement[0] = _bq;
this._selectNode(this.currentElement[0]);
}
exec = false;
} else {
value = 'blockquote';
}
return [exec, 'formatblock', value];
},
/**
* @method cmd_outdent
* @param value Value passed from the execCommand method
* @description This is an execCommand override method. It is called from execCommand when the execCommand('outdent') is used.
*/
cmd_outdent: function(value) {
var exec = true, selEl = this._getSelectedElement(), _bq = null, _span = null;
//if (this.browser.webkit || this.browser.ie || this.browser.gecko) {
if (this.browser.webkit || this.browser.ie) {
//if (this.browser.ie) {
selEl = this._getSelectedElement();
if (this._isElement(selEl, 'blockquote')) {
var par = selEl.parentNode;
if (this._isElement(selEl.parentNode, 'blockquote')) {
par.innerHTML = selEl.innerHTML;
this._selectNode(par);
} else {
_span = this._getDoc().createElement('span');
_span.innerHTML = selEl.innerHTML;
YAHOO.util.Dom.addClass(_span, 'yui-non');
par.replaceChild(_span, selEl);
this._selectNode(_span);
}
} else {
}
exec = false;
} else {
value = false;
}
return [exec, 'outdent', value];
},
/**
* @method cmd_justify
* @param dir The direction to justify
* @description This is a factory method for the justify family of commands.
*/
cmd_justify: function(dir) {
if (this.browser.ie) {
if (this._hasSelection()) {
this._createCurrentElement('span');
this._swapEl(this.currentElement[0], 'div', function(el) {
el.style.textAlign = dir;
});
return [false];
}
}
return [true, 'justify' + dir, ''];
},
/**
* @method cmd_justifycenter
* @param value Value passed from the execCommand method
* @description This is an execCommand override method. It is called from execCommand when the execCommand('justifycenter') is used.
*/
cmd_justifycenter: function() {
return [this.cmd_justify('center')];
},
/**
* @method cmd_justifyleft
* @param value Value passed from the execCommand method
* @description This is an execCommand override method. It is called from execCommand when the execCommand('justifyleft') is used.
*/
cmd_justifyleft: function() {
return [this.cmd_justify('left')];
},
/**
* @method cmd_justifyright
* @param value Value passed from the execCommand method
* @description This is an execCommand override method. It is called from execCommand when the execCommand('justifyright') is used.
*/
cmd_justifyright: function() {
return [this.cmd_justify('right')];
},
/* }}}*/
/**
* @method toString
* @description Returns a string representing the editor.
* @return {String}
*/
toString: function() {
var str = 'Editor';
if (this.get && this.get('element_cont')) {
str = 'Editor (#' + this.get('element_cont').get('id') + ')' + ((this.get('disabled') ? ' Disabled' : ''));
}
return str;
}
});
/**
* @description Class to hold Window information between uses. We use the same panel to show the windows, so using this will allow you to configure a window before it is shown.
* This is what you pass to Editor.openWindow();. These parameters will not take effect until the openWindow() is called in the editor.
* @class EditorWindow
* @param {String} name The name of the window.
* @param {Object} attrs Attributes for the window. Current attributes used are : height and width
*/
YAHOO.widget.EditorWindow = function(name, attrs) {
/**
* @private
* @property name
* @description A unique name for the window
*/
this.name = name.replace(' ', '_');
/**
* @private
* @property attrs
* @description The window attributes
*/
this.attrs = attrs;
};
YAHOO.widget.EditorWindow.prototype = {
/**
* @private
* @property header
* @description Holder for the header of the window, used in Editor.openWindow
*/
header: null,
/**
* @private
* @property body
* @description Holder for the body of the window, used in Editor.openWindow
*/
body: null,
/**
* @private
* @property footer
* @description Holder for the footer of the window, used in Editor.openWindow
*/
footer: null,
/**
* @method setHeader
* @description Sets the header for the window.
* @param {String/HTMLElement} str The string or DOM reference to be used as the windows header.
*/
setHeader: function(str) {
this.header = str;
},
/**
* @method setBody
* @description Sets the body for the window.
* @param {String/HTMLElement} str The string or DOM reference to be used as the windows body.
*/
setBody: function(str) {
this.body = str;
},
/**
* @method setFooter
* @description Sets the footer for the window.
* @param {String/HTMLElement} str The string or DOM reference to be used as the windows footer.
*/
setFooter: function(str) {
this.footer = str;
},
/**
* @method toString
* @description Returns a string representing the EditorWindow.
* @return {String}
*/
toString: function() {
return 'Editor Window (' + this.name + ')';
}
};
/**
* @event beforeOpenWindow
* @param {EditorWindow } win The EditorWindow object
* @param {Overlay} panel The Overlay object that is used to create the window.
* @description Event fires before an Editor Window is opened. See Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event afterOpenWindow
* @param {EditorWindow } win The EditorWindow object
* @param {Overlay} panel The Overlay object that is used to create the window.
* @description Event fires after an Editor Window is opened. See Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event closeWindow
* @param {EditorWindow } win The EditorWindow object
* @description Event fires after an Editor Window is closed. See Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event windowCMDOpen
* @param {EditorWindow } win The EditorWindow object
* @param {Overlay} panel The Overlay object that is used to create the window.
* @description Dynamic event fired when an EditorWindow is opened.. The dynamic event is based on the name of the window. Example Window: createlink, opening this window would fire the windowcreatelinkOpen event. See Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event windowCMDClose
* @param {EditorWindow } win The EditorWindow object
* @param {Overlay} panel The Overlay object that is used to create the window.
* @description Dynamic event fired when an EditorWindow is closed.. The dynamic event is based on the name of the window. Example Window: createlink, opening this window would fire the windowcreatelinkClose event. See Element.addListener for more information on listening for this event.
* @type YAHOO.util.CustomEvent
*/
/**
* @event windowRender
* @param {EditorWindow } win The EditorWindow object
* @param {Overlay} panel The Overlay object that is used to create the window.
* @description Event fired when the initial Overlay is rendered. Can be used to manipulate the content of the panel.
* @type YAHOO.util.CustomEvent
*/
/**
* @event windowInsertImageRender
* @param {Overlay} panel The Overlay object that is used to create the window.
* @param {HTMLElement} body The HTML element used as the body of the window..
* @param {Toolbar} toolbar A reference to the toolbar object used inside this window.
* @description Event fired when the pre render of the Insert Image window has finished.
* @type YAHOO.util.CustomEvent
*/
/**
* @event windowCreateLinkRender
* @param {Overlay} panel The Overlay object that is used to create the window.
* @param {HTMLElement} body The HTML element used as the body of the window..
* @description Event fired when the pre render of the Create Link window has finished.
* @type YAHOO.util.CustomEvent
*/
})();
YAHOO.register("editor", YAHOO.widget.Editor, {version: "2.6.0", build: "1321"});