|
0
|
1 /*
|
|
|
2 Copyright (c) 2009, Yahoo! Inc. All rights reserved.
|
|
|
3 Code licensed under the BSD License:
|
|
|
4 http://developer.yahoo.net/yui/license.txt
|
|
|
5 version: 2.8.0r4
|
|
|
6 */
|
|
|
7 (function() {
|
|
|
8 var Dom = YAHOO.util.Dom,
|
|
|
9 Event = YAHOO.util.Event,
|
|
|
10 Lang = YAHOO.lang;
|
|
|
11 /**
|
|
|
12 * @module editor
|
|
|
13 * @description <p>Creates a rich custom Toolbar Button. Primarily used with the Rich Text Editor's Toolbar</p>
|
|
|
14 * @class ToolbarButtonAdvanced
|
|
|
15 * @namespace YAHOO.widget
|
|
|
16 * @requires yahoo, dom, element, event, container_core, menu, button
|
|
|
17 *
|
|
|
18 * Provides a toolbar button based on the button and menu widgets.
|
|
|
19 * @constructor
|
|
|
20 * @class ToolbarButtonAdvanced
|
|
|
21 * @param {String/HTMLElement} el The element to turn into a button.
|
|
|
22 * @param {Object} attrs Object liternal containing configuration parameters.
|
|
|
23 */
|
|
|
24 if (YAHOO.widget.Button) {
|
|
|
25 YAHOO.widget.ToolbarButtonAdvanced = YAHOO.widget.Button;
|
|
|
26 /**
|
|
|
27 * @property buttonType
|
|
|
28 * @private
|
|
|
29 * @description Tells if the Button is a Rich Button or a Simple Button
|
|
|
30 */
|
|
|
31 YAHOO.widget.ToolbarButtonAdvanced.prototype.buttonType = 'rich';
|
|
|
32 /**
|
|
|
33 * @method checkValue
|
|
|
34 * @param {String} value The value of the option that we want to mark as selected
|
|
|
35 * @description Select an option by value
|
|
|
36 */
|
|
|
37 YAHOO.widget.ToolbarButtonAdvanced.prototype.checkValue = function(value) {
|
|
|
38 var _menuItems = this.getMenu().getItems();
|
|
|
39 if (_menuItems.length === 0) {
|
|
|
40 this.getMenu()._onBeforeShow();
|
|
|
41 _menuItems = this.getMenu().getItems();
|
|
|
42 }
|
|
|
43 for (var i = 0; i < _menuItems.length; i++) {
|
|
|
44 _menuItems[i].cfg.setProperty('checked', false);
|
|
|
45 if (_menuItems[i].value == value) {
|
|
|
46 _menuItems[i].cfg.setProperty('checked', true);
|
|
|
47 }
|
|
|
48 }
|
|
|
49 };
|
|
|
50 } else {
|
|
|
51 YAHOO.widget.ToolbarButtonAdvanced = function() {};
|
|
|
52 }
|
|
|
53
|
|
|
54
|
|
|
55 /**
|
|
|
56 * @description <p>Creates a basic custom Toolbar Button. Primarily used with the Rich Text Editor's Toolbar</p><p>Provides a toolbar button based on the button and menu widgets, <select> elements are used in place of menu's.</p>
|
|
|
57 * @class ToolbarButton
|
|
|
58 * @namespace YAHOO.widget
|
|
|
59 * @requires yahoo, dom, element, event
|
|
|
60 * @extends YAHOO.util.Element
|
|
|
61 *
|
|
|
62 *
|
|
|
63 * @constructor
|
|
|
64 * @param {String/HTMLElement} el The element to turn into a button.
|
|
|
65 * @param {Object} attrs Object liternal containing configuration parameters.
|
|
|
66 */
|
|
|
67
|
|
|
68 YAHOO.widget.ToolbarButton = function(el, attrs) {
|
|
|
69
|
|
|
70 if (Lang.isObject(arguments[0]) && !Dom.get(el).nodeType) {
|
|
|
71 attrs = el;
|
|
|
72 }
|
|
|
73 var local_attrs = (attrs || {});
|
|
|
74
|
|
|
75 var oConfig = {
|
|
|
76 element: null,
|
|
|
77 attributes: local_attrs
|
|
|
78 };
|
|
|
79
|
|
|
80 if (!oConfig.attributes.type) {
|
|
|
81 oConfig.attributes.type = 'push';
|
|
|
82 }
|
|
|
83
|
|
|
84 oConfig.element = document.createElement('span');
|
|
|
85 oConfig.element.setAttribute('unselectable', 'on');
|
|
|
86 oConfig.element.className = 'yui-button yui-' + oConfig.attributes.type + '-button';
|
|
|
87 oConfig.element.innerHTML = '<span class="first-child"><a href="#">LABEL</a></span>';
|
|
|
88 oConfig.element.firstChild.firstChild.tabIndex = '-1';
|
|
|
89 oConfig.attributes.id = (oConfig.attributes.id || Dom.generateId());
|
|
|
90 oConfig.element.id = oConfig.attributes.id;
|
|
|
91
|
|
|
92 YAHOO.widget.ToolbarButton.superclass.constructor.call(this, oConfig.element, oConfig.attributes);
|
|
|
93 };
|
|
|
94
|
|
|
95 YAHOO.extend(YAHOO.widget.ToolbarButton, YAHOO.util.Element, {
|
|
|
96 /**
|
|
|
97 * @property buttonType
|
|
|
98 * @private
|
|
|
99 * @description Tells if the Button is a Rich Button or a Simple Button
|
|
|
100 */
|
|
|
101 buttonType: 'normal',
|
|
|
102 /**
|
|
|
103 * @method _handleMouseOver
|
|
|
104 * @private
|
|
|
105 * @description Adds classes to the button elements on mouseover (hover)
|
|
|
106 */
|
|
|
107 _handleMouseOver: function() {
|
|
|
108 if (!this.get('disabled')) {
|
|
|
109 this.addClass('yui-button-hover');
|
|
|
110 this.addClass('yui-' + this.get('type') + '-button-hover');
|
|
|
111 }
|
|
|
112 },
|
|
|
113 /**
|
|
|
114 * @method _handleMouseOut
|
|
|
115 * @private
|
|
|
116 * @description Removes classes from the button elements on mouseout (hover)
|
|
|
117 */
|
|
|
118 _handleMouseOut: function() {
|
|
|
119 this.removeClass('yui-button-hover');
|
|
|
120 this.removeClass('yui-' + this.get('type') + '-button-hover');
|
|
|
121 },
|
|
|
122 /**
|
|
|
123 * @method checkValue
|
|
|
124 * @param {String} value The value of the option that we want to mark as selected
|
|
|
125 * @description Select an option by value
|
|
|
126 */
|
|
|
127 checkValue: function(value) {
|
|
|
128 if (this.get('type') == 'menu') {
|
|
|
129 var opts = this._button.options;
|
|
|
130 for (var i = 0; i < opts.length; i++) {
|
|
|
131 if (opts[i].value == value) {
|
|
|
132 opts.selectedIndex = i;
|
|
|
133 }
|
|
|
134 }
|
|
|
135 }
|
|
|
136 },
|
|
|
137 /**
|
|
|
138 * @method init
|
|
|
139 * @description The ToolbarButton class's initialization method
|
|
|
140 */
|
|
|
141 init: function(p_oElement, p_oAttributes) {
|
|
|
142 YAHOO.widget.ToolbarButton.superclass.init.call(this, p_oElement, p_oAttributes);
|
|
|
143
|
|
|
144 this.on('mouseover', this._handleMouseOver, this, true);
|
|
|
145 this.on('mouseout', this._handleMouseOut, this, true);
|
|
|
146 this.on('click', function(ev) {
|
|
|
147 Event.stopEvent(ev);
|
|
|
148 return false;
|
|
|
149 }, this, true);
|
|
|
150 },
|
|
|
151 /**
|
|
|
152 * @method initAttributes
|
|
|
153 * @description Initializes all of the configuration attributes used to create
|
|
|
154 * the toolbar.
|
|
|
155 * @param {Object} attr Object literal specifying a set of
|
|
|
156 * configuration attributes used to create the toolbar.
|
|
|
157 */
|
|
|
158 initAttributes: function(attr) {
|
|
|
159 YAHOO.widget.ToolbarButton.superclass.initAttributes.call(this, attr);
|
|
|
160 /**
|
|
|
161 * @attribute value
|
|
|
162 * @description The value of the button
|
|
|
163 * @type String
|
|
|
164 */
|
|
|
165 this.setAttributeConfig('value', {
|
|
|
166 value: attr.value
|
|
|
167 });
|
|
|
168 /**
|
|
|
169 * @attribute menu
|
|
|
170 * @description The menu attribute, see YAHOO.widget.Button
|
|
|
171 * @type Object
|
|
|
172 */
|
|
|
173 this.setAttributeConfig('menu', {
|
|
|
174 value: attr.menu || false
|
|
|
175 });
|
|
|
176 /**
|
|
|
177 * @attribute type
|
|
|
178 * @description The type of button to create: push, menu, color, select, spin
|
|
|
179 * @type String
|
|
|
180 */
|
|
|
181 this.setAttributeConfig('type', {
|
|
|
182 value: attr.type,
|
|
|
183 writeOnce: true,
|
|
|
184 method: function(type) {
|
|
|
185 var el, opt;
|
|
|
186 if (!this._button) {
|
|
|
187 this._button = this.get('element').getElementsByTagName('a')[0];
|
|
|
188 }
|
|
|
189 switch (type) {
|
|
|
190 case 'select':
|
|
|
191 case 'menu':
|
|
|
192 el = document.createElement('select');
|
|
|
193 el.id = this.get('id');
|
|
|
194 var menu = this.get('menu');
|
|
|
195 for (var i = 0; i < menu.length; i++) {
|
|
|
196 opt = document.createElement('option');
|
|
|
197 opt.innerHTML = menu[i].text;
|
|
|
198 opt.value = menu[i].value;
|
|
|
199 if (menu[i].checked) {
|
|
|
200 opt.selected = true;
|
|
|
201 }
|
|
|
202 el.appendChild(opt);
|
|
|
203 }
|
|
|
204 this._button.parentNode.replaceChild(el, this._button);
|
|
|
205 Event.on(el, 'change', this._handleSelect, this, true);
|
|
|
206 this._button = el;
|
|
|
207 break;
|
|
|
208 }
|
|
|
209 }
|
|
|
210 });
|
|
|
211
|
|
|
212 /**
|
|
|
213 * @attribute disabled
|
|
|
214 * @description Set the button into a disabled state
|
|
|
215 * @type String
|
|
|
216 */
|
|
|
217 this.setAttributeConfig('disabled', {
|
|
|
218 value: attr.disabled || false,
|
|
|
219 method: function(disabled) {
|
|
|
220 if (disabled) {
|
|
|
221 this.addClass('yui-button-disabled');
|
|
|
222 this.addClass('yui-' + this.get('type') + '-button-disabled');
|
|
|
223 } else {
|
|
|
224 this.removeClass('yui-button-disabled');
|
|
|
225 this.removeClass('yui-' + this.get('type') + '-button-disabled');
|
|
|
226 }
|
|
|
227 if ((this.get('type') == 'menu') || (this.get('type') == 'select')) {
|
|
|
228 this._button.disabled = disabled;
|
|
|
229 }
|
|
|
230 }
|
|
|
231 });
|
|
|
232
|
|
|
233 /**
|
|
|
234 * @attribute label
|
|
|
235 * @description The text label for the button
|
|
|
236 * @type String
|
|
|
237 */
|
|
|
238 this.setAttributeConfig('label', {
|
|
|
239 value: attr.label,
|
|
|
240 method: function(label) {
|
|
|
241 if (!this._button) {
|
|
|
242 this._button = this.get('element').getElementsByTagName('a')[0];
|
|
|
243 }
|
|
|
244 if (this.get('type') == 'push') {
|
|
|
245 this._button.innerHTML = label;
|
|
|
246 }
|
|
|
247 }
|
|
|
248 });
|
|
|
249
|
|
|
250 /**
|
|
|
251 * @attribute title
|
|
|
252 * @description The title of the button
|
|
|
253 * @type String
|
|
|
254 */
|
|
|
255 this.setAttributeConfig('title', {
|
|
|
256 value: attr.title
|
|
|
257 });
|
|
|
258
|
|
|
259 /**
|
|
|
260 * @config container
|
|
|
261 * @description The container that the button is rendered to, handled by Toolbar
|
|
|
262 * @type String
|
|
|
263 */
|
|
|
264 this.setAttributeConfig('container', {
|
|
|
265 value: null,
|
|
|
266 writeOnce: true,
|
|
|
267 method: function(cont) {
|
|
|
268 this.appendTo(cont);
|
|
|
269 }
|
|
|
270 });
|
|
|
271
|
|
|
272 },
|
|
|
273 /**
|
|
|
274 * @private
|
|
|
275 * @method _handleSelect
|
|
|
276 * @description The event fired when a change event gets fired on a select element
|
|
|
277 * @param {Event} ev The change event.
|
|
|
278 */
|
|
|
279 _handleSelect: function(ev) {
|
|
|
280 var tar = Event.getTarget(ev);
|
|
|
281 var value = tar.options[tar.selectedIndex].value;
|
|
|
282 this.fireEvent('change', {type: 'change', value: value });
|
|
|
283 },
|
|
|
284 /**
|
|
|
285 * @method getMenu
|
|
|
286 * @description A stub function to mimic YAHOO.widget.Button's getMenu method
|
|
|
287 */
|
|
|
288 getMenu: function() {
|
|
|
289 return this.get('menu');
|
|
|
290 },
|
|
|
291 /**
|
|
|
292 * @method destroy
|
|
|
293 * @description Destroy the button
|
|
|
294 */
|
|
|
295 destroy: function() {
|
|
|
296 Event.purgeElement(this.get('element'), true);
|
|
|
297 this.get('element').parentNode.removeChild(this.get('element'));
|
|
|
298 //Brutal Object Destroy
|
|
|
299 for (var i in this) {
|
|
|
300 if (Lang.hasOwnProperty(this, i)) {
|
|
|
301 this[i] = null;
|
|
|
302 }
|
|
|
303 }
|
|
|
304 },
|
|
|
305 /**
|
|
|
306 * @method fireEvent
|
|
|
307 * @description Overridden fireEvent method to prevent DOM events from firing if the button is disabled.
|
|
|
308 */
|
|
|
309 fireEvent: function(p_sType, p_aArgs) {
|
|
|
310 // Disabled buttons should not respond to DOM events
|
|
|
311 if (this.DOM_EVENTS[p_sType] && this.get('disabled')) {
|
|
|
312 Event.stopEvent(p_aArgs);
|
|
|
313 return;
|
|
|
314 }
|
|
|
315
|
|
|
316 YAHOO.widget.ToolbarButton.superclass.fireEvent.call(this, p_sType, p_aArgs);
|
|
|
317 },
|
|
|
318 /**
|
|
|
319 * @method toString
|
|
|
320 * @description Returns a string representing the toolbar.
|
|
|
321 * @return {String}
|
|
|
322 */
|
|
|
323 toString: function() {
|
|
|
324 return 'ToolbarButton (' + this.get('id') + ')';
|
|
|
325 }
|
|
|
326
|
|
|
327 });
|
|
|
328 })();
|
|
|
329 /**
|
|
|
330 * @module editor
|
|
|
331 * @description <p>Creates a rich Toolbar widget based on Button. Primarily used with the Rich Text Editor</p>
|
|
|
332 * @namespace YAHOO.widget
|
|
|
333 * @requires yahoo, dom, element, event, toolbarbutton
|
|
|
334 * @optional container_core, dragdrop
|
|
|
335 */
|
|
|
336 (function() {
|
|
|
337 var Dom = YAHOO.util.Dom,
|
|
|
338 Event = YAHOO.util.Event,
|
|
|
339 Lang = YAHOO.lang;
|
|
|
340
|
|
|
341 var getButton = function(id) {
|
|
|
342 var button = id;
|
|
|
343 if (Lang.isString(id)) {
|
|
|
344 button = this.getButtonById(id);
|
|
|
345 }
|
|
|
346 if (Lang.isNumber(id)) {
|
|
|
347 button = this.getButtonByIndex(id);
|
|
|
348 }
|
|
|
349 if ((!(button instanceof YAHOO.widget.ToolbarButton)) && (!(button instanceof YAHOO.widget.ToolbarButtonAdvanced))) {
|
|
|
350 button = this.getButtonByValue(id);
|
|
|
351 }
|
|
|
352 if ((button instanceof YAHOO.widget.ToolbarButton) || (button instanceof YAHOO.widget.ToolbarButtonAdvanced)) {
|
|
|
353 return button;
|
|
|
354 }
|
|
|
355 return false;
|
|
|
356 };
|
|
|
357
|
|
|
358 /**
|
|
|
359 * Provides a rich toolbar widget based on the button and menu widgets
|
|
|
360 * @constructor
|
|
|
361 * @class Toolbar
|
|
|
362 * @extends YAHOO.util.Element
|
|
|
363 * @param {String/HTMLElement} el The element to turn into a toolbar.
|
|
|
364 * @param {Object} attrs Object liternal containing configuration parameters.
|
|
|
365 */
|
|
|
366 YAHOO.widget.Toolbar = function(el, attrs) {
|
|
|
367
|
|
|
368 if (Lang.isObject(arguments[0]) && !Dom.get(el).nodeType) {
|
|
|
369 attrs = el;
|
|
|
370 }
|
|
|
371 var local_attrs = {};
|
|
|
372 if (attrs) {
|
|
|
373 Lang.augmentObject(local_attrs, attrs); //Break the config reference
|
|
|
374 }
|
|
|
375
|
|
|
376
|
|
|
377 var oConfig = {
|
|
|
378 element: null,
|
|
|
379 attributes: local_attrs
|
|
|
380 };
|
|
|
381
|
|
|
382
|
|
|
383 if (Lang.isString(el) && Dom.get(el)) {
|
|
|
384 oConfig.element = Dom.get(el);
|
|
|
385 } else if (Lang.isObject(el) && Dom.get(el) && Dom.get(el).nodeType) {
|
|
|
386 oConfig.element = Dom.get(el);
|
|
|
387 }
|
|
|
388
|
|
|
389
|
|
|
390 if (!oConfig.element) {
|
|
|
391 oConfig.element = document.createElement('DIV');
|
|
|
392 oConfig.element.id = Dom.generateId();
|
|
|
393
|
|
|
394 if (local_attrs.container && Dom.get(local_attrs.container)) {
|
|
|
395 Dom.get(local_attrs.container).appendChild(oConfig.element);
|
|
|
396 }
|
|
|
397 }
|
|
|
398
|
|
|
399
|
|
|
400 if (!oConfig.element.id) {
|
|
|
401 oConfig.element.id = ((Lang.isString(el)) ? el : Dom.generateId());
|
|
|
402 }
|
|
|
403
|
|
|
404 var fs = document.createElement('fieldset');
|
|
|
405 var lg = document.createElement('legend');
|
|
|
406 lg.innerHTML = 'Toolbar';
|
|
|
407 fs.appendChild(lg);
|
|
|
408
|
|
|
409 var cont = document.createElement('DIV');
|
|
|
410 oConfig.attributes.cont = cont;
|
|
|
411 Dom.addClass(cont, 'yui-toolbar-subcont');
|
|
|
412 fs.appendChild(cont);
|
|
|
413 oConfig.element.appendChild(fs);
|
|
|
414
|
|
|
415 oConfig.element.tabIndex = -1;
|
|
|
416
|
|
|
417
|
|
|
418 oConfig.attributes.element = oConfig.element;
|
|
|
419 oConfig.attributes.id = oConfig.element.id;
|
|
|
420
|
|
|
421 this._configuredButtons = [];
|
|
|
422
|
|
|
423 YAHOO.widget.Toolbar.superclass.constructor.call(this, oConfig.element, oConfig.attributes);
|
|
|
424
|
|
|
425 };
|
|
|
426
|
|
|
427 YAHOO.extend(YAHOO.widget.Toolbar, YAHOO.util.Element, {
|
|
|
428 /**
|
|
|
429 * @protected
|
|
|
430 * @property _configuredButtons
|
|
|
431 * @type Array
|
|
|
432 */
|
|
|
433 _configuredButtons: null,
|
|
|
434 /**
|
|
|
435 * @method _addMenuClasses
|
|
|
436 * @private
|
|
|
437 * @description This method is called from Menu's renderEvent to add a few more classes to the menu items
|
|
|
438 * @param {String} ev The event that fired.
|
|
|
439 * @param {Array} na Array of event information.
|
|
|
440 * @param {Object} o Button config object.
|
|
|
441 */
|
|
|
442 _addMenuClasses: function(ev, na, o) {
|
|
|
443 Dom.addClass(this.element, 'yui-toolbar-' + o.get('value') + '-menu');
|
|
|
444 if (Dom.hasClass(o._button.parentNode.parentNode, 'yui-toolbar-select')) {
|
|
|
445 Dom.addClass(this.element, 'yui-toolbar-select-menu');
|
|
|
446 }
|
|
|
447 var items = this.getItems();
|
|
|
448 for (var i = 0; i < items.length; i++) {
|
|
|
449 Dom.addClass(items[i].element, 'yui-toolbar-' + o.get('value') + '-' + ((items[i].value) ? items[i].value.replace(/ /g, '-').toLowerCase() : items[i]._oText.nodeValue.replace(/ /g, '-').toLowerCase()));
|
|
|
450 Dom.addClass(items[i].element, 'yui-toolbar-' + o.get('value') + '-' + ((items[i].value) ? items[i].value.replace(/ /g, '-') : items[i]._oText.nodeValue.replace(/ /g, '-')));
|
|
|
451 }
|
|
|
452 },
|
|
|
453 /**
|
|
|
454 * @property buttonType
|
|
|
455 * @description The default button to use
|
|
|
456 * @type Object
|
|
|
457 */
|
|
|
458 buttonType: YAHOO.widget.ToolbarButton,
|
|
|
459 /**
|
|
|
460 * @property dd
|
|
|
461 * @description The DragDrop instance associated with the Toolbar
|
|
|
462 * @type Object
|
|
|
463 */
|
|
|
464 dd: null,
|
|
|
465 /**
|
|
|
466 * @property _colorData
|
|
|
467 * @description Object reference containing colors hex and text values.
|
|
|
468 * @type Object
|
|
|
469 */
|
|
|
470 _colorData: {
|
|
|
471 /* {{{ _colorData */
|
|
|
472 '#111111': 'Obsidian',
|
|
|
473 '#2D2D2D': 'Dark Gray',
|
|
|
474 '#434343': 'Shale',
|
|
|
475 '#5B5B5B': 'Flint',
|
|
|
476 '#737373': 'Gray',
|
|
|
477 '#8B8B8B': 'Concrete',
|
|
|
478 '#A2A2A2': 'Gray',
|
|
|
479 '#B9B9B9': 'Titanium',
|
|
|
480 '#000000': 'Black',
|
|
|
481 '#D0D0D0': 'Light Gray',
|
|
|
482 '#E6E6E6': 'Silver',
|
|
|
483 '#FFFFFF': 'White',
|
|
|
484 '#BFBF00': 'Pumpkin',
|
|
|
485 '#FFFF00': 'Yellow',
|
|
|
486 '#FFFF40': 'Banana',
|
|
|
487 '#FFFF80': 'Pale Yellow',
|
|
|
488 '#FFFFBF': 'Butter',
|
|
|
489 '#525330': 'Raw Siena',
|
|
|
490 '#898A49': 'Mildew',
|
|
|
491 '#AEA945': 'Olive',
|
|
|
492 '#7F7F00': 'Paprika',
|
|
|
493 '#C3BE71': 'Earth',
|
|
|
494 '#E0DCAA': 'Khaki',
|
|
|
495 '#FCFAE1': 'Cream',
|
|
|
496 '#60BF00': 'Cactus',
|
|
|
497 '#80FF00': 'Chartreuse',
|
|
|
498 '#A0FF40': 'Green',
|
|
|
499 '#C0FF80': 'Pale Lime',
|
|
|
500 '#DFFFBF': 'Light Mint',
|
|
|
501 '#3B5738': 'Green',
|
|
|
502 '#668F5A': 'Lime Gray',
|
|
|
503 '#7F9757': 'Yellow',
|
|
|
504 '#407F00': 'Clover',
|
|
|
505 '#8A9B55': 'Pistachio',
|
|
|
506 '#B7C296': 'Light Jade',
|
|
|
507 '#E6EBD5': 'Breakwater',
|
|
|
508 '#00BF00': 'Spring Frost',
|
|
|
509 '#00FF80': 'Pastel Green',
|
|
|
510 '#40FFA0': 'Light Emerald',
|
|
|
511 '#80FFC0': 'Sea Foam',
|
|
|
512 '#BFFFDF': 'Sea Mist',
|
|
|
513 '#033D21': 'Dark Forrest',
|
|
|
514 '#438059': 'Moss',
|
|
|
515 '#7FA37C': 'Medium Green',
|
|
|
516 '#007F40': 'Pine',
|
|
|
517 '#8DAE94': 'Yellow Gray Green',
|
|
|
518 '#ACC6B5': 'Aqua Lung',
|
|
|
519 '#DDEBE2': 'Sea Vapor',
|
|
|
520 '#00BFBF': 'Fog',
|
|
|
521 '#00FFFF': 'Cyan',
|
|
|
522 '#40FFFF': 'Turquoise Blue',
|
|
|
523 '#80FFFF': 'Light Aqua',
|
|
|
524 '#BFFFFF': 'Pale Cyan',
|
|
|
525 '#033D3D': 'Dark Teal',
|
|
|
526 '#347D7E': 'Gray Turquoise',
|
|
|
527 '#609A9F': 'Green Blue',
|
|
|
528 '#007F7F': 'Seaweed',
|
|
|
529 '#96BDC4': 'Green Gray',
|
|
|
530 '#B5D1D7': 'Soapstone',
|
|
|
531 '#E2F1F4': 'Light Turquoise',
|
|
|
532 '#0060BF': 'Summer Sky',
|
|
|
533 '#0080FF': 'Sky Blue',
|
|
|
534 '#40A0FF': 'Electric Blue',
|
|
|
535 '#80C0FF': 'Light Azure',
|
|
|
536 '#BFDFFF': 'Ice Blue',
|
|
|
537 '#1B2C48': 'Navy',
|
|
|
538 '#385376': 'Biscay',
|
|
|
539 '#57708F': 'Dusty Blue',
|
|
|
540 '#00407F': 'Sea Blue',
|
|
|
541 '#7792AC': 'Sky Blue Gray',
|
|
|
542 '#A8BED1': 'Morning Sky',
|
|
|
543 '#DEEBF6': 'Vapor',
|
|
|
544 '#0000BF': 'Deep Blue',
|
|
|
545 '#0000FF': 'Blue',
|
|
|
546 '#4040FF': 'Cerulean Blue',
|
|
|
547 '#8080FF': 'Evening Blue',
|
|
|
548 '#BFBFFF': 'Light Blue',
|
|
|
549 '#212143': 'Deep Indigo',
|
|
|
550 '#373E68': 'Sea Blue',
|
|
|
551 '#444F75': 'Night Blue',
|
|
|
552 '#00007F': 'Indigo Blue',
|
|
|
553 '#585E82': 'Dockside',
|
|
|
554 '#8687A4': 'Blue Gray',
|
|
|
555 '#D2D1E1': 'Light Blue Gray',
|
|
|
556 '#6000BF': 'Neon Violet',
|
|
|
557 '#8000FF': 'Blue Violet',
|
|
|
558 '#A040FF': 'Violet Purple',
|
|
|
559 '#C080FF': 'Violet Dusk',
|
|
|
560 '#DFBFFF': 'Pale Lavender',
|
|
|
561 '#302449': 'Cool Shale',
|
|
|
562 '#54466F': 'Dark Indigo',
|
|
|
563 '#655A7F': 'Dark Violet',
|
|
|
564 '#40007F': 'Violet',
|
|
|
565 '#726284': 'Smoky Violet',
|
|
|
566 '#9E8FA9': 'Slate Gray',
|
|
|
567 '#DCD1DF': 'Violet White',
|
|
|
568 '#BF00BF': 'Royal Violet',
|
|
|
569 '#FF00FF': 'Fuchsia',
|
|
|
570 '#FF40FF': 'Magenta',
|
|
|
571 '#FF80FF': 'Orchid',
|
|
|
572 '#FFBFFF': 'Pale Magenta',
|
|
|
573 '#4A234A': 'Dark Purple',
|
|
|
574 '#794A72': 'Medium Purple',
|
|
|
575 '#936386': 'Cool Granite',
|
|
|
576 '#7F007F': 'Purple',
|
|
|
577 '#9D7292': 'Purple Moon',
|
|
|
578 '#C0A0B6': 'Pale Purple',
|
|
|
579 '#ECDAE5': 'Pink Cloud',
|
|
|
580 '#BF005F': 'Hot Pink',
|
|
|
581 '#FF007F': 'Deep Pink',
|
|
|
582 '#FF409F': 'Grape',
|
|
|
583 '#FF80BF': 'Electric Pink',
|
|
|
584 '#FFBFDF': 'Pink',
|
|
|
585 '#451528': 'Purple Red',
|
|
|
586 '#823857': 'Purple Dino',
|
|
|
587 '#A94A76': 'Purple Gray',
|
|
|
588 '#7F003F': 'Rose',
|
|
|
589 '#BC6F95': 'Antique Mauve',
|
|
|
590 '#D8A5BB': 'Cool Marble',
|
|
|
591 '#F7DDE9': 'Pink Granite',
|
|
|
592 '#C00000': 'Apple',
|
|
|
593 '#FF0000': 'Fire Truck',
|
|
|
594 '#FF4040': 'Pale Red',
|
|
|
595 '#FF8080': 'Salmon',
|
|
|
596 '#FFC0C0': 'Warm Pink',
|
|
|
597 '#441415': 'Sepia',
|
|
|
598 '#82393C': 'Rust',
|
|
|
599 '#AA4D4E': 'Brick',
|
|
|
600 '#800000': 'Brick Red',
|
|
|
601 '#BC6E6E': 'Mauve',
|
|
|
602 '#D8A3A4': 'Shrimp Pink',
|
|
|
603 '#F8DDDD': 'Shell Pink',
|
|
|
604 '#BF5F00': 'Dark Orange',
|
|
|
605 '#FF7F00': 'Orange',
|
|
|
606 '#FF9F40': 'Grapefruit',
|
|
|
607 '#FFBF80': 'Canteloupe',
|
|
|
608 '#FFDFBF': 'Wax',
|
|
|
609 '#482C1B': 'Dark Brick',
|
|
|
610 '#855A40': 'Dirt',
|
|
|
611 '#B27C51': 'Tan',
|
|
|
612 '#7F3F00': 'Nutmeg',
|
|
|
613 '#C49B71': 'Mustard',
|
|
|
614 '#E1C4A8': 'Pale Tan',
|
|
|
615 '#FDEEE0': 'Marble'
|
|
|
616 /* }}} */
|
|
|
617 },
|
|
|
618 /**
|
|
|
619 * @property _colorPicker
|
|
|
620 * @description The HTML Element containing the colorPicker
|
|
|
621 * @type HTMLElement
|
|
|
622 */
|
|
|
623 _colorPicker: null,
|
|
|
624 /**
|
|
|
625 * @property STR_COLLAPSE
|
|
|
626 * @description String for Toolbar Collapse Button
|
|
|
627 * @type String
|
|
|
628 */
|
|
|
629 STR_COLLAPSE: 'Collapse Toolbar',
|
|
|
630 /**
|
|
|
631 * @property STR_EXPAND
|
|
|
632 * @description String for Toolbar Collapse Button - Expand
|
|
|
633 * @type String
|
|
|
634 */
|
|
|
635 STR_EXPAND: 'Expand Toolbar',
|
|
|
636 /**
|
|
|
637 * @property STR_SPIN_LABEL
|
|
|
638 * @description String for spinbutton dynamic label. Note the {VALUE} will be replaced with YAHOO.lang.substitute
|
|
|
639 * @type String
|
|
|
640 */
|
|
|
641 STR_SPIN_LABEL: 'Spin Button with value {VALUE}. Use Control Shift Up Arrow and Control Shift Down arrow keys to increase or decrease the value.',
|
|
|
642 /**
|
|
|
643 * @property STR_SPIN_UP
|
|
|
644 * @description String for spinbutton up
|
|
|
645 * @type String
|
|
|
646 */
|
|
|
647 STR_SPIN_UP: 'Click to increase the value of this input',
|
|
|
648 /**
|
|
|
649 * @property STR_SPIN_DOWN
|
|
|
650 * @description String for spinbutton down
|
|
|
651 * @type String
|
|
|
652 */
|
|
|
653 STR_SPIN_DOWN: 'Click to decrease the value of this input',
|
|
|
654 /**
|
|
|
655 * @property _titlebar
|
|
|
656 * @description Object reference to the titlebar
|
|
|
657 * @type HTMLElement
|
|
|
658 */
|
|
|
659 _titlebar: null,
|
|
|
660 /**
|
|
|
661 * @property browser
|
|
|
662 * @description Standard browser detection
|
|
|
663 * @type Object
|
|
|
664 */
|
|
|
665 browser: YAHOO.env.ua,
|
|
|
666 /**
|
|
|
667 * @protected
|
|
|
668 * @property _buttonList
|
|
|
669 * @description Internal property list of current buttons in the toolbar
|
|
|
670 * @type Array
|
|
|
671 */
|
|
|
672 _buttonList: null,
|
|
|
673 /**
|
|
|
674 * @protected
|
|
|
675 * @property _buttonGroupList
|
|
|
676 * @description Internal property list of current button groups in the toolbar
|
|
|
677 * @type Array
|
|
|
678 */
|
|
|
679 _buttonGroupList: null,
|
|
|
680 /**
|
|
|
681 * @protected
|
|
|
682 * @property _sep
|
|
|
683 * @description Internal reference to the separator HTML Element for cloning
|
|
|
684 * @type HTMLElement
|
|
|
685 */
|
|
|
686 _sep: null,
|
|
|
687 /**
|
|
|
688 * @protected
|
|
|
689 * @property _sepCount
|
|
|
690 * @description Internal refernce for counting separators, so we can give them a useful class name for styling
|
|
|
691 * @type Number
|
|
|
692 */
|
|
|
693 _sepCount: null,
|
|
|
694 /**
|
|
|
695 * @protected
|
|
|
696 * @property draghandle
|
|
|
697 * @type HTMLElement
|
|
|
698 */
|
|
|
699 _dragHandle: null,
|
|
|
700 /**
|
|
|
701 * @protected
|
|
|
702 * @property _toolbarConfigs
|
|
|
703 * @type Object
|
|
|
704 */
|
|
|
705 _toolbarConfigs: {
|
|
|
706 renderer: true
|
|
|
707 },
|
|
|
708 /**
|
|
|
709 * @protected
|
|
|
710 * @property CLASS_CONTAINER
|
|
|
711 * @description Default CSS class to apply to the toolbar container element
|
|
|
712 * @type String
|
|
|
713 */
|
|
|
714 CLASS_CONTAINER: 'yui-toolbar-container',
|
|
|
715 /**
|
|
|
716 * @protected
|
|
|
717 * @property CLASS_DRAGHANDLE
|
|
|
718 * @description Default CSS class to apply to the toolbar's drag handle element
|
|
|
719 * @type String
|
|
|
720 */
|
|
|
721 CLASS_DRAGHANDLE: 'yui-toolbar-draghandle',
|
|
|
722 /**
|
|
|
723 * @protected
|
|
|
724 * @property CLASS_SEPARATOR
|
|
|
725 * @description Default CSS class to apply to all separators in the toolbar
|
|
|
726 * @type String
|
|
|
727 */
|
|
|
728 CLASS_SEPARATOR: 'yui-toolbar-separator',
|
|
|
729 /**
|
|
|
730 * @protected
|
|
|
731 * @property CLASS_DISABLED
|
|
|
732 * @description Default CSS class to apply when the toolbar is disabled
|
|
|
733 * @type String
|
|
|
734 */
|
|
|
735 CLASS_DISABLED: 'yui-toolbar-disabled',
|
|
|
736 /**
|
|
|
737 * @protected
|
|
|
738 * @property CLASS_PREFIX
|
|
|
739 * @description Default prefix for dynamically created class names
|
|
|
740 * @type String
|
|
|
741 */
|
|
|
742 CLASS_PREFIX: 'yui-toolbar',
|
|
|
743 /**
|
|
|
744 * @method init
|
|
|
745 * @description The Toolbar class's initialization method
|
|
|
746 */
|
|
|
747 init: function(p_oElement, p_oAttributes) {
|
|
|
748 YAHOO.widget.Toolbar.superclass.init.call(this, p_oElement, p_oAttributes);
|
|
|
749 },
|
|
|
750 /**
|
|
|
751 * @method initAttributes
|
|
|
752 * @description Initializes all of the configuration attributes used to create
|
|
|
753 * the toolbar.
|
|
|
754 * @param {Object} attr Object literal specifying a set of
|
|
|
755 * configuration attributes used to create the toolbar.
|
|
|
756 */
|
|
|
757 initAttributes: function(attr) {
|
|
|
758 YAHOO.widget.Toolbar.superclass.initAttributes.call(this, attr);
|
|
|
759 this.addClass(this.CLASS_CONTAINER);
|
|
|
760
|
|
|
761 /**
|
|
|
762 * @attribute buttonType
|
|
|
763 * @description The buttonType to use (advanced or basic)
|
|
|
764 * @type String
|
|
|
765 */
|
|
|
766 this.setAttributeConfig('buttonType', {
|
|
|
767 value: attr.buttonType || 'basic',
|
|
|
768 writeOnce: true,
|
|
|
769 validator: function(type) {
|
|
|
770 switch (type) {
|
|
|
771 case 'advanced':
|
|
|
772 case 'basic':
|
|
|
773 return true;
|
|
|
774 }
|
|
|
775 return false;
|
|
|
776 },
|
|
|
777 method: function(type) {
|
|
|
778 if (type == 'advanced') {
|
|
|
779 if (YAHOO.widget.Button) {
|
|
|
780 this.buttonType = YAHOO.widget.ToolbarButtonAdvanced;
|
|
|
781 } else {
|
|
|
782 this.buttonType = YAHOO.widget.ToolbarButton;
|
|
|
783 }
|
|
|
784 } else {
|
|
|
785 this.buttonType = YAHOO.widget.ToolbarButton;
|
|
|
786 }
|
|
|
787 }
|
|
|
788 });
|
|
|
789
|
|
|
790
|
|
|
791 /**
|
|
|
792 * @attribute buttons
|
|
|
793 * @description Object specifying the buttons to include in the toolbar
|
|
|
794 * Example:
|
|
|
795 * <code><pre>
|
|
|
796 * {
|
|
|
797 * { id: 'b3', type: 'button', label: 'Underline', value: 'underline' },
|
|
|
798 * { type: 'separator' },
|
|
|
799 * { id: 'b4', type: 'menu', label: 'Align', value: 'align',
|
|
|
800 * menu: [
|
|
|
801 * { text: "Left", value: 'alignleft' },
|
|
|
802 * { text: "Center", value: 'aligncenter' },
|
|
|
803 * { text: "Right", value: 'alignright' }
|
|
|
804 * ]
|
|
|
805 * }
|
|
|
806 * }
|
|
|
807 * </pre></code>
|
|
|
808 * @type Array
|
|
|
809 */
|
|
|
810
|
|
|
811 this.setAttributeConfig('buttons', {
|
|
|
812 value: [],
|
|
|
813 writeOnce: true,
|
|
|
814 method: function(data) {
|
|
|
815 var i, button, buttons, len, b;
|
|
|
816 for (i in data) {
|
|
|
817 if (Lang.hasOwnProperty(data, i)) {
|
|
|
818 if (data[i].type == 'separator') {
|
|
|
819 this.addSeparator();
|
|
|
820 } else if (data[i].group !== undefined) {
|
|
|
821 buttons = this.addButtonGroup(data[i]);
|
|
|
822 if (buttons) {
|
|
|
823 len = buttons.length;
|
|
|
824 for(b = 0; b < len; b++) {
|
|
|
825 if (buttons[b]) {
|
|
|
826 this._configuredButtons[this._configuredButtons.length] = buttons[b].id;
|
|
|
827 }
|
|
|
828 }
|
|
|
829 }
|
|
|
830
|
|
|
831 } else {
|
|
|
832 button = this.addButton(data[i]);
|
|
|
833 if (button) {
|
|
|
834 this._configuredButtons[this._configuredButtons.length] = button.id;
|
|
|
835 }
|
|
|
836 }
|
|
|
837 }
|
|
|
838 }
|
|
|
839 }
|
|
|
840 });
|
|
|
841
|
|
|
842 /**
|
|
|
843 * @attribute disabled
|
|
|
844 * @description Boolean indicating if the toolbar should be disabled. It will also disable the draggable attribute if it is on.
|
|
|
845 * @default false
|
|
|
846 * @type Boolean
|
|
|
847 */
|
|
|
848 this.setAttributeConfig('disabled', {
|
|
|
849 value: false,
|
|
|
850 method: function(disabled) {
|
|
|
851 if (this.get('disabled') === disabled) {
|
|
|
852 return false;
|
|
|
853 }
|
|
|
854 if (disabled) {
|
|
|
855 this.addClass(this.CLASS_DISABLED);
|
|
|
856 this.set('draggable', false);
|
|
|
857 this.disableAllButtons();
|
|
|
858 } else {
|
|
|
859 this.removeClass(this.CLASS_DISABLED);
|
|
|
860 if (this._configs.draggable._initialConfig.value) {
|
|
|
861 //Draggable by default, set it back
|
|
|
862 this.set('draggable', true);
|
|
|
863 }
|
|
|
864 this.resetAllButtons();
|
|
|
865 }
|
|
|
866 }
|
|
|
867 });
|
|
|
868
|
|
|
869 /**
|
|
|
870 * @config cont
|
|
|
871 * @description The container for the toolbar.
|
|
|
872 * @type HTMLElement
|
|
|
873 */
|
|
|
874 this.setAttributeConfig('cont', {
|
|
|
875 value: attr.cont,
|
|
|
876 readOnly: true
|
|
|
877 });
|
|
|
878
|
|
|
879
|
|
|
880 /**
|
|
|
881 * @attribute grouplabels
|
|
|
882 * @description Boolean indicating if the toolbar should show the group label's text string.
|
|
|
883 * @default true
|
|
|
884 * @type Boolean
|
|
|
885 */
|
|
|
886 this.setAttributeConfig('grouplabels', {
|
|
|
887 value: ((attr.grouplabels === false) ? false : true),
|
|
|
888 method: function(grouplabels) {
|
|
|
889 if (grouplabels) {
|
|
|
890 Dom.removeClass(this.get('cont'), (this.CLASS_PREFIX + '-nogrouplabels'));
|
|
|
891 } else {
|
|
|
892 Dom.addClass(this.get('cont'), (this.CLASS_PREFIX + '-nogrouplabels'));
|
|
|
893 }
|
|
|
894 }
|
|
|
895 });
|
|
|
896 /**
|
|
|
897 * @attribute titlebar
|
|
|
898 * @description Boolean indicating if the toolbar should have a titlebar. If
|
|
|
899 * passed a string, it will use that as the titlebar text
|
|
|
900 * @default false
|
|
|
901 * @type Boolean or String
|
|
|
902 */
|
|
|
903 this.setAttributeConfig('titlebar', {
|
|
|
904 value: false,
|
|
|
905 method: function(titlebar) {
|
|
|
906 if (titlebar) {
|
|
|
907 if (this._titlebar && this._titlebar.parentNode) {
|
|
|
908 this._titlebar.parentNode.removeChild(this._titlebar);
|
|
|
909 }
|
|
|
910 this._titlebar = document.createElement('DIV');
|
|
|
911 this._titlebar.tabIndex = '-1';
|
|
|
912 Event.on(this._titlebar, 'focus', function() {
|
|
|
913 this._handleFocus();
|
|
|
914 }, this, true);
|
|
|
915 Dom.addClass(this._titlebar, this.CLASS_PREFIX + '-titlebar');
|
|
|
916 if (Lang.isString(titlebar)) {
|
|
|
917 var h2 = document.createElement('h2');
|
|
|
918 h2.tabIndex = '-1';
|
|
|
919 h2.innerHTML = '<a href="#" tabIndex="0">' + titlebar + '</a>';
|
|
|
920 this._titlebar.appendChild(h2);
|
|
|
921 Event.on(h2.firstChild, 'click', function(ev) {
|
|
|
922 Event.stopEvent(ev);
|
|
|
923 });
|
|
|
924 Event.on([h2, h2.firstChild], 'focus', function() {
|
|
|
925 this._handleFocus();
|
|
|
926 }, this, true);
|
|
|
927 }
|
|
|
928 if (this.get('firstChild')) {
|
|
|
929 this.insertBefore(this._titlebar, this.get('firstChild'));
|
|
|
930 } else {
|
|
|
931 this.appendChild(this._titlebar);
|
|
|
932 }
|
|
|
933 if (this.get('collapse')) {
|
|
|
934 this.set('collapse', true);
|
|
|
935 }
|
|
|
936 } else if (this._titlebar) {
|
|
|
937 if (this._titlebar && this._titlebar.parentNode) {
|
|
|
938 this._titlebar.parentNode.removeChild(this._titlebar);
|
|
|
939 }
|
|
|
940 }
|
|
|
941 }
|
|
|
942 });
|
|
|
943
|
|
|
944
|
|
|
945 /**
|
|
|
946 * @attribute collapse
|
|
|
947 * @description Boolean indicating if the the titlebar should have a collapse button.
|
|
|
948 * The collapse button will not remove the toolbar, it will minimize it to the titlebar
|
|
|
949 * @default false
|
|
|
950 * @type Boolean
|
|
|
951 */
|
|
|
952 this.setAttributeConfig('collapse', {
|
|
|
953 value: false,
|
|
|
954 method: function(collapse) {
|
|
|
955 if (this._titlebar) {
|
|
|
956 var collapseEl = null;
|
|
|
957 var el = Dom.getElementsByClassName('collapse', 'span', this._titlebar);
|
|
|
958 if (collapse) {
|
|
|
959 if (el.length > 0) {
|
|
|
960 //There is already a collapse button
|
|
|
961 return true;
|
|
|
962 }
|
|
|
963 collapseEl = document.createElement('SPAN');
|
|
|
964 collapseEl.innerHTML = 'X';
|
|
|
965 collapseEl.title = this.STR_COLLAPSE;
|
|
|
966
|
|
|
967 Dom.addClass(collapseEl, 'collapse');
|
|
|
968 this._titlebar.appendChild(collapseEl);
|
|
|
969 Event.addListener(collapseEl, 'click', function() {
|
|
|
970 if (Dom.hasClass(this.get('cont').parentNode, 'yui-toolbar-container-collapsed')) {
|
|
|
971 this.collapse(false); //Expand Toolbar
|
|
|
972 } else {
|
|
|
973 this.collapse(); //Collapse Toolbar
|
|
|
974 }
|
|
|
975 }, this, true);
|
|
|
976 } else {
|
|
|
977 collapseEl = Dom.getElementsByClassName('collapse', 'span', this._titlebar);
|
|
|
978 if (collapseEl[0]) {
|
|
|
979 if (Dom.hasClass(this.get('cont').parentNode, 'yui-toolbar-container-collapsed')) {
|
|
|
980 //We are closed, reopen the titlebar..
|
|
|
981 this.collapse(false); //Expand Toolbar
|
|
|
982 }
|
|
|
983 collapseEl[0].parentNode.removeChild(collapseEl[0]);
|
|
|
984 }
|
|
|
985 }
|
|
|
986 }
|
|
|
987 }
|
|
|
988 });
|
|
|
989
|
|
|
990 /**
|
|
|
991 * @attribute draggable
|
|
|
992 * @description Boolean indicating if the toolbar should be draggable.
|
|
|
993 * @default false
|
|
|
994 * @type Boolean
|
|
|
995 */
|
|
|
996
|
|
|
997 this.setAttributeConfig('draggable', {
|
|
|
998 value: (attr.draggable || false),
|
|
|
999 method: function(draggable) {
|
|
|
1000 if (draggable && !this.get('titlebar')) {
|
|
|
1001 if (!this._dragHandle) {
|
|
|
1002 this._dragHandle = document.createElement('SPAN');
|
|
|
1003 this._dragHandle.innerHTML = '|';
|
|
|
1004 this._dragHandle.setAttribute('title', 'Click to drag the toolbar');
|
|
|
1005 this._dragHandle.id = this.get('id') + '_draghandle';
|
|
|
1006 Dom.addClass(this._dragHandle, this.CLASS_DRAGHANDLE);
|
|
|
1007 if (this.get('cont').hasChildNodes()) {
|
|
|
1008 this.get('cont').insertBefore(this._dragHandle, this.get('cont').firstChild);
|
|
|
1009 } else {
|
|
|
1010 this.get('cont').appendChild(this._dragHandle);
|
|
|
1011 }
|
|
|
1012 this.dd = new YAHOO.util.DD(this.get('id'));
|
|
|
1013 this.dd.setHandleElId(this._dragHandle.id);
|
|
|
1014
|
|
|
1015 }
|
|
|
1016 } else {
|
|
|
1017 if (this._dragHandle) {
|
|
|
1018 this._dragHandle.parentNode.removeChild(this._dragHandle);
|
|
|
1019 this._dragHandle = null;
|
|
|
1020 this.dd = null;
|
|
|
1021 }
|
|
|
1022 }
|
|
|
1023 if (this._titlebar) {
|
|
|
1024 if (draggable) {
|
|
|
1025 this.dd = new YAHOO.util.DD(this.get('id'));
|
|
|
1026 this.dd.setHandleElId(this._titlebar);
|
|
|
1027 Dom.addClass(this._titlebar, 'draggable');
|
|
|
1028 } else {
|
|
|
1029 Dom.removeClass(this._titlebar, 'draggable');
|
|
|
1030 if (this.dd) {
|
|
|
1031 this.dd.unreg();
|
|
|
1032 this.dd = null;
|
|
|
1033 }
|
|
|
1034 }
|
|
|
1035 }
|
|
|
1036 },
|
|
|
1037 validator: function(value) {
|
|
|
1038 var ret = true;
|
|
|
1039 if (!YAHOO.util.DD) {
|
|
|
1040 ret = false;
|
|
|
1041 }
|
|
|
1042 return ret;
|
|
|
1043 }
|
|
|
1044 });
|
|
|
1045
|
|
|
1046 },
|
|
|
1047 /**
|
|
|
1048 * @method addButtonGroup
|
|
|
1049 * @description Add a new button group to the toolbar. (uses addButton)
|
|
|
1050 * @param {Object} oGroup Object literal reference to the Groups Config (contains an array of button configs as well as the group label)
|
|
|
1051 */
|
|
|
1052 addButtonGroup: function(oGroup) {
|
|
|
1053 if (!this.get('element')) {
|
|
|
1054 this._queue[this._queue.length] = ['addButtonGroup', arguments];
|
|
|
1055 return false;
|
|
|
1056 }
|
|
|
1057
|
|
|
1058 if (!this.hasClass(this.CLASS_PREFIX + '-grouped')) {
|
|
|
1059 this.addClass(this.CLASS_PREFIX + '-grouped');
|
|
|
1060 }
|
|
|
1061 var div = document.createElement('DIV');
|
|
|
1062 Dom.addClass(div, this.CLASS_PREFIX + '-group');
|
|
|
1063 Dom.addClass(div, this.CLASS_PREFIX + '-group-' + oGroup.group);
|
|
|
1064 if (oGroup.label) {
|
|
|
1065 var label = document.createElement('h3');
|
|
|
1066 label.innerHTML = oGroup.label;
|
|
|
1067 div.appendChild(label);
|
|
|
1068 }
|
|
|
1069 if (!this.get('grouplabels')) {
|
|
|
1070 Dom.addClass(this.get('cont'), this.CLASS_PREFIX, '-nogrouplabels');
|
|
|
1071 }
|
|
|
1072
|
|
|
1073 this.get('cont').appendChild(div);
|
|
|
1074
|
|
|
1075 //For accessibility, let's put all of the group buttons in an Unordered List
|
|
|
1076 var ul = document.createElement('ul');
|
|
|
1077 div.appendChild(ul);
|
|
|
1078
|
|
|
1079 if (!this._buttonGroupList) {
|
|
|
1080 this._buttonGroupList = {};
|
|
|
1081 }
|
|
|
1082
|
|
|
1083 this._buttonGroupList[oGroup.group] = ul;
|
|
|
1084
|
|
|
1085 //An array of the button ids added to this group
|
|
|
1086 //This is used for destruction later...
|
|
|
1087 var addedButtons = [],
|
|
|
1088 button;
|
|
|
1089
|
|
|
1090
|
|
|
1091 for (var i = 0; i < oGroup.buttons.length; i++) {
|
|
|
1092 var li = document.createElement('li');
|
|
|
1093 li.className = this.CLASS_PREFIX + '-groupitem';
|
|
|
1094 ul.appendChild(li);
|
|
|
1095 if ((oGroup.buttons[i].type !== undefined) && oGroup.buttons[i].type == 'separator') {
|
|
|
1096 this.addSeparator(li);
|
|
|
1097 } else {
|
|
|
1098 oGroup.buttons[i].container = li;
|
|
|
1099 button = this.addButton(oGroup.buttons[i]);
|
|
|
1100 if (button) {
|
|
|
1101 addedButtons[addedButtons.length] = button.id;
|
|
|
1102 }
|
|
|
1103 }
|
|
|
1104 }
|
|
|
1105 return addedButtons;
|
|
|
1106 },
|
|
|
1107 /**
|
|
|
1108 * @method addButtonToGroup
|
|
|
1109 * @description Add a new button to a toolbar group. Buttons supported:
|
|
|
1110 * push, split, menu, select, color, spin
|
|
|
1111 * @param {Object} oButton Object literal reference to the Button's Config
|
|
|
1112 * @param {String} group The Group identifier passed into the initial config
|
|
|
1113 * @param {HTMLElement} after Optional HTML element to insert this button after in the DOM.
|
|
|
1114 */
|
|
|
1115 addButtonToGroup: function(oButton, group, after) {
|
|
|
1116 var groupCont = this._buttonGroupList[group],
|
|
|
1117 li = document.createElement('li');
|
|
|
1118
|
|
|
1119 li.className = this.CLASS_PREFIX + '-groupitem';
|
|
|
1120 oButton.container = li;
|
|
|
1121 this.addButton(oButton, after);
|
|
|
1122 groupCont.appendChild(li);
|
|
|
1123 },
|
|
|
1124 /**
|
|
|
1125 * @method addButton
|
|
|
1126 * @description Add a new button to the toolbar. Buttons supported:
|
|
|
1127 * push, split, menu, select, color, spin
|
|
|
1128 * @param {Object} oButton Object literal reference to the Button's Config
|
|
|
1129 * @param {HTMLElement} after Optional HTML element to insert this button after in the DOM.
|
|
|
1130 */
|
|
|
1131 addButton: function(oButton, after) {
|
|
|
1132 if (!this.get('element')) {
|
|
|
1133 this._queue[this._queue.length] = ['addButton', arguments];
|
|
|
1134 return false;
|
|
|
1135 }
|
|
|
1136 if (!this._buttonList) {
|
|
|
1137 this._buttonList = [];
|
|
|
1138 }
|
|
|
1139 if (!oButton.container) {
|
|
|
1140 oButton.container = this.get('cont');
|
|
|
1141 }
|
|
|
1142
|
|
|
1143 if ((oButton.type == 'menu') || (oButton.type == 'split') || (oButton.type == 'select')) {
|
|
|
1144 if (Lang.isArray(oButton.menu)) {
|
|
|
1145 for (var i in oButton.menu) {
|
|
|
1146 if (Lang.hasOwnProperty(oButton.menu, i)) {
|
|
|
1147 var funcObject = {
|
|
|
1148 fn: function(ev, x, oMenu) {
|
|
|
1149 if (!oButton.menucmd) {
|
|
|
1150 oButton.menucmd = oButton.value;
|
|
|
1151 }
|
|
|
1152 oButton.value = ((oMenu.value) ? oMenu.value : oMenu._oText.nodeValue);
|
|
|
1153 },
|
|
|
1154 scope: this
|
|
|
1155 };
|
|
|
1156 oButton.menu[i].onclick = funcObject;
|
|
|
1157 }
|
|
|
1158 }
|
|
|
1159 }
|
|
|
1160 }
|
|
|
1161 var _oButton = {}, skip = false;
|
|
|
1162 for (var o in oButton) {
|
|
|
1163 if (Lang.hasOwnProperty(oButton, o)) {
|
|
|
1164 if (!this._toolbarConfigs[o]) {
|
|
|
1165 _oButton[o] = oButton[o];
|
|
|
1166 }
|
|
|
1167 }
|
|
|
1168 }
|
|
|
1169 if (oButton.type == 'select') {
|
|
|
1170 _oButton.type = 'menu';
|
|
|
1171 }
|
|
|
1172 if (oButton.type == 'spin') {
|
|
|
1173 _oButton.type = 'push';
|
|
|
1174 }
|
|
|
1175 if (_oButton.type == 'color') {
|
|
|
1176 if (YAHOO.widget.Overlay) {
|
|
|
1177 _oButton = this._makeColorButton(_oButton);
|
|
|
1178 } else {
|
|
|
1179 skip = true;
|
|
|
1180 }
|
|
|
1181 }
|
|
|
1182 if (_oButton.menu) {
|
|
|
1183 if ((YAHOO.widget.Overlay) && (oButton.menu instanceof YAHOO.widget.Overlay)) {
|
|
|
1184 oButton.menu.showEvent.subscribe(function() {
|
|
|
1185 this._button = _oButton;
|
|
|
1186 });
|
|
|
1187 } else {
|
|
|
1188 for (var m = 0; m < _oButton.menu.length; m++) {
|
|
|
1189 if (!_oButton.menu[m].value) {
|
|
|
1190 _oButton.menu[m].value = _oButton.menu[m].text;
|
|
|
1191 }
|
|
|
1192 }
|
|
|
1193 if (this.browser.webkit) {
|
|
|
1194 _oButton.focusmenu = false;
|
|
|
1195 }
|
|
|
1196 }
|
|
|
1197 }
|
|
|
1198 if (skip) {
|
|
|
1199 oButton = false;
|
|
|
1200 } else {
|
|
|
1201 //Add to .get('buttons') manually
|
|
|
1202 this._configs.buttons.value[this._configs.buttons.value.length] = oButton;
|
|
|
1203
|
|
|
1204 var tmp = new this.buttonType(_oButton);
|
|
|
1205 tmp.get('element').tabIndex = '-1';
|
|
|
1206 tmp.get('element').setAttribute('role', 'button');
|
|
|
1207 tmp._selected = true;
|
|
|
1208
|
|
|
1209 if (this.get('disabled')) {
|
|
|
1210 //Toolbar is disabled, disable the new button too!
|
|
|
1211 tmp.set('disabled', true);
|
|
|
1212 }
|
|
|
1213 if (!oButton.id) {
|
|
|
1214 oButton.id = tmp.get('id');
|
|
|
1215 }
|
|
|
1216
|
|
|
1217 if (after) {
|
|
|
1218 var el = tmp.get('element');
|
|
|
1219 var nextSib = null;
|
|
|
1220 if (after.get) {
|
|
|
1221 nextSib = after.get('element').nextSibling;
|
|
|
1222 } else if (after.nextSibling) {
|
|
|
1223 nextSib = after.nextSibling;
|
|
|
1224 }
|
|
|
1225 if (nextSib) {
|
|
|
1226 nextSib.parentNode.insertBefore(el, nextSib);
|
|
|
1227 }
|
|
|
1228 }
|
|
|
1229 tmp.addClass(this.CLASS_PREFIX + '-' + tmp.get('value'));
|
|
|
1230
|
|
|
1231 var icon = document.createElement('span');
|
|
|
1232 icon.className = this.CLASS_PREFIX + '-icon';
|
|
|
1233 tmp.get('element').insertBefore(icon, tmp.get('firstChild'));
|
|
|
1234 if (tmp._button.tagName.toLowerCase() == 'button') {
|
|
|
1235 tmp.get('element').setAttribute('unselectable', 'on');
|
|
|
1236 //Replace the Button HTML Element with an a href if it exists
|
|
|
1237 var a = document.createElement('a');
|
|
|
1238 a.innerHTML = tmp._button.innerHTML;
|
|
|
1239 a.href = '#';
|
|
|
1240 a.tabIndex = '-1';
|
|
|
1241 Event.on(a, 'click', function(ev) {
|
|
|
1242 Event.stopEvent(ev);
|
|
|
1243 });
|
|
|
1244 tmp._button.parentNode.replaceChild(a, tmp._button);
|
|
|
1245 tmp._button = a;
|
|
|
1246 }
|
|
|
1247
|
|
|
1248 if (oButton.type == 'select') {
|
|
|
1249 if (tmp._button.tagName.toLowerCase() == 'select') {
|
|
|
1250 icon.parentNode.removeChild(icon);
|
|
|
1251 var iel = tmp._button,
|
|
|
1252 parEl = tmp.get('element');
|
|
|
1253 parEl.parentNode.replaceChild(iel, parEl);
|
|
|
1254 //The 'element' value is currently the orphaned element
|
|
|
1255 //In order for "destroy" to execute we need to get('element') to reference the correct node.
|
|
|
1256 //I'm not sure if there is a direct approach to setting this value.
|
|
|
1257 tmp._configs.element.value = iel;
|
|
|
1258 } else {
|
|
|
1259 //Don't put a class on it if it's a real select element
|
|
|
1260 tmp.addClass(this.CLASS_PREFIX + '-select');
|
|
|
1261 }
|
|
|
1262 }
|
|
|
1263 if (oButton.type == 'spin') {
|
|
|
1264 if (!Lang.isArray(oButton.range)) {
|
|
|
1265 oButton.range = [ 10, 100 ];
|
|
|
1266 }
|
|
|
1267 this._makeSpinButton(tmp, oButton);
|
|
|
1268 }
|
|
|
1269 tmp.get('element').setAttribute('title', tmp.get('label'));
|
|
|
1270 if (oButton.type != 'spin') {
|
|
|
1271 if ((YAHOO.widget.Overlay) && (_oButton.menu instanceof YAHOO.widget.Overlay)) {
|
|
|
1272 var showPicker = function(ev) {
|
|
|
1273 var exec = true;
|
|
|
1274 if (ev.keyCode && (ev.keyCode == 9)) {
|
|
|
1275 exec = false;
|
|
|
1276 }
|
|
|
1277 if (exec) {
|
|
|
1278 if (this._colorPicker) {
|
|
|
1279 this._colorPicker._button = oButton.value;
|
|
|
1280 }
|
|
|
1281 var menuEL = tmp.getMenu().element;
|
|
|
1282 if (Dom.getStyle(menuEL, 'visibility') == 'hidden') {
|
|
|
1283 tmp.getMenu().show();
|
|
|
1284 } else {
|
|
|
1285 tmp.getMenu().hide();
|
|
|
1286 }
|
|
|
1287 }
|
|
|
1288 YAHOO.util.Event.stopEvent(ev);
|
|
|
1289 };
|
|
|
1290 tmp.on('mousedown', showPicker, oButton, this);
|
|
|
1291 tmp.on('keydown', showPicker, oButton, this);
|
|
|
1292
|
|
|
1293 } else if ((oButton.type != 'menu') && (oButton.type != 'select')) {
|
|
|
1294 tmp.on('keypress', this._buttonClick, oButton, this);
|
|
|
1295 tmp.on('mousedown', function(ev) {
|
|
|
1296 YAHOO.util.Event.stopEvent(ev);
|
|
|
1297 this._buttonClick(ev, oButton);
|
|
|
1298 }, oButton, this);
|
|
|
1299 tmp.on('click', function(ev) {
|
|
|
1300 YAHOO.util.Event.stopEvent(ev);
|
|
|
1301 });
|
|
|
1302 } else {
|
|
|
1303 //Stop the mousedown event so we can trap the selection in the editor!
|
|
|
1304 tmp.on('mousedown', function(ev) {
|
|
|
1305 YAHOO.util.Event.stopEvent(ev);
|
|
|
1306 });
|
|
|
1307 tmp.on('click', function(ev) {
|
|
|
1308 YAHOO.util.Event.stopEvent(ev);
|
|
|
1309 });
|
|
|
1310 tmp.on('change', function(ev) {
|
|
|
1311 if (!ev.target) {
|
|
|
1312 if (!oButton.menucmd) {
|
|
|
1313 oButton.menucmd = oButton.value;
|
|
|
1314 }
|
|
|
1315 oButton.value = ev.value;
|
|
|
1316 this._buttonClick(ev, oButton);
|
|
|
1317 }
|
|
|
1318 }, this, true);
|
|
|
1319
|
|
|
1320 var self = this;
|
|
|
1321 //Hijack the mousedown event in the menu and make it fire a button click..
|
|
|
1322 tmp.on('appendTo', function() {
|
|
|
1323 var tmp = this;
|
|
|
1324 if (tmp.getMenu() && tmp.getMenu().mouseDownEvent) {
|
|
|
1325 tmp.getMenu().mouseDownEvent.subscribe(function(ev, args) {
|
|
|
1326 var oMenu = args[1];
|
|
|
1327 YAHOO.util.Event.stopEvent(args[0]);
|
|
|
1328 tmp._onMenuClick(args[0], tmp);
|
|
|
1329 if (!oButton.menucmd) {
|
|
|
1330 oButton.menucmd = oButton.value;
|
|
|
1331 }
|
|
|
1332 oButton.value = ((oMenu.value) ? oMenu.value : oMenu._oText.nodeValue);
|
|
|
1333 self._buttonClick.call(self, args[1], oButton);
|
|
|
1334 tmp._hideMenu();
|
|
|
1335 return false;
|
|
|
1336 });
|
|
|
1337 tmp.getMenu().clickEvent.subscribe(function(ev, args) {
|
|
|
1338 YAHOO.util.Event.stopEvent(args[0]);
|
|
|
1339 });
|
|
|
1340 tmp.getMenu().mouseUpEvent.subscribe(function(ev, args) {
|
|
|
1341 YAHOO.util.Event.stopEvent(args[0]);
|
|
|
1342 });
|
|
|
1343 }
|
|
|
1344 });
|
|
|
1345
|
|
|
1346 }
|
|
|
1347 } else {
|
|
|
1348 //Stop the mousedown event so we can trap the selection in the editor!
|
|
|
1349 tmp.on('mousedown', function(ev) {
|
|
|
1350 YAHOO.util.Event.stopEvent(ev);
|
|
|
1351 });
|
|
|
1352 tmp.on('click', function(ev) {
|
|
|
1353 YAHOO.util.Event.stopEvent(ev);
|
|
|
1354 });
|
|
|
1355 }
|
|
|
1356 if (this.browser.ie) {
|
|
|
1357 /*
|
|
|
1358 //Add a couple of new events for IE
|
|
|
1359 tmp.DOM_EVENTS.focusin = true;
|
|
|
1360 tmp.DOM_EVENTS.focusout = true;
|
|
|
1361
|
|
|
1362 //Stop them so we don't loose focus in the Editor
|
|
|
1363 tmp.on('focusin', function(ev) {
|
|
|
1364 YAHOO.util.Event.stopEvent(ev);
|
|
|
1365 }, oButton, this);
|
|
|
1366
|
|
|
1367 tmp.on('focusout', function(ev) {
|
|
|
1368 YAHOO.util.Event.stopEvent(ev);
|
|
|
1369 }, oButton, this);
|
|
|
1370 tmp.on('click', function(ev) {
|
|
|
1371 YAHOO.util.Event.stopEvent(ev);
|
|
|
1372 }, oButton, this);
|
|
|
1373 */
|
|
|
1374 }
|
|
|
1375 if (this.browser.webkit) {
|
|
|
1376 //This will keep the document from gaining focus and the editor from loosing it..
|
|
|
1377 //Forcefully remove the focus calls in button!
|
|
|
1378 tmp.hasFocus = function() {
|
|
|
1379 return true;
|
|
|
1380 };
|
|
|
1381 }
|
|
|
1382 this._buttonList[this._buttonList.length] = tmp;
|
|
|
1383 if ((oButton.type == 'menu') || (oButton.type == 'split') || (oButton.type == 'select')) {
|
|
|
1384 if (Lang.isArray(oButton.menu)) {
|
|
|
1385 var menu = tmp.getMenu();
|
|
|
1386 if (menu && menu.renderEvent) {
|
|
|
1387 menu.renderEvent.subscribe(this._addMenuClasses, tmp);
|
|
|
1388 if (oButton.renderer) {
|
|
|
1389 menu.renderEvent.subscribe(oButton.renderer, tmp);
|
|
|
1390 }
|
|
|
1391 }
|
|
|
1392 }
|
|
|
1393 }
|
|
|
1394 }
|
|
|
1395 return oButton;
|
|
|
1396 },
|
|
|
1397 /**
|
|
|
1398 * @method addSeparator
|
|
|
1399 * @description Add a new button separator to the toolbar.
|
|
|
1400 * @param {HTMLElement} cont Optional HTML element to insert this button into.
|
|
|
1401 * @param {HTMLElement} after Optional HTML element to insert this button after in the DOM.
|
|
|
1402 */
|
|
|
1403 addSeparator: function(cont, after) {
|
|
|
1404 if (!this.get('element')) {
|
|
|
1405 this._queue[this._queue.length] = ['addSeparator', arguments];
|
|
|
1406 return false;
|
|
|
1407 }
|
|
|
1408 var sepCont = ((cont) ? cont : this.get('cont'));
|
|
|
1409 if (!this.get('element')) {
|
|
|
1410 this._queue[this._queue.length] = ['addSeparator', arguments];
|
|
|
1411 return false;
|
|
|
1412 }
|
|
|
1413 if (this._sepCount === null) {
|
|
|
1414 this._sepCount = 0;
|
|
|
1415 }
|
|
|
1416 if (!this._sep) {
|
|
|
1417 this._sep = document.createElement('SPAN');
|
|
|
1418 Dom.addClass(this._sep, this.CLASS_SEPARATOR);
|
|
|
1419 this._sep.innerHTML = '|';
|
|
|
1420 }
|
|
|
1421 var _sep = this._sep.cloneNode(true);
|
|
|
1422 this._sepCount++;
|
|
|
1423 Dom.addClass(_sep, this.CLASS_SEPARATOR + '-' + this._sepCount);
|
|
|
1424 if (after) {
|
|
|
1425 var nextSib = null;
|
|
|
1426 if (after.get) {
|
|
|
1427 nextSib = after.get('element').nextSibling;
|
|
|
1428 } else if (after.nextSibling) {
|
|
|
1429 nextSib = after.nextSibling;
|
|
|
1430 } else {
|
|
|
1431 nextSib = after;
|
|
|
1432 }
|
|
|
1433 if (nextSib) {
|
|
|
1434 if (nextSib == after) {
|
|
|
1435 nextSib.parentNode.appendChild(_sep);
|
|
|
1436 } else {
|
|
|
1437 nextSib.parentNode.insertBefore(_sep, nextSib);
|
|
|
1438 }
|
|
|
1439 }
|
|
|
1440 } else {
|
|
|
1441 sepCont.appendChild(_sep);
|
|
|
1442 }
|
|
|
1443 return _sep;
|
|
|
1444 },
|
|
|
1445 /**
|
|
|
1446 * @method _createColorPicker
|
|
|
1447 * @private
|
|
|
1448 * @description Creates the core DOM reference to the color picker menu item.
|
|
|
1449 * @param {String} id the id of the toolbar to prefix this DOM container with.
|
|
|
1450 */
|
|
|
1451 _createColorPicker: function(id) {
|
|
|
1452 if (Dom.get(id + '_colors')) {
|
|
|
1453 Dom.get(id + '_colors').parentNode.removeChild(Dom.get(id + '_colors'));
|
|
|
1454 }
|
|
|
1455 var picker = document.createElement('div');
|
|
|
1456 picker.className = 'yui-toolbar-colors';
|
|
|
1457 picker.id = id + '_colors';
|
|
|
1458 picker.style.display = 'none';
|
|
|
1459 Event.on(window, 'load', function() {
|
|
|
1460 document.body.appendChild(picker);
|
|
|
1461 }, this, true);
|
|
|
1462
|
|
|
1463 this._colorPicker = picker;
|
|
|
1464
|
|
|
1465 var html = '';
|
|
|
1466 for (var i in this._colorData) {
|
|
|
1467 if (Lang.hasOwnProperty(this._colorData, i)) {
|
|
|
1468 html += '<a style="background-color: ' + i + '" href="#">' + i.replace('#', '') + '</a>';
|
|
|
1469 }
|
|
|
1470 }
|
|
|
1471 html += '<span><em>X</em><strong></strong></span>';
|
|
|
1472 window.setTimeout(function() {
|
|
|
1473 picker.innerHTML = html;
|
|
|
1474 }, 0);
|
|
|
1475
|
|
|
1476 Event.on(picker, 'mouseover', function(ev) {
|
|
|
1477 var picker = this._colorPicker;
|
|
|
1478 var em = picker.getElementsByTagName('em')[0];
|
|
|
1479 var strong = picker.getElementsByTagName('strong')[0];
|
|
|
1480 var tar = Event.getTarget(ev);
|
|
|
1481 if (tar.tagName.toLowerCase() == 'a') {
|
|
|
1482 em.style.backgroundColor = tar.style.backgroundColor;
|
|
|
1483 strong.innerHTML = this._colorData['#' + tar.innerHTML] + '<br>' + tar.innerHTML;
|
|
|
1484 }
|
|
|
1485 }, this, true);
|
|
|
1486 Event.on(picker, 'focus', function(ev) {
|
|
|
1487 Event.stopEvent(ev);
|
|
|
1488 });
|
|
|
1489 Event.on(picker, 'click', function(ev) {
|
|
|
1490 Event.stopEvent(ev);
|
|
|
1491 });
|
|
|
1492 Event.on(picker, 'mousedown', function(ev) {
|
|
|
1493 Event.stopEvent(ev);
|
|
|
1494 var tar = Event.getTarget(ev);
|
|
|
1495 if (tar.tagName.toLowerCase() == 'a') {
|
|
|
1496 var retVal = this.fireEvent('colorPickerClicked', { type: 'colorPickerClicked', target: this, button: this._colorPicker._button, color: tar.innerHTML, colorName: this._colorData['#' + tar.innerHTML] } );
|
|
|
1497 if (retVal !== false) {
|
|
|
1498 var info = {
|
|
|
1499 color: tar.innerHTML,
|
|
|
1500 colorName: this._colorData['#' + tar.innerHTML],
|
|
|
1501 value: this._colorPicker._button
|
|
|
1502 };
|
|
|
1503
|
|
|
1504 this.fireEvent('buttonClick', { type: 'buttonClick', target: this.get('element'), button: info });
|
|
|
1505 }
|
|
|
1506 this.getButtonByValue(this._colorPicker._button).getMenu().hide();
|
|
|
1507 }
|
|
|
1508 }, this, true);
|
|
|
1509 },
|
|
|
1510 /**
|
|
|
1511 * @method _resetColorPicker
|
|
|
1512 * @private
|
|
|
1513 * @description Clears the currently selected color or mouseover color in the color picker.
|
|
|
1514 */
|
|
|
1515 _resetColorPicker: function() {
|
|
|
1516 var em = this._colorPicker.getElementsByTagName('em')[0];
|
|
|
1517 var strong = this._colorPicker.getElementsByTagName('strong')[0];
|
|
|
1518 em.style.backgroundColor = 'transparent';
|
|
|
1519 strong.innerHTML = '';
|
|
|
1520 },
|
|
|
1521 /**
|
|
|
1522 * @method _makeColorButton
|
|
|
1523 * @private
|
|
|
1524 * @description Called to turn a "color" button into a menu button with an Overlay for the menu.
|
|
|
1525 * @param {Object} _oButton <a href="YAHOO.widget.ToolbarButton.html">YAHOO.widget.ToolbarButton</a> reference
|
|
|
1526 */
|
|
|
1527 _makeColorButton: function(_oButton) {
|
|
|
1528 if (!this._colorPicker) {
|
|
|
1529 this._createColorPicker(this.get('id'));
|
|
|
1530 }
|
|
|
1531 _oButton.type = 'color';
|
|
|
1532 _oButton.menu = new YAHOO.widget.Overlay(this.get('id') + '_' + _oButton.value + '_menu', { visible: false, position: 'absolute', iframe: true });
|
|
|
1533 _oButton.menu.setBody('');
|
|
|
1534 _oButton.menu.render(this.get('cont'));
|
|
|
1535 Dom.addClass(_oButton.menu.element, 'yui-button-menu');
|
|
|
1536 Dom.addClass(_oButton.menu.element, 'yui-color-button-menu');
|
|
|
1537 _oButton.menu.beforeShowEvent.subscribe(function() {
|
|
|
1538 _oButton.menu.cfg.setProperty('zindex', 5); //Re Adjust the overlays zIndex.. not sure why.
|
|
|
1539 _oButton.menu.cfg.setProperty('context', [this.getButtonById(_oButton.id).get('element'), 'tl', 'bl']); //Re Adjust the overlay.. not sure why.
|
|
|
1540 //Move the DOM reference of the color picker to the Overlay that we are about to show.
|
|
|
1541 this._resetColorPicker();
|
|
|
1542 var _p = this._colorPicker;
|
|
|
1543 if (_p.parentNode) {
|
|
|
1544 _p.parentNode.removeChild(_p);
|
|
|
1545 }
|
|
|
1546 _oButton.menu.setBody('');
|
|
|
1547 _oButton.menu.appendToBody(_p);
|
|
|
1548 this._colorPicker.style.display = 'block';
|
|
|
1549 }, this, true);
|
|
|
1550 return _oButton;
|
|
|
1551 },
|
|
|
1552 /**
|
|
|
1553 * @private
|
|
|
1554 * @method _makeSpinButton
|
|
|
1555 * @description Create a button similar to an OS Spin button.. It has an up/down arrow combo to scroll through a range of int values.
|
|
|
1556 * @param {Object} _button <a href="YAHOO.widget.ToolbarButton.html">YAHOO.widget.ToolbarButton</a> reference
|
|
|
1557 * @param {Object} oButton Object literal containing the buttons initial config
|
|
|
1558 */
|
|
|
1559 _makeSpinButton: function(_button, oButton) {
|
|
|
1560 _button.addClass(this.CLASS_PREFIX + '-spinbutton');
|
|
|
1561 var self = this,
|
|
|
1562 _par = _button._button.parentNode.parentNode, //parentNode of Button Element for appending child
|
|
|
1563 range = oButton.range,
|
|
|
1564 _b1 = document.createElement('a'),
|
|
|
1565 _b2 = document.createElement('a');
|
|
|
1566 _b1.href = '#';
|
|
|
1567 _b2.href = '#';
|
|
|
1568 _b1.tabIndex = '-1';
|
|
|
1569 _b2.tabIndex = '-1';
|
|
|
1570
|
|
|
1571 //Setup the up and down arrows
|
|
|
1572 _b1.className = 'up';
|
|
|
1573 _b1.title = this.STR_SPIN_UP;
|
|
|
1574 _b1.innerHTML = this.STR_SPIN_UP;
|
|
|
1575 _b2.className = 'down';
|
|
|
1576 _b2.title = this.STR_SPIN_DOWN;
|
|
|
1577 _b2.innerHTML = this.STR_SPIN_DOWN;
|
|
|
1578
|
|
|
1579 //Append them to the container
|
|
|
1580 _par.appendChild(_b1);
|
|
|
1581 _par.appendChild(_b2);
|
|
|
1582
|
|
|
1583 var label = YAHOO.lang.substitute(this.STR_SPIN_LABEL, { VALUE: _button.get('label') });
|
|
|
1584 _button.set('title', label);
|
|
|
1585
|
|
|
1586 var cleanVal = function(value) {
|
|
|
1587 value = ((value < range[0]) ? range[0] : value);
|
|
|
1588 value = ((value > range[1]) ? range[1] : value);
|
|
|
1589 return value;
|
|
|
1590 };
|
|
|
1591
|
|
|
1592 var br = this.browser;
|
|
|
1593 var tbar = false;
|
|
|
1594 var strLabel = this.STR_SPIN_LABEL;
|
|
|
1595 if (this._titlebar && this._titlebar.firstChild) {
|
|
|
1596 tbar = this._titlebar.firstChild;
|
|
|
1597 }
|
|
|
1598
|
|
|
1599 var _intUp = function(ev) {
|
|
|
1600 YAHOO.util.Event.stopEvent(ev);
|
|
|
1601 if (!_button.get('disabled') && (ev.keyCode != 9)) {
|
|
|
1602 var value = parseInt(_button.get('label'), 10);
|
|
|
1603 value++;
|
|
|
1604 value = cleanVal(value);
|
|
|
1605 _button.set('label', ''+value);
|
|
|
1606 var label = YAHOO.lang.substitute(strLabel, { VALUE: _button.get('label') });
|
|
|
1607 _button.set('title', label);
|
|
|
1608 if (!br.webkit && tbar) {
|
|
|
1609 //tbar.focus(); //We do this for accessibility, on the re-focus of the element, a screen reader will re-read the title that was just changed
|
|
|
1610 //_button.focus();
|
|
|
1611 }
|
|
|
1612 self._buttonClick(ev, oButton);
|
|
|
1613 }
|
|
|
1614 };
|
|
|
1615
|
|
|
1616 var _intDown = function(ev) {
|
|
|
1617 YAHOO.util.Event.stopEvent(ev);
|
|
|
1618 if (!_button.get('disabled') && (ev.keyCode != 9)) {
|
|
|
1619 var value = parseInt(_button.get('label'), 10);
|
|
|
1620 value--;
|
|
|
1621 value = cleanVal(value);
|
|
|
1622
|
|
|
1623 _button.set('label', ''+value);
|
|
|
1624 var label = YAHOO.lang.substitute(strLabel, { VALUE: _button.get('label') });
|
|
|
1625 _button.set('title', label);
|
|
|
1626 if (!br.webkit && tbar) {
|
|
|
1627 //tbar.focus(); //We do this for accessibility, on the re-focus of the element, a screen reader will re-read the title that was just changed
|
|
|
1628 //_button.focus();
|
|
|
1629 }
|
|
|
1630 self._buttonClick(ev, oButton);
|
|
|
1631 }
|
|
|
1632 };
|
|
|
1633
|
|
|
1634 var _intKeyUp = function(ev) {
|
|
|
1635 if (ev.keyCode == 38) {
|
|
|
1636 _intUp(ev);
|
|
|
1637 } else if (ev.keyCode == 40) {
|
|
|
1638 _intDown(ev);
|
|
|
1639 } else if (ev.keyCode == 107 && ev.shiftKey) { //Plus Key
|
|
|
1640 _intUp(ev);
|
|
|
1641 } else if (ev.keyCode == 109 && ev.shiftKey) { //Minus Key
|
|
|
1642 _intDown(ev);
|
|
|
1643 }
|
|
|
1644 };
|
|
|
1645
|
|
|
1646 //Handle arrow keys..
|
|
|
1647 _button.on('keydown', _intKeyUp, this, true);
|
|
|
1648
|
|
|
1649 //Listen for the click on the up button and act on it
|
|
|
1650 //Listen for the click on the down button and act on it
|
|
|
1651 Event.on(_b1, 'mousedown',function(ev) {
|
|
|
1652 Event.stopEvent(ev);
|
|
|
1653 }, this, true);
|
|
|
1654 Event.on(_b2, 'mousedown', function(ev) {
|
|
|
1655 Event.stopEvent(ev);
|
|
|
1656 }, this, true);
|
|
|
1657 Event.on(_b1, 'click', _intUp, this, true);
|
|
|
1658 Event.on(_b2, 'click', _intDown, this, true);
|
|
|
1659 },
|
|
|
1660 /**
|
|
|
1661 * @protected
|
|
|
1662 * @method _buttonClick
|
|
|
1663 * @description Click handler for all buttons in the toolbar.
|
|
|
1664 * @param {String} ev The event that was passed in.
|
|
|
1665 * @param {Object} info Object literal of information about the button that was clicked.
|
|
|
1666 */
|
|
|
1667 _buttonClick: function(ev, info) {
|
|
|
1668 var doEvent = true;
|
|
|
1669
|
|
|
1670 if (ev && ev.type == 'keypress') {
|
|
|
1671 if (ev.keyCode == 9) {
|
|
|
1672 doEvent = false;
|
|
|
1673 } else if ((ev.keyCode === 13) || (ev.keyCode === 0) || (ev.keyCode === 32)) {
|
|
|
1674 } else {
|
|
|
1675 doEvent = false;
|
|
|
1676 }
|
|
|
1677 }
|
|
|
1678
|
|
|
1679 if (doEvent) {
|
|
|
1680 var fireNextEvent = true,
|
|
|
1681 retValue = false;
|
|
|
1682
|
|
|
1683 info.isSelected = this.isSelected(info.id);
|
|
|
1684
|
|
|
1685 if (info.value) {
|
|
|
1686 retValue = this.fireEvent(info.value + 'Click', { type: info.value + 'Click', target: this.get('element'), button: info });
|
|
|
1687 if (retValue === false) {
|
|
|
1688 fireNextEvent = false;
|
|
|
1689 }
|
|
|
1690 }
|
|
|
1691
|
|
|
1692 if (info.menucmd && fireNextEvent) {
|
|
|
1693 retValue = this.fireEvent(info.menucmd + 'Click', { type: info.menucmd + 'Click', target: this.get('element'), button: info });
|
|
|
1694 if (retValue === false) {
|
|
|
1695 fireNextEvent = false;
|
|
|
1696 }
|
|
|
1697 }
|
|
|
1698 if (fireNextEvent) {
|
|
|
1699 this.fireEvent('buttonClick', { type: 'buttonClick', target: this.get('element'), button: info });
|
|
|
1700 }
|
|
|
1701
|
|
|
1702 if (info.type == 'select') {
|
|
|
1703 var button = this.getButtonById(info.id);
|
|
|
1704 if (button.buttonType == 'rich') {
|
|
|
1705 var txt = info.value;
|
|
|
1706 for (var i = 0; i < info.menu.length; i++) {
|
|
|
1707 if (info.menu[i].value == info.value) {
|
|
|
1708 txt = info.menu[i].text;
|
|
|
1709 break;
|
|
|
1710 }
|
|
|
1711 }
|
|
|
1712 button.set('label', '<span class="yui-toolbar-' + info.menucmd + '-' + (info.value).replace(/ /g, '-').toLowerCase() + '">' + txt + '</span>');
|
|
|
1713 var _items = button.getMenu().getItems();
|
|
|
1714 for (var m = 0; m < _items.length; m++) {
|
|
|
1715 if (_items[m].value.toLowerCase() == info.value.toLowerCase()) {
|
|
|
1716 _items[m].cfg.setProperty('checked', true);
|
|
|
1717 } else {
|
|
|
1718 _items[m].cfg.setProperty('checked', false);
|
|
|
1719 }
|
|
|
1720 }
|
|
|
1721 }
|
|
|
1722 }
|
|
|
1723 if (ev) {
|
|
|
1724 Event.stopEvent(ev);
|
|
|
1725 }
|
|
|
1726 }
|
|
|
1727 },
|
|
|
1728 /**
|
|
|
1729 * @private
|
|
|
1730 * @property _keyNav
|
|
|
1731 * @description Flag to determine if the arrow nav listeners have been attached
|
|
|
1732 * @type Boolean
|
|
|
1733 */
|
|
|
1734 _keyNav: null,
|
|
|
1735 /**
|
|
|
1736 * @private
|
|
|
1737 * @property _navCounter
|
|
|
1738 * @description Internal counter for walking the buttons in the toolbar with the arrow keys
|
|
|
1739 * @type Number
|
|
|
1740 */
|
|
|
1741 _navCounter: null,
|
|
|
1742 /**
|
|
|
1743 * @private
|
|
|
1744 * @method _navigateButtons
|
|
|
1745 * @description Handles the navigation/focus of toolbar buttons with the Arrow Keys
|
|
|
1746 * @param {Event} ev The Key Event
|
|
|
1747 */
|
|
|
1748 _navigateButtons: function(ev) {
|
|
|
1749 switch (ev.keyCode) {
|
|
|
1750 case 37:
|
|
|
1751 case 39:
|
|
|
1752 if (ev.keyCode == 37) {
|
|
|
1753 this._navCounter--;
|
|
|
1754 } else {
|
|
|
1755 this._navCounter++;
|
|
|
1756 }
|
|
|
1757 if (this._navCounter > (this._buttonList.length - 1)) {
|
|
|
1758 this._navCounter = 0;
|
|
|
1759 }
|
|
|
1760 if (this._navCounter < 0) {
|
|
|
1761 this._navCounter = (this._buttonList.length - 1);
|
|
|
1762 }
|
|
|
1763 if (this._buttonList[this._navCounter]) {
|
|
|
1764 var el = this._buttonList[this._navCounter].get('element');
|
|
|
1765 if (this.browser.ie) {
|
|
|
1766 el = this._buttonList[this._navCounter].get('element').getElementsByTagName('a')[0];
|
|
|
1767 }
|
|
|
1768 if (this._buttonList[this._navCounter].get('disabled')) {
|
|
|
1769 this._navigateButtons(ev);
|
|
|
1770 } else {
|
|
|
1771 el.focus();
|
|
|
1772 }
|
|
|
1773 }
|
|
|
1774 break;
|
|
|
1775 }
|
|
|
1776 },
|
|
|
1777 /**
|
|
|
1778 * @private
|
|
|
1779 * @method _handleFocus
|
|
|
1780 * @description Sets up the listeners for the arrow key navigation
|
|
|
1781 */
|
|
|
1782 _handleFocus: function() {
|
|
|
1783 if (!this._keyNav) {
|
|
|
1784 var ev = 'keypress';
|
|
|
1785 if (this.browser.ie) {
|
|
|
1786 ev = 'keydown';
|
|
|
1787 }
|
|
|
1788 Event.on(this.get('element'), ev, this._navigateButtons, this, true);
|
|
|
1789 this._keyNav = true;
|
|
|
1790 this._navCounter = -1;
|
|
|
1791 }
|
|
|
1792 },
|
|
|
1793 /**
|
|
|
1794 * @method getButtonById
|
|
|
1795 * @description Gets a button instance from the toolbar by is Dom id.
|
|
|
1796 * @param {String} id The Dom id to query for.
|
|
|
1797 * @return {<a href="YAHOO.widget.ToolbarButton.html">YAHOO.widget.ToolbarButton</a>}
|
|
|
1798 */
|
|
|
1799 getButtonById: function(id) {
|
|
|
1800 var len = this._buttonList.length;
|
|
|
1801 for (var i = 0; i < len; i++) {
|
|
|
1802 if (this._buttonList[i] && this._buttonList[i].get('id') == id) {
|
|
|
1803 return this._buttonList[i];
|
|
|
1804 }
|
|
|
1805 }
|
|
|
1806 return false;
|
|
|
1807 },
|
|
|
1808 /**
|
|
|
1809 * @method getButtonByValue
|
|
|
1810 * @description Gets a button instance or a menuitem instance from the toolbar by it's value.
|
|
|
1811 * @param {String} value The button value to query for.
|
|
|
1812 * @return {<a href="YAHOO.widget.ToolbarButton.html">YAHOO.widget.ToolbarButton</a> or <a href="YAHOO.widget.MenuItem.html">YAHOO.widget.MenuItem</a>}
|
|
|
1813 */
|
|
|
1814 getButtonByValue: function(value) {
|
|
|
1815 var _buttons = this.get('buttons');
|
|
|
1816 if (!_buttons) {
|
|
|
1817 return false;
|
|
|
1818 }
|
|
|
1819 var len = _buttons.length;
|
|
|
1820 for (var i = 0; i < len; i++) {
|
|
|
1821 if (_buttons[i].group !== undefined) {
|
|
|
1822 for (var m = 0; m < _buttons[i].buttons.length; m++) {
|
|
|
1823 if ((_buttons[i].buttons[m].value == value) || (_buttons[i].buttons[m].menucmd == value)) {
|
|
|
1824 return this.getButtonById(_buttons[i].buttons[m].id);
|
|
|
1825 }
|
|
|
1826 if (_buttons[i].buttons[m].menu) { //Menu Button, loop through the values
|
|
|
1827 for (var s = 0; s < _buttons[i].buttons[m].menu.length; s++) {
|
|
|
1828 if (_buttons[i].buttons[m].menu[s].value == value) {
|
|
|
1829 return this.getButtonById(_buttons[i].buttons[m].id);
|
|
|
1830 }
|
|
|
1831 }
|
|
|
1832 }
|
|
|
1833 }
|
|
|
1834 } else {
|
|
|
1835 if ((_buttons[i].value == value) || (_buttons[i].menucmd == value)) {
|
|
|
1836 return this.getButtonById(_buttons[i].id);
|
|
|
1837 }
|
|
|
1838 if (_buttons[i].menu) { //Menu Button, loop through the values
|
|
|
1839 for (var j = 0; j < _buttons[i].menu.length; j++) {
|
|
|
1840 if (_buttons[i].menu[j].value == value) {
|
|
|
1841 return this.getButtonById(_buttons[i].id);
|
|
|
1842 }
|
|
|
1843 }
|
|
|
1844 }
|
|
|
1845 }
|
|
|
1846 }
|
|
|
1847 return false;
|
|
|
1848 },
|
|
|
1849 /**
|
|
|
1850 * @method getButtonByIndex
|
|
|
1851 * @description Gets a button instance from the toolbar by is index in _buttonList.
|
|
|
1852 * @param {Number} index The index of the button in _buttonList.
|
|
|
1853 * @return {<a href="YAHOO.widget.ToolbarButton.html">YAHOO.widget.ToolbarButton</a>}
|
|
|
1854 */
|
|
|
1855 getButtonByIndex: function(index) {
|
|
|
1856 if (this._buttonList[index]) {
|
|
|
1857 return this._buttonList[index];
|
|
|
1858 } else {
|
|
|
1859 return false;
|
|
|
1860 }
|
|
|
1861 },
|
|
|
1862 /**
|
|
|
1863 * @method getButtons
|
|
|
1864 * @description Returns an array of buttons in the current toolbar
|
|
|
1865 * @return {Array}
|
|
|
1866 */
|
|
|
1867 getButtons: function() {
|
|
|
1868 return this._buttonList;
|
|
|
1869 },
|
|
|
1870 /**
|
|
|
1871 * @method disableButton
|
|
|
1872 * @description Disables a button in the toolbar.
|
|
|
1873 * @param {String/Number} id Disable a button by it's id, index or value.
|
|
|
1874 * @return {Boolean}
|
|
|
1875 */
|
|
|
1876 disableButton: function(id) {
|
|
|
1877 var button = getButton.call(this, id);
|
|
|
1878 if (button) {
|
|
|
1879 button.set('disabled', true);
|
|
|
1880 } else {
|
|
|
1881 return false;
|
|
|
1882 }
|
|
|
1883 },
|
|
|
1884 /**
|
|
|
1885 * @method enableButton
|
|
|
1886 * @description Enables a button in the toolbar.
|
|
|
1887 * @param {String/Number} id Enable a button by it's id, index or value.
|
|
|
1888 * @return {Boolean}
|
|
|
1889 */
|
|
|
1890 enableButton: function(id) {
|
|
|
1891 if (this.get('disabled')) {
|
|
|
1892 return false;
|
|
|
1893 }
|
|
|
1894 var button = getButton.call(this, id);
|
|
|
1895 if (button) {
|
|
|
1896 if (button.get('disabled')) {
|
|
|
1897 button.set('disabled', false);
|
|
|
1898 }
|
|
|
1899 } else {
|
|
|
1900 return false;
|
|
|
1901 }
|
|
|
1902 },
|
|
|
1903 /**
|
|
|
1904 * @method isSelected
|
|
|
1905 * @description Tells if a button is selected or not.
|
|
|
1906 * @param {String/Number} id A button by it's id, index or value.
|
|
|
1907 * @return {Boolean}
|
|
|
1908 */
|
|
|
1909 isSelected: function(id) {
|
|
|
1910 var button = getButton.call(this, id);
|
|
|
1911 if (button) {
|
|
|
1912 return button._selected;
|
|
|
1913 }
|
|
|
1914 return false;
|
|
|
1915 },
|
|
|
1916 /**
|
|
|
1917 * @method selectButton
|
|
|
1918 * @description Selects a button in the toolbar.
|
|
|
1919 * @param {String/Number} id Select a button by it's id, index or value.
|
|
|
1920 * @param {String} value If this is a Menu Button, check this item in the menu
|
|
|
1921 * @return {Boolean}
|
|
|
1922 */
|
|
|
1923 selectButton: function(id, value) {
|
|
|
1924 var button = getButton.call(this, id);
|
|
|
1925 if (button) {
|
|
|
1926 button.addClass('yui-button-selected');
|
|
|
1927 button.addClass('yui-button-' + button.get('value') + '-selected');
|
|
|
1928 button._selected = true;
|
|
|
1929 if (value) {
|
|
|
1930 if (button.buttonType == 'rich') {
|
|
|
1931 var _items = button.getMenu().getItems();
|
|
|
1932 for (var m = 0; m < _items.length; m++) {
|
|
|
1933 if (_items[m].value == value) {
|
|
|
1934 _items[m].cfg.setProperty('checked', true);
|
|
|
1935 button.set('label', '<span class="yui-toolbar-' + button.get('value') + '-' + (value).replace(/ /g, '-').toLowerCase() + '">' + _items[m]._oText.nodeValue + '</span>');
|
|
|
1936 } else {
|
|
|
1937 _items[m].cfg.setProperty('checked', false);
|
|
|
1938 }
|
|
|
1939 }
|
|
|
1940 }
|
|
|
1941 }
|
|
|
1942 } else {
|
|
|
1943 return false;
|
|
|
1944 }
|
|
|
1945 },
|
|
|
1946 /**
|
|
|
1947 * @method deselectButton
|
|
|
1948 * @description Deselects a button in the toolbar.
|
|
|
1949 * @param {String/Number} id Deselect a button by it's id, index or value.
|
|
|
1950 * @return {Boolean}
|
|
|
1951 */
|
|
|
1952 deselectButton: function(id) {
|
|
|
1953 var button = getButton.call(this, id);
|
|
|
1954 if (button) {
|
|
|
1955 button.removeClass('yui-button-selected');
|
|
|
1956 button.removeClass('yui-button-' + button.get('value') + '-selected');
|
|
|
1957 button.removeClass('yui-button-hover');
|
|
|
1958 button._selected = false;
|
|
|
1959 } else {
|
|
|
1960 return false;
|
|
|
1961 }
|
|
|
1962 },
|
|
|
1963 /**
|
|
|
1964 * @method deselectAllButtons
|
|
|
1965 * @description Deselects all buttons in the toolbar.
|
|
|
1966 * @return {Boolean}
|
|
|
1967 */
|
|
|
1968 deselectAllButtons: function() {
|
|
|
1969 var len = this._buttonList.length;
|
|
|
1970 for (var i = 0; i < len; i++) {
|
|
|
1971 this.deselectButton(this._buttonList[i]);
|
|
|
1972 }
|
|
|
1973 },
|
|
|
1974 /**
|
|
|
1975 * @method disableAllButtons
|
|
|
1976 * @description Disables all buttons in the toolbar.
|
|
|
1977 * @return {Boolean}
|
|
|
1978 */
|
|
|
1979 disableAllButtons: function() {
|
|
|
1980 if (this.get('disabled')) {
|
|
|
1981 return false;
|
|
|
1982 }
|
|
|
1983 var len = this._buttonList.length;
|
|
|
1984 for (var i = 0; i < len; i++) {
|
|
|
1985 this.disableButton(this._buttonList[i]);
|
|
|
1986 }
|
|
|
1987 },
|
|
|
1988 /**
|
|
|
1989 * @method enableAllButtons
|
|
|
1990 * @description Enables all buttons in the toolbar.
|
|
|
1991 * @return {Boolean}
|
|
|
1992 */
|
|
|
1993 enableAllButtons: function() {
|
|
|
1994 if (this.get('disabled')) {
|
|
|
1995 return false;
|
|
|
1996 }
|
|
|
1997 var len = this._buttonList.length;
|
|
|
1998 for (var i = 0; i < len; i++) {
|
|
|
1999 this.enableButton(this._buttonList[i]);
|
|
|
2000 }
|
|
|
2001 },
|
|
|
2002 /**
|
|
|
2003 * @method resetAllButtons
|
|
|
2004 * @description Resets all buttons to their initial state.
|
|
|
2005 * @param {Object} _ex Except these buttons
|
|
|
2006 * @return {Boolean}
|
|
|
2007 */
|
|
|
2008 resetAllButtons: function(_ex) {
|
|
|
2009 if (!Lang.isObject(_ex)) {
|
|
|
2010 _ex = {};
|
|
|
2011 }
|
|
|
2012 if (this.get('disabled') || !this._buttonList) {
|
|
|
2013 return false;
|
|
|
2014 }
|
|
|
2015 var len = this._buttonList.length;
|
|
|
2016 for (var i = 0; i < len; i++) {
|
|
|
2017 var _button = this._buttonList[i];
|
|
|
2018 if (_button) {
|
|
|
2019 var disabled = _button._configs.disabled._initialConfig.value;
|
|
|
2020 if (_ex[_button.get('id')]) {
|
|
|
2021 this.enableButton(_button);
|
|
|
2022 this.selectButton(_button);
|
|
|
2023 } else {
|
|
|
2024 if (disabled) {
|
|
|
2025 this.disableButton(_button);
|
|
|
2026 } else {
|
|
|
2027 this.enableButton(_button);
|
|
|
2028 }
|
|
|
2029 this.deselectButton(_button);
|
|
|
2030 }
|
|
|
2031 }
|
|
|
2032 }
|
|
|
2033 },
|
|
|
2034 /**
|
|
|
2035 * @method destroyButton
|
|
|
2036 * @description Destroy a button in the toolbar.
|
|
|
2037 * @param {String/Number} id Destroy a button by it's id or index.
|
|
|
2038 * @return {Boolean}
|
|
|
2039 */
|
|
|
2040 destroyButton: function(id) {
|
|
|
2041 var button = getButton.call(this, id);
|
|
|
2042 if (button) {
|
|
|
2043 var thisID = button.get('id'),
|
|
|
2044 new_list = [], i = 0,
|
|
|
2045 len = this._buttonList.length;
|
|
|
2046
|
|
|
2047 button.destroy();
|
|
|
2048
|
|
|
2049 for (i = 0; i < len; i++) {
|
|
|
2050 if (this._buttonList[i].get('id') != thisID) {
|
|
|
2051 new_list[new_list.length]= this._buttonList[i];
|
|
|
2052 }
|
|
|
2053 }
|
|
|
2054
|
|
|
2055 this._buttonList = new_list;
|
|
|
2056 } else {
|
|
|
2057 return false;
|
|
|
2058 }
|
|
|
2059 },
|
|
|
2060 /**
|
|
|
2061 * @method destroy
|
|
|
2062 * @description Destroys the toolbar, all of it's elements and objects.
|
|
|
2063 * @return {Boolean}
|
|
|
2064 */
|
|
|
2065 destroy: function() {
|
|
|
2066 var len = this._configuredButtons.length, j, i;
|
|
|
2067 for(b = 0; b < len; b++) {
|
|
|
2068 this.destroyButton(this._configuredButtons[b]);
|
|
|
2069 }
|
|
|
2070
|
|
|
2071 this._configuredButtons = null;
|
|
|
2072
|
|
|
2073 this.get('element').innerHTML = '';
|
|
|
2074 this.get('element').className = '';
|
|
|
2075 //Brutal Object Destroy
|
|
|
2076 for (i in this) {
|
|
|
2077 if (Lang.hasOwnProperty(this, i)) {
|
|
|
2078 this[i] = null;
|
|
|
2079 }
|
|
|
2080 }
|
|
|
2081 return true;
|
|
|
2082 },
|
|
|
2083 /**
|
|
|
2084 * @method collapse
|
|
|
2085 * @description Programatically collapse the toolbar.
|
|
|
2086 * @param {Boolean} collapse True to collapse, false to expand.
|
|
|
2087 */
|
|
|
2088 collapse: function(collapse) {
|
|
|
2089 var el = Dom.getElementsByClassName('collapse', 'span', this._titlebar);
|
|
|
2090 if (collapse === false) {
|
|
|
2091 Dom.removeClass(this.get('cont').parentNode, 'yui-toolbar-container-collapsed');
|
|
|
2092 if (el[0]) {
|
|
|
2093 Dom.removeClass(el[0], 'collapsed');
|
|
|
2094 el[0].title = this.STR_COLLAPSE;
|
|
|
2095 }
|
|
|
2096 this.fireEvent('toolbarExpanded', { type: 'toolbarExpanded', target: this });
|
|
|
2097 } else {
|
|
|
2098 if (el[0]) {
|
|
|
2099 Dom.addClass(el[0], 'collapsed');
|
|
|
2100 el[0].title = this.STR_EXPAND;
|
|
|
2101 }
|
|
|
2102 Dom.addClass(this.get('cont').parentNode, 'yui-toolbar-container-collapsed');
|
|
|
2103 this.fireEvent('toolbarCollapsed', { type: 'toolbarCollapsed', target: this });
|
|
|
2104 }
|
|
|
2105 },
|
|
|
2106 /**
|
|
|
2107 * @method toString
|
|
|
2108 * @description Returns a string representing the toolbar.
|
|
|
2109 * @return {String}
|
|
|
2110 */
|
|
|
2111 toString: function() {
|
|
|
2112 return 'Toolbar (#' + this.get('element').id + ') with ' + this._buttonList.length + ' buttons.';
|
|
|
2113 }
|
|
|
2114 });
|
|
|
2115 /**
|
|
|
2116 * @event buttonClick
|
|
|
2117 * @param {Object} o The object passed to this handler is the button config used to create the button.
|
|
|
2118 * @description Fires when any botton receives a click event. Passes back a single object representing the buttons config object. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
|
|
|
2119 * @type YAHOO.util.CustomEvent
|
|
|
2120 */
|
|
|
2121 /**
|
|
|
2122 * @event valueClick
|
|
|
2123 * @param {Object} o The object passed to this handler is the button config used to create the button.
|
|
|
2124 * @description This is a special dynamic event that is created and dispatched based on the value property
|
|
|
2125 * of the button config. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
|
|
|
2126 * Example:
|
|
|
2127 * <code><pre>
|
|
|
2128 * buttons : [
|
|
|
2129 * { type: 'button', value: 'test', value: 'testButton' }
|
|
|
2130 * ]</pre>
|
|
|
2131 * </code>
|
|
|
2132 * With the valueClick event you could subscribe to this buttons click event with this:
|
|
|
2133 * tbar.in('testButtonClick', function() { alert('test button clicked'); })
|
|
|
2134 * @type YAHOO.util.CustomEvent
|
|
|
2135 */
|
|
|
2136 /**
|
|
|
2137 * @event toolbarExpanded
|
|
|
2138 * @description Fires when the toolbar is expanded via the collapse button. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
|
|
|
2139 * @type YAHOO.util.CustomEvent
|
|
|
2140 */
|
|
|
2141 /**
|
|
|
2142 * @event toolbarCollapsed
|
|
|
2143 * @description Fires when the toolbar is collapsed via the collapse button. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
|
|
|
2144 * @type YAHOO.util.CustomEvent
|
|
|
2145 */
|
|
|
2146 })();
|
|
|
2147 /**
|
|
|
2148 * @module editor
|
|
|
2149 * @description <p>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.</p>
|
|
|
2150 * @namespace YAHOO.widget
|
|
|
2151 * @requires yahoo, dom, element, event, toolbar
|
|
|
2152 * @optional animation, container_core, resize, dragdrop
|
|
|
2153 */
|
|
|
2154
|
|
|
2155 (function() {
|
|
|
2156 var Dom = YAHOO.util.Dom,
|
|
|
2157 Event = YAHOO.util.Event,
|
|
|
2158 Lang = YAHOO.lang,
|
|
|
2159 Toolbar = YAHOO.widget.Toolbar;
|
|
|
2160
|
|
|
2161 /**
|
|
|
2162 * 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.
|
|
|
2163 * @constructor
|
|
|
2164 * @class SimpleEditor
|
|
|
2165 * @extends YAHOO.util.Element
|
|
|
2166 * @param {String/HTMLElement} el The textarea element to turn into an editor.
|
|
|
2167 * @param {Object} attrs Object liternal containing configuration parameters.
|
|
|
2168 */
|
|
|
2169
|
|
|
2170 YAHOO.widget.SimpleEditor = function(el, attrs) {
|
|
|
2171
|
|
|
2172 var o = {};
|
|
|
2173 if (Lang.isObject(el) && (!el.tagName) && !attrs) {
|
|
|
2174 Lang.augmentObject(o, el); //Break the config reference
|
|
|
2175 el = document.createElement('textarea');
|
|
|
2176 this.DOMReady = true;
|
|
|
2177 if (o.container) {
|
|
|
2178 var c = Dom.get(o.container);
|
|
|
2179 c.appendChild(el);
|
|
|
2180 } else {
|
|
|
2181 document.body.appendChild(el);
|
|
|
2182 }
|
|
|
2183 } else {
|
|
|
2184 if (attrs) {
|
|
|
2185 Lang.augmentObject(o, attrs); //Break the config reference
|
|
|
2186 }
|
|
|
2187 }
|
|
|
2188
|
|
|
2189 var oConfig = {
|
|
|
2190 element: null,
|
|
|
2191 attributes: o
|
|
|
2192 }, id = null;
|
|
|
2193
|
|
|
2194 if (Lang.isString(el)) {
|
|
|
2195 id = el;
|
|
|
2196 } else {
|
|
|
2197 if (oConfig.attributes.id) {
|
|
|
2198 id = oConfig.attributes.id;
|
|
|
2199 } else {
|
|
|
2200 this.DOMReady = true;
|
|
|
2201 id = Dom.generateId(el);
|
|
|
2202 }
|
|
|
2203 }
|
|
|
2204 oConfig.element = el;
|
|
|
2205
|
|
|
2206 var element_cont = document.createElement('DIV');
|
|
|
2207 oConfig.attributes.element_cont = new YAHOO.util.Element(element_cont, {
|
|
|
2208 id: id + '_container'
|
|
|
2209 });
|
|
|
2210 var div = document.createElement('div');
|
|
|
2211 Dom.addClass(div, 'first-child');
|
|
|
2212 oConfig.attributes.element_cont.appendChild(div);
|
|
|
2213
|
|
|
2214 if (!oConfig.attributes.toolbar_cont) {
|
|
|
2215 oConfig.attributes.toolbar_cont = document.createElement('DIV');
|
|
|
2216 oConfig.attributes.toolbar_cont.id = id + '_toolbar';
|
|
|
2217 div.appendChild(oConfig.attributes.toolbar_cont);
|
|
|
2218 }
|
|
|
2219 var editorWrapper = document.createElement('DIV');
|
|
|
2220 div.appendChild(editorWrapper);
|
|
|
2221 oConfig.attributes.editor_wrapper = editorWrapper;
|
|
|
2222
|
|
|
2223 YAHOO.widget.SimpleEditor.superclass.constructor.call(this, oConfig.element, oConfig.attributes);
|
|
|
2224 };
|
|
|
2225
|
|
|
2226
|
|
|
2227 YAHOO.extend(YAHOO.widget.SimpleEditor, YAHOO.util.Element, {
|
|
|
2228 /**
|
|
|
2229 * @private
|
|
|
2230 * @property _resizeConfig
|
|
|
2231 * @description The default config for the Resize Utility
|
|
|
2232 */
|
|
|
2233 _resizeConfig: {
|
|
|
2234 handles: ['br'],
|
|
|
2235 autoRatio: true,
|
|
|
2236 status: true,
|
|
|
2237 proxy: true,
|
|
|
2238 useShim: true,
|
|
|
2239 setSize: false
|
|
|
2240 },
|
|
|
2241 /**
|
|
|
2242 * @private
|
|
|
2243 * @method _setupResize
|
|
|
2244 * @description Creates the Resize instance and binds its events.
|
|
|
2245 */
|
|
|
2246 _setupResize: function() {
|
|
|
2247 if (!YAHOO.util.DD || !YAHOO.util.Resize) { return false; }
|
|
|
2248 if (this.get('resize')) {
|
|
|
2249 var config = {};
|
|
|
2250 Lang.augmentObject(config, this._resizeConfig); //Break the config reference
|
|
|
2251 this.resize = new YAHOO.util.Resize(this.get('element_cont').get('element'), config);
|
|
|
2252 this.resize.on('resize', function(args) {
|
|
|
2253 var anim = this.get('animate');
|
|
|
2254 this.set('animate', false);
|
|
|
2255 this.set('width', args.width + 'px');
|
|
|
2256 var h = args.height,
|
|
|
2257 th = (this.toolbar.get('element').clientHeight + 2),
|
|
|
2258 dh = 0;
|
|
|
2259 if (this.dompath) {
|
|
|
2260 dh = (this.dompath.clientHeight + 1); //It has a 1px top border..
|
|
|
2261 }
|
|
|
2262 var newH = (h - th - dh);
|
|
|
2263 this.set('height', newH + 'px');
|
|
|
2264 this.get('element_cont').setStyle('height', '');
|
|
|
2265 this.set('animate', anim);
|
|
|
2266 }, this, true);
|
|
|
2267 }
|
|
|
2268 },
|
|
|
2269 /**
|
|
|
2270 * @property resize
|
|
|
2271 * @description A reference to the Resize object
|
|
|
2272 * @type YAHOO.util.Resize
|
|
|
2273 */
|
|
|
2274 resize: null,
|
|
|
2275 /**
|
|
|
2276 * @private
|
|
|
2277 * @method _setupDD
|
|
|
2278 * @description Sets up the DD instance used from the 'drag' config option.
|
|
|
2279 */
|
|
|
2280 _setupDD: function() {
|
|
|
2281 if (!YAHOO.util.DD) { return false; }
|
|
|
2282 if (this.get('drag')) {
|
|
|
2283 var d = this.get('drag'),
|
|
|
2284 dd = YAHOO.util.DD;
|
|
|
2285 if (d === 'proxy') {
|
|
|
2286 dd = YAHOO.util.DDProxy;
|
|
|
2287 }
|
|
|
2288
|
|
|
2289 this.dd = new dd(this.get('element_cont').get('element'));
|
|
|
2290 this.toolbar.addClass('draggable');
|
|
|
2291 this.dd.setHandleElId(this.toolbar._titlebar);
|
|
|
2292 }
|
|
|
2293 },
|
|
|
2294 /**
|
|
|
2295 * @property dd
|
|
|
2296 * @description A reference to the DragDrop object.
|
|
|
2297 * @type YAHOO.util.DD/YAHOO.util.DDProxy
|
|
|
2298 */
|
|
|
2299 dd: null,
|
|
|
2300 /**
|
|
|
2301 * @private
|
|
|
2302 * @property _lastCommand
|
|
|
2303 * @description A cache of the last execCommand (used for Undo/Redo so they don't mark an undo level)
|
|
|
2304 * @type String
|
|
|
2305 */
|
|
|
2306 _lastCommand: null,
|
|
|
2307 _undoNodeChange: function() {},
|
|
|
2308 _storeUndo: function() {},
|
|
|
2309 /**
|
|
|
2310 * @private
|
|
|
2311 * @method _checkKey
|
|
|
2312 * @description Checks a keyMap entry against a key event
|
|
|
2313 * @param {Object} k The _keyMap object
|
|
|
2314 * @param {Event} e The Mouse Event
|
|
|
2315 * @return {Boolean}
|
|
|
2316 */
|
|
|
2317 _checkKey: function(k, e) {
|
|
|
2318 var ret = false;
|
|
|
2319 if ((e.keyCode === k.key)) {
|
|
|
2320 if (k.mods && (k.mods.length > 0)) {
|
|
|
2321 var val = 0;
|
|
|
2322 for (var i = 0; i < k.mods.length; i++) {
|
|
|
2323 if (this.browser.mac) {
|
|
|
2324 if (k.mods[i] == 'ctrl') {
|
|
|
2325 k.mods[i] = 'meta';
|
|
|
2326 }
|
|
|
2327 }
|
|
|
2328 if (e[k.mods[i] + 'Key'] === true) {
|
|
|
2329 val++;
|
|
|
2330 }
|
|
|
2331 }
|
|
|
2332 if (val === k.mods.length) {
|
|
|
2333 ret = true;
|
|
|
2334 }
|
|
|
2335 } else {
|
|
|
2336 ret = true;
|
|
|
2337 }
|
|
|
2338 }
|
|
|
2339 return ret;
|
|
|
2340 },
|
|
|
2341 /**
|
|
|
2342 * @private
|
|
|
2343 * @property _keyMap
|
|
|
2344 * @description Named key maps for various actions in the Editor. Example: <code>CLOSE_WINDOW: { key: 87, mods: ['shift', 'ctrl'] }</code>.
|
|
|
2345 * This entry shows that when key 87 (W) is found with the modifiers of shift and control, the window will close. You can customize this object to tweak keyboard shortcuts.
|
|
|
2346 * @type {Object/Mixed}
|
|
|
2347 */
|
|
|
2348 _keyMap: {
|
|
|
2349 SELECT_ALL: {
|
|
|
2350 key: 65, //A key
|
|
|
2351 mods: ['ctrl']
|
|
|
2352 },
|
|
|
2353 CLOSE_WINDOW: {
|
|
|
2354 key: 87, //W key
|
|
|
2355 mods: ['shift', 'ctrl']
|
|
|
2356 },
|
|
|
2357 FOCUS_TOOLBAR: {
|
|
|
2358 key: 27,
|
|
|
2359 mods: ['shift']
|
|
|
2360 },
|
|
|
2361 FOCUS_AFTER: {
|
|
|
2362 key: 27
|
|
|
2363 },
|
|
|
2364 FONT_SIZE_UP: {
|
|
|
2365 key: 38,
|
|
|
2366 mods: ['shift', 'ctrl']
|
|
|
2367 },
|
|
|
2368 FONT_SIZE_DOWN: {
|
|
|
2369 key: 40,
|
|
|
2370 mods: ['shift', 'ctrl']
|
|
|
2371 },
|
|
|
2372 CREATE_LINK: {
|
|
|
2373 key: 76,
|
|
|
2374 mods: ['shift', 'ctrl']
|
|
|
2375 },
|
|
|
2376 BOLD: {
|
|
|
2377 key: 66,
|
|
|
2378 mods: ['shift', 'ctrl']
|
|
|
2379 },
|
|
|
2380 ITALIC: {
|
|
|
2381 key: 73,
|
|
|
2382 mods: ['shift', 'ctrl']
|
|
|
2383 },
|
|
|
2384 UNDERLINE: {
|
|
|
2385 key: 85,
|
|
|
2386 mods: ['shift', 'ctrl']
|
|
|
2387 },
|
|
|
2388 UNDO: {
|
|
|
2389 key: 90,
|
|
|
2390 mods: ['ctrl']
|
|
|
2391 },
|
|
|
2392 REDO: {
|
|
|
2393 key: 90,
|
|
|
2394 mods: ['shift', 'ctrl']
|
|
|
2395 },
|
|
|
2396 JUSTIFY_LEFT: {
|
|
|
2397 key: 219,
|
|
|
2398 mods: ['shift', 'ctrl']
|
|
|
2399 },
|
|
|
2400 JUSTIFY_CENTER: {
|
|
|
2401 key: 220,
|
|
|
2402 mods: ['shift', 'ctrl']
|
|
|
2403 },
|
|
|
2404 JUSTIFY_RIGHT: {
|
|
|
2405 key: 221,
|
|
|
2406 mods: ['shift', 'ctrl']
|
|
|
2407 }
|
|
|
2408 },
|
|
|
2409 /**
|
|
|
2410 * @private
|
|
|
2411 * @method _cleanClassName
|
|
|
2412 * @description Makes a useable classname from dynamic data, by dropping it to lowercase and replacing spaces with -'s.
|
|
|
2413 * @param {String} str The classname to clean up
|
|
|
2414 * @return {String}
|
|
|
2415 */
|
|
|
2416 _cleanClassName: function(str) {
|
|
|
2417 return str.replace(/ /g, '-').toLowerCase();
|
|
|
2418 },
|
|
|
2419 /**
|
|
|
2420 * @property _textarea
|
|
|
2421 * @description Flag to determine if we are using a textarea or an HTML Node.
|
|
|
2422 * @type Boolean
|
|
|
2423 */
|
|
|
2424 _textarea: null,
|
|
|
2425 /**
|
|
|
2426 * @property _docType
|
|
|
2427 * @description The DOCTYPE to use in the editable container.
|
|
|
2428 * @type String
|
|
|
2429 */
|
|
|
2430 _docType: '<!DOCTYPE HTML PUBLIC "-/'+'/W3C/'+'/DTD HTML 4.01/'+'/EN" "http:/'+'/www.w3.org/TR/html4/strict.dtd">',
|
|
|
2431 /**
|
|
|
2432 * @property editorDirty
|
|
|
2433 * @description This flag will be set when certain things in the Editor happen. It is to be used by the developer to check to see if content has changed.
|
|
|
2434 * @type Boolean
|
|
|
2435 */
|
|
|
2436 editorDirty: null,
|
|
|
2437 /**
|
|
|
2438 * @property _defaultCSS
|
|
|
2439 * @description The default CSS used in the config for 'css'. This way you can add to the config like this: { css: YAHOO.widget.SimpleEditor.prototype._defaultCSS + 'ADD MYY CSS HERE' }
|
|
|
2440 * @type String
|
|
|
2441 */
|
|
|
2442 _defaultCSS: 'html { height: 95%; } body { padding: 7px; background-color: #fff; font: 13px/1.22 arial,helvetica,clean,sans-serif;*font-size:small;*font:x-small; } a, a:visited, a:hover { color: blue !important; text-decoration: underline !important; cursor: text !important; } .warning-localfile { border-bottom: 1px dashed red !important; } .yui-busy { cursor: wait !important; } img.selected { border: 2px dotted #808080; } img { cursor: pointer !important; border: none; } body.ptags.webkit div.yui-wk-p { margin: 11px 0; } body.ptags.webkit div.yui-wk-div { margin: 0; }',
|
|
|
2443 /**
|
|
|
2444 * @property _defaultToolbar
|
|
|
2445 * @private
|
|
|
2446 * @description Default toolbar config.
|
|
|
2447 * @type Object
|
|
|
2448 */
|
|
|
2449 _defaultToolbar: null,
|
|
|
2450 /**
|
|
|
2451 * @property _lastButton
|
|
|
2452 * @private
|
|
|
2453 * @description The last button pressed, so we don't disable it.
|
|
|
2454 * @type Object
|
|
|
2455 */
|
|
|
2456 _lastButton: null,
|
|
|
2457 /**
|
|
|
2458 * @property _baseHREF
|
|
|
2459 * @private
|
|
|
2460 * @description The base location of the editable page (this page) so that relative paths for image work.
|
|
|
2461 * @type String
|
|
|
2462 */
|
|
|
2463 _baseHREF: function() {
|
|
|
2464 var href = document.location.href;
|
|
|
2465 if (href.indexOf('?') !== -1) { //Remove the query string
|
|
|
2466 href = href.substring(0, href.indexOf('?'));
|
|
|
2467 }
|
|
|
2468 href = href.substring(0, href.lastIndexOf('/')) + '/';
|
|
|
2469 return href;
|
|
|
2470 }(),
|
|
|
2471 /**
|
|
|
2472 * @property _lastImage
|
|
|
2473 * @private
|
|
|
2474 * @description Safari reference for the last image selected (for styling as selected).
|
|
|
2475 * @type HTMLElement
|
|
|
2476 */
|
|
|
2477 _lastImage: null,
|
|
|
2478 /**
|
|
|
2479 * @property _blankImageLoaded
|
|
|
2480 * @private
|
|
|
2481 * @description Don't load the blank image more than once..
|
|
|
2482 * @type Boolean
|
|
|
2483 */
|
|
|
2484 _blankImageLoaded: null,
|
|
|
2485 /**
|
|
|
2486 * @property _fixNodesTimer
|
|
|
2487 * @private
|
|
|
2488 * @description Holder for the fixNodes timer
|
|
|
2489 * @type Date
|
|
|
2490 */
|
|
|
2491 _fixNodesTimer: null,
|
|
|
2492 /**
|
|
|
2493 * @property _nodeChangeTimer
|
|
|
2494 * @private
|
|
|
2495 * @description Holds a reference to the nodeChange setTimeout call
|
|
|
2496 * @type Number
|
|
|
2497 */
|
|
|
2498 _nodeChangeTimer: null,
|
|
|
2499 /**
|
|
|
2500 * @property _nodeChangeDelayTimer
|
|
|
2501 * @private
|
|
|
2502 * @description Holds a reference to the nodeChangeDelay setTimeout call
|
|
|
2503 * @type Number
|
|
|
2504 */
|
|
|
2505 _nodeChangeDelayTimer: null,
|
|
|
2506 /**
|
|
|
2507 * @property _lastNodeChangeEvent
|
|
|
2508 * @private
|
|
|
2509 * @description Flag to determine the last event that fired a node change
|
|
|
2510 * @type Event
|
|
|
2511 */
|
|
|
2512 _lastNodeChangeEvent: null,
|
|
|
2513 /**
|
|
|
2514 * @property _lastNodeChange
|
|
|
2515 * @private
|
|
|
2516 * @description Flag to determine when the last node change was fired
|
|
|
2517 * @type Date
|
|
|
2518 */
|
|
|
2519 _lastNodeChange: 0,
|
|
|
2520 /**
|
|
|
2521 * @property _rendered
|
|
|
2522 * @private
|
|
|
2523 * @description Flag to determine if editor has been rendered or not
|
|
|
2524 * @type Boolean
|
|
|
2525 */
|
|
|
2526 _rendered: null,
|
|
|
2527 /**
|
|
|
2528 * @property DOMReady
|
|
|
2529 * @private
|
|
|
2530 * @description Flag to determine if DOM is ready or not
|
|
|
2531 * @type Boolean
|
|
|
2532 */
|
|
|
2533 DOMReady: null,
|
|
|
2534 /**
|
|
|
2535 * @property _selection
|
|
|
2536 * @private
|
|
|
2537 * @description Holder for caching iframe selections
|
|
|
2538 * @type Object
|
|
|
2539 */
|
|
|
2540 _selection: null,
|
|
|
2541 /**
|
|
|
2542 * @property _mask
|
|
|
2543 * @private
|
|
|
2544 * @description DOM Element holder for the editor Mask when disabled
|
|
|
2545 * @type Object
|
|
|
2546 */
|
|
|
2547 _mask: null,
|
|
|
2548 /**
|
|
|
2549 * @property _showingHiddenElements
|
|
|
2550 * @private
|
|
|
2551 * @description Status of the hidden elements button
|
|
|
2552 * @type Boolean
|
|
|
2553 */
|
|
|
2554 _showingHiddenElements: null,
|
|
|
2555 /**
|
|
|
2556 * @property currentWindow
|
|
|
2557 * @description A reference to the currently open EditorWindow
|
|
|
2558 * @type Object
|
|
|
2559 */
|
|
|
2560 currentWindow: null,
|
|
|
2561 /**
|
|
|
2562 * @property currentEvent
|
|
|
2563 * @description A reference to the current editor event
|
|
|
2564 * @type Event
|
|
|
2565 */
|
|
|
2566 currentEvent: null,
|
|
|
2567 /**
|
|
|
2568 * @property operaEvent
|
|
|
2569 * @private
|
|
|
2570 * @description setTimeout holder for Opera and Image DoubleClick event..
|
|
|
2571 * @type Object
|
|
|
2572 */
|
|
|
2573 operaEvent: null,
|
|
|
2574 /**
|
|
|
2575 * @property currentFont
|
|
|
2576 * @description A reference to the last font selected from the Toolbar
|
|
|
2577 * @type HTMLElement
|
|
|
2578 */
|
|
|
2579 currentFont: null,
|
|
|
2580 /**
|
|
|
2581 * @property currentElement
|
|
|
2582 * @description A reference to the current working element in the editor
|
|
|
2583 * @type Array
|
|
|
2584 */
|
|
|
2585 currentElement: null,
|
|
|
2586 /**
|
|
|
2587 * @property dompath
|
|
|
2588 * @description A reference to the dompath container for writing the current working dom path to.
|
|
|
2589 * @type HTMLElement
|
|
|
2590 */
|
|
|
2591 dompath: null,
|
|
|
2592 /**
|
|
|
2593 * @property beforeElement
|
|
|
2594 * @description A reference to the H2 placed before the editor for Accessibilty.
|
|
|
2595 * @type HTMLElement
|
|
|
2596 */
|
|
|
2597 beforeElement: null,
|
|
|
2598 /**
|
|
|
2599 * @property afterElement
|
|
|
2600 * @description A reference to the H2 placed after the editor for Accessibilty.
|
|
|
2601 * @type HTMLElement
|
|
|
2602 */
|
|
|
2603 afterElement: null,
|
|
|
2604 /**
|
|
|
2605 * @property invalidHTML
|
|
|
2606 * @description Contains a list of HTML elements that are invalid inside the editor. They will be removed when they are found. If you set the value of a key to "{ keepContents: true }", then the element will be replaced with a yui-non span to be filtered out when cleanHTML is called. The only tag that is ignored here is the span tag as it will force the Editor into a loop and freeze the browser. However.. all of these tags will be removed in the cleanHTML routine.
|
|
|
2607 * @type Object
|
|
|
2608 */
|
|
|
2609 invalidHTML: {
|
|
|
2610 form: true,
|
|
|
2611 input: true,
|
|
|
2612 button: true,
|
|
|
2613 select: true,
|
|
|
2614 link: true,
|
|
|
2615 html: true,
|
|
|
2616 body: true,
|
|
|
2617 iframe: true,
|
|
|
2618 script: true,
|
|
|
2619 style: true,
|
|
|
2620 textarea: true
|
|
|
2621 },
|
|
|
2622 /**
|
|
|
2623 * @property toolbar
|
|
|
2624 * @description Local property containing the <a href="YAHOO.widget.Toolbar.html">YAHOO.widget.Toolbar</a> instance
|
|
|
2625 * @type <a href="YAHOO.widget.Toolbar.html">YAHOO.widget.Toolbar</a>
|
|
|
2626 */
|
|
|
2627 toolbar: null,
|
|
|
2628 /**
|
|
|
2629 * @private
|
|
|
2630 * @property _contentTimer
|
|
|
2631 * @description setTimeout holder for documentReady check
|
|
|
2632 */
|
|
|
2633 _contentTimer: null,
|
|
|
2634 /**
|
|
|
2635 * @private
|
|
|
2636 * @property _contentTimerMax
|
|
|
2637 * @description The number of times the loaded content should be checked before giving up. Default: 500
|
|
|
2638 */
|
|
|
2639 _contentTimerMax: 500,
|
|
|
2640 /**
|
|
|
2641 * @private
|
|
|
2642 * @property _contentTimerCounter
|
|
|
2643 * @description Counter to check the number of times the body is polled for before giving up
|
|
|
2644 * @type Number
|
|
|
2645 */
|
|
|
2646 _contentTimerCounter: 0,
|
|
|
2647 /**
|
|
|
2648 * @private
|
|
|
2649 * @property _disabled
|
|
|
2650 * @description The Toolbar items that should be disabled if there is no selection present in the editor.
|
|
|
2651 * @type Array
|
|
|
2652 */
|
|
|
2653 _disabled: [ 'createlink', 'fontname', 'fontsize', 'forecolor', 'backcolor' ],
|
|
|
2654 /**
|
|
|
2655 * @private
|
|
|
2656 * @property _alwaysDisabled
|
|
|
2657 * @description The Toolbar items that should ALWAYS be disabled event if there is a selection present in the editor.
|
|
|
2658 * @type Object
|
|
|
2659 */
|
|
|
2660 _alwaysDisabled: { undo: true, redo: true },
|
|
|
2661 /**
|
|
|
2662 * @private
|
|
|
2663 * @property _alwaysEnabled
|
|
|
2664 * @description The Toolbar items that should ALWAYS be enabled event if there isn't a selection present in the editor.
|
|
|
2665 * @type Object
|
|
|
2666 */
|
|
|
2667 _alwaysEnabled: { },
|
|
|
2668 /**
|
|
|
2669 * @private
|
|
|
2670 * @property _semantic
|
|
|
2671 * @description The Toolbar commands that we should attempt to make tags out of instead of using styles.
|
|
|
2672 * @type Object
|
|
|
2673 */
|
|
|
2674 _semantic: { 'bold': true, 'italic' : true, 'underline' : true },
|
|
|
2675 /**
|
|
|
2676 * @private
|
|
|
2677 * @property _tag2cmd
|
|
|
2678 * @description A tag map of HTML tags to convert to the different types of commands so we can select the proper toolbar button.
|
|
|
2679 * @type Object
|
|
|
2680 */
|
|
|
2681 _tag2cmd: {
|
|
|
2682 'b': 'bold',
|
|
|
2683 'strong': 'bold',
|
|
|
2684 'i': 'italic',
|
|
|
2685 'em': 'italic',
|
|
|
2686 'u': 'underline',
|
|
|
2687 'sup': 'superscript',
|
|
|
2688 'sub': 'subscript',
|
|
|
2689 'img': 'insertimage',
|
|
|
2690 'a' : 'createlink',
|
|
|
2691 'ul' : 'insertunorderedlist',
|
|
|
2692 'ol' : 'insertorderedlist'
|
|
|
2693 },
|
|
|
2694
|
|
|
2695 /**
|
|
|
2696 * @private _createIframe
|
|
|
2697 * @description Creates the DOM and YUI Element for the iFrame editor area.
|
|
|
2698 * @param {String} id The string ID to prefix the iframe with
|
|
|
2699 * @return {Object} iFrame object
|
|
|
2700 */
|
|
|
2701 _createIframe: function() {
|
|
|
2702 var ifrmDom = document.createElement('iframe');
|
|
|
2703 ifrmDom.id = this.get('id') + '_editor';
|
|
|
2704 var config = {
|
|
|
2705 border: '0',
|
|
|
2706 frameBorder: '0',
|
|
|
2707 marginWidth: '0',
|
|
|
2708 marginHeight: '0',
|
|
|
2709 leftMargin: '0',
|
|
|
2710 topMargin: '0',
|
|
|
2711 allowTransparency: 'true',
|
|
|
2712 width: '100%'
|
|
|
2713 };
|
|
|
2714 if (this.get('autoHeight')) {
|
|
|
2715 config.scrolling = 'no';
|
|
|
2716 }
|
|
|
2717 for (var i in config) {
|
|
|
2718 if (Lang.hasOwnProperty(config, i)) {
|
|
|
2719 ifrmDom.setAttribute(i, config[i]);
|
|
|
2720 }
|
|
|
2721 }
|
|
|
2722 var isrc = 'javascript:;';
|
|
|
2723 if (this.browser.ie) {
|
|
|
2724 //isrc = 'about:blank';
|
|
|
2725 //TODO - Check this, I have changed it before..
|
|
|
2726 isrc = 'javascript:false;';
|
|
|
2727 }
|
|
|
2728 ifrmDom.setAttribute('src', isrc);
|
|
|
2729 var ifrm = new YAHOO.util.Element(ifrmDom);
|
|
|
2730 ifrm.setStyle('visibility', 'hidden');
|
|
|
2731 return ifrm;
|
|
|
2732 },
|
|
|
2733 /**
|
|
|
2734 * @private _isElement
|
|
|
2735 * @description Checks to see if an Element reference is a valid one and has a certain tag type
|
|
|
2736 * @param {HTMLElement} el The element to check
|
|
|
2737 * @param {String} tag The tag that the element needs to be
|
|
|
2738 * @return {Boolean}
|
|
|
2739 */
|
|
|
2740 _isElement: function(el, tag) {
|
|
|
2741 if (el && el.tagName && (el.tagName.toLowerCase() == tag)) {
|
|
|
2742 return true;
|
|
|
2743 }
|
|
|
2744 if (el && el.getAttribute && (el.getAttribute('tag') == tag)) {
|
|
|
2745 return true;
|
|
|
2746 }
|
|
|
2747 return false;
|
|
|
2748 },
|
|
|
2749 /**
|
|
|
2750 * @private _hasParent
|
|
|
2751 * @description Checks to see if an Element reference or one of it's parents is a valid one and has a certain tag type
|
|
|
2752 * @param {HTMLElement} el The element to check
|
|
|
2753 * @param {String} tag The tag that the element needs to be
|
|
|
2754 * @return HTMLElement
|
|
|
2755 */
|
|
|
2756 _hasParent: function(el, tag) {
|
|
|
2757 if (!el || !el.parentNode) {
|
|
|
2758 return false;
|
|
|
2759 }
|
|
|
2760
|
|
|
2761 while (el.parentNode) {
|
|
|
2762 if (this._isElement(el, tag)) {
|
|
|
2763 return el;
|
|
|
2764 }
|
|
|
2765 if (el.parentNode) {
|
|
|
2766 el = el.parentNode;
|
|
|
2767 } else {
|
|
|
2768 return false;
|
|
|
2769 }
|
|
|
2770 }
|
|
|
2771 return false;
|
|
|
2772 },
|
|
|
2773 /**
|
|
|
2774 * @private
|
|
|
2775 * @method _getDoc
|
|
|
2776 * @description Get the Document of the IFRAME
|
|
|
2777 * @return {Object}
|
|
|
2778 */
|
|
|
2779 _getDoc: function() {
|
|
|
2780 var value = false;
|
|
|
2781 try {
|
|
|
2782 if (this.get('iframe').get('element').contentWindow.document) {
|
|
|
2783 value = this.get('iframe').get('element').contentWindow.document;
|
|
|
2784 return value;
|
|
|
2785 }
|
|
|
2786 } catch (e) {
|
|
|
2787 return false;
|
|
|
2788 }
|
|
|
2789 },
|
|
|
2790 /**
|
|
|
2791 * @private
|
|
|
2792 * @method _getWindow
|
|
|
2793 * @description Get the Window of the IFRAME
|
|
|
2794 * @return {Object}
|
|
|
2795 */
|
|
|
2796 _getWindow: function() {
|
|
|
2797 return this.get('iframe').get('element').contentWindow;
|
|
|
2798 },
|
|
|
2799 /**
|
|
|
2800 * @method focus
|
|
|
2801 * @description Attempt to set the focus of the iframes window.
|
|
|
2802 */
|
|
|
2803 focus: function() {
|
|
|
2804 this._getWindow().focus();
|
|
|
2805 },
|
|
|
2806 /**
|
|
|
2807 * @private
|
|
|
2808 * @depreciated - This should not be used, moved to this.focus();
|
|
|
2809 * @method _focusWindow
|
|
|
2810 * @description Attempt to set the focus of the iframes window.
|
|
|
2811 */
|
|
|
2812 _focusWindow: function() {
|
|
|
2813 this.focus();
|
|
|
2814 },
|
|
|
2815 /**
|
|
|
2816 * @private
|
|
|
2817 * @method _hasSelection
|
|
|
2818 * @description Determines if there is a selection in the editor document.
|
|
|
2819 * @return {Boolean}
|
|
|
2820 */
|
|
|
2821 _hasSelection: function() {
|
|
|
2822 var sel = this._getSelection();
|
|
|
2823 var range = this._getRange();
|
|
|
2824 var hasSel = false;
|
|
|
2825
|
|
|
2826 if (!sel || !range) {
|
|
|
2827 return hasSel;
|
|
|
2828 }
|
|
|
2829
|
|
|
2830 //Internet Explorer
|
|
|
2831 if (this.browser.ie || this.browser.opera) {
|
|
|
2832 if (range.text) {
|
|
|
2833 hasSel = true;
|
|
|
2834 }
|
|
|
2835 if (range.html) {
|
|
|
2836 hasSel = true;
|
|
|
2837 }
|
|
|
2838 } else {
|
|
|
2839 if (this.browser.webkit) {
|
|
|
2840 if (sel+'' !== '') {
|
|
|
2841 hasSel = true;
|
|
|
2842 }
|
|
|
2843 } else {
|
|
|
2844 if (sel && (sel.toString() !== '') && (sel !== undefined)) {
|
|
|
2845 hasSel = true;
|
|
|
2846 }
|
|
|
2847 }
|
|
|
2848 }
|
|
|
2849 return hasSel;
|
|
|
2850 },
|
|
|
2851 /**
|
|
|
2852 * @private
|
|
|
2853 * @method _getSelection
|
|
|
2854 * @description Handles the different selection objects across the A-Grade list.
|
|
|
2855 * @return {Object} Selection Object
|
|
|
2856 */
|
|
|
2857 _getSelection: function() {
|
|
|
2858 var _sel = null;
|
|
|
2859 if (this._getDoc() && this._getWindow()) {
|
|
|
2860 if (this._getDoc().selection) {
|
|
|
2861 _sel = this._getDoc().selection;
|
|
|
2862 } else {
|
|
|
2863 _sel = this._getWindow().getSelection();
|
|
|
2864 }
|
|
|
2865 //Handle Safari's lack of Selection Object
|
|
|
2866 if (this.browser.webkit) {
|
|
|
2867 if (_sel.baseNode) {
|
|
|
2868 this._selection = {};
|
|
|
2869 this._selection.baseNode = _sel.baseNode;
|
|
|
2870 this._selection.baseOffset = _sel.baseOffset;
|
|
|
2871 this._selection.extentNode = _sel.extentNode;
|
|
|
2872 this._selection.extentOffset = _sel.extentOffset;
|
|
|
2873 } else if (this._selection !== null) {
|
|
|
2874 _sel = this._getWindow().getSelection();
|
|
|
2875 _sel.setBaseAndExtent(
|
|
|
2876 this._selection.baseNode,
|
|
|
2877 this._selection.baseOffset,
|
|
|
2878 this._selection.extentNode,
|
|
|
2879 this._selection.extentOffset);
|
|
|
2880 this._selection = null;
|
|
|
2881 }
|
|
|
2882 }
|
|
|
2883 }
|
|
|
2884 return _sel;
|
|
|
2885 },
|
|
|
2886 /**
|
|
|
2887 * @private
|
|
|
2888 * @method _selectNode
|
|
|
2889 * @description Places the highlight around a given node
|
|
|
2890 * @param {HTMLElement} node The node to select
|
|
|
2891 */
|
|
|
2892 _selectNode: function(node, collapse) {
|
|
|
2893 if (!node) {
|
|
|
2894 return false;
|
|
|
2895 }
|
|
|
2896 var sel = this._getSelection(),
|
|
|
2897 range = null;
|
|
|
2898
|
|
|
2899 if (this.browser.ie) {
|
|
|
2900 try { //IE freaks out here sometimes..
|
|
|
2901 range = this._getDoc().body.createTextRange();
|
|
|
2902 range.moveToElementText(node);
|
|
|
2903 range.select();
|
|
|
2904 } catch (e) {
|
|
|
2905 }
|
|
|
2906 } else if (this.browser.webkit) {
|
|
|
2907 if (collapse) {
|
|
|
2908 sel.setBaseAndExtent(node, 1, node, node.innerText.length);
|
|
|
2909 } else {
|
|
|
2910 sel.setBaseAndExtent(node, 0, node, node.innerText.length);
|
|
|
2911 }
|
|
|
2912 } else if (this.browser.opera) {
|
|
|
2913 sel = this._getWindow().getSelection();
|
|
|
2914 range = this._getDoc().createRange();
|
|
|
2915 range.selectNode(node);
|
|
|
2916 sel.removeAllRanges();
|
|
|
2917 sel.addRange(range);
|
|
|
2918 } else {
|
|
|
2919 range = this._getDoc().createRange();
|
|
|
2920 range.selectNodeContents(node);
|
|
|
2921 sel.removeAllRanges();
|
|
|
2922 sel.addRange(range);
|
|
|
2923 }
|
|
|
2924 //TODO - Check Performance
|
|
|
2925 this.nodeChange();
|
|
|
2926 },
|
|
|
2927 /**
|
|
|
2928 * @private
|
|
|
2929 * @method _getRange
|
|
|
2930 * @description Handles the different range objects across the A-Grade list.
|
|
|
2931 * @return {Object} Range Object
|
|
|
2932 */
|
|
|
2933 _getRange: function() {
|
|
|
2934 var sel = this._getSelection();
|
|
|
2935
|
|
|
2936 if (sel === null) {
|
|
|
2937 return null;
|
|
|
2938 }
|
|
|
2939
|
|
|
2940 if (this.browser.webkit && !sel.getRangeAt) {
|
|
|
2941 var _range = this._getDoc().createRange();
|
|
|
2942 try {
|
|
|
2943 _range.setStart(sel.anchorNode, sel.anchorOffset);
|
|
|
2944 _range.setEnd(sel.focusNode, sel.focusOffset);
|
|
|
2945 } catch (e) {
|
|
|
2946 _range = this._getWindow().getSelection()+'';
|
|
|
2947 }
|
|
|
2948 return _range;
|
|
|
2949 }
|
|
|
2950
|
|
|
2951 if (this.browser.ie || this.browser.opera) {
|
|
|
2952 try {
|
|
|
2953 return sel.createRange();
|
|
|
2954 } catch (e2) {
|
|
|
2955 return null;
|
|
|
2956 }
|
|
|
2957 }
|
|
|
2958
|
|
|
2959 if (sel.rangeCount > 0) {
|
|
|
2960 return sel.getRangeAt(0);
|
|
|
2961 }
|
|
|
2962 return null;
|
|
|
2963 },
|
|
|
2964 /**
|
|
|
2965 * @private
|
|
|
2966 * @method _setDesignMode
|
|
|
2967 * @description Sets the designMode property of the iFrame document's body.
|
|
|
2968 * @param {String} state This should be either on or off
|
|
|
2969 */
|
|
|
2970 _setDesignMode: function(state) {
|
|
|
2971 if (this.get('setDesignMode')) {
|
|
|
2972 try {
|
|
|
2973 this._getDoc().designMode = ((state.toLowerCase() == 'off') ? 'off' : 'on');
|
|
|
2974 } catch(e) { }
|
|
|
2975 }
|
|
|
2976 },
|
|
|
2977 /**
|
|
|
2978 * @private
|
|
|
2979 * @method _toggleDesignMode
|
|
|
2980 * @description Toggles the designMode property of the iFrame document on and off.
|
|
|
2981 * @return {String} The state that it was set to.
|
|
|
2982 */
|
|
|
2983 _toggleDesignMode: function() {
|
|
|
2984 var _dMode = this._getDoc().designMode,
|
|
|
2985 _state = ((_dMode.toLowerCase() == 'on') ? 'off' : 'on');
|
|
|
2986 this._setDesignMode(_state);
|
|
|
2987 return _state;
|
|
|
2988 },
|
|
|
2989 /**
|
|
|
2990 * @private
|
|
|
2991 * @property _focused
|
|
|
2992 * @description Holder for trapping focus/blur state and prevent double events
|
|
|
2993 * @type Boolean
|
|
|
2994 */
|
|
|
2995 _focused: null,
|
|
|
2996 /**
|
|
|
2997 * @private
|
|
|
2998 * @method _handleFocus
|
|
|
2999 * @description Handles the focus of the iframe. Note, this is window focus event, not an Editor focus event.
|
|
|
3000 * @param {Event} e The DOM Event
|
|
|
3001 */
|
|
|
3002 _handleFocus: function(e) {
|
|
|
3003 if (!this._focused) {
|
|
|
3004 this._focused = true;
|
|
|
3005 this.fireEvent('editorWindowFocus', { type: 'editorWindowFocus', target: this });
|
|
|
3006 }
|
|
|
3007 },
|
|
|
3008 /**
|
|
|
3009 * @private
|
|
|
3010 * @method _handleBlur
|
|
|
3011 * @description Handles the blur of the iframe. Note, this is window blur event, not an Editor blur event.
|
|
|
3012 * @param {Event} e The DOM Event
|
|
|
3013 */
|
|
|
3014 _handleBlur: function(e) {
|
|
|
3015 if (this._focused) {
|
|
|
3016 this._focused = false;
|
|
|
3017 this.fireEvent('editorWindowBlur', { type: 'editorWindowBlur', target: this });
|
|
|
3018 }
|
|
|
3019 },
|
|
|
3020 /**
|
|
|
3021 * @private
|
|
|
3022 * @method _initEditorEvents
|
|
|
3023 * @description This method sets up the listeners on the Editors document.
|
|
|
3024 */
|
|
|
3025 _initEditorEvents: function() {
|
|
|
3026 //Setup Listeners on iFrame
|
|
|
3027 var doc = this._getDoc(),
|
|
|
3028 win = this._getWindow();
|
|
|
3029
|
|
|
3030 Event.on(doc, 'mouseup', this._handleMouseUp, this, true);
|
|
|
3031 Event.on(doc, 'mousedown', this._handleMouseDown, this, true);
|
|
|
3032 Event.on(doc, 'click', this._handleClick, this, true);
|
|
|
3033 Event.on(doc, 'dblclick', this._handleDoubleClick, this, true);
|
|
|
3034 Event.on(doc, 'keypress', this._handleKeyPress, this, true);
|
|
|
3035 Event.on(doc, 'keyup', this._handleKeyUp, this, true);
|
|
|
3036 Event.on(doc, 'keydown', this._handleKeyDown, this, true);
|
|
|
3037 /* TODO -- Everyone but Opera works here..
|
|
|
3038 Event.on(doc, 'paste', function() {
|
|
|
3039 }, this, true);
|
|
|
3040 */
|
|
|
3041
|
|
|
3042 //Focus and blur..
|
|
|
3043 Event.on(win, 'focus', this._handleFocus, this, true);
|
|
|
3044 Event.on(win, 'blur', this._handleBlur, this, true);
|
|
|
3045 },
|
|
|
3046 /**
|
|
|
3047 * @private
|
|
|
3048 * @method _removeEditorEvents
|
|
|
3049 * @description This method removes the listeners on the Editors document (for disabling).
|
|
|
3050 */
|
|
|
3051 _removeEditorEvents: function() {
|
|
|
3052 //Remove Listeners on iFrame
|
|
|
3053 var doc = this._getDoc(),
|
|
|
3054 win = this._getWindow();
|
|
|
3055
|
|
|
3056 Event.removeListener(doc, 'mouseup', this._handleMouseUp, this, true);
|
|
|
3057 Event.removeListener(doc, 'mousedown', this._handleMouseDown, this, true);
|
|
|
3058 Event.removeListener(doc, 'click', this._handleClick, this, true);
|
|
|
3059 Event.removeListener(doc, 'dblclick', this._handleDoubleClick, this, true);
|
|
|
3060 Event.removeListener(doc, 'keypress', this._handleKeyPress, this, true);
|
|
|
3061 Event.removeListener(doc, 'keyup', this._handleKeyUp, this, true);
|
|
|
3062 Event.removeListener(doc, 'keydown', this._handleKeyDown, this, true);
|
|
|
3063
|
|
|
3064 //Focus and blur..
|
|
|
3065 Event.removeListener(win, 'focus', this._handleFocus, this, true);
|
|
|
3066 Event.removeListener(win, 'blur', this._handleBlur, this, true);
|
|
|
3067 },
|
|
|
3068 _fixWebkitDivs: function() {
|
|
|
3069 if (this.browser.webkit) {
|
|
|
3070 var divs = this._getDoc().body.getElementsByTagName('div');
|
|
|
3071 Dom.addClass(divs, 'yui-wk-div');
|
|
|
3072 }
|
|
|
3073 },
|
|
|
3074 /**
|
|
|
3075 * @private
|
|
|
3076 * @method _initEditor
|
|
|
3077 * @param {Boolean} raw Don't add events.
|
|
|
3078 * @description This method is fired from _checkLoaded when the document is ready. It turns on designMode and set's up the listeners.
|
|
|
3079 */
|
|
|
3080 _initEditor: function(raw) {
|
|
|
3081 if (this._editorInit) {
|
|
|
3082 return;
|
|
|
3083 }
|
|
|
3084 this._editorInit = true;
|
|
|
3085 if (this.browser.ie) {
|
|
|
3086 this._getDoc().body.style.margin = '0';
|
|
|
3087 }
|
|
|
3088 if (!this.get('disabled')) {
|
|
|
3089 this._setDesignMode('on');
|
|
|
3090 this._contentTimerCounter = 0;
|
|
|
3091 }
|
|
|
3092 if (!this._getDoc().body) {
|
|
|
3093 this._contentTimerCounter = 0;
|
|
|
3094 this._editorInit = false;
|
|
|
3095 this._checkLoaded();
|
|
|
3096 return false;
|
|
|
3097 }
|
|
|
3098
|
|
|
3099 if (!raw) {
|
|
|
3100 this.toolbar.on('buttonClick', this._handleToolbarClick, this, true);
|
|
|
3101 }
|
|
|
3102 if (!this.get('disabled')) {
|
|
|
3103 this._initEditorEvents();
|
|
|
3104 this.toolbar.set('disabled', false);
|
|
|
3105 }
|
|
|
3106
|
|
|
3107 if (raw) {
|
|
|
3108 this.fireEvent('editorContentReloaded', { type: 'editorreloaded', target: this });
|
|
|
3109 } else {
|
|
|
3110 this.fireEvent('editorContentLoaded', { type: 'editorLoaded', target: this });
|
|
|
3111 }
|
|
|
3112 this._fixWebkitDivs();
|
|
|
3113 if (this.get('dompath')) {
|
|
|
3114 var self = this;
|
|
|
3115 setTimeout(function() {
|
|
|
3116 self._writeDomPath.call(self);
|
|
|
3117 self._setupResize.call(self);
|
|
|
3118 }, 150);
|
|
|
3119 }
|
|
|
3120 var br = [];
|
|
|
3121 for (var i in this.browser) {
|
|
|
3122 if (this.browser[i]) {
|
|
|
3123 br.push(i);
|
|
|
3124 }
|
|
|
3125 }
|
|
|
3126 if (this.get('ptags')) {
|
|
|
3127 br.push('ptags');
|
|
|
3128 }
|
|
|
3129 Dom.addClass(this._getDoc().body, br.join(' '));
|
|
|
3130 this.nodeChange(true);
|
|
|
3131 },
|
|
|
3132 /**
|
|
|
3133 * @private
|
|
|
3134 * @method _checkLoaded
|
|
|
3135 * @param {Boolean} raw Don't add events.
|
|
|
3136 * @description Called from a setTimeout loop to check if the iframes body.onload event has fired, then it will init the editor.
|
|
|
3137 */
|
|
|
3138 _checkLoaded: function(raw) {
|
|
|
3139 this._editorInit = false;
|
|
|
3140 this._contentTimerCounter++;
|
|
|
3141 if (this._contentTimer) {
|
|
|
3142 clearTimeout(this._contentTimer);
|
|
|
3143 }
|
|
|
3144 if (this._contentTimerCounter > this._contentTimerMax) {
|
|
|
3145 return false;
|
|
|
3146 }
|
|
|
3147 var init = false;
|
|
|
3148 try {
|
|
|
3149 if (this._getDoc() && this._getDoc().body) {
|
|
|
3150 if (this.browser.ie) {
|
|
|
3151 if (this._getDoc().body.readyState == 'complete') {
|
|
|
3152 init = true;
|
|
|
3153 }
|
|
|
3154 } else {
|
|
|
3155 if (this._getDoc().body._rteLoaded === true) {
|
|
|
3156 init = true;
|
|
|
3157 }
|
|
|
3158 }
|
|
|
3159 }
|
|
|
3160 } catch (e) {
|
|
|
3161 init = false;
|
|
|
3162 }
|
|
|
3163
|
|
|
3164 if (init === true) {
|
|
|
3165 //The onload event has fired, clean up after ourselves and fire the _initEditor method
|
|
|
3166 this._initEditor(raw);
|
|
|
3167 } else {
|
|
|
3168 var self = this;
|
|
|
3169 this._contentTimer = setTimeout(function() {
|
|
|
3170 self._checkLoaded.call(self, raw);
|
|
|
3171 }, 20);
|
|
|
3172 }
|
|
|
3173 },
|
|
|
3174 /**
|
|
|
3175 * @private
|
|
|
3176 * @method _setInitialContent
|
|
|
3177 * @param {Boolean} raw Don't add events.
|
|
|
3178 * @description This method will open the iframes content document and write the textareas value into it, then start the body.onload checking.
|
|
|
3179 */
|
|
|
3180 _setInitialContent: function(raw) {
|
|
|
3181
|
|
|
3182 var value = ((this._textarea) ? this.get('element').value : this.get('element').innerHTML),
|
|
|
3183 doc = null;
|
|
|
3184
|
|
|
3185 if (value === '') {
|
|
|
3186 value = '<br>';
|
|
|
3187 }
|
|
|
3188
|
|
|
3189 var html = Lang.substitute(this.get('html'), {
|
|
|
3190 TITLE: this.STR_TITLE,
|
|
|
3191 CONTENT: this._cleanIncomingHTML(value),
|
|
|
3192 CSS: this.get('css'),
|
|
|
3193 HIDDEN_CSS: ((this.get('hiddencss')) ? this.get('hiddencss') : '/* No Hidden CSS */'),
|
|
|
3194 EXTRA_CSS: ((this.get('extracss')) ? this.get('extracss') : '/* No Extra CSS */')
|
|
|
3195 }),
|
|
|
3196 check = true;
|
|
|
3197
|
|
|
3198 html = html.replace(/RIGHT_BRACKET/gi, '{');
|
|
|
3199 html = html.replace(/LEFT_BRACKET/gi, '}');
|
|
|
3200
|
|
|
3201 if (document.compatMode != 'BackCompat') {
|
|
|
3202 html = this._docType + "\n" + html;
|
|
|
3203 } else {
|
|
|
3204 }
|
|
|
3205
|
|
|
3206 if (this.browser.ie || this.browser.webkit || this.browser.opera || (navigator.userAgent.indexOf('Firefox/1.5') != -1)) {
|
|
|
3207 //Firefox 1.5 doesn't like setting designMode on an document created with a data url
|
|
|
3208 try {
|
|
|
3209 //Adobe AIR Code
|
|
|
3210 if (this.browser.air) {
|
|
|
3211 doc = this._getDoc().implementation.createHTMLDocument();
|
|
|
3212 var origDoc = this._getDoc();
|
|
|
3213 origDoc.open();
|
|
|
3214 origDoc.close();
|
|
|
3215 doc.open();
|
|
|
3216 doc.write(html);
|
|
|
3217 doc.close();
|
|
|
3218 var node = origDoc.importNode(doc.getElementsByTagName("html")[0], true);
|
|
|
3219 origDoc.replaceChild(node, origDoc.getElementsByTagName("html")[0]);
|
|
|
3220 origDoc.body._rteLoaded = true;
|
|
|
3221 } else {
|
|
|
3222 doc = this._getDoc();
|
|
|
3223 doc.open();
|
|
|
3224 doc.write(html);
|
|
|
3225 doc.close();
|
|
|
3226 }
|
|
|
3227 } catch (e) {
|
|
|
3228 //Safari will only be here if we are hidden
|
|
|
3229 check = false;
|
|
|
3230 }
|
|
|
3231 } else {
|
|
|
3232 //This keeps Firefox 2 from writing the iframe to history preserving the back buttons functionality
|
|
|
3233 this.get('iframe').get('element').src = 'data:text/html;charset=utf-8,' + encodeURIComponent(html);
|
|
|
3234 }
|
|
|
3235 this.get('iframe').setStyle('visibility', '');
|
|
|
3236 if (check) {
|
|
|
3237 this._checkLoaded(raw);
|
|
|
3238 }
|
|
|
3239 },
|
|
|
3240 /**
|
|
|
3241 * @private
|
|
|
3242 * @method _setMarkupType
|
|
|
3243 * @param {String} action The action to take. Possible values are: css, default or semantic
|
|
|
3244 * @description This method will turn on/off the useCSS execCommand.
|
|
|
3245 */
|
|
|
3246 _setMarkupType: function(action) {
|
|
|
3247 switch (this.get('markup')) {
|
|
|
3248 case 'css':
|
|
|
3249 this._setEditorStyle(true);
|
|
|
3250 break;
|
|
|
3251 case 'default':
|
|
|
3252 this._setEditorStyle(false);
|
|
|
3253 break;
|
|
|
3254 case 'semantic':
|
|
|
3255 case 'xhtml':
|
|
|
3256 if (this._semantic[action]) {
|
|
|
3257 this._setEditorStyle(false);
|
|
|
3258 } else {
|
|
|
3259 this._setEditorStyle(true);
|
|
|
3260 }
|
|
|
3261 break;
|
|
|
3262 }
|
|
|
3263 },
|
|
|
3264 /**
|
|
|
3265 * Set the editor to use CSS instead of HTML
|
|
|
3266 * @param {Booleen} stat True/False
|
|
|
3267 */
|
|
|
3268 _setEditorStyle: function(stat) {
|
|
|
3269 try {
|
|
|
3270 this._getDoc().execCommand('useCSS', false, !stat);
|
|
|
3271 } catch (ex) {
|
|
|
3272 }
|
|
|
3273 },
|
|
|
3274 /**
|
|
|
3275 * @private
|
|
|
3276 * @method _getSelectedElement
|
|
|
3277 * @description This method will attempt to locate the element that was last interacted with, either via selection, location or event.
|
|
|
3278 * @return {HTMLElement} The currently selected element.
|
|
|
3279 */
|
|
|
3280 _getSelectedElement: function() {
|
|
|
3281 var doc = this._getDoc(),
|
|
|
3282 range = null,
|
|
|
3283 sel = null,
|
|
|
3284 elm = null,
|
|
|
3285 check = true;
|
|
|
3286
|
|
|
3287 if (this.browser.ie) {
|
|
|
3288 this.currentEvent = this._getWindow().event; //Event utility assumes window.event, so we need to reset it to this._getWindow().event;
|
|
|
3289 range = this._getRange();
|
|
|
3290 if (range) {
|
|
|
3291 elm = range.item ? range.item(0) : range.parentElement();
|
|
|
3292 if (this._hasSelection()) {
|
|
|
3293 //TODO
|
|
|
3294 //WTF.. Why can't I get an element reference here?!??!
|
|
|
3295 }
|
|
|
3296 if (elm === doc.body) {
|
|
|
3297 elm = null;
|
|
|
3298 }
|
|
|
3299 }
|
|
|
3300 if ((this.currentEvent !== null) && (this.currentEvent.keyCode === 0)) {
|
|
|
3301 elm = Event.getTarget(this.currentEvent);
|
|
|
3302 }
|
|
|
3303 } else {
|
|
|
3304 sel = this._getSelection();
|
|
|
3305 range = this._getRange();
|
|
|
3306
|
|
|
3307 if (!sel || !range) {
|
|
|
3308 return null;
|
|
|
3309 }
|
|
|
3310 //TODO
|
|
|
3311 if (!this._hasSelection() && this.browser.webkit3) {
|
|
|
3312 //check = false;
|
|
|
3313 }
|
|
|
3314 if (this.browser.gecko) {
|
|
|
3315 //Added in 2.6.0
|
|
|
3316 if (range.startContainer) {
|
|
|
3317 if (range.startContainer.nodeType === 3) {
|
|
|
3318 elm = range.startContainer.parentNode;
|
|
|
3319 } else if (range.startContainer.nodeType === 1) {
|
|
|
3320 elm = range.startContainer;
|
|
|
3321 }
|
|
|
3322 //Added in 2.7.0
|
|
|
3323 if (this.currentEvent) {
|
|
|
3324 var tar = Event.getTarget(this.currentEvent);
|
|
|
3325 if (!this._isElement(tar, 'html')) {
|
|
|
3326 if (elm !== tar) {
|
|
|
3327 elm = tar;
|
|
|
3328 }
|
|
|
3329 }
|
|
|
3330 }
|
|
|
3331 }
|
|
|
3332 }
|
|
|
3333
|
|
|
3334 if (check) {
|
|
|
3335 if (sel.anchorNode && (sel.anchorNode.nodeType == 3)) {
|
|
|
3336 if (sel.anchorNode.parentNode) { //next check parentNode
|
|
|
3337 elm = sel.anchorNode.parentNode;
|
|
|
3338 }
|
|
|
3339 if (sel.anchorNode.nextSibling != sel.focusNode.nextSibling) {
|
|
|
3340 elm = sel.anchorNode.nextSibling;
|
|
|
3341 }
|
|
|
3342 }
|
|
|
3343 if (this._isElement(elm, 'br')) {
|
|
|
3344 elm = null;
|
|
|
3345 }
|
|
|
3346 if (!elm) {
|
|
|
3347 elm = range.commonAncestorContainer;
|
|
|
3348 if (!range.collapsed) {
|
|
|
3349 if (range.startContainer == range.endContainer) {
|
|
|
3350 if (range.startOffset - range.endOffset < 2) {
|
|
|
3351 if (range.startContainer.hasChildNodes()) {
|
|
|
3352 elm = range.startContainer.childNodes[range.startOffset];
|
|
|
3353 }
|
|
|
3354 }
|
|
|
3355 }
|
|
|
3356 }
|
|
|
3357 }
|
|
|
3358 }
|
|
|
3359 }
|
|
|
3360
|
|
|
3361 if (this.currentEvent !== null) {
|
|
|
3362 try {
|
|
|
3363 switch (this.currentEvent.type) {
|
|
|
3364 case 'click':
|
|
|
3365 case 'mousedown':
|
|
|
3366 case 'mouseup':
|
|
|
3367 if (this.browser.webkit) {
|
|
|
3368 elm = Event.getTarget(this.currentEvent);
|
|
|
3369 }
|
|
|
3370 break;
|
|
|
3371 default:
|
|
|
3372 //Do nothing
|
|
|
3373 break;
|
|
|
3374 }
|
|
|
3375 } catch (e) {
|
|
|
3376 }
|
|
|
3377 } else if ((this.currentElement && this.currentElement[0]) && (!this.browser.ie)) {
|
|
|
3378 //TODO is this still needed?
|
|
|
3379 //elm = this.currentElement[0];
|
|
|
3380 }
|
|
|
3381
|
|
|
3382
|
|
|
3383 if (this.browser.opera || this.browser.webkit) {
|
|
|
3384 if (this.currentEvent && !elm) {
|
|
|
3385 elm = YAHOO.util.Event.getTarget(this.currentEvent);
|
|
|
3386 }
|
|
|
3387 }
|
|
|
3388 if (!elm || !elm.tagName) {
|
|
|
3389 elm = doc.body;
|
|
|
3390 }
|
|
|
3391 if (this._isElement(elm, 'html')) {
|
|
|
3392 //Safari sometimes gives us the HTML node back..
|
|
|
3393 elm = doc.body;
|
|
|
3394 }
|
|
|
3395 if (this._isElement(elm, 'body')) {
|
|
|
3396 //make sure that body means this body not the parent..
|
|
|
3397 elm = doc.body;
|
|
|
3398 }
|
|
|
3399 if (elm && !elm.parentNode) { //Not in document
|
|
|
3400 elm = doc.body;
|
|
|
3401 }
|
|
|
3402 if (elm === undefined) {
|
|
|
3403 elm = null;
|
|
|
3404 }
|
|
|
3405 return elm;
|
|
|
3406 },
|
|
|
3407 /**
|
|
|
3408 * @private
|
|
|
3409 * @method _getDomPath
|
|
|
3410 * @description This method will attempt to build the DOM path from the currently selected element.
|
|
|
3411 * @param HTMLElement el The element to start with, if not provided _getSelectedElement is used
|
|
|
3412 * @return {Array} An array of node references that will create the DOM Path.
|
|
|
3413 */
|
|
|
3414 _getDomPath: function(el) {
|
|
|
3415 if (!el) {
|
|
|
3416 el = this._getSelectedElement();
|
|
|
3417 }
|
|
|
3418 var domPath = [];
|
|
|
3419 while (el !== null) {
|
|
|
3420 if (el.ownerDocument != this._getDoc()) {
|
|
|
3421 el = null;
|
|
|
3422 break;
|
|
|
3423 }
|
|
|
3424 //Check to see if we get el.nodeName and nodeType
|
|
|
3425 if (el.nodeName && el.nodeType && (el.nodeType == 1)) {
|
|
|
3426 domPath[domPath.length] = el;
|
|
|
3427 }
|
|
|
3428
|
|
|
3429 if (this._isElement(el, 'body')) {
|
|
|
3430 break;
|
|
|
3431 }
|
|
|
3432
|
|
|
3433 el = el.parentNode;
|
|
|
3434 }
|
|
|
3435 if (domPath.length === 0) {
|
|
|
3436 if (this._getDoc() && this._getDoc().body) {
|
|
|
3437 domPath[0] = this._getDoc().body;
|
|
|
3438 }
|
|
|
3439 }
|
|
|
3440 return domPath.reverse();
|
|
|
3441 },
|
|
|
3442 /**
|
|
|
3443 * @private
|
|
|
3444 * @method _writeDomPath
|
|
|
3445 * @description Write the current DOM path out to the dompath container below the editor.
|
|
|
3446 */
|
|
|
3447 _writeDomPath: function() {
|
|
|
3448 var path = this._getDomPath(),
|
|
|
3449 pathArr = [],
|
|
|
3450 classPath = '',
|
|
|
3451 pathStr = '';
|
|
|
3452
|
|
|
3453 for (var i = 0; i < path.length; i++) {
|
|
|
3454 var tag = path[i].tagName.toLowerCase();
|
|
|
3455 if ((tag == 'ol') && (path[i].type)) {
|
|
|
3456 tag += ':' + path[i].type;
|
|
|
3457 }
|
|
|
3458 if (Dom.hasClass(path[i], 'yui-tag')) {
|
|
|
3459 tag = path[i].getAttribute('tag');
|
|
|
3460 }
|
|
|
3461 if ((this.get('markup') == 'semantic') || (this.get('markup') == 'xhtml')) {
|
|
|
3462 switch (tag) {
|
|
|
3463 case 'b': tag = 'strong'; break;
|
|
|
3464 case 'i': tag = 'em'; break;
|
|
|
3465 }
|
|
|
3466 }
|
|
|
3467 if (!Dom.hasClass(path[i], 'yui-non')) {
|
|
|
3468 if (Dom.hasClass(path[i], 'yui-tag')) {
|
|
|
3469 pathStr = tag;
|
|
|
3470 } else {
|
|
|
3471 classPath = ((path[i].className !== '') ? '.' + path[i].className.replace(/ /g, '.') : '');
|
|
|
3472 if ((classPath.indexOf('yui') != -1) || (classPath.toLowerCase().indexOf('apple-style-span') != -1)) {
|
|
|
3473 classPath = '';
|
|
|
3474 }
|
|
|
3475 pathStr = tag + ((path[i].id) ? '#' + path[i].id : '') + classPath;
|
|
|
3476 }
|
|
|
3477 switch (tag) {
|
|
|
3478 case 'body':
|
|
|
3479 pathStr = 'body';
|
|
|
3480 break;
|
|
|
3481 case 'a':
|
|
|
3482 if (path[i].getAttribute('href', 2)) {
|
|
|
3483 pathStr += ':' + path[i].getAttribute('href', 2).replace('mailto:', '').replace('http:/'+'/', '').replace('https:/'+'/', ''); //May need to add others here ftp
|
|
|
3484 }
|
|
|
3485 break;
|
|
|
3486 case 'img':
|
|
|
3487 var h = path[i].height;
|
|
|
3488 var w = path[i].width;
|
|
|
3489 if (path[i].style.height) {
|
|
|
3490 h = parseInt(path[i].style.height, 10);
|
|
|
3491 }
|
|
|
3492 if (path[i].style.width) {
|
|
|
3493 w = parseInt(path[i].style.width, 10);
|
|
|
3494 }
|
|
|
3495 pathStr += '(' + w + 'x' + h + ')';
|
|
|
3496 break;
|
|
|
3497 }
|
|
|
3498
|
|
|
3499 if (pathStr.length > 10) {
|
|
|
3500 pathStr = '<span title="' + pathStr + '">' + pathStr.substring(0, 10) + '...' + '</span>';
|
|
|
3501 } else {
|
|
|
3502 pathStr = '<span title="' + pathStr + '">' + pathStr + '</span>';
|
|
|
3503 }
|
|
|
3504 pathArr[pathArr.length] = pathStr;
|
|
|
3505 }
|
|
|
3506 }
|
|
|
3507 var str = pathArr.join(' ' + this.SEP_DOMPATH + ' ');
|
|
|
3508 //Prevent flickering
|
|
|
3509 if (this.dompath.innerHTML != str) {
|
|
|
3510 this.dompath.innerHTML = str;
|
|
|
3511 }
|
|
|
3512 },
|
|
|
3513 /**
|
|
|
3514 * @private
|
|
|
3515 * @method _fixNodes
|
|
|
3516 * @description Fix href and imgs as well as remove invalid HTML.
|
|
|
3517 */
|
|
|
3518 _fixNodes: function() {
|
|
|
3519 try {
|
|
|
3520 var doc = this._getDoc(),
|
|
|
3521 els = [];
|
|
|
3522
|
|
|
3523 for (var v in this.invalidHTML) {
|
|
|
3524 if (YAHOO.lang.hasOwnProperty(this.invalidHTML, v)) {
|
|
|
3525 if (v.toLowerCase() != 'span') {
|
|
|
3526 var tags = doc.body.getElementsByTagName(v);
|
|
|
3527 if (tags.length) {
|
|
|
3528 for (var i = 0; i < tags.length; i++) {
|
|
|
3529 els.push(tags[i]);
|
|
|
3530 }
|
|
|
3531 }
|
|
|
3532 }
|
|
|
3533 }
|
|
|
3534 }
|
|
|
3535 for (var h = 0; h < els.length; h++) {
|
|
|
3536 if (els[h].parentNode) {
|
|
|
3537 if (Lang.isObject(this.invalidHTML[els[h].tagName.toLowerCase()]) && this.invalidHTML[els[h].tagName.toLowerCase()].keepContents) {
|
|
|
3538 this._swapEl(els[h], 'span', function(el) {
|
|
|
3539 el.className = 'yui-non';
|
|
|
3540 });
|
|
|
3541 } else {
|
|
|
3542 els[h].parentNode.removeChild(els[h]);
|
|
|
3543 }
|
|
|
3544 }
|
|
|
3545 }
|
|
|
3546 var imgs = this._getDoc().getElementsByTagName('img');
|
|
|
3547 Dom.addClass(imgs, 'yui-img');
|
|
|
3548 } catch(e) {}
|
|
|
3549 },
|
|
|
3550 /**
|
|
|
3551 * @private
|
|
|
3552 * @method _isNonEditable
|
|
|
3553 * @param Event ev The Dom event being checked
|
|
|
3554 * @description Method is called at the beginning of all event handlers to check if this element or a parent element has the class yui-noedit (this.CLASS_NOEDIT) applied.
|
|
|
3555 * If it does, then this method will stop the event and return true. The event handlers will then return false and stop the nodeChange from occuring. This method will also
|
|
|
3556 * disable and enable the Editor's toolbar based on the noedit state.
|
|
|
3557 * @return Boolean
|
|
|
3558 */
|
|
|
3559 _isNonEditable: function(ev) {
|
|
|
3560 if (this.get('allowNoEdit')) {
|
|
|
3561 var el = Event.getTarget(ev);
|
|
|
3562 if (this._isElement(el, 'html')) {
|
|
|
3563 el = null;
|
|
|
3564 }
|
|
|
3565 var path = this._getDomPath(el);
|
|
|
3566 for (var i = (path.length - 1); i > -1; i--) {
|
|
|
3567 if (Dom.hasClass(path[i], this.CLASS_NOEDIT)) {
|
|
|
3568 //if (this.toolbar.get('disabled') === false) {
|
|
|
3569 // this.toolbar.set('disabled', true);
|
|
|
3570 //}
|
|
|
3571 try {
|
|
|
3572 this._getDoc().execCommand('enableObjectResizing', false, 'false');
|
|
|
3573 } catch (e) {}
|
|
|
3574 this.nodeChange();
|
|
|
3575 Event.stopEvent(ev);
|
|
|
3576 return true;
|
|
|
3577 }
|
|
|
3578 }
|
|
|
3579 //if (this.toolbar.get('disabled') === true) {
|
|
|
3580 //Should only happen once..
|
|
|
3581 //this.toolbar.set('disabled', false);
|
|
|
3582 try {
|
|
|
3583 this._getDoc().execCommand('enableObjectResizing', false, 'true');
|
|
|
3584 } catch (e2) {}
|
|
|
3585 //}
|
|
|
3586 }
|
|
|
3587 return false;
|
|
|
3588 },
|
|
|
3589 /**
|
|
|
3590 * @private
|
|
|
3591 * @method _setCurrentEvent
|
|
|
3592 * @param {Event} ev The event to cache
|
|
|
3593 * @description Sets the current event property
|
|
|
3594 */
|
|
|
3595 _setCurrentEvent: function(ev) {
|
|
|
3596 this.currentEvent = ev;
|
|
|
3597 },
|
|
|
3598 /**
|
|
|
3599 * @private
|
|
|
3600 * @method _handleClick
|
|
|
3601 * @param {Event} ev The event we are working on.
|
|
|
3602 * @description Handles all click events inside the iFrame document.
|
|
|
3603 */
|
|
|
3604 _handleClick: function(ev) {
|
|
|
3605 var ret = this.fireEvent('beforeEditorClick', { type: 'beforeEditorClick', target: this, ev: ev });
|
|
|
3606 if (ret === false) {
|
|
|
3607 return false;
|
|
|
3608 }
|
|
|
3609 if (this._isNonEditable(ev)) {
|
|
|
3610 return false;
|
|
|
3611 }
|
|
|
3612 this._setCurrentEvent(ev);
|
|
|
3613 if (this.currentWindow) {
|
|
|
3614 this.closeWindow();
|
|
|
3615 }
|
|
|
3616 if (this.currentWindow) {
|
|
|
3617 this.closeWindow();
|
|
|
3618 }
|
|
|
3619 if (this.browser.webkit) {
|
|
|
3620 var tar =Event.getTarget(ev);
|
|
|
3621 if (this._isElement(tar, 'a') || this._isElement(tar.parentNode, 'a')) {
|
|
|
3622 Event.stopEvent(ev);
|
|
|
3623 this.nodeChange();
|
|
|
3624 }
|
|
|
3625 } else {
|
|
|
3626 this.nodeChange();
|
|
|
3627 }
|
|
|
3628 this.fireEvent('editorClick', { type: 'editorClick', target: this, ev: ev });
|
|
|
3629 },
|
|
|
3630 /**
|
|
|
3631 * @private
|
|
|
3632 * @method _handleMouseUp
|
|
|
3633 * @param {Event} ev The event we are working on.
|
|
|
3634 * @description Handles all mouseup events inside the iFrame document.
|
|
|
3635 */
|
|
|
3636 _handleMouseUp: function(ev) {
|
|
|
3637 var ret = this.fireEvent('beforeEditorMouseUp', { type: 'beforeEditorMouseUp', target: this, ev: ev });
|
|
|
3638 if (ret === false) {
|
|
|
3639 return false;
|
|
|
3640 }
|
|
|
3641 if (this._isNonEditable(ev)) {
|
|
|
3642 return false;
|
|
|
3643 }
|
|
|
3644 //Don't set current event for mouseup.
|
|
|
3645 //It get's fired after a menu is closed and gives up a bogus event to work with
|
|
|
3646 //this._setCurrentEvent(ev);
|
|
|
3647 var self = this;
|
|
|
3648 if (this.browser.opera) {
|
|
|
3649 /*
|
|
|
3650 * @knownissue Opera appears to stop the MouseDown, Click and DoubleClick events on an image inside of a document with designMode on..
|
|
|
3651 * @browser Opera
|
|
|
3652 * @description This work around traps the MouseUp event and sets a timer to check if another MouseUp event fires in so many seconds. If another event is fired, they we internally fire the DoubleClick event.
|
|
|
3653 */
|
|
|
3654 var sel = Event.getTarget(ev);
|
|
|
3655 if (this._isElement(sel, 'img')) {
|
|
|
3656 this.nodeChange();
|
|
|
3657 if (this.operaEvent) {
|
|
|
3658 clearTimeout(this.operaEvent);
|
|
|
3659 this.operaEvent = null;
|
|
|
3660 this._handleDoubleClick(ev);
|
|
|
3661 } else {
|
|
|
3662 this.operaEvent = window.setTimeout(function() {
|
|
|
3663 self.operaEvent = false;
|
|
|
3664 }, 700);
|
|
|
3665 }
|
|
|
3666 }
|
|
|
3667 }
|
|
|
3668 //This will stop Safari from selecting the entire document if you select all the text in the editor
|
|
|
3669 if (this.browser.webkit || this.browser.opera) {
|
|
|
3670 if (this.browser.webkit) {
|
|
|
3671 Event.stopEvent(ev);
|
|
|
3672 }
|
|
|
3673 }
|
|
|
3674 this.nodeChange();
|
|
|
3675 this.fireEvent('editorMouseUp', { type: 'editorMouseUp', target: this, ev: ev });
|
|
|
3676 },
|
|
|
3677 /**
|
|
|
3678 * @private
|
|
|
3679 * @method _handleMouseDown
|
|
|
3680 * @param {Event} ev The event we are working on.
|
|
|
3681 * @description Handles all mousedown events inside the iFrame document.
|
|
|
3682 */
|
|
|
3683 _handleMouseDown: function(ev) {
|
|
|
3684 var ret = this.fireEvent('beforeEditorMouseDown', { type: 'beforeEditorMouseDown', target: this, ev: ev });
|
|
|
3685 if (ret === false) {
|
|
|
3686 return false;
|
|
|
3687 }
|
|
|
3688 if (this._isNonEditable(ev)) {
|
|
|
3689 return false;
|
|
|
3690 }
|
|
|
3691 this._setCurrentEvent(ev);
|
|
|
3692 var sel = Event.getTarget(ev);
|
|
|
3693 if (this.browser.webkit && this._hasSelection()) {
|
|
|
3694 var _sel = this._getSelection();
|
|
|
3695 if (!this.browser.webkit3) {
|
|
|
3696 _sel.collapse(true);
|
|
|
3697 } else {
|
|
|
3698 _sel.collapseToStart();
|
|
|
3699 }
|
|
|
3700 }
|
|
|
3701 if (this.browser.webkit && this._lastImage) {
|
|
|
3702 Dom.removeClass(this._lastImage, 'selected');
|
|
|
3703 this._lastImage = null;
|
|
|
3704 }
|
|
|
3705 if (this._isElement(sel, 'img') || this._isElement(sel, 'a')) {
|
|
|
3706 if (this.browser.webkit) {
|
|
|
3707 Event.stopEvent(ev);
|
|
|
3708 if (this._isElement(sel, 'img')) {
|
|
|
3709 Dom.addClass(sel, 'selected');
|
|
|
3710 this._lastImage = sel;
|
|
|
3711 }
|
|
|
3712 }
|
|
|
3713 if (this.currentWindow) {
|
|
|
3714 this.closeWindow();
|
|
|
3715 }
|
|
|
3716 this.nodeChange();
|
|
|
3717 }
|
|
|
3718 this.fireEvent('editorMouseDown', { type: 'editorMouseDown', target: this, ev: ev });
|
|
|
3719 },
|
|
|
3720 /**
|
|
|
3721 * @private
|
|
|
3722 * @method _handleDoubleClick
|
|
|
3723 * @param {Event} ev The event we are working on.
|
|
|
3724 * @description Handles all doubleclick events inside the iFrame document.
|
|
|
3725 */
|
|
|
3726 _handleDoubleClick: function(ev) {
|
|
|
3727 var ret = this.fireEvent('beforeEditorDoubleClick', { type: 'beforeEditorDoubleClick', target: this, ev: ev });
|
|
|
3728 if (ret === false) {
|
|
|
3729 return false;
|
|
|
3730 }
|
|
|
3731 if (this._isNonEditable(ev)) {
|
|
|
3732 return false;
|
|
|
3733 }
|
|
|
3734 this._setCurrentEvent(ev);
|
|
|
3735 var sel = Event.getTarget(ev);
|
|
|
3736 if (this._isElement(sel, 'img')) {
|
|
|
3737 this.currentElement[0] = sel;
|
|
|
3738 this.toolbar.fireEvent('insertimageClick', { type: 'insertimageClick', target: this.toolbar });
|
|
|
3739 this.fireEvent('afterExecCommand', { type: 'afterExecCommand', target: this });
|
|
|
3740 } else if (this._hasParent(sel, 'a')) { //Handle elements inside an a
|
|
|
3741 this.currentElement[0] = this._hasParent(sel, 'a');
|
|
|
3742 this.toolbar.fireEvent('createlinkClick', { type: 'createlinkClick', target: this.toolbar });
|
|
|
3743 this.fireEvent('afterExecCommand', { type: 'afterExecCommand', target: this });
|
|
|
3744 }
|
|
|
3745 this.nodeChange();
|
|
|
3746 this.fireEvent('editorDoubleClick', { type: 'editorDoubleClick', target: this, ev: ev });
|
|
|
3747 },
|
|
|
3748 /**
|
|
|
3749 * @private
|
|
|
3750 * @method _handleKeyUp
|
|
|
3751 * @param {Event} ev The event we are working on.
|
|
|
3752 * @description Handles all keyup events inside the iFrame document.
|
|
|
3753 */
|
|
|
3754 _handleKeyUp: function(ev) {
|
|
|
3755 var ret = this.fireEvent('beforeEditorKeyUp', { type: 'beforeEditorKeyUp', target: this, ev: ev });
|
|
|
3756 if (ret === false) {
|
|
|
3757 return false;
|
|
|
3758 }
|
|
|
3759 if (this._isNonEditable(ev)) {
|
|
|
3760 return false;
|
|
|
3761 }
|
|
|
3762 this._storeUndo();
|
|
|
3763 this._setCurrentEvent(ev);
|
|
|
3764 switch (ev.keyCode) {
|
|
|
3765 case this._keyMap.SELECT_ALL.key:
|
|
|
3766 if (this._checkKey(this._keyMap.SELECT_ALL, ev)) {
|
|
|
3767 this.nodeChange();
|
|
|
3768 }
|
|
|
3769 break;
|
|
|
3770 case 32: //Space Bar
|
|
|
3771 case 35: //End
|
|
|
3772 case 36: //Home
|
|
|
3773 case 37: //Left Arrow
|
|
|
3774 case 38: //Up Arrow
|
|
|
3775 case 39: //Right Arrow
|
|
|
3776 case 40: //Down Arrow
|
|
|
3777 case 46: //Forward Delete
|
|
|
3778 case 8: //Delete
|
|
|
3779 case this._keyMap.CLOSE_WINDOW.key: //W key if window is open
|
|
|
3780 if ((ev.keyCode == this._keyMap.CLOSE_WINDOW.key) && this.currentWindow) {
|
|
|
3781 if (this._checkKey(this._keyMap.CLOSE_WINDOW, ev)) {
|
|
|
3782 this.closeWindow();
|
|
|
3783 }
|
|
|
3784 } else {
|
|
|
3785 if (!this.browser.ie) {
|
|
|
3786 if (this._nodeChangeTimer) {
|
|
|
3787 clearTimeout(this._nodeChangeTimer);
|
|
|
3788 }
|
|
|
3789 var self = this;
|
|
|
3790 this._nodeChangeTimer = setTimeout(function() {
|
|
|
3791 self._nodeChangeTimer = null;
|
|
|
3792 self.nodeChange.call(self);
|
|
|
3793 }, 100);
|
|
|
3794 } else {
|
|
|
3795 this.nodeChange();
|
|
|
3796 }
|
|
|
3797 this.editorDirty = true;
|
|
|
3798 }
|
|
|
3799 break;
|
|
|
3800 }
|
|
|
3801 this.fireEvent('editorKeyUp', { type: 'editorKeyUp', target: this, ev: ev });
|
|
|
3802 },
|
|
|
3803 /**
|
|
|
3804 * @private
|
|
|
3805 * @method _handleKeyPress
|
|
|
3806 * @param {Event} ev The event we are working on.
|
|
|
3807 * @description Handles all keypress events inside the iFrame document.
|
|
|
3808 */
|
|
|
3809 _handleKeyPress: function(ev) {
|
|
|
3810 var ret = this.fireEvent('beforeEditorKeyPress', { type: 'beforeEditorKeyPress', target: this, ev: ev });
|
|
|
3811 if (ret === false) {
|
|
|
3812 return false;
|
|
|
3813 }
|
|
|
3814
|
|
|
3815 if (this.get('allowNoEdit')) {
|
|
|
3816 //if (ev && ev.keyCode && ((ev.keyCode == 46) || ev.keyCode == 63272)) {
|
|
|
3817 if (ev && ev.keyCode && (ev.keyCode == 63272)) {
|
|
|
3818 //Forward delete key
|
|
|
3819 Event.stopEvent(ev);
|
|
|
3820 }
|
|
|
3821 }
|
|
|
3822 if (this._isNonEditable(ev)) {
|
|
|
3823 return false;
|
|
|
3824 }
|
|
|
3825 this._setCurrentEvent(ev);
|
|
|
3826 this._storeUndo();
|
|
|
3827 if (this.browser.opera) {
|
|
|
3828 if (ev.keyCode === 13) {
|
|
|
3829 var tar = this._getSelectedElement();
|
|
|
3830 if (!this._isElement(tar, 'li')) {
|
|
|
3831 this.execCommand('inserthtml', '<br>');
|
|
|
3832 Event.stopEvent(ev);
|
|
|
3833 }
|
|
|
3834 }
|
|
|
3835 }
|
|
|
3836 if (this.browser.webkit) {
|
|
|
3837 if (!this.browser.webkit3) {
|
|
|
3838 if (ev.keyCode && (ev.keyCode == 122) && (ev.metaKey)) {
|
|
|
3839 //This is CMD + z (for undo)
|
|
|
3840 if (this._hasParent(this._getSelectedElement(), 'li')) {
|
|
|
3841 Event.stopEvent(ev);
|
|
|
3842 }
|
|
|
3843 }
|
|
|
3844 }
|
|
|
3845 this._listFix(ev);
|
|
|
3846 }
|
|
|
3847 this._fixListDupIds();
|
|
|
3848 this.fireEvent('editorKeyPress', { type: 'editorKeyPress', target: this, ev: ev });
|
|
|
3849 },
|
|
|
3850 /**
|
|
|
3851 * @private
|
|
|
3852 * @method _handleKeyDown
|
|
|
3853 * @param {Event} ev The event we are working on.
|
|
|
3854 * @description Handles all keydown events inside the iFrame document.
|
|
|
3855 */
|
|
|
3856 _handleKeyDown: function(ev) {
|
|
|
3857 var ret = this.fireEvent('beforeEditorKeyDown', { type: 'beforeEditorKeyDown', target: this, ev: ev });
|
|
|
3858 if (ret === false) {
|
|
|
3859 return false;
|
|
|
3860 }
|
|
|
3861 var tar = null, _range = null;
|
|
|
3862 if (this._isNonEditable(ev)) {
|
|
|
3863 return false;
|
|
|
3864 }
|
|
|
3865 this._setCurrentEvent(ev);
|
|
|
3866 if (this.currentWindow) {
|
|
|
3867 this.closeWindow();
|
|
|
3868 }
|
|
|
3869 if (this.currentWindow) {
|
|
|
3870 this.closeWindow();
|
|
|
3871 }
|
|
|
3872 var doExec = false,
|
|
|
3873 action = null,
|
|
|
3874 value = null,
|
|
|
3875 exec = false;
|
|
|
3876
|
|
|
3877
|
|
|
3878 switch (ev.keyCode) {
|
|
|
3879 case this._keyMap.FOCUS_TOOLBAR.key:
|
|
|
3880 if (this._checkKey(this._keyMap.FOCUS_TOOLBAR, ev)) {
|
|
|
3881 var h = this.toolbar.getElementsByTagName('h2')[0];
|
|
|
3882 if (h && h.firstChild) {
|
|
|
3883 h.firstChild.focus();
|
|
|
3884 }
|
|
|
3885 } else if (this._checkKey(this._keyMap.FOCUS_AFTER, ev)) {
|
|
|
3886 //Focus After Element - Esc
|
|
|
3887 this.afterElement.focus();
|
|
|
3888 }
|
|
|
3889 Event.stopEvent(ev);
|
|
|
3890 doExec = false;
|
|
|
3891 break;
|
|
|
3892 //case 76: //L
|
|
|
3893 case this._keyMap.CREATE_LINK.key: //L
|
|
|
3894 if (this._hasSelection()) {
|
|
|
3895 if (this._checkKey(this._keyMap.CREATE_LINK, ev)) {
|
|
|
3896 var makeLink = true;
|
|
|
3897 if (this.get('limitCommands')) {
|
|
|
3898 if (!this.toolbar.getButtonByValue('createlink')) {
|
|
|
3899 makeLink = false;
|
|
|
3900 }
|
|
|
3901 }
|
|
|
3902 if (makeLink) {
|
|
|
3903 this.execCommand('createlink', '');
|
|
|
3904 this.toolbar.fireEvent('createlinkClick', { type: 'createlinkClick', target: this.toolbar });
|
|
|
3905 this.fireEvent('afterExecCommand', { type: 'afterExecCommand', target: this });
|
|
|
3906 doExec = false;
|
|
|
3907 }
|
|
|
3908 }
|
|
|
3909 }
|
|
|
3910 break;
|
|
|
3911 //case 90: //Z
|
|
|
3912 case this._keyMap.UNDO.key:
|
|
|
3913 case this._keyMap.REDO.key:
|
|
|
3914 if (this._checkKey(this._keyMap.REDO, ev)) {
|
|
|
3915 action = 'redo';
|
|
|
3916 doExec = true;
|
|
|
3917 } else if (this._checkKey(this._keyMap.UNDO, ev)) {
|
|
|
3918 action = 'undo';
|
|
|
3919 doExec = true;
|
|
|
3920 }
|
|
|
3921 break;
|
|
|
3922 //case 66: //B
|
|
|
3923 case this._keyMap.BOLD.key:
|
|
|
3924 if (this._checkKey(this._keyMap.BOLD, ev)) {
|
|
|
3925 action = 'bold';
|
|
|
3926 doExec = true;
|
|
|
3927 }
|
|
|
3928 break;
|
|
|
3929 case this._keyMap.FONT_SIZE_UP.key:
|
|
|
3930 case this._keyMap.FONT_SIZE_DOWN.key:
|
|
|
3931 var uk = false, dk = false;
|
|
|
3932 if (this._checkKey(this._keyMap.FONT_SIZE_UP, ev)) {
|
|
|
3933 uk = true;
|
|
|
3934 }
|
|
|
3935 if (this._checkKey(this._keyMap.FONT_SIZE_DOWN, ev)) {
|
|
|
3936 dk = true;
|
|
|
3937 }
|
|
|
3938 if (uk || dk) {
|
|
|
3939 var fs_button = this.toolbar.getButtonByValue('fontsize'),
|
|
|
3940 label = parseInt(fs_button.get('label'), 10),
|
|
|
3941 newValue = (label + 1);
|
|
|
3942
|
|
|
3943 if (dk) {
|
|
|
3944 newValue = (label - 1);
|
|
|
3945 }
|
|
|
3946
|
|
|
3947 action = 'fontsize';
|
|
|
3948 value = newValue + 'px';
|
|
|
3949 doExec = true;
|
|
|
3950 }
|
|
|
3951 break;
|
|
|
3952 //case 73: //I
|
|
|
3953 case this._keyMap.ITALIC.key:
|
|
|
3954 if (this._checkKey(this._keyMap.ITALIC, ev)) {
|
|
|
3955 action = 'italic';
|
|
|
3956 doExec = true;
|
|
|
3957 }
|
|
|
3958 break;
|
|
|
3959 //case 85: //U
|
|
|
3960 case this._keyMap.UNDERLINE.key:
|
|
|
3961 if (this._checkKey(this._keyMap.UNDERLINE, ev)) {
|
|
|
3962 action = 'underline';
|
|
|
3963 doExec = true;
|
|
|
3964 }
|
|
|
3965 break;
|
|
|
3966 case 9:
|
|
|
3967 if (this.browser.ie) {
|
|
|
3968 //Insert a tab in Internet Explorer
|
|
|
3969 _range = this._getRange();
|
|
|
3970 tar = this._getSelectedElement();
|
|
|
3971 if (!this._isElement(tar, 'li')) {
|
|
|
3972 if (_range) {
|
|
|
3973 _range.pasteHTML(' ');
|
|
|
3974 _range.collapse(false);
|
|
|
3975 _range.select();
|
|
|
3976 }
|
|
|
3977 Event.stopEvent(ev);
|
|
|
3978 }
|
|
|
3979 }
|
|
|
3980 //Firefox 3 code
|
|
|
3981 if (this.browser.gecko > 1.8) {
|
|
|
3982 tar = this._getSelectedElement();
|
|
|
3983 if (this._isElement(tar, 'li')) {
|
|
|
3984 if (ev.shiftKey) {
|
|
|
3985 this._getDoc().execCommand('outdent', null, '');
|
|
|
3986 } else {
|
|
|
3987 this._getDoc().execCommand('indent', null, '');
|
|
|
3988 }
|
|
|
3989
|
|
|
3990 } else if (!this._hasSelection()) {
|
|
|
3991 this.execCommand('inserthtml', ' ');
|
|
|
3992 }
|
|
|
3993 Event.stopEvent(ev);
|
|
|
3994 }
|
|
|
3995 break;
|
|
|
3996 case 13:
|
|
|
3997 var p = null, i = 0;
|
|
|
3998 if (this.get('ptags') && !ev.shiftKey) {
|
|
|
3999 if (this.browser.gecko) {
|
|
|
4000 tar = this._getSelectedElement();
|
|
|
4001 if (!this._hasParent(tar, 'li')) {
|
|
|
4002 if (this._hasParent(tar, 'p')) {
|
|
|
4003 p = this._getDoc().createElement('p');
|
|
|
4004 p.innerHTML = ' ';
|
|
|
4005 Dom.insertAfter(p, tar);
|
|
|
4006 this._selectNode(p.firstChild);
|
|
|
4007 } else if (this._isElement(tar, 'body')) {
|
|
|
4008 this.execCommand('insertparagraph', null);
|
|
|
4009 var ps = this._getDoc().body.getElementsByTagName('p');
|
|
|
4010 for (i = 0; i < ps.length; i++) {
|
|
|
4011 if (ps[i].getAttribute('_moz_dirty') !== null) {
|
|
|
4012 p = this._getDoc().createElement('p');
|
|
|
4013 p.innerHTML = ' ';
|
|
|
4014 Dom.insertAfter(p, ps[i]);
|
|
|
4015 this._selectNode(p.firstChild);
|
|
|
4016 ps[i].removeAttribute('_moz_dirty');
|
|
|
4017 }
|
|
|
4018 }
|
|
|
4019 } else {
|
|
|
4020 doExec = true;
|
|
|
4021 action = 'insertparagraph';
|
|
|
4022 }
|
|
|
4023 Event.stopEvent(ev);
|
|
|
4024 }
|
|
|
4025 }
|
|
|
4026 if (this.browser.webkit) {
|
|
|
4027 tar = this._getSelectedElement();
|
|
|
4028 if (!this._hasParent(tar, 'li')) {
|
|
|
4029 this.execCommand('insertparagraph', null);
|
|
|
4030 var divs = this._getDoc().body.getElementsByTagName('div');
|
|
|
4031 for (i = 0; i < divs.length; i++) {
|
|
|
4032 if (!Dom.hasClass(divs[i], 'yui-wk-div')) {
|
|
|
4033 Dom.addClass(divs[i], 'yui-wk-p');
|
|
|
4034 }
|
|
|
4035 }
|
|
|
4036 Event.stopEvent(ev);
|
|
|
4037 }
|
|
|
4038 }
|
|
|
4039 } else {
|
|
|
4040 if (this.browser.webkit) {
|
|
|
4041 tar = this._getSelectedElement();
|
|
|
4042 if (!this._hasParent(tar, 'li')) {
|
|
|
4043 if (this.browser.webkit4) {
|
|
|
4044 this.execCommand('insertlinebreak');
|
|
|
4045 } else {
|
|
|
4046 this.execCommand('inserthtml', '<var id="yui-br"></var>');
|
|
|
4047 var holder = this._getDoc().getElementById('yui-br'),
|
|
|
4048 br = this._getDoc().createElement('br'),
|
|
|
4049 caret = this._getDoc().createElement('span');
|
|
|
4050
|
|
|
4051 holder.parentNode.replaceChild(br, holder);
|
|
|
4052 caret.className = 'yui-non';
|
|
|
4053 caret.innerHTML = ' ';
|
|
|
4054 Dom.insertAfter(caret, br);
|
|
|
4055 this._selectNode(caret);
|
|
|
4056 }
|
|
|
4057 Event.stopEvent(ev);
|
|
|
4058 }
|
|
|
4059 }
|
|
|
4060 if (this.browser.ie) {
|
|
|
4061 //Insert a <br> instead of a <p></p> in Internet Explorer
|
|
|
4062 _range = this._getRange();
|
|
|
4063 tar = this._getSelectedElement();
|
|
|
4064 if (!this._isElement(tar, 'li')) {
|
|
|
4065 if (_range) {
|
|
|
4066 _range.pasteHTML('<br>');
|
|
|
4067 _range.collapse(false);
|
|
|
4068 _range.select();
|
|
|
4069 }
|
|
|
4070 Event.stopEvent(ev);
|
|
|
4071 }
|
|
|
4072 }
|
|
|
4073 }
|
|
|
4074 break;
|
|
|
4075 }
|
|
|
4076 if (this.browser.ie) {
|
|
|
4077 this._listFix(ev);
|
|
|
4078 }
|
|
|
4079 if (doExec && action) {
|
|
|
4080 this.execCommand(action, value);
|
|
|
4081 Event.stopEvent(ev);
|
|
|
4082 this.nodeChange();
|
|
|
4083 }
|
|
|
4084 this._storeUndo();
|
|
|
4085 this.fireEvent('editorKeyDown', { type: 'editorKeyDown', target: this, ev: ev });
|
|
|
4086 },
|
|
|
4087 /**
|
|
|
4088 * @private
|
|
|
4089 * @property _fixListRunning
|
|
|
4090 * @type Boolean
|
|
|
4091 * @description Keeps more than one _fixListDupIds from running at the same time.
|
|
|
4092 */
|
|
|
4093 _fixListRunning: null,
|
|
|
4094 /**
|
|
|
4095 * @private
|
|
|
4096 * @method _fixListDupIds
|
|
|
4097 * @description Some browsers will duplicate the id of an LI when created in designMode.
|
|
|
4098 * This method will fix the duplicate id issue. However it will only preserve the first element
|
|
|
4099 * in the document list with the unique id.
|
|
|
4100 */
|
|
|
4101 _fixListDupIds: function() {
|
|
|
4102 if (this._fixListRunning) {
|
|
|
4103 return false;
|
|
|
4104 }
|
|
|
4105 if (this._getDoc()) {
|
|
|
4106 this._fixListRunning = true;
|
|
|
4107 var lis = this._getDoc().body.getElementsByTagName('li'),
|
|
|
4108 i = 0, ids = {};
|
|
|
4109 for (i = 0; i < lis.length; i++) {
|
|
|
4110 if (lis[i].id) {
|
|
|
4111 if (ids[lis[i].id]) {
|
|
|
4112 lis[i].id = '';
|
|
|
4113 }
|
|
|
4114 ids[lis[i].id] = true;
|
|
|
4115 }
|
|
|
4116 }
|
|
|
4117 this._fixListRunning = false;
|
|
|
4118 }
|
|
|
4119 },
|
|
|
4120 /**
|
|
|
4121 * @private
|
|
|
4122 * @method _listFix
|
|
|
4123 * @param {Event} ev The event we are working on.
|
|
|
4124 * @description Handles the Enter key, Tab Key and Shift + Tab keys for List Items.
|
|
|
4125 */
|
|
|
4126 _listFix: function(ev) {
|
|
|
4127 var testLi = null, par = null, preContent = false, range = null;
|
|
|
4128 //Enter Key
|
|
|
4129 if (this.browser.webkit) {
|
|
|
4130 if (ev.keyCode && (ev.keyCode == 13)) {
|
|
|
4131 if (this._hasParent(this._getSelectedElement(), 'li')) {
|
|
|
4132 var tar = this._hasParent(this._getSelectedElement(), 'li');
|
|
|
4133 if (tar.previousSibling) {
|
|
|
4134 if (tar.firstChild && (tar.firstChild.length == 1)) {
|
|
|
4135 this._selectNode(tar);
|
|
|
4136 }
|
|
|
4137 }
|
|
|
4138 }
|
|
|
4139 }
|
|
|
4140 }
|
|
|
4141 //Shift + Tab Key
|
|
|
4142 if (ev.keyCode && ((!this.browser.webkit3 && (ev.keyCode == 25)) || ((this.browser.webkit3 || !this.browser.webkit) && ((ev.keyCode == 9) && ev.shiftKey)))) {
|
|
|
4143 testLi = this._getSelectedElement();
|
|
|
4144 if (this._hasParent(testLi, 'li')) {
|
|
|
4145 testLi = this._hasParent(testLi, 'li');
|
|
|
4146 if (this._hasParent(testLi, 'ul') || this._hasParent(testLi, 'ol')) {
|
|
|
4147 par = this._hasParent(testLi, 'ul');
|
|
|
4148 if (!par) {
|
|
|
4149 par = this._hasParent(testLi, 'ol');
|
|
|
4150 }
|
|
|
4151 if (this._isElement(par.previousSibling, 'li')) {
|
|
|
4152 par.removeChild(testLi);
|
|
|
4153 par.parentNode.insertBefore(testLi, par.nextSibling);
|
|
|
4154 if (this.browser.ie) {
|
|
|
4155 range = this._getDoc().body.createTextRange();
|
|
|
4156 range.moveToElementText(testLi);
|
|
|
4157 range.collapse(false);
|
|
|
4158 range.select();
|
|
|
4159 }
|
|
|
4160 if (this.browser.webkit) {
|
|
|
4161 this._selectNode(testLi.firstChild);
|
|
|
4162 }
|
|
|
4163 Event.stopEvent(ev);
|
|
|
4164 }
|
|
|
4165 }
|
|
|
4166 }
|
|
|
4167 }
|
|
|
4168 //Tab Key
|
|
|
4169 if (ev.keyCode && ((ev.keyCode == 9) && (!ev.shiftKey))) {
|
|
|
4170 var preLi = this._getSelectedElement();
|
|
|
4171 if (this._hasParent(preLi, 'li')) {
|
|
|
4172 preContent = this._hasParent(preLi, 'li').innerHTML;
|
|
|
4173 }
|
|
|
4174 if (this.browser.webkit) {
|
|
|
4175 this._getDoc().execCommand('inserttext', false, '\t');
|
|
|
4176 }
|
|
|
4177 testLi = this._getSelectedElement();
|
|
|
4178 if (this._hasParent(testLi, 'li')) {
|
|
|
4179 par = this._hasParent(testLi, 'li');
|
|
|
4180 var newUl = this._getDoc().createElement(par.parentNode.tagName.toLowerCase());
|
|
|
4181 if (this.browser.webkit) {
|
|
|
4182 var span = Dom.getElementsByClassName('Apple-tab-span', 'span', par);
|
|
|
4183 //Remove the span element that Safari puts in
|
|
|
4184 if (span[0]) {
|
|
|
4185 par.removeChild(span[0]);
|
|
|
4186 par.innerHTML = Lang.trim(par.innerHTML);
|
|
|
4187 //Put the HTML from the LI into this new LI
|
|
|
4188 if (preContent) {
|
|
|
4189 par.innerHTML = '<span class="yui-non">' + preContent + '</span> ';
|
|
|
4190 } else {
|
|
|
4191 par.innerHTML = '<span class="yui-non"> </span> ';
|
|
|
4192 }
|
|
|
4193 }
|
|
|
4194 } else {
|
|
|
4195 if (preContent) {
|
|
|
4196 par.innerHTML = preContent + ' ';
|
|
|
4197 } else {
|
|
|
4198 par.innerHTML = ' ';
|
|
|
4199 }
|
|
|
4200 }
|
|
|
4201
|
|
|
4202 par.parentNode.replaceChild(newUl, par);
|
|
|
4203 newUl.appendChild(par);
|
|
|
4204 if (this.browser.webkit) {
|
|
|
4205 this._getSelection().setBaseAndExtent(par.firstChild, 1, par.firstChild, par.firstChild.innerText.length);
|
|
|
4206 if (!this.browser.webkit3) {
|
|
|
4207 par.parentNode.parentNode.style.display = 'list-item';
|
|
|
4208 setTimeout(function() {
|
|
|
4209 par.parentNode.parentNode.style.display = 'block';
|
|
|
4210 }, 1);
|
|
|
4211 }
|
|
|
4212 } else if (this.browser.ie) {
|
|
|
4213 range = this._getDoc().body.createTextRange();
|
|
|
4214 range.moveToElementText(par);
|
|
|
4215 range.collapse(false);
|
|
|
4216 range.select();
|
|
|
4217 } else {
|
|
|
4218 this._selectNode(par);
|
|
|
4219 }
|
|
|
4220 Event.stopEvent(ev);
|
|
|
4221 }
|
|
|
4222 if (this.browser.webkit) {
|
|
|
4223 Event.stopEvent(ev);
|
|
|
4224 }
|
|
|
4225 this.nodeChange();
|
|
|
4226 }
|
|
|
4227 },
|
|
|
4228 /**
|
|
|
4229 * @method nodeChange
|
|
|
4230 * @param {Boolean} force Optional paramenter to skip the threshold counter
|
|
|
4231 * @description Handles setting up the toolbar buttons, getting the Dom path, fixing nodes.
|
|
|
4232 */
|
|
|
4233 nodeChange: function(force) {
|
|
|
4234 var NCself = this;
|
|
|
4235 this._storeUndo();
|
|
|
4236 if (this.get('nodeChangeDelay')) {
|
|
|
4237 this._nodeChangeDelayTimer = window.setTimeout(function() {
|
|
|
4238 NCself._nodeChangeDelayTimer = null;
|
|
|
4239 NCself._nodeChange.apply(NCself, arguments);
|
|
|
4240 }, 0);
|
|
|
4241 } else {
|
|
|
4242 this._nodeChange();
|
|
|
4243 }
|
|
|
4244 },
|
|
|
4245 /**
|
|
|
4246 * @private
|
|
|
4247 * @method _nodeChange
|
|
|
4248 * @param {Boolean} force Optional paramenter to skip the threshold counter
|
|
|
4249 * @description Fired from nodeChange in a setTimeout.
|
|
|
4250 */
|
|
|
4251 _nodeChange: function(force) {
|
|
|
4252 var threshold = parseInt(this.get('nodeChangeThreshold'), 10),
|
|
|
4253 thisNodeChange = Math.round(new Date().getTime() / 1000),
|
|
|
4254 self = this;
|
|
|
4255
|
|
|
4256 if (force === true) {
|
|
|
4257 this._lastNodeChange = 0;
|
|
|
4258 }
|
|
|
4259
|
|
|
4260 if ((this._lastNodeChange + threshold) < thisNodeChange) {
|
|
|
4261 if (this._fixNodesTimer === null) {
|
|
|
4262 this._fixNodesTimer = window.setTimeout(function() {
|
|
|
4263 self._fixNodes.call(self);
|
|
|
4264 self._fixNodesTimer = null;
|
|
|
4265 }, 0);
|
|
|
4266 }
|
|
|
4267 }
|
|
|
4268 this._lastNodeChange = thisNodeChange;
|
|
|
4269 if (this.currentEvent) {
|
|
|
4270 try {
|
|
|
4271 this._lastNodeChangeEvent = this.currentEvent.type;
|
|
|
4272 } catch (e) {}
|
|
|
4273 }
|
|
|
4274
|
|
|
4275 var beforeNodeChange = this.fireEvent('beforeNodeChange', { type: 'beforeNodeChange', target: this });
|
|
|
4276 if (beforeNodeChange === false) {
|
|
|
4277 return false;
|
|
|
4278 }
|
|
|
4279 if (this.get('dompath')) {
|
|
|
4280 window.setTimeout(function() {
|
|
|
4281 self._writeDomPath.call(self);
|
|
|
4282 }, 0);
|
|
|
4283 }
|
|
|
4284 //Check to see if we are disabled before continuing
|
|
|
4285 if (!this.get('disabled')) {
|
|
|
4286 if (this.STOP_NODE_CHANGE) {
|
|
|
4287 //Reset this var for next action
|
|
|
4288 this.STOP_NODE_CHANGE = false;
|
|
|
4289 return false;
|
|
|
4290 } else {
|
|
|
4291 var sel = this._getSelection(),
|
|
|
4292 range = this._getRange(),
|
|
|
4293 el = this._getSelectedElement(),
|
|
|
4294 fn_button = this.toolbar.getButtonByValue('fontname'),
|
|
|
4295 fs_button = this.toolbar.getButtonByValue('fontsize'),
|
|
|
4296 undo_button = this.toolbar.getButtonByValue('undo'),
|
|
|
4297 redo_button = this.toolbar.getButtonByValue('redo');
|
|
|
4298
|
|
|
4299 //Handle updating the toolbar with active buttons
|
|
|
4300 var _ex = {};
|
|
|
4301 if (this._lastButton) {
|
|
|
4302 _ex[this._lastButton.id] = true;
|
|
|
4303 //this._lastButton = null;
|
|
|
4304 }
|
|
|
4305 if (!this._isElement(el, 'body')) {
|
|
|
4306 if (fn_button) {
|
|
|
4307 _ex[fn_button.get('id')] = true;
|
|
|
4308 }
|
|
|
4309 if (fs_button) {
|
|
|
4310 _ex[fs_button.get('id')] = true;
|
|
|
4311 }
|
|
|
4312 }
|
|
|
4313 if (redo_button) {
|
|
|
4314 delete _ex[redo_button.get('id')];
|
|
|
4315 }
|
|
|
4316 this.toolbar.resetAllButtons(_ex);
|
|
|
4317
|
|
|
4318 //Handle disabled buttons
|
|
|
4319 for (var d = 0; d < this._disabled.length; d++) {
|
|
|
4320 var _button = this.toolbar.getButtonByValue(this._disabled[d]);
|
|
|
4321 if (_button && _button.get) {
|
|
|
4322 if (this._lastButton && (_button.get('id') === this._lastButton.id)) {
|
|
|
4323 //Skip
|
|
|
4324 } else {
|
|
|
4325 if (!this._hasSelection() && !this.get('insert')) {
|
|
|
4326 switch (this._disabled[d]) {
|
|
|
4327 case 'fontname':
|
|
|
4328 case 'fontsize':
|
|
|
4329 break;
|
|
|
4330 default:
|
|
|
4331 //No Selection - disable
|
|
|
4332 this.toolbar.disableButton(_button);
|
|
|
4333 }
|
|
|
4334 } else {
|
|
|
4335 if (!this._alwaysDisabled[this._disabled[d]]) {
|
|
|
4336 this.toolbar.enableButton(_button);
|
|
|
4337 }
|
|
|
4338 }
|
|
|
4339 if (!this._alwaysEnabled[this._disabled[d]]) {
|
|
|
4340 this.toolbar.deselectButton(_button);
|
|
|
4341 }
|
|
|
4342 }
|
|
|
4343 }
|
|
|
4344 }
|
|
|
4345 var path = this._getDomPath();
|
|
|
4346 var tag = null, cmd = null;
|
|
|
4347 for (var i = 0; i < path.length; i++) {
|
|
|
4348 tag = path[i].tagName.toLowerCase();
|
|
|
4349 if (path[i].getAttribute('tag')) {
|
|
|
4350 tag = path[i].getAttribute('tag').toLowerCase();
|
|
|
4351 }
|
|
|
4352 cmd = this._tag2cmd[tag];
|
|
|
4353 if (cmd === undefined) {
|
|
|
4354 cmd = [];
|
|
|
4355 }
|
|
|
4356 if (!Lang.isArray(cmd)) {
|
|
|
4357 cmd = [cmd];
|
|
|
4358 }
|
|
|
4359
|
|
|
4360 //Bold and Italic styles
|
|
|
4361 if (path[i].style.fontWeight.toLowerCase() == 'bold') {
|
|
|
4362 cmd[cmd.length] = 'bold';
|
|
|
4363 }
|
|
|
4364 if (path[i].style.fontStyle.toLowerCase() == 'italic') {
|
|
|
4365 cmd[cmd.length] = 'italic';
|
|
|
4366 }
|
|
|
4367 if (path[i].style.textDecoration.toLowerCase() == 'underline') {
|
|
|
4368 cmd[cmd.length] = 'underline';
|
|
|
4369 }
|
|
|
4370 if (path[i].style.textDecoration.toLowerCase() == 'line-through') {
|
|
|
4371 cmd[cmd.length] = 'strikethrough';
|
|
|
4372 }
|
|
|
4373 if (cmd.length > 0) {
|
|
|
4374 for (var j = 0; j < cmd.length; j++) {
|
|
|
4375 this.toolbar.selectButton(cmd[j]);
|
|
|
4376 this.toolbar.enableButton(cmd[j]);
|
|
|
4377 }
|
|
|
4378 }
|
|
|
4379 //Handle Alignment
|
|
|
4380 switch (path[i].style.textAlign.toLowerCase()) {
|
|
|
4381 case 'left':
|
|
|
4382 case 'right':
|
|
|
4383 case 'center':
|
|
|
4384 case 'justify':
|
|
|
4385 var alignType = path[i].style.textAlign.toLowerCase();
|
|
|
4386 if (path[i].style.textAlign.toLowerCase() == 'justify') {
|
|
|
4387 alignType = 'full';
|
|
|
4388 }
|
|
|
4389 this.toolbar.selectButton('justify' + alignType);
|
|
|
4390 this.toolbar.enableButton('justify' + alignType);
|
|
|
4391 break;
|
|
|
4392 }
|
|
|
4393 }
|
|
|
4394 //After for loop
|
|
|
4395
|
|
|
4396 //Reset Font Family and Size to the inital configs
|
|
|
4397 if (fn_button) {
|
|
|
4398 var family = fn_button._configs.label._initialConfig.value;
|
|
|
4399 fn_button.set('label', '<span class="yui-toolbar-fontname-' + this._cleanClassName(family) + '">' + family + '</span>');
|
|
|
4400 this._updateMenuChecked('fontname', family);
|
|
|
4401 }
|
|
|
4402
|
|
|
4403 if (fs_button) {
|
|
|
4404 fs_button.set('label', fs_button._configs.label._initialConfig.value);
|
|
|
4405 }
|
|
|
4406
|
|
|
4407 var hd_button = this.toolbar.getButtonByValue('heading');
|
|
|
4408 if (hd_button) {
|
|
|
4409 hd_button.set('label', hd_button._configs.label._initialConfig.value);
|
|
|
4410 this._updateMenuChecked('heading', 'none');
|
|
|
4411 }
|
|
|
4412 var img_button = this.toolbar.getButtonByValue('insertimage');
|
|
|
4413 if (img_button && this.currentWindow && (this.currentWindow.name == 'insertimage')) {
|
|
|
4414 this.toolbar.disableButton(img_button);
|
|
|
4415 }
|
|
|
4416 if (this._lastButton && this._lastButton.isSelected) {
|
|
|
4417 this.toolbar.deselectButton(this._lastButton.id);
|
|
|
4418 }
|
|
|
4419 this._undoNodeChange();
|
|
|
4420 }
|
|
|
4421 }
|
|
|
4422
|
|
|
4423 this.fireEvent('afterNodeChange', { type: 'afterNodeChange', target: this });
|
|
|
4424 },
|
|
|
4425 /**
|
|
|
4426 * @private
|
|
|
4427 * @method _updateMenuChecked
|
|
|
4428 * @param {Object} button The command identifier of the button you want to check
|
|
|
4429 * @param {String} value The value of the menu item you want to check
|
|
|
4430 * @param {<a href="YAHOO.widget.Toolbar.html">YAHOO.widget.Toolbar</a>} The Toolbar instance the button belongs to (defaults to this.toolbar)
|
|
|
4431 * @description Gets the menu from a button instance, if the menu is not rendered it will render it. It will then search the menu for the specified value, unchecking all other items and checking the specified on.
|
|
|
4432 */
|
|
|
4433 _updateMenuChecked: function(button, value, tbar) {
|
|
|
4434 if (!tbar) {
|
|
|
4435 tbar = this.toolbar;
|
|
|
4436 }
|
|
|
4437 var _button = tbar.getButtonByValue(button);
|
|
|
4438 _button.checkValue(value);
|
|
|
4439 },
|
|
|
4440 /**
|
|
|
4441 * @private
|
|
|
4442 * @method _handleToolbarClick
|
|
|
4443 * @param {Event} ev The event that triggered the button click
|
|
|
4444 * @description This is an event handler attached to the Toolbar's buttonClick event. It will fire execCommand with the command identifier from the Toolbar Button.
|
|
|
4445 */
|
|
|
4446 _handleToolbarClick: function(ev) {
|
|
|
4447 var value = '';
|
|
|
4448 var str = '';
|
|
|
4449 var cmd = ev.button.value;
|
|
|
4450 if (ev.button.menucmd) {
|
|
|
4451 value = cmd;
|
|
|
4452 cmd = ev.button.menucmd;
|
|
|
4453 }
|
|
|
4454 this._lastButton = ev.button;
|
|
|
4455 if (this.STOP_EXEC_COMMAND) {
|
|
|
4456 this.STOP_EXEC_COMMAND = false;
|
|
|
4457 return false;
|
|
|
4458 } else {
|
|
|
4459 this.execCommand(cmd, value);
|
|
|
4460 if (!this.browser.webkit) {
|
|
|
4461 var Fself = this;
|
|
|
4462 setTimeout(function() {
|
|
|
4463 Fself.focus.call(Fself);
|
|
|
4464 }, 5);
|
|
|
4465 }
|
|
|
4466 }
|
|
|
4467 Event.stopEvent(ev);
|
|
|
4468 },
|
|
|
4469 /**
|
|
|
4470 * @private
|
|
|
4471 * @method _setupAfterElement
|
|
|
4472 * @description Creates the accessibility h2 header and places it after the iframe in the Dom for navigation.
|
|
|
4473 */
|
|
|
4474 _setupAfterElement: function() {
|
|
|
4475 if (!this.beforeElement) {
|
|
|
4476 this.beforeElement = document.createElement('h2');
|
|
|
4477 this.beforeElement.className = 'yui-editor-skipheader';
|
|
|
4478 this.beforeElement.tabIndex = '-1';
|
|
|
4479 this.beforeElement.innerHTML = this.STR_BEFORE_EDITOR;
|
|
|
4480 this.get('element_cont').get('firstChild').insertBefore(this.beforeElement, this.toolbar.get('nextSibling'));
|
|
|
4481 }
|
|
|
4482 if (!this.afterElement) {
|
|
|
4483 this.afterElement = document.createElement('h2');
|
|
|
4484 this.afterElement.className = 'yui-editor-skipheader';
|
|
|
4485 this.afterElement.tabIndex = '-1';
|
|
|
4486 this.afterElement.innerHTML = this.STR_LEAVE_EDITOR;
|
|
|
4487 this.get('element_cont').get('firstChild').appendChild(this.afterElement);
|
|
|
4488 }
|
|
|
4489 },
|
|
|
4490 /**
|
|
|
4491 * @private
|
|
|
4492 * @method _disableEditor
|
|
|
4493 * @param {Boolean} disabled Pass true to disable, false to enable
|
|
|
4494 * @description Creates a mask to place over the Editor.
|
|
|
4495 */
|
|
|
4496 _disableEditor: function(disabled) {
|
|
|
4497 var iframe, par, html, height;
|
|
|
4498 if (!this.get('disabled_iframe')) {
|
|
|
4499 iframe = this._createIframe();
|
|
|
4500 iframe.set('id', 'disabled_' + this.get('iframe').get('id'));
|
|
|
4501 iframe.setStyle('height', '100%');
|
|
|
4502 iframe.setStyle('display', 'none');
|
|
|
4503 iframe.setStyle('visibility', 'visible');
|
|
|
4504 this.set('disabled_iframe', iframe);
|
|
|
4505 par = this.get('iframe').get('parentNode');
|
|
|
4506 par.appendChild(iframe.get('element'));
|
|
|
4507 }
|
|
|
4508 if (!iframe) {
|
|
|
4509 iframe = this.get('disabled_iframe');
|
|
|
4510 }
|
|
|
4511 if (disabled) {
|
|
|
4512 this._orgIframe = this.get('iframe');
|
|
|
4513
|
|
|
4514 if (this.toolbar) {
|
|
|
4515 this.toolbar.set('disabled', true);
|
|
|
4516 }
|
|
|
4517
|
|
|
4518 html = this.getEditorHTML();
|
|
|
4519 height = this.get('iframe').get('offsetHeight');
|
|
|
4520 iframe.setStyle('visibility', '');
|
|
|
4521 iframe.setStyle('position', '');
|
|
|
4522 iframe.setStyle('top', '');
|
|
|
4523 iframe.setStyle('left', '');
|
|
|
4524 this._orgIframe.setStyle('visibility', 'hidden');
|
|
|
4525 this._orgIframe.setStyle('position', 'absolute');
|
|
|
4526 this._orgIframe.setStyle('top', '-99999px');
|
|
|
4527 this._orgIframe.setStyle('left', '-99999px');
|
|
|
4528 this.set('iframe', iframe);
|
|
|
4529 this._setInitialContent(true);
|
|
|
4530
|
|
|
4531 if (!this._mask) {
|
|
|
4532 this._mask = document.createElement('DIV');
|
|
|
4533 Dom.addClass(this._mask, 'yui-editor-masked');
|
|
|
4534 if (this.browser.ie) {
|
|
|
4535 this._mask.style.height = height + 'px';
|
|
|
4536 }
|
|
|
4537 this.get('iframe').get('parentNode').appendChild(this._mask);
|
|
|
4538 }
|
|
|
4539 this.on('editorContentReloaded', function() {
|
|
|
4540 this._getDoc().body._rteLoaded = false;
|
|
|
4541 this.setEditorHTML(html);
|
|
|
4542 iframe.setStyle('display', 'block');
|
|
|
4543 this.unsubscribeAll('editorContentReloaded');
|
|
|
4544 });
|
|
|
4545 } else {
|
|
|
4546 if (this._mask) {
|
|
|
4547 this._mask.parentNode.removeChild(this._mask);
|
|
|
4548 this._mask = null;
|
|
|
4549 if (this.toolbar) {
|
|
|
4550 this.toolbar.set('disabled', false);
|
|
|
4551 }
|
|
|
4552 iframe.setStyle('visibility', 'hidden');
|
|
|
4553 iframe.setStyle('position', 'absolute');
|
|
|
4554 iframe.setStyle('top', '-99999px');
|
|
|
4555 iframe.setStyle('left', '-99999px');
|
|
|
4556 this._orgIframe.setStyle('visibility', '');
|
|
|
4557 this._orgIframe.setStyle('position', '');
|
|
|
4558 this._orgIframe.setStyle('top', '');
|
|
|
4559 this._orgIframe.setStyle('left', '');
|
|
|
4560 this.set('iframe', this._orgIframe);
|
|
|
4561
|
|
|
4562 this.focus();
|
|
|
4563 var self = this;
|
|
|
4564 window.setTimeout(function() {
|
|
|
4565 self.nodeChange.call(self);
|
|
|
4566 }, 100);
|
|
|
4567 }
|
|
|
4568 }
|
|
|
4569 },
|
|
|
4570 /**
|
|
|
4571 * @property SEP_DOMPATH
|
|
|
4572 * @description The value to place in between the Dom path items
|
|
|
4573 * @type String
|
|
|
4574 */
|
|
|
4575 SEP_DOMPATH: '<',
|
|
|
4576 /**
|
|
|
4577 * @property STR_LEAVE_EDITOR
|
|
|
4578 * @description The accessibility string for the element after the iFrame
|
|
|
4579 * @type String
|
|
|
4580 */
|
|
|
4581 STR_LEAVE_EDITOR: 'You have left the Rich Text Editor.',
|
|
|
4582 /**
|
|
|
4583 * @property STR_BEFORE_EDITOR
|
|
|
4584 * @description The accessibility string for the element before the iFrame
|
|
|
4585 * @type String
|
|
|
4586 */
|
|
|
4587 STR_BEFORE_EDITOR: 'This text field can contain stylized text and graphics. To cycle through all formatting options, use the keyboard shortcut Shift + Escape to place focus on the toolbar and navigate between options with your arrow keys. To exit this text editor use the Escape key and continue tabbing. <h4>Common formatting keyboard shortcuts:</h4><ul><li>Control Shift B sets text to bold</li> <li>Control Shift I sets text to italic</li> <li>Control Shift U underlines text</li> <li>Control Shift L adds an HTML link</li></ul>',
|
|
|
4588 /**
|
|
|
4589 * @property STR_TITLE
|
|
|
4590 * @description The Title of the HTML document that is created in the iFrame
|
|
|
4591 * @type String
|
|
|
4592 */
|
|
|
4593 STR_TITLE: 'Rich Text Area.',
|
|
|
4594 /**
|
|
|
4595 * @property STR_IMAGE_HERE
|
|
|
4596 * @description The text to place in the URL textbox when using the blankimage.
|
|
|
4597 * @type String
|
|
|
4598 */
|
|
|
4599 STR_IMAGE_HERE: 'Image URL Here',
|
|
|
4600 /**
|
|
|
4601 * @property STR_IMAGE_URL
|
|
|
4602 * @description The label string for Image URL
|
|
|
4603 * @type String
|
|
|
4604 */
|
|
|
4605 STR_IMAGE_URL: 'Image URL',
|
|
|
4606 /**
|
|
|
4607 * @property STR_LINK_URL
|
|
|
4608 * @description The label string for the Link URL.
|
|
|
4609 * @type String
|
|
|
4610 */
|
|
|
4611 STR_LINK_URL: 'Link URL',
|
|
|
4612 /**
|
|
|
4613 * @protected
|
|
|
4614 * @property STOP_EXEC_COMMAND
|
|
|
4615 * @description Set to true when you want the default execCommand function to not process anything
|
|
|
4616 * @type Boolean
|
|
|
4617 */
|
|
|
4618 STOP_EXEC_COMMAND: false,
|
|
|
4619 /**
|
|
|
4620 * @protected
|
|
|
4621 * @property STOP_NODE_CHANGE
|
|
|
4622 * @description Set to true when you want the default nodeChange function to not process anything
|
|
|
4623 * @type Boolean
|
|
|
4624 */
|
|
|
4625 STOP_NODE_CHANGE: false,
|
|
|
4626 /**
|
|
|
4627 * @protected
|
|
|
4628 * @property CLASS_NOEDIT
|
|
|
4629 * @description CSS class applied to elements that are not editable.
|
|
|
4630 * @type String
|
|
|
4631 */
|
|
|
4632 CLASS_NOEDIT: 'yui-noedit',
|
|
|
4633 /**
|
|
|
4634 * @protected
|
|
|
4635 * @property CLASS_CONTAINER
|
|
|
4636 * @description Default CSS class to apply to the editors container element
|
|
|
4637 * @type String
|
|
|
4638 */
|
|
|
4639 CLASS_CONTAINER: 'yui-editor-container',
|
|
|
4640 /**
|
|
|
4641 * @protected
|
|
|
4642 * @property CLASS_EDITABLE
|
|
|
4643 * @description Default CSS class to apply to the editors iframe element
|
|
|
4644 * @type String
|
|
|
4645 */
|
|
|
4646 CLASS_EDITABLE: 'yui-editor-editable',
|
|
|
4647 /**
|
|
|
4648 * @protected
|
|
|
4649 * @property CLASS_EDITABLE_CONT
|
|
|
4650 * @description Default CSS class to apply to the editors iframe's parent element
|
|
|
4651 * @type String
|
|
|
4652 */
|
|
|
4653 CLASS_EDITABLE_CONT: 'yui-editor-editable-container',
|
|
|
4654 /**
|
|
|
4655 * @protected
|
|
|
4656 * @property CLASS_PREFIX
|
|
|
4657 * @description Default prefix for dynamically created class names
|
|
|
4658 * @type String
|
|
|
4659 */
|
|
|
4660 CLASS_PREFIX: 'yui-editor',
|
|
|
4661 /**
|
|
|
4662 * @property browser
|
|
|
4663 * @description Standard browser detection
|
|
|
4664 * @type Object
|
|
|
4665 */
|
|
|
4666 browser: function() {
|
|
|
4667 var br = YAHOO.env.ua;
|
|
|
4668 //Check for webkit3
|
|
|
4669 if (br.webkit >= 420) {
|
|
|
4670 br.webkit3 = br.webkit;
|
|
|
4671 } else {
|
|
|
4672 br.webkit3 = 0;
|
|
|
4673 }
|
|
|
4674 if (br.webkit >= 530) {
|
|
|
4675 br.webkit4 = br.webkit;
|
|
|
4676 } else {
|
|
|
4677 br.webkit4 = 0;
|
|
|
4678 }
|
|
|
4679 br.mac = false;
|
|
|
4680 //Check for Mac
|
|
|
4681 if (navigator.userAgent.indexOf('Macintosh') !== -1) {
|
|
|
4682 br.mac = true;
|
|
|
4683 }
|
|
|
4684
|
|
|
4685 return br;
|
|
|
4686 }(),
|
|
|
4687 /**
|
|
|
4688 * @method init
|
|
|
4689 * @description The Editor class' initialization method
|
|
|
4690 */
|
|
|
4691 init: function(p_oElement, p_oAttributes) {
|
|
|
4692
|
|
|
4693 if (!this._defaultToolbar) {
|
|
|
4694 this._defaultToolbar = {
|
|
|
4695 collapse: true,
|
|
|
4696 titlebar: 'Text Editing Tools',
|
|
|
4697 draggable: false,
|
|
|
4698 buttons: [
|
|
|
4699 { group: 'fontstyle', label: 'Font Name and Size',
|
|
|
4700 buttons: [
|
|
|
4701 { type: 'select', label: 'Arial', value: 'fontname', disabled: true,
|
|
|
4702 menu: [
|
|
|
4703 { text: 'Arial', checked: true },
|
|
|
4704 { text: 'Arial Black' },
|
|
|
4705 { text: 'Comic Sans MS' },
|
|
|
4706 { text: 'Courier New' },
|
|
|
4707 { text: 'Lucida Console' },
|
|
|
4708 { text: 'Tahoma' },
|
|
|
4709 { text: 'Times New Roman' },
|
|
|
4710 { text: 'Trebuchet MS' },
|
|
|
4711 { text: 'Verdana' }
|
|
|
4712 ]
|
|
|
4713 },
|
|
|
4714 { type: 'spin', label: '13', value: 'fontsize', range: [ 9, 75 ], disabled: true }
|
|
|
4715 ]
|
|
|
4716 },
|
|
|
4717 { type: 'separator' },
|
|
|
4718 { group: 'textstyle', label: 'Font Style',
|
|
|
4719 buttons: [
|
|
|
4720 { type: 'push', label: 'Bold CTRL + SHIFT + B', value: 'bold' },
|
|
|
4721 { type: 'push', label: 'Italic CTRL + SHIFT + I', value: 'italic' },
|
|
|
4722 { type: 'push', label: 'Underline CTRL + SHIFT + U', value: 'underline' },
|
|
|
4723 { type: 'push', label: 'Strike Through', value: 'strikethrough' },
|
|
|
4724 { type: 'separator' },
|
|
|
4725 { type: 'color', label: 'Font Color', value: 'forecolor', disabled: true },
|
|
|
4726 { type: 'color', label: 'Background Color', value: 'backcolor', disabled: true }
|
|
|
4727
|
|
|
4728 ]
|
|
|
4729 },
|
|
|
4730 { type: 'separator' },
|
|
|
4731 { group: 'indentlist', label: 'Lists',
|
|
|
4732 buttons: [
|
|
|
4733 { type: 'push', label: 'Create an Unordered List', value: 'insertunorderedlist' },
|
|
|
4734 { type: 'push', label: 'Create an Ordered List', value: 'insertorderedlist' }
|
|
|
4735 ]
|
|
|
4736 },
|
|
|
4737 { type: 'separator' },
|
|
|
4738 { group: 'insertitem', label: 'Insert Item',
|
|
|
4739 buttons: [
|
|
|
4740 { type: 'push', label: 'HTML Link CTRL + SHIFT + L', value: 'createlink', disabled: true },
|
|
|
4741 { type: 'push', label: 'Insert Image', value: 'insertimage' }
|
|
|
4742 ]
|
|
|
4743 }
|
|
|
4744 ]
|
|
|
4745 };
|
|
|
4746 }
|
|
|
4747
|
|
|
4748 YAHOO.widget.SimpleEditor.superclass.init.call(this, p_oElement, p_oAttributes);
|
|
|
4749 YAHOO.widget.EditorInfo._instances[this.get('id')] = this;
|
|
|
4750
|
|
|
4751
|
|
|
4752 this.currentElement = [];
|
|
|
4753 this.on('contentReady', function() {
|
|
|
4754 this.DOMReady = true;
|
|
|
4755 this.fireQueue();
|
|
|
4756 }, this, true);
|
|
|
4757
|
|
|
4758 },
|
|
|
4759 /**
|
|
|
4760 * @method initAttributes
|
|
|
4761 * @description Initializes all of the configuration attributes used to create
|
|
|
4762 * the editor.
|
|
|
4763 * @param {Object} attr Object literal specifying a set of
|
|
|
4764 * configuration attributes used to create the editor.
|
|
|
4765 */
|
|
|
4766 initAttributes: function(attr) {
|
|
|
4767 YAHOO.widget.SimpleEditor.superclass.initAttributes.call(this, attr);
|
|
|
4768 var self = this;
|
|
|
4769
|
|
|
4770 /**
|
|
|
4771 * @config setDesignMode
|
|
|
4772 * @description Should the Editor set designMode on the document. Default: true.
|
|
|
4773 * @default true
|
|
|
4774 * @type Boolean
|
|
|
4775 */
|
|
|
4776 this.setAttributeConfig('setDesignMode', {
|
|
|
4777 value: ((attr.setDesignMode === false) ? false : true)
|
|
|
4778 });
|
|
|
4779 /**
|
|
|
4780 * @config nodeChangeDelay
|
|
|
4781 * @description Do we wrap the nodeChange method in a timeout for performance. Default: true.
|
|
|
4782 * @default true
|
|
|
4783 * @type Boolean
|
|
|
4784 */
|
|
|
4785 this.setAttributeConfig('nodeChangeDelay', {
|
|
|
4786 value: ((attr.nodeChangeDelay === false) ? false : true)
|
|
|
4787 });
|
|
|
4788 /**
|
|
|
4789 * @config maxUndo
|
|
|
4790 * @description The max number of undo levels to store.
|
|
|
4791 * @default 30
|
|
|
4792 * @type Number
|
|
|
4793 */
|
|
|
4794 this.setAttributeConfig('maxUndo', {
|
|
|
4795 writeOnce: true,
|
|
|
4796 value: attr.maxUndo || 30
|
|
|
4797 });
|
|
|
4798
|
|
|
4799 /**
|
|
|
4800 * @config ptags
|
|
|
4801 * @description If true, the editor uses <P> tags instead of <br> tags. (Use Shift + Enter to get a <br>)
|
|
|
4802 * @default false
|
|
|
4803 * @type Boolean
|
|
|
4804 */
|
|
|
4805 this.setAttributeConfig('ptags', {
|
|
|
4806 writeOnce: true,
|
|
|
4807 value: attr.ptags || false
|
|
|
4808 });
|
|
|
4809 /**
|
|
|
4810 * @config insert
|
|
|
4811 * @description If true, selection is not required for: fontname, fontsize, forecolor, backcolor.
|
|
|
4812 * @default false
|
|
|
4813 * @type Boolean
|
|
|
4814 */
|
|
|
4815 this.setAttributeConfig('insert', {
|
|
|
4816 writeOnce: true,
|
|
|
4817 value: attr.insert || false,
|
|
|
4818 method: function(insert) {
|
|
|
4819 if (insert) {
|
|
|
4820 var buttons = {
|
|
|
4821 fontname: true,
|
|
|
4822 fontsize: true,
|
|
|
4823 forecolor: true,
|
|
|
4824 backcolor: true
|
|
|
4825 };
|
|
|
4826 var tmp = this._defaultToolbar.buttons;
|
|
|
4827 for (var i = 0; i < tmp.length; i++) {
|
|
|
4828 if (tmp[i].buttons) {
|
|
|
4829 for (var a = 0; a < tmp[i].buttons.length; a++) {
|
|
|
4830 if (tmp[i].buttons[a].value) {
|
|
|
4831 if (buttons[tmp[i].buttons[a].value]) {
|
|
|
4832 delete tmp[i].buttons[a].disabled;
|
|
|
4833 }
|
|
|
4834 }
|
|
|
4835 }
|
|
|
4836 }
|
|
|
4837 }
|
|
|
4838 }
|
|
|
4839 }
|
|
|
4840 });
|
|
|
4841 /**
|
|
|
4842 * @config container
|
|
|
4843 * @description Used when dynamically creating the Editor from Javascript with no default textarea.
|
|
|
4844 * We will create one and place it in this container. If no container is passed we will append to document.body.
|
|
|
4845 * @default false
|
|
|
4846 * @type HTMLElement
|
|
|
4847 */
|
|
|
4848 this.setAttributeConfig('container', {
|
|
|
4849 writeOnce: true,
|
|
|
4850 value: attr.container || false
|
|
|
4851 });
|
|
|
4852 /**
|
|
|
4853 * @config plainText
|
|
|
4854 * @description Process the inital textarea data as if it was plain text. Accounting for spaces, tabs and line feeds.
|
|
|
4855 * @default false
|
|
|
4856 * @type Boolean
|
|
|
4857 */
|
|
|
4858 this.setAttributeConfig('plainText', {
|
|
|
4859 writeOnce: true,
|
|
|
4860 value: attr.plainText || false
|
|
|
4861 });
|
|
|
4862 /**
|
|
|
4863 * @private
|
|
|
4864 * @config iframe
|
|
|
4865 * @description Internal config for holding the iframe element.
|
|
|
4866 * @default null
|
|
|
4867 * @type HTMLElement
|
|
|
4868 */
|
|
|
4869 this.setAttributeConfig('iframe', {
|
|
|
4870 value: null
|
|
|
4871 });
|
|
|
4872 /**
|
|
|
4873 * @private
|
|
|
4874 * @config disabled_iframe
|
|
|
4875 * @description Internal config for holding the iframe element used when disabling the Editor.
|
|
|
4876 * @default null
|
|
|
4877 * @type HTMLElement
|
|
|
4878 */
|
|
|
4879 this.setAttributeConfig('disabled_iframe', {
|
|
|
4880 value: null
|
|
|
4881 });
|
|
|
4882 /**
|
|
|
4883 * @private
|
|
|
4884 * @depreciated - No longer used, should use this.get('element')
|
|
|
4885 * @config textarea
|
|
|
4886 * @description Internal config for holding the textarea element (replaced with element).
|
|
|
4887 * @default null
|
|
|
4888 * @type HTMLElement
|
|
|
4889 */
|
|
|
4890 this.setAttributeConfig('textarea', {
|
|
|
4891 value: null,
|
|
|
4892 writeOnce: true
|
|
|
4893 });
|
|
|
4894 /**
|
|
|
4895 * @config nodeChangeThreshold
|
|
|
4896 * @description The number of seconds that need to be in between nodeChange processing
|
|
|
4897 * @default 3
|
|
|
4898 * @type Number
|
|
|
4899 */
|
|
|
4900 this.setAttributeConfig('nodeChangeThreshold', {
|
|
|
4901 value: attr.nodeChangeThreshold || 3,
|
|
|
4902 validator: YAHOO.lang.isNumber
|
|
|
4903 });
|
|
|
4904 /**
|
|
|
4905 * @config allowNoEdit
|
|
|
4906 * @description Should the editor check for non-edit fields. It should be noted that this technique is not perfect. If the user does the right things, they will still be able to make changes.
|
|
|
4907 * Such as highlighting an element below and above the content and hitting a toolbar button or a shortcut key.
|
|
|
4908 * @default false
|
|
|
4909 * @type Boolean
|
|
|
4910 */
|
|
|
4911 this.setAttributeConfig('allowNoEdit', {
|
|
|
4912 value: attr.allowNoEdit || false,
|
|
|
4913 validator: YAHOO.lang.isBoolean
|
|
|
4914 });
|
|
|
4915 /**
|
|
|
4916 * @config limitCommands
|
|
|
4917 * @description Should the Editor limit the allowed execCommands to the ones available in the toolbar. If true, then execCommand and keyboard shortcuts will fail if they are not defined in the toolbar.
|
|
|
4918 * @default false
|
|
|
4919 * @type Boolean
|
|
|
4920 */
|
|
|
4921 this.setAttributeConfig('limitCommands', {
|
|
|
4922 value: attr.limitCommands || false,
|
|
|
4923 validator: YAHOO.lang.isBoolean
|
|
|
4924 });
|
|
|
4925 /**
|
|
|
4926 * @config element_cont
|
|
|
4927 * @description Internal config for the editors container
|
|
|
4928 * @default false
|
|
|
4929 * @type HTMLElement
|
|
|
4930 */
|
|
|
4931 this.setAttributeConfig('element_cont', {
|
|
|
4932 value: attr.element_cont
|
|
|
4933 });
|
|
|
4934 /**
|
|
|
4935 * @private
|
|
|
4936 * @config editor_wrapper
|
|
|
4937 * @description The outter wrapper for the entire editor.
|
|
|
4938 * @default null
|
|
|
4939 * @type HTMLElement
|
|
|
4940 */
|
|
|
4941 this.setAttributeConfig('editor_wrapper', {
|
|
|
4942 value: attr.editor_wrapper || null,
|
|
|
4943 writeOnce: true
|
|
|
4944 });
|
|
|
4945 /**
|
|
|
4946 * @attribute height
|
|
|
4947 * @description The height of the editor iframe container, not including the toolbar..
|
|
|
4948 * @default Best guessed size of the textarea, for best results use CSS to style the height of the textarea or pass it in as an argument
|
|
|
4949 * @type String
|
|
|
4950 */
|
|
|
4951 this.setAttributeConfig('height', {
|
|
|
4952 value: attr.height || Dom.getStyle(self.get('element'), 'height'),
|
|
|
4953 method: function(height) {
|
|
|
4954 if (this._rendered) {
|
|
|
4955 //We have been rendered, change the height
|
|
|
4956 if (this.get('animate')) {
|
|
|
4957 var anim = new YAHOO.util.Anim(this.get('iframe').get('parentNode'), {
|
|
|
4958 height: {
|
|
|
4959 to: parseInt(height, 10)
|
|
|
4960 }
|
|
|
4961 }, 0.5);
|
|
|
4962 anim.animate();
|
|
|
4963 } else {
|
|
|
4964 Dom.setStyle(this.get('iframe').get('parentNode'), 'height', height);
|
|
|
4965 }
|
|
|
4966 }
|
|
|
4967 }
|
|
|
4968 });
|
|
|
4969 /**
|
|
|
4970 * @config autoHeight
|
|
|
4971 * @description Remove the scrollbars from the edit area and resize it to fit the content. It will not go any lower than the current config height.
|
|
|
4972 * @default false
|
|
|
4973 * @type Boolean || Number
|
|
|
4974 */
|
|
|
4975 this.setAttributeConfig('autoHeight', {
|
|
|
4976 value: attr.autoHeight || false,
|
|
|
4977 method: function(a) {
|
|
|
4978 if (a) {
|
|
|
4979 if (this.get('iframe')) {
|
|
|
4980 this.get('iframe').get('element').setAttribute('scrolling', 'no');
|
|
|
4981 }
|
|
|
4982 this.on('afterNodeChange', this._handleAutoHeight, this, true);
|
|
|
4983 this.on('editorKeyDown', this._handleAutoHeight, this, true);
|
|
|
4984 this.on('editorKeyPress', this._handleAutoHeight, this, true);
|
|
|
4985 } else {
|
|
|
4986 if (this.get('iframe')) {
|
|
|
4987 this.get('iframe').get('element').setAttribute('scrolling', 'auto');
|
|
|
4988 }
|
|
|
4989 this.unsubscribe('afterNodeChange', this._handleAutoHeight);
|
|
|
4990 this.unsubscribe('editorKeyDown', this._handleAutoHeight);
|
|
|
4991 this.unsubscribe('editorKeyPress', this._handleAutoHeight);
|
|
|
4992 }
|
|
|
4993 }
|
|
|
4994 });
|
|
|
4995 /**
|
|
|
4996 * @attribute width
|
|
|
4997 * @description The width of the editor container.
|
|
|
4998 * @default Best guessed size of the textarea, for best results use CSS to style the width of the textarea or pass it in as an argument
|
|
|
4999 * @type String
|
|
|
5000 */
|
|
|
5001 this.setAttributeConfig('width', {
|
|
|
5002 value: attr.width || Dom.getStyle(this.get('element'), 'width'),
|
|
|
5003 method: function(width) {
|
|
|
5004 if (this._rendered) {
|
|
|
5005 //We have been rendered, change the width
|
|
|
5006 if (this.get('animate')) {
|
|
|
5007 var anim = new YAHOO.util.Anim(this.get('element_cont').get('element'), {
|
|
|
5008 width: {
|
|
|
5009 to: parseInt(width, 10)
|
|
|
5010 }
|
|
|
5011 }, 0.5);
|
|
|
5012 anim.animate();
|
|
|
5013 } else {
|
|
|
5014 this.get('element_cont').setStyle('width', width);
|
|
|
5015 }
|
|
|
5016 }
|
|
|
5017 }
|
|
|
5018 });
|
|
|
5019
|
|
|
5020 /**
|
|
|
5021 * @attribute blankimage
|
|
|
5022 * @description The URL for the image placeholder to put in when inserting an image.
|
|
|
5023 * @default The yahooapis.com address for the current release + 'assets/blankimage.png'
|
|
|
5024 * @type String
|
|
|
5025 */
|
|
|
5026 this.setAttributeConfig('blankimage', {
|
|
|
5027 value: attr.blankimage || this._getBlankImage()
|
|
|
5028 });
|
|
|
5029 /**
|
|
|
5030 * @attribute css
|
|
|
5031 * @description The Base CSS used to format the content of the editor
|
|
|
5032 * @default <code><pre>html {
|
|
|
5033 height: 95%;
|
|
|
5034 }
|
|
|
5035 body {
|
|
|
5036 height: 100%;
|
|
|
5037 padding: 7px; background-color: #fff; font:13px/1.22 arial,helvetica,clean,sans-serif;*font-size:small;*font:x-small;
|
|
|
5038 }
|
|
|
5039 a {
|
|
|
5040 color: blue;
|
|
|
5041 text-decoration: underline;
|
|
|
5042 cursor: pointer;
|
|
|
5043 }
|
|
|
5044 .warning-localfile {
|
|
|
5045 border-bottom: 1px dashed red !important;
|
|
|
5046 }
|
|
|
5047 .yui-busy {
|
|
|
5048 cursor: wait !important;
|
|
|
5049 }
|
|
|
5050 img.selected { //Safari image selection
|
|
|
5051 border: 2px dotted #808080;
|
|
|
5052 }
|
|
|
5053 img {
|
|
|
5054 cursor: pointer !important;
|
|
|
5055 border: none;
|
|
|
5056 }
|
|
|
5057 </pre></code>
|
|
|
5058 * @type String
|
|
|
5059 */
|
|
|
5060 this.setAttributeConfig('css', {
|
|
|
5061 value: attr.css || this._defaultCSS,
|
|
|
5062 writeOnce: true
|
|
|
5063 });
|
|
|
5064 /**
|
|
|
5065 * @attribute html
|
|
|
5066 * @description The default HTML to be written to the iframe document before the contents are loaded (Note that the DOCTYPE attr will be added at render item)
|
|
|
5067 * @default This HTML requires a few things if you are to override:
|
|
|
5068 <p><code>{TITLE}, {CSS}, {HIDDEN_CSS}, {EXTRA_CSS}</code> and <code>{CONTENT}</code> need to be there, they are passed to YAHOO.lang.substitute to be replace with other strings.<p>
|
|
|
5069 <p><code>onload="document.body._rteLoaded = true;"</code> : the onload statement must be there or the editor will not finish loading.</p>
|
|
|
5070 <code>
|
|
|
5071 <pre>
|
|
|
5072 <html>
|
|
|
5073 <head>
|
|
|
5074 <title>{TITLE}</title>
|
|
|
5075 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
|
|
|
5076 <style>
|
|
|
5077 {CSS}
|
|
|
5078 </style>
|
|
|
5079 <style>
|
|
|
5080 {HIDDEN_CSS}
|
|
|
5081 </style>
|
|
|
5082 <style>
|
|
|
5083 {EXTRA_CSS}
|
|
|
5084 </style>
|
|
|
5085 </head>
|
|
|
5086 <body onload="document.body._rteLoaded = true;">
|
|
|
5087 {CONTENT}
|
|
|
5088 </body>
|
|
|
5089 </html>
|
|
|
5090 </pre>
|
|
|
5091 </code>
|
|
|
5092 * @type String
|
|
|
5093 */
|
|
|
5094 this.setAttributeConfig('html', {
|
|
|
5095 value: attr.html || '<html><head><title>{TITLE}</title><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><base href="' + this._baseHREF + '"><style>{CSS}</style><style>{HIDDEN_CSS}</style><style>{EXTRA_CSS}</style></head><body onload="document.body._rteLoaded = true;">{CONTENT}</body></html>',
|
|
|
5096 writeOnce: true
|
|
|
5097 });
|
|
|
5098
|
|
|
5099 /**
|
|
|
5100 * @attribute extracss
|
|
|
5101 * @description Extra user defined css to load after the default SimpleEditor CSS
|
|
|
5102 * @default ''
|
|
|
5103 * @type String
|
|
|
5104 */
|
|
|
5105 this.setAttributeConfig('extracss', {
|
|
|
5106 value: attr.extracss || '',
|
|
|
5107 writeOnce: true
|
|
|
5108 });
|
|
|
5109
|
|
|
5110 /**
|
|
|
5111 * @attribute handleSubmit
|
|
|
5112 * @description Config handles if the editor will attach itself to the textareas parent form's submit handler.
|
|
|
5113 If it is set to true, the editor will attempt to attach a submit listener to the textareas parent form.
|
|
|
5114 Then it will trigger the editors save handler and place the new content back into the text area before the form is submitted.
|
|
|
5115 * @default false
|
|
|
5116 * @type Boolean
|
|
|
5117 */
|
|
|
5118 this.setAttributeConfig('handleSubmit', {
|
|
|
5119 value: attr.handleSubmit || false,
|
|
|
5120 method: function(exec) {
|
|
|
5121 if (this.get('element').form) {
|
|
|
5122 if (!this._formButtons) {
|
|
|
5123 this._formButtons = [];
|
|
|
5124 }
|
|
|
5125 if (exec) {
|
|
|
5126 Event.on(this.get('element').form, 'submit', this._handleFormSubmit, this, true);
|
|
|
5127 var i = this.get('element').form.getElementsByTagName('input');
|
|
|
5128 for (var s = 0; s < i.length; s++) {
|
|
|
5129 var type = i[s].getAttribute('type');
|
|
|
5130 if (type && (type.toLowerCase() == 'submit')) {
|
|
|
5131 Event.on(i[s], 'click', this._handleFormButtonClick, this, true);
|
|
|
5132 this._formButtons[this._formButtons.length] = i[s];
|
|
|
5133 }
|
|
|
5134 }
|
|
|
5135 } else {
|
|
|
5136 Event.removeListener(this.get('element').form, 'submit', this._handleFormSubmit);
|
|
|
5137 if (this._formButtons) {
|
|
|
5138 Event.removeListener(this._formButtons, 'click', this._handleFormButtonClick);
|
|
|
5139 }
|
|
|
5140 }
|
|
|
5141 }
|
|
|
5142 }
|
|
|
5143 });
|
|
|
5144 /**
|
|
|
5145 * @attribute disabled
|
|
|
5146 * @description This will toggle the editor's disabled state. When the editor is disabled, designMode is turned off and a mask is placed over the iframe so no interaction can take place.
|
|
|
5147 All Toolbar buttons are also disabled so they cannot be used.
|
|
|
5148 * @default false
|
|
|
5149 * @type Boolean
|
|
|
5150 */
|
|
|
5151
|
|
|
5152 this.setAttributeConfig('disabled', {
|
|
|
5153 value: false,
|
|
|
5154 method: function(disabled) {
|
|
|
5155 if (this._rendered) {
|
|
|
5156 this._disableEditor(disabled);
|
|
|
5157 }
|
|
|
5158 }
|
|
|
5159 });
|
|
|
5160 /**
|
|
|
5161 * @config saveEl
|
|
|
5162 * @description When save HTML is called, this element will be updated as well as the source of data.
|
|
|
5163 * @default element
|
|
|
5164 * @type HTMLElement
|
|
|
5165 */
|
|
|
5166 this.setAttributeConfig('saveEl', {
|
|
|
5167 value: this.get('element')
|
|
|
5168 });
|
|
|
5169 /**
|
|
|
5170 * @config toolbar_cont
|
|
|
5171 * @description Internal config for the toolbars container
|
|
|
5172 * @default false
|
|
|
5173 * @type Boolean
|
|
|
5174 */
|
|
|
5175 this.setAttributeConfig('toolbar_cont', {
|
|
|
5176 value: null,
|
|
|
5177 writeOnce: true
|
|
|
5178 });
|
|
|
5179 /**
|
|
|
5180 * @attribute toolbar
|
|
|
5181 * @description The default toolbar config.
|
|
|
5182 * @type Object
|
|
|
5183 */
|
|
|
5184 this.setAttributeConfig('toolbar', {
|
|
|
5185 value: attr.toolbar || this._defaultToolbar,
|
|
|
5186 writeOnce: true,
|
|
|
5187 method: function(toolbar) {
|
|
|
5188 if (!toolbar.buttonType) {
|
|
|
5189 toolbar.buttonType = this._defaultToolbar.buttonType;
|
|
|
5190 }
|
|
|
5191 this._defaultToolbar = toolbar;
|
|
|
5192 }
|
|
|
5193 });
|
|
|
5194 /**
|
|
|
5195 * @attribute animate
|
|
|
5196 * @description Should the editor animate window movements
|
|
|
5197 * @default false unless Animation is found, then true
|
|
|
5198 * @type Boolean
|
|
|
5199 */
|
|
|
5200 this.setAttributeConfig('animate', {
|
|
|
5201 value: ((attr.animate) ? ((YAHOO.util.Anim) ? true : false) : false),
|
|
|
5202 validator: function(value) {
|
|
|
5203 var ret = true;
|
|
|
5204 if (!YAHOO.util.Anim) {
|
|
|
5205 ret = false;
|
|
|
5206 }
|
|
|
5207 return ret;
|
|
|
5208 }
|
|
|
5209 });
|
|
|
5210 /**
|
|
|
5211 * @config panel
|
|
|
5212 * @description A reference to the panel we are using for windows.
|
|
|
5213 * @default false
|
|
|
5214 * @type Boolean
|
|
|
5215 */
|
|
|
5216 this.setAttributeConfig('panel', {
|
|
|
5217 value: null,
|
|
|
5218 writeOnce: true,
|
|
|
5219 validator: function(value) {
|
|
|
5220 var ret = true;
|
|
|
5221 if (!YAHOO.widget.Overlay) {
|
|
|
5222 ret = false;
|
|
|
5223 }
|
|
|
5224 return ret;
|
|
|
5225 }
|
|
|
5226 });
|
|
|
5227 /**
|
|
|
5228 * @attribute focusAtStart
|
|
|
5229 * @description Should we focus the window when the content is ready?
|
|
|
5230 * @default false
|
|
|
5231 * @type Boolean
|
|
|
5232 */
|
|
|
5233 this.setAttributeConfig('focusAtStart', {
|
|
|
5234 value: attr.focusAtStart || false,
|
|
|
5235 writeOnce: true,
|
|
|
5236 method: function(fs) {
|
|
|
5237 if (fs) {
|
|
|
5238 this.on('editorContentLoaded', function() {
|
|
|
5239 var self = this;
|
|
|
5240 setTimeout(function() {
|
|
|
5241 self.focus.call(self);
|
|
|
5242 self.editorDirty = false;
|
|
|
5243 }, 400);
|
|
|
5244 }, this, true);
|
|
|
5245 }
|
|
|
5246 }
|
|
|
5247 });
|
|
|
5248 /**
|
|
|
5249 * @attribute dompath
|
|
|
5250 * @description Toggle the display of the current Dom path below the editor
|
|
|
5251 * @default false
|
|
|
5252 * @type Boolean
|
|
|
5253 */
|
|
|
5254 this.setAttributeConfig('dompath', {
|
|
|
5255 value: attr.dompath || false,
|
|
|
5256 method: function(dompath) {
|
|
|
5257 if (dompath && !this.dompath) {
|
|
|
5258 this.dompath = document.createElement('DIV');
|
|
|
5259 this.dompath.id = this.get('id') + '_dompath';
|
|
|
5260 Dom.addClass(this.dompath, 'dompath');
|
|
|
5261 this.get('element_cont').get('firstChild').appendChild(this.dompath);
|
|
|
5262 if (this.get('iframe')) {
|
|
|
5263 this._writeDomPath();
|
|
|
5264 }
|
|
|
5265 } else if (!dompath && this.dompath) {
|
|
|
5266 this.dompath.parentNode.removeChild(this.dompath);
|
|
|
5267 this.dompath = null;
|
|
|
5268 }
|
|
|
5269 }
|
|
|
5270 });
|
|
|
5271 /**
|
|
|
5272 * @attribute markup
|
|
|
5273 * @description Should we try to adjust the markup for the following types: semantic, css, default or xhtml
|
|
|
5274 * @default "semantic"
|
|
|
5275 * @type String
|
|
|
5276 */
|
|
|
5277 this.setAttributeConfig('markup', {
|
|
|
5278 value: attr.markup || 'semantic',
|
|
|
5279 validator: function(markup) {
|
|
|
5280 switch (markup.toLowerCase()) {
|
|
|
5281 case 'semantic':
|
|
|
5282 case 'css':
|
|
|
5283 case 'default':
|
|
|
5284 case 'xhtml':
|
|
|
5285 return true;
|
|
|
5286 }
|
|
|
5287 return false;
|
|
|
5288 }
|
|
|
5289 });
|
|
|
5290 /**
|
|
|
5291 * @attribute removeLineBreaks
|
|
|
5292 * @description Should we remove linebreaks and extra spaces on cleanup
|
|
|
5293 * @default false
|
|
|
5294 * @type Boolean
|
|
|
5295 */
|
|
|
5296 this.setAttributeConfig('removeLineBreaks', {
|
|
|
5297 value: attr.removeLineBreaks || false,
|
|
|
5298 validator: YAHOO.lang.isBoolean
|
|
|
5299 });
|
|
|
5300
|
|
|
5301 /**
|
|
|
5302 * @config drag
|
|
|
5303 * @description Set this config to make the Editor draggable, pass 'proxy' to make use YAHOO.util.DDProxy.
|
|
|
5304 * @type {Boolean/String}
|
|
|
5305 */
|
|
|
5306 this.setAttributeConfig('drag', {
|
|
|
5307 writeOnce: true,
|
|
|
5308 value: attr.drag || false
|
|
|
5309 });
|
|
|
5310
|
|
|
5311 /**
|
|
|
5312 * @config resize
|
|
|
5313 * @description Set this to true to make the Editor Resizable with YAHOO.util.Resize. The default config is available: myEditor._resizeConfig
|
|
|
5314 * Animation will be ignored while performing this resize to allow for the dynamic change in size of the toolbar.
|
|
|
5315 * @type Boolean
|
|
|
5316 */
|
|
|
5317 this.setAttributeConfig('resize', {
|
|
|
5318 writeOnce: true,
|
|
|
5319 value: attr.resize || false
|
|
|
5320 });
|
|
|
5321
|
|
|
5322 /**
|
|
|
5323 * @config filterWord
|
|
|
5324 * @description Attempt to filter out MS Word HTML from the Editor's output.
|
|
|
5325 * @type Boolean
|
|
|
5326 */
|
|
|
5327 this.setAttributeConfig('filterWord', {
|
|
|
5328 value: attr.filterWord || false,
|
|
|
5329 validator: YAHOO.lang.isBoolean
|
|
|
5330 });
|
|
|
5331
|
|
|
5332 },
|
|
|
5333 /**
|
|
|
5334 * @private
|
|
|
5335 * @method _getBlankImage
|
|
|
5336 * @description Retrieves the full url of the image to use as the blank image.
|
|
|
5337 * @return {String} The URL to the blank image
|
|
|
5338 */
|
|
|
5339 _getBlankImage: function() {
|
|
|
5340 if (!this.DOMReady) {
|
|
|
5341 this._queue[this._queue.length] = ['_getBlankImage', arguments];
|
|
|
5342 return '';
|
|
|
5343 }
|
|
|
5344 var img = '';
|
|
|
5345 if (!this._blankImageLoaded) {
|
|
|
5346 if (YAHOO.widget.EditorInfo.blankImage) {
|
|
|
5347 this.set('blankimage', YAHOO.widget.EditorInfo.blankImage);
|
|
|
5348 this._blankImageLoaded = true;
|
|
|
5349 } else {
|
|
|
5350 var div = document.createElement('div');
|
|
|
5351 div.style.position = 'absolute';
|
|
|
5352 div.style.top = '-9999px';
|
|
|
5353 div.style.left = '-9999px';
|
|
|
5354 div.className = this.CLASS_PREFIX + '-blankimage';
|
|
|
5355 document.body.appendChild(div);
|
|
|
5356 img = YAHOO.util.Dom.getStyle(div, 'background-image');
|
|
|
5357 img = img.replace('url(', '').replace(')', '').replace(/"/g, '');
|
|
|
5358 //Adobe AIR Code
|
|
|
5359 img = img.replace('app:/', '');
|
|
|
5360 this.set('blankimage', img);
|
|
|
5361 this._blankImageLoaded = true;
|
|
|
5362 div.parentNode.removeChild(div);
|
|
|
5363 YAHOO.widget.EditorInfo.blankImage = img;
|
|
|
5364 }
|
|
|
5365 } else {
|
|
|
5366 img = this.get('blankimage');
|
|
|
5367 }
|
|
|
5368 return img;
|
|
|
5369 },
|
|
|
5370 /**
|
|
|
5371 * @private
|
|
|
5372 * @method _handleAutoHeight
|
|
|
5373 * @description Handles resizing the editor's height based on the content
|
|
|
5374 */
|
|
|
5375 _handleAutoHeight: function() {
|
|
|
5376 var doc = this._getDoc(),
|
|
|
5377 body = doc.body,
|
|
|
5378 docEl = doc.documentElement;
|
|
|
5379
|
|
|
5380 var height = parseInt(Dom.getStyle(this.get('editor_wrapper'), 'height'), 10);
|
|
|
5381 var newHeight = body.scrollHeight;
|
|
|
5382 if (this.browser.webkit) {
|
|
|
5383 newHeight = docEl.scrollHeight;
|
|
|
5384 }
|
|
|
5385 if (newHeight < parseInt(this.get('height'), 10)) {
|
|
|
5386 newHeight = parseInt(this.get('height'), 10);
|
|
|
5387 }
|
|
|
5388 if ((height != newHeight) && (newHeight >= parseInt(this.get('height'), 10))) {
|
|
|
5389 var anim = this.get('animate');
|
|
|
5390 this.set('animate', false);
|
|
|
5391 this.set('height', newHeight + 'px');
|
|
|
5392 this.set('animate', anim);
|
|
|
5393 if (this.browser.ie) {
|
|
|
5394 //Internet Explorer needs this
|
|
|
5395 this.get('iframe').setStyle('height', '99%');
|
|
|
5396 this.get('iframe').setStyle('zoom', '1');
|
|
|
5397 var self = this;
|
|
|
5398 window.setTimeout(function() {
|
|
|
5399 self.get('iframe').setStyle('height', '100%');
|
|
|
5400 }, 1);
|
|
|
5401 }
|
|
|
5402 }
|
|
|
5403 },
|
|
|
5404 /**
|
|
|
5405 * @private
|
|
|
5406 * @property _formButtons
|
|
|
5407 * @description Array of buttons that are in the Editor's parent form (for handleSubmit)
|
|
|
5408 * @type Array
|
|
|
5409 */
|
|
|
5410 _formButtons: null,
|
|
|
5411 /**
|
|
|
5412 * @private
|
|
|
5413 * @property _formButtonClicked
|
|
|
5414 * @description The form button that was clicked to submit the form.
|
|
|
5415 * @type HTMLElement
|
|
|
5416 */
|
|
|
5417 _formButtonClicked: null,
|
|
|
5418 /**
|
|
|
5419 * @private
|
|
|
5420 * @method _handleFormButtonClick
|
|
|
5421 * @description The click listener assigned to each submit button in the Editor's parent form.
|
|
|
5422 * @param {Event} ev The click event
|
|
|
5423 */
|
|
|
5424 _handleFormButtonClick: function(ev) {
|
|
|
5425 var tar = Event.getTarget(ev);
|
|
|
5426 this._formButtonClicked = tar;
|
|
|
5427 },
|
|
|
5428 /**
|
|
|
5429 * @private
|
|
|
5430 * @method _handleFormSubmit
|
|
|
5431 * @description Handles the form submission.
|
|
|
5432 * @param {Object} ev The Form Submit Event
|
|
|
5433 */
|
|
|
5434 _handleFormSubmit: function(ev) {
|
|
|
5435 this.saveHTML();
|
|
|
5436
|
|
|
5437 var form = this.get('element').form,
|
|
|
5438 tar = this._formButtonClicked || false;
|
|
|
5439
|
|
|
5440 Event.removeListener(form, 'submit', this._handleFormSubmit);
|
|
|
5441 if (YAHOO.env.ua.ie) {
|
|
|
5442 //form.fireEvent("onsubmit");
|
|
|
5443 if (tar && !tar.disabled) {
|
|
|
5444 tar.click();
|
|
|
5445 }
|
|
|
5446 } else { // Gecko, Opera, and Safari
|
|
|
5447 if (tar && !tar.disabled) {
|
|
|
5448 tar.click();
|
|
|
5449 }
|
|
|
5450 var oEvent = document.createEvent("HTMLEvents");
|
|
|
5451 oEvent.initEvent("submit", true, true);
|
|
|
5452 form.dispatchEvent(oEvent);
|
|
|
5453 if (YAHOO.env.ua.webkit) {
|
|
|
5454 if (YAHOO.lang.isFunction(form.submit)) {
|
|
|
5455 form.submit();
|
|
|
5456 }
|
|
|
5457 }
|
|
|
5458 }
|
|
|
5459 //2.6.0
|
|
|
5460 //Removed this, not need since removing Safari 2.x
|
|
|
5461 //Event.stopEvent(ev);
|
|
|
5462 },
|
|
|
5463 /**
|
|
|
5464 * @private
|
|
|
5465 * @method _handleFontSize
|
|
|
5466 * @description Handles the font size button in the toolbar.
|
|
|
5467 * @param {Object} o Object returned from Toolbar's buttonClick Event
|
|
|
5468 */
|
|
|
5469 _handleFontSize: function(o) {
|
|
|
5470 var button = this.toolbar.getButtonById(o.button.id);
|
|
|
5471 var value = button.get('label') + 'px';
|
|
|
5472 this.execCommand('fontsize', value);
|
|
|
5473 return false;
|
|
|
5474 },
|
|
|
5475 /**
|
|
|
5476 * @private
|
|
|
5477 * @description Handles the colorpicker buttons in the toolbar.
|
|
|
5478 * @param {Object} o Object returned from Toolbar's buttonClick Event
|
|
|
5479 */
|
|
|
5480 _handleColorPicker: function(o) {
|
|
|
5481 var cmd = o.button;
|
|
|
5482 var value = '#' + o.color;
|
|
|
5483 if ((cmd == 'forecolor') || (cmd == 'backcolor')) {
|
|
|
5484 this.execCommand(cmd, value);
|
|
|
5485 }
|
|
|
5486 },
|
|
|
5487 /**
|
|
|
5488 * @private
|
|
|
5489 * @method _handleAlign
|
|
|
5490 * @description Handles the alignment buttons in the toolbar.
|
|
|
5491 * @param {Object} o Object returned from Toolbar's buttonClick Event
|
|
|
5492 */
|
|
|
5493 _handleAlign: function(o) {
|
|
|
5494 var cmd = null;
|
|
|
5495 for (var i = 0; i < o.button.menu.length; i++) {
|
|
|
5496 if (o.button.menu[i].value == o.button.value) {
|
|
|
5497 cmd = o.button.menu[i].value;
|
|
|
5498 }
|
|
|
5499 }
|
|
|
5500 var value = this._getSelection();
|
|
|
5501
|
|
|
5502 this.execCommand(cmd, value);
|
|
|
5503 return false;
|
|
|
5504 },
|
|
|
5505 /**
|
|
|
5506 * @private
|
|
|
5507 * @method _handleAfterNodeChange
|
|
|
5508 * @description Fires after a nodeChange happens to setup the things that where reset on the node change (button state).
|
|
|
5509 */
|
|
|
5510 _handleAfterNodeChange: function() {
|
|
|
5511 var path = this._getDomPath(),
|
|
|
5512 elm = null,
|
|
|
5513 family = null,
|
|
|
5514 fontsize = null,
|
|
|
5515 validFont = false,
|
|
|
5516 fn_button = this.toolbar.getButtonByValue('fontname'),
|
|
|
5517 fs_button = this.toolbar.getButtonByValue('fontsize'),
|
|
|
5518 hd_button = this.toolbar.getButtonByValue('heading');
|
|
|
5519
|
|
|
5520 for (var i = 0; i < path.length; i++) {
|
|
|
5521 elm = path[i];
|
|
|
5522
|
|
|
5523 var tag = elm.tagName.toLowerCase();
|
|
|
5524
|
|
|
5525
|
|
|
5526 if (elm.getAttribute('tag')) {
|
|
|
5527 tag = elm.getAttribute('tag');
|
|
|
5528 }
|
|
|
5529
|
|
|
5530 family = elm.getAttribute('face');
|
|
|
5531 if (Dom.getStyle(elm, 'font-family')) {
|
|
|
5532 family = Dom.getStyle(elm, 'font-family');
|
|
|
5533 //Adobe AIR Code
|
|
|
5534 family = family.replace(/'/g, '');
|
|
|
5535 }
|
|
|
5536
|
|
|
5537 if (tag.substring(0, 1) == 'h') {
|
|
|
5538 if (hd_button) {
|
|
|
5539 for (var h = 0; h < hd_button._configs.menu.value.length; h++) {
|
|
|
5540 if (hd_button._configs.menu.value[h].value.toLowerCase() == tag) {
|
|
|
5541 hd_button.set('label', hd_button._configs.menu.value[h].text);
|
|
|
5542 }
|
|
|
5543 }
|
|
|
5544 this._updateMenuChecked('heading', tag);
|
|
|
5545 }
|
|
|
5546 }
|
|
|
5547 }
|
|
|
5548
|
|
|
5549 if (fn_button) {
|
|
|
5550 for (var b = 0; b < fn_button._configs.menu.value.length; b++) {
|
|
|
5551 if (family && fn_button._configs.menu.value[b].text.toLowerCase() == family.toLowerCase()) {
|
|
|
5552 validFont = true;
|
|
|
5553 family = fn_button._configs.menu.value[b].text; //Put the proper menu name in the button
|
|
|
5554 }
|
|
|
5555 }
|
|
|
5556 if (!validFont) {
|
|
|
5557 family = fn_button._configs.label._initialConfig.value;
|
|
|
5558 }
|
|
|
5559 var familyLabel = '<span class="yui-toolbar-fontname-' + this._cleanClassName(family) + '">' + family + '</span>';
|
|
|
5560 if (fn_button.get('label') != familyLabel) {
|
|
|
5561 fn_button.set('label', familyLabel);
|
|
|
5562 this._updateMenuChecked('fontname', family);
|
|
|
5563 }
|
|
|
5564 }
|
|
|
5565
|
|
|
5566 if (fs_button) {
|
|
|
5567 fontsize = parseInt(Dom.getStyle(elm, 'fontSize'), 10);
|
|
|
5568 if ((fontsize === null) || isNaN(fontsize)) {
|
|
|
5569 fontsize = fs_button._configs.label._initialConfig.value;
|
|
|
5570 }
|
|
|
5571 fs_button.set('label', ''+fontsize);
|
|
|
5572 }
|
|
|
5573
|
|
|
5574 if (!this._isElement(elm, 'body') && !this._isElement(elm, 'img')) {
|
|
|
5575 this.toolbar.enableButton(fn_button);
|
|
|
5576 this.toolbar.enableButton(fs_button);
|
|
|
5577 this.toolbar.enableButton('forecolor');
|
|
|
5578 this.toolbar.enableButton('backcolor');
|
|
|
5579 }
|
|
|
5580 if (this._isElement(elm, 'img')) {
|
|
|
5581 if (YAHOO.widget.Overlay) {
|
|
|
5582 this.toolbar.enableButton('createlink');
|
|
|
5583 }
|
|
|
5584 }
|
|
|
5585 if (this._hasParent(elm, 'blockquote')) {
|
|
|
5586 this.toolbar.selectButton('indent');
|
|
|
5587 this.toolbar.disableButton('indent');
|
|
|
5588 this.toolbar.enableButton('outdent');
|
|
|
5589 }
|
|
|
5590 if (this._hasParent(elm, 'ol') || this._hasParent(elm, 'ul')) {
|
|
|
5591 this.toolbar.disableButton('indent');
|
|
|
5592 }
|
|
|
5593 this._lastButton = null;
|
|
|
5594
|
|
|
5595 },
|
|
|
5596 /**
|
|
|
5597 * @private
|
|
|
5598 * @method _handleInsertImageClick
|
|
|
5599 * @description Opens the Image Properties Window when the insert Image button is clicked or an Image is Double Clicked.
|
|
|
5600 */
|
|
|
5601 _handleInsertImageClick: function() {
|
|
|
5602 if (this.get('limitCommands')) {
|
|
|
5603 if (!this.toolbar.getButtonByValue('insertimage')) {
|
|
|
5604 return false;
|
|
|
5605 }
|
|
|
5606 }
|
|
|
5607
|
|
|
5608 this.toolbar.set('disabled', true); //Disable the toolbar when the prompt is showing
|
|
|
5609 var _handleAEC = function() {
|
|
|
5610 var el = this.currentElement[0],
|
|
|
5611 src = 'http://';
|
|
|
5612 if (!el) {
|
|
|
5613 el = this._getSelectedElement();
|
|
|
5614 }
|
|
|
5615 if (el) {
|
|
|
5616 if (el.getAttribute('src')) {
|
|
|
5617 src = el.getAttribute('src', 2);
|
|
|
5618 if (src.indexOf(this.get('blankimage')) != -1) {
|
|
|
5619 src = this.STR_IMAGE_HERE;
|
|
|
5620 }
|
|
|
5621 }
|
|
|
5622 }
|
|
|
5623 var str = prompt(this.STR_IMAGE_URL + ': ', src);
|
|
|
5624 if ((str !== '') && (str !== null)) {
|
|
|
5625 el.setAttribute('src', str);
|
|
|
5626 } else if (str === '') {
|
|
|
5627 el.parentNode.removeChild(el);
|
|
|
5628 this.currentElement = [];
|
|
|
5629 this.nodeChange();
|
|
|
5630 } else if ((str === null)) {
|
|
|
5631 src = el.getAttribute('src', 2);
|
|
|
5632 if (src.indexOf(this.get('blankimage')) != -1) {
|
|
|
5633 el.parentNode.removeChild(el);
|
|
|
5634 this.currentElement = [];
|
|
|
5635 this.nodeChange();
|
|
|
5636 }
|
|
|
5637 }
|
|
|
5638 this.closeWindow();
|
|
|
5639 this.toolbar.set('disabled', false);
|
|
|
5640 this.unsubscribe('afterExecCommand', _handleAEC, this, true);
|
|
|
5641 };
|
|
|
5642 this.on('afterExecCommand', _handleAEC, this, true);
|
|
|
5643 },
|
|
|
5644 /**
|
|
|
5645 * @private
|
|
|
5646 * @method _handleInsertImageWindowClose
|
|
|
5647 * @description Handles the closing of the Image Properties Window.
|
|
|
5648 */
|
|
|
5649 _handleInsertImageWindowClose: function() {
|
|
|
5650 this.nodeChange();
|
|
|
5651 },
|
|
|
5652 /**
|
|
|
5653 * @private
|
|
|
5654 * @method _isLocalFile
|
|
|
5655 * @param {String} url THe url/string to check
|
|
|
5656 * @description Checks to see if a string (href or img src) is possibly a local file reference..
|
|
|
5657 */
|
|
|
5658 _isLocalFile: function(url) {
|
|
|
5659 if ((url) && (url !== '') && ((url.indexOf('file:/') != -1) || (url.indexOf(':\\') != -1))) {
|
|
|
5660 return true;
|
|
|
5661 }
|
|
|
5662 return false;
|
|
|
5663 },
|
|
|
5664 /**
|
|
|
5665 * @private
|
|
|
5666 * @method _handleCreateLinkClick
|
|
|
5667 * @description Handles the opening of the Link Properties Window when the Create Link button is clicked or an href is doubleclicked.
|
|
|
5668 */
|
|
|
5669 _handleCreateLinkClick: function() {
|
|
|
5670 if (this.get('limitCommands')) {
|
|
|
5671 if (!this.toolbar.getButtonByValue('createlink')) {
|
|
|
5672 return false;
|
|
|
5673 }
|
|
|
5674 }
|
|
|
5675
|
|
|
5676 this.toolbar.set('disabled', true); //Disable the toolbar when the prompt is showing
|
|
|
5677
|
|
|
5678 var _handleAEC = function() {
|
|
|
5679 var el = this.currentElement[0],
|
|
|
5680 url = '';
|
|
|
5681
|
|
|
5682 if (el) {
|
|
|
5683 if (el.getAttribute('href', 2) !== null) {
|
|
|
5684 url = el.getAttribute('href', 2);
|
|
|
5685 }
|
|
|
5686 }
|
|
|
5687 var str = prompt(this.STR_LINK_URL + ': ', url);
|
|
|
5688 if ((str !== '') && (str !== null)) {
|
|
|
5689 var urlValue = str;
|
|
|
5690 if ((urlValue.indexOf(':/'+'/') == -1) && (urlValue.substring(0,1) != '/') && (urlValue.substring(0, 6).toLowerCase() != 'mailto')) {
|
|
|
5691 if ((urlValue.indexOf('@') != -1) && (urlValue.substring(0, 6).toLowerCase() != 'mailto')) {
|
|
|
5692 //Found an @ sign, prefix with mailto:
|
|
|
5693 urlValue = 'mailto:' + urlValue;
|
|
|
5694 } else {
|
|
|
5695 /* :// not found adding */
|
|
|
5696 if (urlValue.substring(0, 1) != '#') {
|
|
|
5697 //urlValue = 'http:/'+'/' + urlValue;
|
|
|
5698 }
|
|
|
5699 }
|
|
|
5700 }
|
|
|
5701 el.setAttribute('href', urlValue);
|
|
|
5702 } else if (str !== null) {
|
|
|
5703 var _span = this._getDoc().createElement('span');
|
|
|
5704 _span.innerHTML = el.innerHTML;
|
|
|
5705 Dom.addClass(_span, 'yui-non');
|
|
|
5706 el.parentNode.replaceChild(_span, el);
|
|
|
5707 }
|
|
|
5708 this.closeWindow();
|
|
|
5709 this.toolbar.set('disabled', false);
|
|
|
5710 this.unsubscribe('afterExecCommand', _handleAEC, this, true);
|
|
|
5711 };
|
|
|
5712 this.on('afterExecCommand', _handleAEC, this);
|
|
|
5713
|
|
|
5714 },
|
|
|
5715 /**
|
|
|
5716 * @private
|
|
|
5717 * @method _handleCreateLinkWindowClose
|
|
|
5718 * @description Handles the closing of the Link Properties Window.
|
|
|
5719 */
|
|
|
5720 _handleCreateLinkWindowClose: function() {
|
|
|
5721 this.nodeChange();
|
|
|
5722 this.currentElement = [];
|
|
|
5723 },
|
|
|
5724 /**
|
|
|
5725 * @method render
|
|
|
5726 * @description Calls the private method _render in a setTimeout to allow for other things on the page to continue to load.
|
|
|
5727 */
|
|
|
5728 render: function() {
|
|
|
5729 if (this._rendered) {
|
|
|
5730 return false;
|
|
|
5731 }
|
|
|
5732 if (!this.DOMReady) {
|
|
|
5733 this._queue[this._queue.length] = ['render', arguments];
|
|
|
5734 return false;
|
|
|
5735 }
|
|
|
5736 if (this.get('element')) {
|
|
|
5737 if (this.get('element').tagName) {
|
|
|
5738 this._textarea = true;
|
|
|
5739 if (this.get('element').tagName.toLowerCase() !== 'textarea') {
|
|
|
5740 this._textarea = false;
|
|
|
5741 }
|
|
|
5742 } else {
|
|
|
5743 return false;
|
|
|
5744 }
|
|
|
5745 } else {
|
|
|
5746 return false;
|
|
|
5747 }
|
|
|
5748 this._rendered = true;
|
|
|
5749 var self = this;
|
|
|
5750 window.setTimeout(function() {
|
|
|
5751 self._render.call(self);
|
|
|
5752 }, 4);
|
|
|
5753 },
|
|
|
5754 /**
|
|
|
5755 * @private
|
|
|
5756 * @method _render
|
|
|
5757 * @description Causes the toolbar and the editor to render and replace the textarea.
|
|
|
5758 */
|
|
|
5759 _render: function() {
|
|
|
5760 var self = this;
|
|
|
5761 this.set('textarea', this.get('element'));
|
|
|
5762
|
|
|
5763 this.get('element_cont').setStyle('display', 'none');
|
|
|
5764 this.get('element_cont').addClass(this.CLASS_CONTAINER);
|
|
|
5765
|
|
|
5766 this.set('iframe', this._createIframe());
|
|
|
5767
|
|
|
5768 window.setTimeout(function() {
|
|
|
5769 self._setInitialContent.call(self);
|
|
|
5770 }, 10);
|
|
|
5771
|
|
|
5772 this.get('editor_wrapper').appendChild(this.get('iframe').get('element'));
|
|
|
5773
|
|
|
5774 if (this.get('disabled')) {
|
|
|
5775 this._disableEditor(true);
|
|
|
5776 }
|
|
|
5777
|
|
|
5778 var tbarConf = this.get('toolbar');
|
|
|
5779 //Create Toolbar instance
|
|
|
5780 if (tbarConf instanceof Toolbar) {
|
|
|
5781 this.toolbar = tbarConf;
|
|
|
5782 //Set the toolbar to disabled until content is loaded
|
|
|
5783 this.toolbar.set('disabled', true);
|
|
|
5784 } else {
|
|
|
5785 //Set the toolbar to disabled until content is loaded
|
|
|
5786 tbarConf.disabled = true;
|
|
|
5787 this.toolbar = new Toolbar(this.get('toolbar_cont'), tbarConf);
|
|
|
5788 }
|
|
|
5789
|
|
|
5790 this.fireEvent('toolbarLoaded', { type: 'toolbarLoaded', target: this.toolbar });
|
|
|
5791
|
|
|
5792
|
|
|
5793 this.toolbar.on('toolbarCollapsed', function() {
|
|
|
5794 if (this.currentWindow) {
|
|
|
5795 this.moveWindow();
|
|
|
5796 }
|
|
|
5797 }, this, true);
|
|
|
5798 this.toolbar.on('toolbarExpanded', function() {
|
|
|
5799 if (this.currentWindow) {
|
|
|
5800 this.moveWindow();
|
|
|
5801 }
|
|
|
5802 }, this, true);
|
|
|
5803 this.toolbar.on('fontsizeClick', this._handleFontSize, this, true);
|
|
|
5804
|
|
|
5805 this.toolbar.on('colorPickerClicked', function(o) {
|
|
|
5806 this._handleColorPicker(o);
|
|
|
5807 return false; //Stop the buttonClick event
|
|
|
5808 }, this, true);
|
|
|
5809
|
|
|
5810 this.toolbar.on('alignClick', this._handleAlign, this, true);
|
|
|
5811 this.on('afterNodeChange', this._handleAfterNodeChange, this, true);
|
|
|
5812 this.toolbar.on('insertimageClick', this._handleInsertImageClick, this, true);
|
|
|
5813 this.on('windowinsertimageClose', this._handleInsertImageWindowClose, this, true);
|
|
|
5814 this.toolbar.on('createlinkClick', this._handleCreateLinkClick, this, true);
|
|
|
5815 this.on('windowcreatelinkClose', this._handleCreateLinkWindowClose, this, true);
|
|
|
5816
|
|
|
5817
|
|
|
5818 //Replace Textarea with editable area
|
|
|
5819 this.get('parentNode').replaceChild(this.get('element_cont').get('element'), this.get('element'));
|
|
|
5820
|
|
|
5821
|
|
|
5822 this.setStyle('visibility', 'hidden');
|
|
|
5823 this.setStyle('position', 'absolute');
|
|
|
5824 this.setStyle('top', '-9999px');
|
|
|
5825 this.setStyle('left', '-9999px');
|
|
|
5826 this.get('element_cont').appendChild(this.get('element'));
|
|
|
5827 this.get('element_cont').setStyle('display', 'block');
|
|
|
5828
|
|
|
5829
|
|
|
5830 Dom.addClass(this.get('iframe').get('parentNode'), this.CLASS_EDITABLE_CONT);
|
|
|
5831 this.get('iframe').addClass(this.CLASS_EDITABLE);
|
|
|
5832
|
|
|
5833 //Set height and width of editor container
|
|
|
5834 this.get('element_cont').setStyle('width', this.get('width'));
|
|
|
5835 Dom.setStyle(this.get('iframe').get('parentNode'), 'height', this.get('height'));
|
|
|
5836
|
|
|
5837 this.get('iframe').setStyle('width', '100%'); //WIDTH
|
|
|
5838 this.get('iframe').setStyle('height', '100%');
|
|
|
5839
|
|
|
5840 this._setupDD();
|
|
|
5841
|
|
|
5842 window.setTimeout(function() {
|
|
|
5843 self._setupAfterElement.call(self);
|
|
|
5844 }, 0);
|
|
|
5845 this.fireEvent('afterRender', { type: 'afterRender', target: this });
|
|
|
5846 },
|
|
|
5847 /**
|
|
|
5848 * @method execCommand
|
|
|
5849 * @param {String} action The "execCommand" action to try to execute (Example: bold, insertimage, inserthtml)
|
|
|
5850 * @param {String} value (optional) The value for a given action such as action: fontname value: 'Verdana'
|
|
|
5851 * @description This method attempts to try and level the differences in the various browsers and their support for execCommand actions
|
|
|
5852 */
|
|
|
5853 execCommand: function(action, value) {
|
|
|
5854 var beforeExec = this.fireEvent('beforeExecCommand', { type: 'beforeExecCommand', target: this, args: arguments });
|
|
|
5855 if ((beforeExec === false) || (this.STOP_EXEC_COMMAND)) {
|
|
|
5856 this.STOP_EXEC_COMMAND = false;
|
|
|
5857 return false;
|
|
|
5858 }
|
|
|
5859 this._lastCommand = action;
|
|
|
5860 this._setMarkupType(action);
|
|
|
5861 if (this.browser.ie) {
|
|
|
5862 this._getWindow().focus();
|
|
|
5863 }
|
|
|
5864 var exec = true;
|
|
|
5865
|
|
|
5866 if (this.get('limitCommands')) {
|
|
|
5867 if (!this.toolbar.getButtonByValue(action)) {
|
|
|
5868 exec = false;
|
|
|
5869 }
|
|
|
5870 }
|
|
|
5871
|
|
|
5872 this.editorDirty = true;
|
|
|
5873
|
|
|
5874 if ((typeof this['cmd_' + action.toLowerCase()] == 'function') && exec) {
|
|
|
5875 var retValue = this['cmd_' + action.toLowerCase()](value);
|
|
|
5876 exec = retValue[0];
|
|
|
5877 if (retValue[1]) {
|
|
|
5878 action = retValue[1];
|
|
|
5879 }
|
|
|
5880 if (retValue[2]) {
|
|
|
5881 value = retValue[2];
|
|
|
5882 }
|
|
|
5883 }
|
|
|
5884 if (exec) {
|
|
|
5885 try {
|
|
|
5886 this._getDoc().execCommand(action, false, value);
|
|
|
5887 } catch(e) {
|
|
|
5888 }
|
|
|
5889 } else {
|
|
|
5890 }
|
|
|
5891 this.on('afterExecCommand', function() {
|
|
|
5892 this.unsubscribeAll('afterExecCommand');
|
|
|
5893 this.nodeChange();
|
|
|
5894 }, this, true);
|
|
|
5895 this.fireEvent('afterExecCommand', { type: 'afterExecCommand', target: this });
|
|
|
5896
|
|
|
5897 },
|
|
|
5898 /* {{{ Command Overrides */
|
|
|
5899
|
|
|
5900 /**
|
|
|
5901 * @method cmd_bold
|
|
|
5902 * @param value Value passed from the execCommand method
|
|
|
5903 * @description This is an execCommand override method. It is called from execCommand when the execCommand('bold') is used.
|
|
|
5904 */
|
|
|
5905 cmd_bold: function(value) {
|
|
|
5906 if (!this.browser.webkit) {
|
|
|
5907 var el = this._getSelectedElement();
|
|
|
5908 if (el && this._isElement(el, 'span') && this._hasSelection()) {
|
|
|
5909 if (el.style.fontWeight == 'bold') {
|
|
|
5910 el.style.fontWeight = '';
|
|
|
5911 var b = this._getDoc().createElement('b'),
|
|
|
5912 par = el.parentNode;
|
|
|
5913 par.replaceChild(b, el);
|
|
|
5914 b.appendChild(el);
|
|
|
5915 }
|
|
|
5916 }
|
|
|
5917 }
|
|
|
5918 return [true];
|
|
|
5919 },
|
|
|
5920 /**
|
|
|
5921 * @method cmd_italic
|
|
|
5922 * @param value Value passed from the execCommand method
|
|
|
5923 * @description This is an execCommand override method. It is called from execCommand when the execCommand('italic') is used.
|
|
|
5924 */
|
|
|
5925
|
|
|
5926 cmd_italic: function(value) {
|
|
|
5927 if (!this.browser.webkit) {
|
|
|
5928 var el = this._getSelectedElement();
|
|
|
5929 if (el && this._isElement(el, 'span') && this._hasSelection()) {
|
|
|
5930 if (el.style.fontStyle == 'italic') {
|
|
|
5931 el.style.fontStyle = '';
|
|
|
5932 var i = this._getDoc().createElement('i'),
|
|
|
5933 par = el.parentNode;
|
|
|
5934 par.replaceChild(i, el);
|
|
|
5935 i.appendChild(el);
|
|
|
5936 }
|
|
|
5937 }
|
|
|
5938 }
|
|
|
5939 return [true];
|
|
|
5940 },
|
|
|
5941
|
|
|
5942
|
|
|
5943 /**
|
|
|
5944 * @method cmd_underline
|
|
|
5945 * @param value Value passed from the execCommand method
|
|
|
5946 * @description This is an execCommand override method. It is called from execCommand when the execCommand('underline') is used.
|
|
|
5947 */
|
|
|
5948 cmd_underline: function(value) {
|
|
|
5949 if (!this.browser.webkit) {
|
|
|
5950 var el = this._getSelectedElement();
|
|
|
5951 if (el && this._isElement(el, 'span')) {
|
|
|
5952 if (el.style.textDecoration == 'underline') {
|
|
|
5953 el.style.textDecoration = 'none';
|
|
|
5954 } else {
|
|
|
5955 el.style.textDecoration = 'underline';
|
|
|
5956 }
|
|
|
5957 return [false];
|
|
|
5958 }
|
|
|
5959 }
|
|
|
5960 return [true];
|
|
|
5961 },
|
|
|
5962 /**
|
|
|
5963 * @method cmd_backcolor
|
|
|
5964 * @param value Value passed from the execCommand method
|
|
|
5965 * @description This is an execCommand override method. It is called from execCommand when the execCommand('backcolor') is used.
|
|
|
5966 */
|
|
|
5967 cmd_backcolor: function(value) {
|
|
|
5968 var exec = true,
|
|
|
5969 el = this._getSelectedElement(),
|
|
|
5970 action = 'backcolor';
|
|
|
5971
|
|
|
5972 if (this.browser.gecko || this.browser.opera) {
|
|
|
5973 this._setEditorStyle(true);
|
|
|
5974 action = 'hilitecolor';
|
|
|
5975 }
|
|
|
5976
|
|
|
5977 if (!this._isElement(el, 'body') && !this._hasSelection()) {
|
|
|
5978 el.style.backgroundColor = value;
|
|
|
5979 this._selectNode(el);
|
|
|
5980 exec = false;
|
|
|
5981 } else {
|
|
|
5982 if (this.get('insert')) {
|
|
|
5983 el = this._createInsertElement({ backgroundColor: value });
|
|
|
5984 } else {
|
|
|
5985 this._createCurrentElement('span', { backgroundColor: value, color: el.style.color, fontSize: el.style.fontSize, fontFamily: el.style.fontFamily });
|
|
|
5986 this._selectNode(this.currentElement[0]);
|
|
|
5987 }
|
|
|
5988 exec = false;
|
|
|
5989 }
|
|
|
5990
|
|
|
5991 return [exec, action];
|
|
|
5992 },
|
|
|
5993 /**
|
|
|
5994 * @method cmd_forecolor
|
|
|
5995 * @param value Value passed from the execCommand method
|
|
|
5996 * @description This is an execCommand override method. It is called from execCommand when the execCommand('forecolor') is used.
|
|
|
5997 */
|
|
|
5998 cmd_forecolor: function(value) {
|
|
|
5999 var exec = true,
|
|
|
6000 el = this._getSelectedElement();
|
|
|
6001
|
|
|
6002 if (!this._isElement(el, 'body') && !this._hasSelection()) {
|
|
|
6003 Dom.setStyle(el, 'color', value);
|
|
|
6004 this._selectNode(el);
|
|
|
6005 exec = false;
|
|
|
6006 } else {
|
|
|
6007 if (this.get('insert')) {
|
|
|
6008 el = this._createInsertElement({ color: value });
|
|
|
6009 } else {
|
|
|
6010 this._createCurrentElement('span', { color: value, fontSize: el.style.fontSize, fontFamily: el.style.fontFamily, backgroundColor: el.style.backgroundColor });
|
|
|
6011 this._selectNode(this.currentElement[0]);
|
|
|
6012 }
|
|
|
6013 exec = false;
|
|
|
6014 }
|
|
|
6015 return [exec];
|
|
|
6016 },
|
|
|
6017 /**
|
|
|
6018 * @method cmd_unlink
|
|
|
6019 * @param value Value passed from the execCommand method
|
|
|
6020 * @description This is an execCommand override method. It is called from execCommand when the execCommand('unlink') is used.
|
|
|
6021 */
|
|
|
6022 cmd_unlink: function(value) {
|
|
|
6023 this._swapEl(this.currentElement[0], 'span', function(el) {
|
|
|
6024 el.className = 'yui-non';
|
|
|
6025 });
|
|
|
6026 return [false];
|
|
|
6027 },
|
|
|
6028 /**
|
|
|
6029 * @method cmd_createlink
|
|
|
6030 * @param value Value passed from the execCommand method
|
|
|
6031 * @description This is an execCommand override method. It is called from execCommand when the execCommand('createlink') is used.
|
|
|
6032 */
|
|
|
6033 cmd_createlink: function(value) {
|
|
|
6034 var el = this._getSelectedElement(), _a = null;
|
|
|
6035 if (this._hasParent(el, 'a')) {
|
|
|
6036 this.currentElement[0] = this._hasParent(el, 'a');
|
|
|
6037 } else if (this._isElement(el, 'li')) {
|
|
|
6038 _a = this._getDoc().createElement('a');
|
|
|
6039 _a.innerHTML = el.innerHTML;
|
|
|
6040 el.innerHTML = '';
|
|
|
6041 el.appendChild(_a);
|
|
|
6042 this.currentElement[0] = _a;
|
|
|
6043 } else if (!this._isElement(el, 'a')) {
|
|
|
6044 this._createCurrentElement('a');
|
|
|
6045 _a = this._swapEl(this.currentElement[0], 'a');
|
|
|
6046 this.currentElement[0] = _a;
|
|
|
6047 } else {
|
|
|
6048 this.currentElement[0] = el;
|
|
|
6049 }
|
|
|
6050 return [false];
|
|
|
6051 },
|
|
|
6052 /**
|
|
|
6053 * @method cmd_insertimage
|
|
|
6054 * @param value Value passed from the execCommand method
|
|
|
6055 * @description This is an execCommand override method. It is called from execCommand when the execCommand('insertimage') is used.
|
|
|
6056 */
|
|
|
6057 cmd_insertimage: function(value) {
|
|
|
6058 var exec = true, _img = null, action = 'insertimage',
|
|
|
6059 el = this._getSelectedElement();
|
|
|
6060
|
|
|
6061 if (value === '') {
|
|
|
6062 value = this.get('blankimage');
|
|
|
6063 }
|
|
|
6064
|
|
|
6065 /*
|
|
|
6066 * @knownissue Safari Cursor Position
|
|
|
6067 * @browser Safari 2.x
|
|
|
6068 * @description The issue here is that we have no way of knowing where the cursor position is
|
|
|
6069 * inside of the iframe, so we have to place the newly inserted data in the best place that we can.
|
|
|
6070 */
|
|
|
6071
|
|
|
6072 if (this._isElement(el, 'img')) {
|
|
|
6073 this.currentElement[0] = el;
|
|
|
6074 exec = false;
|
|
|
6075 } else {
|
|
|
6076 if (this._getDoc().queryCommandEnabled(action)) {
|
|
|
6077 this._getDoc().execCommand(action, false, value);
|
|
|
6078 var imgs = this._getDoc().getElementsByTagName('img');
|
|
|
6079 for (var i = 0; i < imgs.length; i++) {
|
|
|
6080 if (!YAHOO.util.Dom.hasClass(imgs[i], 'yui-img')) {
|
|
|
6081 YAHOO.util.Dom.addClass(imgs[i], 'yui-img');
|
|
|
6082 this.currentElement[0] = imgs[i];
|
|
|
6083 }
|
|
|
6084 }
|
|
|
6085 exec = false;
|
|
|
6086 } else {
|
|
|
6087 if (el == this._getDoc().body) {
|
|
|
6088 _img = this._getDoc().createElement('img');
|
|
|
6089 _img.setAttribute('src', value);
|
|
|
6090 YAHOO.util.Dom.addClass(_img, 'yui-img');
|
|
|
6091 this._getDoc().body.appendChild(_img);
|
|
|
6092 } else {
|
|
|
6093 this._createCurrentElement('img');
|
|
|
6094 _img = this._getDoc().createElement('img');
|
|
|
6095 _img.setAttribute('src', value);
|
|
|
6096 YAHOO.util.Dom.addClass(_img, 'yui-img');
|
|
|
6097 this.currentElement[0].parentNode.replaceChild(_img, this.currentElement[0]);
|
|
|
6098 }
|
|
|
6099 this.currentElement[0] = _img;
|
|
|
6100 exec = false;
|
|
|
6101 }
|
|
|
6102 }
|
|
|
6103 return [exec];
|
|
|
6104 },
|
|
|
6105 /**
|
|
|
6106 * @method cmd_inserthtml
|
|
|
6107 * @param value Value passed from the execCommand method
|
|
|
6108 * @description This is an execCommand override method. It is called from execCommand when the execCommand('inserthtml') is used.
|
|
|
6109 */
|
|
|
6110 cmd_inserthtml: function(value) {
|
|
|
6111 var exec = true, action = 'inserthtml', _span = null, _range = null;
|
|
|
6112 /*
|
|
|
6113 * @knownissue Safari cursor position
|
|
|
6114 * @browser Safari 2.x
|
|
|
6115 * @description The issue here is that we have no way of knowing where the cursor position is
|
|
|
6116 * inside of the iframe, so we have to place the newly inserted data in the best place that we can.
|
|
|
6117 */
|
|
|
6118 if (this.browser.webkit && !this._getDoc().queryCommandEnabled(action)) {
|
|
|
6119 this._createCurrentElement('img');
|
|
|
6120 _span = this._getDoc().createElement('span');
|
|
|
6121 _span.innerHTML = value;
|
|
|
6122 this.currentElement[0].parentNode.replaceChild(_span, this.currentElement[0]);
|
|
|
6123 exec = false;
|
|
|
6124 } else if (this.browser.ie) {
|
|
|
6125 _range = this._getRange();
|
|
|
6126 if (_range.item) {
|
|
|
6127 _range.item(0).outerHTML = value;
|
|
|
6128 } else {
|
|
|
6129 _range.pasteHTML(value);
|
|
|
6130 }
|
|
|
6131 exec = false;
|
|
|
6132 }
|
|
|
6133 return [exec];
|
|
|
6134 },
|
|
|
6135 /**
|
|
|
6136 * @method cmd_list
|
|
|
6137 * @param tag The tag of the list you want to create (eg, ul or ol)
|
|
|
6138 * @description This is a combined execCommand override method. It is called from the cmd_insertorderedlist and cmd_insertunorderedlist methods.
|
|
|
6139 */
|
|
|
6140 cmd_list: function(tag) {
|
|
|
6141 var exec = true, list = null, li = 0, el = null, str = '',
|
|
|
6142 selEl = this._getSelectedElement(), action = 'insertorderedlist';
|
|
|
6143 if (tag == 'ul') {
|
|
|
6144 action = 'insertunorderedlist';
|
|
|
6145 }
|
|
|
6146 /*
|
|
|
6147 * @knownissue Safari 2.+ doesn't support ordered and unordered lists
|
|
|
6148 * @browser Safari 2.x
|
|
|
6149 * The issue with this workaround is that when applied to a set of text
|
|
|
6150 * that has BR's in it, Safari may or may not pick up the individual items as
|
|
|
6151 * list items. This is fixed in WebKit (Safari 3)
|
|
|
6152 * 2.6.0: Seems there are still some issues with List Creation and Safari 3, reverting to previously working Safari 2.x code
|
|
|
6153 */
|
|
|
6154 //if ((this.browser.webkit && !this._getDoc().queryCommandEnabled(action))) {
|
|
|
6155 if ((this.browser.webkit && !this.browser.webkit4) || (this.browser.opera)) {
|
|
|
6156 if (this._isElement(selEl, 'li') && this._isElement(selEl.parentNode, tag)) {
|
|
|
6157 el = selEl.parentNode;
|
|
|
6158 list = this._getDoc().createElement('span');
|
|
|
6159 YAHOO.util.Dom.addClass(list, 'yui-non');
|
|
|
6160 str = '';
|
|
|
6161 var lis = el.getElementsByTagName('li'), p_tag = ((this.browser.opera && this.get('ptags')) ? 'p' : 'div');
|
|
|
6162 for (li = 0; li < lis.length; li++) {
|
|
|
6163 str += '<' + p_tag + '>' + lis[li].innerHTML + '</' + p_tag + '>';
|
|
|
6164 }
|
|
|
6165 list.innerHTML = str;
|
|
|
6166 this.currentElement[0] = el;
|
|
|
6167 this.currentElement[0].parentNode.replaceChild(list, this.currentElement[0]);
|
|
|
6168 } else {
|
|
|
6169 this._createCurrentElement(tag.toLowerCase());
|
|
|
6170 list = this._getDoc().createElement(tag);
|
|
|
6171 for (li = 0; li < this.currentElement.length; li++) {
|
|
|
6172 var newli = this._getDoc().createElement('li');
|
|
|
6173 newli.innerHTML = this.currentElement[li].innerHTML + '<span class="yui-non"> </span> ';
|
|
|
6174 list.appendChild(newli);
|
|
|
6175 if (li > 0) {
|
|
|
6176 this.currentElement[li].parentNode.removeChild(this.currentElement[li]);
|
|
|
6177 }
|
|
|
6178 }
|
|
|
6179 var b_tag = ((this.browser.opera) ? '<BR>' : '<br>'),
|
|
|
6180 items = list.firstChild.innerHTML.split(b_tag), i, item;
|
|
|
6181 if (items.length > 0) {
|
|
|
6182 list.innerHTML = '';
|
|
|
6183 for (i = 0; i < items.length; i++) {
|
|
|
6184 item = this._getDoc().createElement('li');
|
|
|
6185 item.innerHTML = items[i];
|
|
|
6186 list.appendChild(item);
|
|
|
6187 }
|
|
|
6188 }
|
|
|
6189
|
|
|
6190 this.currentElement[0].parentNode.replaceChild(list, this.currentElement[0]);
|
|
|
6191 this.currentElement[0] = list;
|
|
|
6192 var _h = this.currentElement[0].firstChild;
|
|
|
6193 _h = Dom.getElementsByClassName('yui-non', 'span', _h)[0];
|
|
|
6194 if (this.browser.webkit) {
|
|
|
6195 this._getSelection().setBaseAndExtent(_h, 1, _h, _h.innerText.length);
|
|
|
6196 }
|
|
|
6197 }
|
|
|
6198 exec = false;
|
|
|
6199 } else {
|
|
|
6200 el = this._getSelectedElement();
|
|
|
6201 if (this._isElement(el, 'li') && this._isElement(el.parentNode, tag) || (this.browser.ie && this._isElement(this._getRange().parentElement, 'li')) || (this.browser.ie && this._isElement(el, 'ul')) || (this.browser.ie && this._isElement(el, 'ol'))) { //we are in a list..
|
|
|
6202 if (this.browser.ie) {
|
|
|
6203 if ((this.browser.ie && this._isElement(el, 'ul')) || (this.browser.ie && this._isElement(el, 'ol'))) {
|
|
|
6204 el = el.getElementsByTagName('li')[0];
|
|
|
6205 }
|
|
|
6206 str = '';
|
|
|
6207 var lis2 = el.parentNode.getElementsByTagName('li');
|
|
|
6208 for (var j = 0; j < lis2.length; j++) {
|
|
|
6209 str += lis2[j].innerHTML + '<br>';
|
|
|
6210 }
|
|
|
6211 var newEl = this._getDoc().createElement('span');
|
|
|
6212 newEl.innerHTML = str;
|
|
|
6213 el.parentNode.parentNode.replaceChild(newEl, el.parentNode);
|
|
|
6214 } else {
|
|
|
6215 this.nodeChange();
|
|
|
6216 this._getDoc().execCommand(action, '', el.parentNode);
|
|
|
6217 this.nodeChange();
|
|
|
6218 }
|
|
|
6219 exec = false;
|
|
|
6220 }
|
|
|
6221 if (this.browser.opera) {
|
|
|
6222 var self = this;
|
|
|
6223 window.setTimeout(function() {
|
|
|
6224 var liso = self._getDoc().getElementsByTagName('li');
|
|
|
6225 for (var i = 0; i < liso.length; i++) {
|
|
|
6226 if (liso[i].innerHTML.toLowerCase() == '<br>') {
|
|
|
6227 liso[i].parentNode.parentNode.removeChild(liso[i].parentNode);
|
|
|
6228 }
|
|
|
6229 }
|
|
|
6230 },30);
|
|
|
6231 }
|
|
|
6232 if (this.browser.ie && exec) {
|
|
|
6233 var html = '';
|
|
|
6234 if (this._getRange().html) {
|
|
|
6235 html = '<li>' + this._getRange().html+ '</li>';
|
|
|
6236 } else {
|
|
|
6237 var t = this._getRange().text.split('\n');
|
|
|
6238 if (t.length > 1) {
|
|
|
6239 html = '';
|
|
|
6240 for (var ie = 0; ie < t.length; ie++) {
|
|
|
6241 html += '<li>' + t[ie] + '</li>';
|
|
|
6242 }
|
|
|
6243 } else {
|
|
|
6244 var txt = this._getRange().text;
|
|
|
6245 if (txt === '') {
|
|
|
6246 html = '<li id="new_list_item">' + txt + '</li>';
|
|
|
6247 } else {
|
|
|
6248 html = '<li>' + txt + '</li>';
|
|
|
6249 }
|
|
|
6250 }
|
|
|
6251 }
|
|
|
6252 this._getRange().pasteHTML('<' + tag + '>' + html + '</' + tag + '>');
|
|
|
6253 var new_item = this._getDoc().getElementById('new_list_item');
|
|
|
6254 if (new_item) {
|
|
|
6255 var range = this._getDoc().body.createTextRange();
|
|
|
6256 range.moveToElementText(new_item);
|
|
|
6257 range.collapse(false);
|
|
|
6258 range.select();
|
|
|
6259 new_item.id = '';
|
|
|
6260 }
|
|
|
6261 exec = false;
|
|
|
6262 }
|
|
|
6263 }
|
|
|
6264 return exec;
|
|
|
6265 },
|
|
|
6266 /**
|
|
|
6267 * @method cmd_insertorderedlist
|
|
|
6268 * @param value Value passed from the execCommand method
|
|
|
6269 * @description This is an execCommand override method. It is called from execCommand when the execCommand('insertorderedlist ') is used.
|
|
|
6270 */
|
|
|
6271 cmd_insertorderedlist: function(value) {
|
|
|
6272 return [this.cmd_list('ol')];
|
|
|
6273 },
|
|
|
6274 /**
|
|
|
6275 * @method cmd_insertunorderedlist
|
|
|
6276 * @param value Value passed from the execCommand method
|
|
|
6277 * @description This is an execCommand override method. It is called from execCommand when the execCommand('insertunorderedlist') is used.
|
|
|
6278 */
|
|
|
6279 cmd_insertunorderedlist: function(value) {
|
|
|
6280 return [this.cmd_list('ul')];
|
|
|
6281 },
|
|
|
6282 /**
|
|
|
6283 * @method cmd_fontname
|
|
|
6284 * @param value Value passed from the execCommand method
|
|
|
6285 * @description This is an execCommand override method. It is called from execCommand when the execCommand('fontname') is used.
|
|
|
6286 */
|
|
|
6287 cmd_fontname: function(value) {
|
|
|
6288 var exec = true,
|
|
|
6289 selEl = this._getSelectedElement();
|
|
|
6290
|
|
|
6291 this.currentFont = value;
|
|
|
6292 if (selEl && selEl.tagName && !this._hasSelection() && !this._isElement(selEl, 'body') && !this.get('insert')) {
|
|
|
6293 YAHOO.util.Dom.setStyle(selEl, 'font-family', value);
|
|
|
6294 exec = false;
|
|
|
6295 } else if (this.get('insert') && !this._hasSelection()) {
|
|
|
6296 var el = this._createInsertElement({ fontFamily: value });
|
|
|
6297 exec = false;
|
|
|
6298 }
|
|
|
6299 return [exec];
|
|
|
6300 },
|
|
|
6301 /**
|
|
|
6302 * @method cmd_fontsize
|
|
|
6303 * @param value Value passed from the execCommand method
|
|
|
6304 * @description This is an execCommand override method. It is called from execCommand when the execCommand('fontsize') is used.
|
|
|
6305 */
|
|
|
6306 cmd_fontsize: function(value) {
|
|
|
6307 var el = null, go = true;
|
|
|
6308 el = this._getSelectedElement();
|
|
|
6309 if (this.browser.webkit) {
|
|
|
6310 if (this.currentElement[0]) {
|
|
|
6311 if (el == this.currentElement[0]) {
|
|
|
6312 go = false;
|
|
|
6313 YAHOO.util.Dom.setStyle(el, 'fontSize', value);
|
|
|
6314 this._selectNode(el);
|
|
|
6315 this.currentElement[0] = el;
|
|
|
6316 }
|
|
|
6317 }
|
|
|
6318 }
|
|
|
6319 if (go) {
|
|
|
6320 if (!this._isElement(this._getSelectedElement(), 'body') && (!this._hasSelection())) {
|
|
|
6321 el = this._getSelectedElement();
|
|
|
6322 YAHOO.util.Dom.setStyle(el, 'fontSize', value);
|
|
|
6323 if (this.get('insert') && this.browser.ie) {
|
|
|
6324 var r = this._getRange();
|
|
|
6325 r.collapse(false);
|
|
|
6326 r.select();
|
|
|
6327 } else {
|
|
|
6328 this._selectNode(el);
|
|
|
6329 }
|
|
|
6330 } else if (this.currentElement && (this.currentElement.length > 0) && (!this._hasSelection()) && (!this.get('insert'))) {
|
|
|
6331 YAHOO.util.Dom.setStyle(this.currentElement, 'fontSize', value);
|
|
|
6332 } else {
|
|
|
6333 if (this.get('insert') && !this._hasSelection()) {
|
|
|
6334 el = this._createInsertElement({ fontSize: value });
|
|
|
6335 this.currentElement[0] = el;
|
|
|
6336 this._selectNode(this.currentElement[0]);
|
|
|
6337 } else {
|
|
|
6338 this._createCurrentElement('span', {'fontSize': value, fontFamily: el.style.fontFamily, color: el.style.color, backgroundColor: el.style.backgroundColor });
|
|
|
6339 this._selectNode(this.currentElement[0]);
|
|
|
6340 }
|
|
|
6341 }
|
|
|
6342 }
|
|
|
6343 return [false];
|
|
|
6344 },
|
|
|
6345 /* }}} */
|
|
|
6346 /**
|
|
|
6347 * @private
|
|
|
6348 * @method _swapEl
|
|
|
6349 * @param {HTMLElement} el The element to swap with
|
|
|
6350 * @param {String} tagName The tagname of the element that you wish to create
|
|
|
6351 * @param {Function} callback (optional) A function to run on the element after it is created, but before it is replaced. An element reference is passed to this function.
|
|
|
6352 * @description This function will create a new element in the DOM and populate it with the contents of another element. Then it will assume it's place.
|
|
|
6353 */
|
|
|
6354 _swapEl: function(el, tagName, callback) {
|
|
|
6355 var _el = this._getDoc().createElement(tagName);
|
|
|
6356 if (el) {
|
|
|
6357 _el.innerHTML = el.innerHTML;
|
|
|
6358 }
|
|
|
6359 if (typeof callback == 'function') {
|
|
|
6360 callback.call(this, _el);
|
|
|
6361 }
|
|
|
6362 if (el) {
|
|
|
6363 el.parentNode.replaceChild(_el, el);
|
|
|
6364 }
|
|
|
6365 return _el;
|
|
|
6366 },
|
|
|
6367 /**
|
|
|
6368 * @private
|
|
|
6369 * @method _createInsertElement
|
|
|
6370 * @description Creates a new "currentElement" then adds some text (and other things) to make it selectable and stylable. Then the user can continue typing.
|
|
|
6371 * @param {Object} css (optional) Object literal containing styles to apply to the new element.
|
|
|
6372 * @return {HTMLElement}
|
|
|
6373 */
|
|
|
6374 _createInsertElement: function(css) {
|
|
|
6375 this._createCurrentElement('span', css);
|
|
|
6376 var el = this.currentElement[0];
|
|
|
6377 if (this.browser.webkit) {
|
|
|
6378 //Little Safari Hackery here..
|
|
|
6379 el.innerHTML = '<span class="yui-non"> </span>';
|
|
|
6380 el = el.firstChild;
|
|
|
6381 this._getSelection().setBaseAndExtent(el, 1, el, el.innerText.length);
|
|
|
6382 } else if (this.browser.ie || this.browser.opera) {
|
|
|
6383 el.innerHTML = ' ';
|
|
|
6384 }
|
|
|
6385 this.focus();
|
|
|
6386 this._selectNode(el, true);
|
|
|
6387 return el;
|
|
|
6388 },
|
|
|
6389 /**
|
|
|
6390 * @private
|
|
|
6391 * @method _createCurrentElement
|
|
|
6392 * @param {String} tagName (optional defaults to a) The tagname of the element that you wish to create
|
|
|
6393 * @param {Object} tagStyle (optional) Object literal containing styles to apply to the new element.
|
|
|
6394 * @description This is a work around for the various browser issues with execCommand. This method will run <code>execCommand('fontname', false, 'yui-tmp')</code> on the given selection.
|
|
|
6395 * It will then search the document for an element with the font-family set to <strong>yui-tmp</strong> and replace that with another span that has other information in it, then assign the new span to the
|
|
|
6396 * <code>this.currentElement</code> array, so we now have element references to the elements that were just modified. At this point we can use standard DOM manipulation to change them as we see fit.
|
|
|
6397 */
|
|
|
6398 _createCurrentElement: function(tagName, tagStyle) {
|
|
|
6399 tagName = ((tagName) ? tagName : 'a');
|
|
|
6400 var tar = null,
|
|
|
6401 el = [],
|
|
|
6402 _doc = this._getDoc();
|
|
|
6403
|
|
|
6404 if (this.currentFont) {
|
|
|
6405 if (!tagStyle) {
|
|
|
6406 tagStyle = {};
|
|
|
6407 }
|
|
|
6408 tagStyle.fontFamily = this.currentFont;
|
|
|
6409 this.currentFont = null;
|
|
|
6410 }
|
|
|
6411 this.currentElement = [];
|
|
|
6412
|
|
|
6413 var _elCreate = function(tagName, tagStyle) {
|
|
|
6414 var el = null;
|
|
|
6415 tagName = ((tagName) ? tagName : 'span');
|
|
|
6416 tagName = tagName.toLowerCase();
|
|
|
6417 switch (tagName) {
|
|
|
6418 case 'h1':
|
|
|
6419 case 'h2':
|
|
|
6420 case 'h3':
|
|
|
6421 case 'h4':
|
|
|
6422 case 'h5':
|
|
|
6423 case 'h6':
|
|
|
6424 el = _doc.createElement(tagName);
|
|
|
6425 break;
|
|
|
6426 default:
|
|
|
6427 el = _doc.createElement(tagName);
|
|
|
6428 if (tagName === 'span') {
|
|
|
6429 YAHOO.util.Dom.addClass(el, 'yui-tag-' + tagName);
|
|
|
6430 YAHOO.util.Dom.addClass(el, 'yui-tag');
|
|
|
6431 el.setAttribute('tag', tagName);
|
|
|
6432 }
|
|
|
6433
|
|
|
6434 for (var k in tagStyle) {
|
|
|
6435 if (YAHOO.lang.hasOwnProperty(tagStyle, k)) {
|
|
|
6436 el.style[k] = tagStyle[k];
|
|
|
6437 }
|
|
|
6438 }
|
|
|
6439 break;
|
|
|
6440 }
|
|
|
6441 return el;
|
|
|
6442 };
|
|
|
6443
|
|
|
6444 if (!this._hasSelection()) {
|
|
|
6445 if (this._getDoc().queryCommandEnabled('insertimage')) {
|
|
|
6446 this._getDoc().execCommand('insertimage', false, 'yui-tmp-img');
|
|
|
6447 var imgs = this._getDoc().getElementsByTagName('img');
|
|
|
6448 for (var j = 0; j < imgs.length; j++) {
|
|
|
6449 if (imgs[j].getAttribute('src', 2) == 'yui-tmp-img') {
|
|
|
6450 el = _elCreate(tagName, tagStyle);
|
|
|
6451 imgs[j].parentNode.replaceChild(el, imgs[j]);
|
|
|
6452 this.currentElement[this.currentElement.length] = el;
|
|
|
6453 }
|
|
|
6454 }
|
|
|
6455 } else {
|
|
|
6456 if (this.currentEvent) {
|
|
|
6457 tar = YAHOO.util.Event.getTarget(this.currentEvent);
|
|
|
6458 } else {
|
|
|
6459 //For Safari..
|
|
|
6460 tar = this._getDoc().body;
|
|
|
6461 }
|
|
|
6462 }
|
|
|
6463 if (tar) {
|
|
|
6464 /*
|
|
|
6465 * @knownissue Safari Cursor Position
|
|
|
6466 * @browser Safari 2.x
|
|
|
6467 * @description The issue here is that we have no way of knowing where the cursor position is
|
|
|
6468 * inside of the iframe, so we have to place the newly inserted data in the best place that we can.
|
|
|
6469 */
|
|
|
6470 el = _elCreate(tagName, tagStyle);
|
|
|
6471 if (this._isElement(tar, 'body') || this._isElement(tar, 'html')) {
|
|
|
6472 if (this._isElement(tar, 'html')) {
|
|
|
6473 tar = this._getDoc().body;
|
|
|
6474 }
|
|
|
6475 tar.appendChild(el);
|
|
|
6476 } else if (tar.nextSibling) {
|
|
|
6477 tar.parentNode.insertBefore(el, tar.nextSibling);
|
|
|
6478 } else {
|
|
|
6479 tar.parentNode.appendChild(el);
|
|
|
6480 }
|
|
|
6481 //this.currentElement = el;
|
|
|
6482 this.currentElement[this.currentElement.length] = el;
|
|
|
6483 this.currentEvent = null;
|
|
|
6484 if (this.browser.webkit) {
|
|
|
6485 //Force Safari to focus the new element
|
|
|
6486 this._getSelection().setBaseAndExtent(el, 0, el, 0);
|
|
|
6487 if (this.browser.webkit3) {
|
|
|
6488 this._getSelection().collapseToStart();
|
|
|
6489 } else {
|
|
|
6490 this._getSelection().collapse(true);
|
|
|
6491 }
|
|
|
6492 }
|
|
|
6493 }
|
|
|
6494 } else {
|
|
|
6495 //Force CSS Styling for this action...
|
|
|
6496 this._setEditorStyle(true);
|
|
|
6497 this._getDoc().execCommand('fontname', false, 'yui-tmp');
|
|
|
6498 var _tmp = [], __tmp, __els = ['font', 'span', 'i', 'b', 'u'];
|
|
|
6499
|
|
|
6500 if (!this._isElement(this._getSelectedElement(), 'body')) {
|
|
|
6501 __els[__els.length] = this._getDoc().getElementsByTagName(this._getSelectedElement().tagName);
|
|
|
6502 __els[__els.length] = this._getDoc().getElementsByTagName(this._getSelectedElement().parentNode.tagName);
|
|
|
6503 }
|
|
|
6504 for (var _els = 0; _els < __els.length; _els++) {
|
|
|
6505 var _tmp1 = this._getDoc().getElementsByTagName(__els[_els]);
|
|
|
6506 for (var e = 0; e < _tmp1.length; e++) {
|
|
|
6507 _tmp[_tmp.length] = _tmp1[e];
|
|
|
6508 }
|
|
|
6509 }
|
|
|
6510
|
|
|
6511
|
|
|
6512 for (var i = 0; i < _tmp.length; i++) {
|
|
|
6513 if ((YAHOO.util.Dom.getStyle(_tmp[i], 'font-family') == 'yui-tmp') || (_tmp[i].face && (_tmp[i].face == 'yui-tmp'))) {
|
|
|
6514 if (tagName !== 'span') {
|
|
|
6515 el = _elCreate(tagName, tagStyle);
|
|
|
6516 } else {
|
|
|
6517 el = _elCreate(_tmp[i].tagName, tagStyle);
|
|
|
6518 }
|
|
|
6519 el.innerHTML = _tmp[i].innerHTML;
|
|
|
6520 if (this._isElement(_tmp[i], 'ol') || (this._isElement(_tmp[i], 'ul'))) {
|
|
|
6521 var fc = _tmp[i].getElementsByTagName('li')[0];
|
|
|
6522 _tmp[i].style.fontFamily = 'inherit';
|
|
|
6523 fc.style.fontFamily = 'inherit';
|
|
|
6524 el.innerHTML = fc.innerHTML;
|
|
|
6525 fc.innerHTML = '';
|
|
|
6526 fc.appendChild(el);
|
|
|
6527 this.currentElement[this.currentElement.length] = el;
|
|
|
6528 } else if (this._isElement(_tmp[i], 'li')) {
|
|
|
6529 _tmp[i].innerHTML = '';
|
|
|
6530 _tmp[i].appendChild(el);
|
|
|
6531 _tmp[i].style.fontFamily = 'inherit';
|
|
|
6532 this.currentElement[this.currentElement.length] = el;
|
|
|
6533 } else {
|
|
|
6534 if (_tmp[i].parentNode) {
|
|
|
6535 _tmp[i].parentNode.replaceChild(el, _tmp[i]);
|
|
|
6536 this.currentElement[this.currentElement.length] = el;
|
|
|
6537 this.currentEvent = null;
|
|
|
6538 if (this.browser.webkit) {
|
|
|
6539 //Force Safari to focus the new element
|
|
|
6540 this._getSelection().setBaseAndExtent(el, 0, el, 0);
|
|
|
6541 if (this.browser.webkit3) {
|
|
|
6542 this._getSelection().collapseToStart();
|
|
|
6543 } else {
|
|
|
6544 this._getSelection().collapse(true);
|
|
|
6545 }
|
|
|
6546 }
|
|
|
6547 if (this.browser.ie && tagStyle && tagStyle.fontSize) {
|
|
|
6548 this._getSelection().empty();
|
|
|
6549 }
|
|
|
6550 if (this.browser.gecko) {
|
|
|
6551 this._getSelection().collapseToStart();
|
|
|
6552 }
|
|
|
6553 }
|
|
|
6554 }
|
|
|
6555 }
|
|
|
6556 }
|
|
|
6557 var len = this.currentElement.length;
|
|
|
6558 for (var o = 0; o < len; o++) {
|
|
|
6559 if ((o + 1) != len) { //Skip the last one in the list
|
|
|
6560 if (this.currentElement[o] && this.currentElement[o].nextSibling) {
|
|
|
6561 if (this._isElement(this.currentElement[o], 'br')) {
|
|
|
6562 this.currentElement[this.currentElement.length] = this.currentElement[o].nextSibling;
|
|
|
6563 }
|
|
|
6564 }
|
|
|
6565 }
|
|
|
6566 }
|
|
|
6567 }
|
|
|
6568 },
|
|
|
6569 /**
|
|
|
6570 * @method saveHTML
|
|
|
6571 * @description Cleans the HTML with the cleanHTML method then places that string back into the textarea.
|
|
|
6572 * @return String
|
|
|
6573 */
|
|
|
6574 saveHTML: function() {
|
|
|
6575 var html = this.cleanHTML();
|
|
|
6576 if (this._textarea) {
|
|
|
6577 this.get('element').value = html;
|
|
|
6578 } else {
|
|
|
6579 this.get('element').innerHTML = html;
|
|
|
6580 }
|
|
|
6581 if (this.get('saveEl') !== this.get('element')) {
|
|
|
6582 var out = this.get('saveEl');
|
|
|
6583 if (Lang.isString(out)) {
|
|
|
6584 out = Dom.get(out);
|
|
|
6585 }
|
|
|
6586 if (out) {
|
|
|
6587 if (out.tagName.toLowerCase() === 'textarea') {
|
|
|
6588 out.value = html;
|
|
|
6589 } else {
|
|
|
6590 out.innerHTML = html;
|
|
|
6591 }
|
|
|
6592 }
|
|
|
6593 }
|
|
|
6594 return html;
|
|
|
6595 },
|
|
|
6596 /**
|
|
|
6597 * @method setEditorHTML
|
|
|
6598 * @param {String} incomingHTML The html content to load into the editor
|
|
|
6599 * @description Loads HTML into the editors body
|
|
|
6600 */
|
|
|
6601 setEditorHTML: function(incomingHTML) {
|
|
|
6602 var html = this._cleanIncomingHTML(incomingHTML);
|
|
|
6603 html = html.replace(/RIGHT_BRACKET/gi, '{');
|
|
|
6604 html = html.replace(/LEFT_BRACKET/gi, '}');
|
|
|
6605 this._getDoc().body.innerHTML = html;
|
|
|
6606 this.nodeChange();
|
|
|
6607 },
|
|
|
6608 /**
|
|
|
6609 * @method getEditorHTML
|
|
|
6610 * @description Gets the unprocessed/unfiltered HTML from the editor
|
|
|
6611 */
|
|
|
6612 getEditorHTML: function() {
|
|
|
6613 try {
|
|
|
6614 var b = this._getDoc().body;
|
|
|
6615 if (b === null) {
|
|
|
6616 return null;
|
|
|
6617 }
|
|
|
6618 return this._getDoc().body.innerHTML;
|
|
|
6619 } catch (e) {
|
|
|
6620 return '';
|
|
|
6621 }
|
|
|
6622 },
|
|
|
6623 /**
|
|
|
6624 * @method show
|
|
|
6625 * @description This method needs to be called if the Editor was hidden (like in a TabView or Panel). It is used to reset the editor after being in a container that was set to display none.
|
|
|
6626 */
|
|
|
6627 show: function() {
|
|
|
6628 if (this.browser.gecko) {
|
|
|
6629 this._setDesignMode('on');
|
|
|
6630 this.focus();
|
|
|
6631 }
|
|
|
6632 if (this.browser.webkit) {
|
|
|
6633 var self = this;
|
|
|
6634 window.setTimeout(function() {
|
|
|
6635 self._setInitialContent.call(self);
|
|
|
6636 }, 10);
|
|
|
6637 }
|
|
|
6638 //Adding this will close all other Editor window's when showing this one.
|
|
|
6639 if (this.currentWindow) {
|
|
|
6640 this.closeWindow();
|
|
|
6641 }
|
|
|
6642 //Put the iframe back in place
|
|
|
6643 this.get('iframe').setStyle('position', 'static');
|
|
|
6644 this.get('iframe').setStyle('left', '');
|
|
|
6645 },
|
|
|
6646 /**
|
|
|
6647 * @method hide
|
|
|
6648 * @description This method needs to be called if the Editor is to be hidden (like in a TabView or Panel). It should be called to clear timeouts and close open editor windows.
|
|
|
6649 */
|
|
|
6650 hide: function() {
|
|
|
6651 //Adding this will close all other Editor window's.
|
|
|
6652 if (this.currentWindow) {
|
|
|
6653 this.closeWindow();
|
|
|
6654 }
|
|
|
6655 if (this._fixNodesTimer) {
|
|
|
6656 clearTimeout(this._fixNodesTimer);
|
|
|
6657 this._fixNodesTimer = null;
|
|
|
6658 }
|
|
|
6659 if (this._nodeChangeTimer) {
|
|
|
6660 clearTimeout(this._nodeChangeTimer);
|
|
|
6661 this._nodeChangeTimer = null;
|
|
|
6662 }
|
|
|
6663 this._lastNodeChange = 0;
|
|
|
6664 //Move the iframe off of the screen, so that in containers with visiblity hidden, IE will not cover other elements.
|
|
|
6665 this.get('iframe').setStyle('position', 'absolute');
|
|
|
6666 this.get('iframe').setStyle('left', '-9999px');
|
|
|
6667 },
|
|
|
6668 /**
|
|
|
6669 * @method _cleanIncomingHTML
|
|
|
6670 * @param {String} html The unfiltered HTML
|
|
|
6671 * @description Process the HTML with a few regexes to clean it up and stabilize the input
|
|
|
6672 * @return {String} The filtered HTML
|
|
|
6673 */
|
|
|
6674 _cleanIncomingHTML: function(html) {
|
|
|
6675 html = html.replace(/{/gi, 'RIGHT_BRACKET');
|
|
|
6676 html = html.replace(/}/gi, 'LEFT_BRACKET');
|
|
|
6677
|
|
|
6678 html = html.replace(/<strong([^>]*)>/gi, '<b$1>');
|
|
|
6679 html = html.replace(/<\/strong>/gi, '</b>');
|
|
|
6680
|
|
|
6681 //replace embed before em check
|
|
|
6682 html = html.replace(/<embed([^>]*)>/gi, '<YUI_EMBED$1>');
|
|
|
6683 html = html.replace(/<\/embed>/gi, '</YUI_EMBED>');
|
|
|
6684
|
|
|
6685 html = html.replace(/<em([^>]*)>/gi, '<i$1>');
|
|
|
6686 html = html.replace(/<\/em>/gi, '</i>');
|
|
|
6687 html = html.replace(/_moz_dirty=""/gi, '');
|
|
|
6688
|
|
|
6689 //Put embed tags back in..
|
|
|
6690 html = html.replace(/<YUI_EMBED([^>]*)>/gi, '<embed$1>');
|
|
|
6691 html = html.replace(/<\/YUI_EMBED>/gi, '</embed>');
|
|
|
6692 if (this.get('plainText')) {
|
|
|
6693 html = html.replace(/\n/g, '<br>').replace(/\r/g, '<br>');
|
|
|
6694 html = html.replace(/ /gi, ' '); //Replace all double spaces
|
|
|
6695 html = html.replace(/\t/gi, ' '); //Replace all tabs
|
|
|
6696 }
|
|
|
6697 //Removing Script Tags from the Editor
|
|
|
6698 html = html.replace(/<script([^>]*)>/gi, '<bad>');
|
|
|
6699 html = html.replace(/<\/script([^>]*)>/gi, '</bad>');
|
|
|
6700 html = html.replace(/<script([^>]*)>/gi, '<bad>');
|
|
|
6701 html = html.replace(/<\/script([^>]*)>/gi, '</bad>');
|
|
|
6702 //Replace the line feeds
|
|
|
6703 html = html.replace(/\r\n/g, '<YUI_LF>').replace(/\n/g, '<YUI_LF>').replace(/\r/g, '<YUI_LF>');
|
|
|
6704
|
|
|
6705 //Remove Bad HTML elements (used to be script nodes)
|
|
|
6706 html = html.replace(new RegExp('<bad([^>]*)>(.*?)<\/bad>', 'gi'), '');
|
|
|
6707 //Replace the lines feeds
|
|
|
6708 html = html.replace(/<YUI_LF>/g, '\n');
|
|
|
6709 return html;
|
|
|
6710 },
|
|
|
6711 /**
|
|
|
6712 * @method cleanHTML
|
|
|
6713 * @param {String} html The unfiltered HTML
|
|
|
6714 * @description Process the HTML with a few regexes to clean it up and stabilize the output
|
|
|
6715 * @return {String} The filtered HTML
|
|
|
6716 */
|
|
|
6717 cleanHTML: function(html) {
|
|
|
6718 //Start Filtering Output
|
|
|
6719 //Begin RegExs..
|
|
|
6720 if (!html) {
|
|
|
6721 html = this.getEditorHTML();
|
|
|
6722 }
|
|
|
6723 var markup = this.get('markup');
|
|
|
6724 //Make some backups...
|
|
|
6725 html = this.pre_filter_linebreaks(html, markup);
|
|
|
6726
|
|
|
6727 //Filter MS Word
|
|
|
6728 html = this.filter_msword(html);
|
|
|
6729
|
|
|
6730 html = html.replace(/<img([^>]*)\/>/gi, '<YUI_IMG$1>');
|
|
|
6731 html = html.replace(/<img([^>]*)>/gi, '<YUI_IMG$1>');
|
|
|
6732
|
|
|
6733 html = html.replace(/<input([^>]*)\/>/gi, '<YUI_INPUT$1>');
|
|
|
6734 html = html.replace(/<input([^>]*)>/gi, '<YUI_INPUT$1>');
|
|
|
6735
|
|
|
6736 html = html.replace(/<ul([^>]*)>/gi, '<YUI_UL$1>');
|
|
|
6737 html = html.replace(/<\/ul>/gi, '<\/YUI_UL>');
|
|
|
6738 html = html.replace(/<blockquote([^>]*)>/gi, '<YUI_BQ$1>');
|
|
|
6739 html = html.replace(/<\/blockquote>/gi, '<\/YUI_BQ>');
|
|
|
6740
|
|
|
6741 html = html.replace(/<embed([^>]*)>/gi, '<YUI_EMBED$1>');
|
|
|
6742 html = html.replace(/<\/embed>/gi, '<\/YUI_EMBED>');
|
|
|
6743
|
|
|
6744 //Convert b and i tags to strong and em tags
|
|
|
6745 if ((markup == 'semantic') || (markup == 'xhtml')) {
|
|
|
6746 html = html.replace(/<i(\s+[^>]*)?>/gi, '<em$1>');
|
|
|
6747 html = html.replace(/<\/i>/gi, '</em>');
|
|
|
6748 html = html.replace(/<b(\s+[^>]*)?>/gi, '<strong$1>');
|
|
|
6749 html = html.replace(/<\/b>/gi, '</strong>');
|
|
|
6750 }
|
|
|
6751
|
|
|
6752 html = html.replace(/_moz_dirty=""/gi, '');
|
|
|
6753
|
|
|
6754 //normalize strikethrough
|
|
|
6755 html = html.replace(/<strike/gi, '<span style="text-decoration: line-through;"');
|
|
|
6756 html = html.replace(/\/strike>/gi, '/span>');
|
|
|
6757
|
|
|
6758
|
|
|
6759 //Case Changing
|
|
|
6760 if (this.browser.ie) {
|
|
|
6761 html = html.replace(/text-decoration/gi, 'text-decoration');
|
|
|
6762 html = html.replace(/font-weight/gi, 'font-weight');
|
|
|
6763 html = html.replace(/_width="([^>]*)"/gi, '');
|
|
|
6764 html = html.replace(/_height="([^>]*)"/gi, '');
|
|
|
6765 //Cleanup Image URL's
|
|
|
6766 var url = this._baseHREF.replace(/\//gi, '\\/'),
|
|
|
6767 re = new RegExp('src="' + url, 'gi');
|
|
|
6768 html = html.replace(re, 'src="');
|
|
|
6769 }
|
|
|
6770 html = html.replace(/<font/gi, '<font');
|
|
|
6771 html = html.replace(/<\/font>/gi, '</font>');
|
|
|
6772 html = html.replace(/<span/gi, '<span');
|
|
|
6773 html = html.replace(/<\/span>/gi, '</span>');
|
|
|
6774 if ((markup == 'semantic') || (markup == 'xhtml') || (markup == 'css')) {
|
|
|
6775 html = html.replace(new RegExp('<font([^>]*)face="([^>]*)">(.*?)<\/font>', 'gi'), '<span $1 style="font-family: $2;">$3</span>');
|
|
|
6776 html = html.replace(/<u/gi, '<span style="text-decoration: underline;"');
|
|
|
6777 if (this.browser.webkit) {
|
|
|
6778 html = html.replace(new RegExp('<span class="Apple-style-span" style="font-weight: bold;">([^>]*)<\/span>', 'gi'), '<strong>$1</strong>');
|
|
|
6779 html = html.replace(new RegExp('<span class="Apple-style-span" style="font-style: italic;">([^>]*)<\/span>', 'gi'), '<em>$1</em>');
|
|
|
6780 }
|
|
|
6781 html = html.replace(/\/u>/gi, '/span>');
|
|
|
6782 if (markup == 'css') {
|
|
|
6783 html = html.replace(/<em([^>]*)>/gi, '<i$1>');
|
|
|
6784 html = html.replace(/<\/em>/gi, '</i>');
|
|
|
6785 html = html.replace(/<strong([^>]*)>/gi, '<b$1>');
|
|
|
6786 html = html.replace(/<\/strong>/gi, '</b>');
|
|
|
6787 html = html.replace(/<b/gi, '<span style="font-weight: bold;"');
|
|
|
6788 html = html.replace(/\/b>/gi, '/span>');
|
|
|
6789 html = html.replace(/<i/gi, '<span style="font-style: italic;"');
|
|
|
6790 html = html.replace(/\/i>/gi, '/span>');
|
|
|
6791 }
|
|
|
6792 html = html.replace(/ /gi, ' '); //Replace all double spaces and replace with a single
|
|
|
6793 } else {
|
|
|
6794 html = html.replace(/<u/gi, '<u');
|
|
|
6795 html = html.replace(/\/u>/gi, '/u>');
|
|
|
6796 }
|
|
|
6797 html = html.replace(/<ol([^>]*)>/gi, '<ol$1>');
|
|
|
6798 html = html.replace(/\/ol>/gi, '/ol>');
|
|
|
6799 html = html.replace(/<li/gi, '<li');
|
|
|
6800 html = html.replace(/\/li>/gi, '/li>');
|
|
|
6801 html = this.filter_safari(html);
|
|
|
6802
|
|
|
6803 html = this.filter_internals(html);
|
|
|
6804
|
|
|
6805 html = this.filter_all_rgb(html);
|
|
|
6806
|
|
|
6807 //Replace our backups with the real thing
|
|
|
6808 html = this.post_filter_linebreaks(html, markup);
|
|
|
6809
|
|
|
6810 if (markup == 'xhtml') {
|
|
|
6811 html = html.replace(/<YUI_IMG([^>]*)>/g, '<img $1 />');
|
|
|
6812 html = html.replace(/<YUI_INPUT([^>]*)>/g, '<input $1 />');
|
|
|
6813 } else {
|
|
|
6814 html = html.replace(/<YUI_IMG([^>]*)>/g, '<img $1>');
|
|
|
6815 html = html.replace(/<YUI_INPUT([^>]*)>/g, '<input $1>');
|
|
|
6816 }
|
|
|
6817 html = html.replace(/<YUI_UL([^>]*)>/g, '<ul$1>');
|
|
|
6818 html = html.replace(/<\/YUI_UL>/g, '<\/ul>');
|
|
|
6819
|
|
|
6820 html = this.filter_invalid_lists(html);
|
|
|
6821
|
|
|
6822 html = html.replace(/<YUI_BQ([^>]*)>/g, '<blockquote$1>');
|
|
|
6823 html = html.replace(/<\/YUI_BQ>/g, '<\/blockquote>');
|
|
|
6824
|
|
|
6825 html = html.replace(/<YUI_EMBED([^>]*)>/g, '<embed$1>');
|
|
|
6826 html = html.replace(/<\/YUI_EMBED>/g, '<\/embed>');
|
|
|
6827
|
|
|
6828 //This should fix &'s in URL's
|
|
|
6829 html = html.replace(/ & /gi, ' YUI_AMP ');
|
|
|
6830 html = html.replace(/ &/gi, ' YUI_AMP_F ');
|
|
|
6831 html = html.replace(/& /gi, ' YUI_AMP_R ');
|
|
|
6832 html = html.replace(/&/gi, '&');
|
|
|
6833 html = html.replace(/ YUI_AMP /gi, ' & ');
|
|
|
6834 html = html.replace(/ YUI_AMP_F /gi, ' &');
|
|
|
6835 html = html.replace(/ YUI_AMP_R /gi, '& ');
|
|
|
6836
|
|
|
6837 //Trim the output, removing whitespace from the beginning and end
|
|
|
6838 html = YAHOO.lang.trim(html);
|
|
|
6839
|
|
|
6840 if (this.get('removeLineBreaks')) {
|
|
|
6841 html = html.replace(/\n/g, '').replace(/\r/g, '');
|
|
|
6842 html = html.replace(/ /gi, ' '); //Replace all double spaces and replace with a single
|
|
|
6843 }
|
|
|
6844
|
|
|
6845 for (var v in this.invalidHTML) {
|
|
|
6846 if (YAHOO.lang.hasOwnProperty(this.invalidHTML, v)) {
|
|
|
6847 if (Lang.isObject(v) && v.keepContents) {
|
|
|
6848 html = html.replace(new RegExp('<' + v + '([^>]*)>(.*?)<\/' + v + '>', 'gi'), '$1');
|
|
|
6849 } else {
|
|
|
6850 html = html.replace(new RegExp('<' + v + '([^>]*)>(.*?)<\/' + v + '>', 'gi'), '');
|
|
|
6851 }
|
|
|
6852 }
|
|
|
6853 }
|
|
|
6854
|
|
|
6855 /* LATER -- Add DOM manipulation
|
|
|
6856 console.log(html);
|
|
|
6857 var frag = document.createDocumentFragment();
|
|
|
6858 frag.innerHTML = html;
|
|
|
6859
|
|
|
6860 var ps = frag.getElementsByTagName('p'),
|
|
|
6861 len = ps.length;
|
|
|
6862 for (var i = 0; i < len; i++) {
|
|
|
6863 var ps2 = ps[i].getElementsByTagName('p');
|
|
|
6864 if (ps2.length) {
|
|
|
6865
|
|
|
6866 }
|
|
|
6867
|
|
|
6868 }
|
|
|
6869 html = frag.innerHTML;
|
|
|
6870 console.log(html);
|
|
|
6871 */
|
|
|
6872
|
|
|
6873 this.fireEvent('cleanHTML', { type: 'cleanHTML', target: this, html: html });
|
|
|
6874
|
|
|
6875 return html;
|
|
|
6876 },
|
|
|
6877 /**
|
|
|
6878 * @method filter_msword
|
|
|
6879 * @param String html The HTML string to filter
|
|
|
6880 * @description Filters out msword html attributes and other junk. Activate with filterWord: true in config
|
|
|
6881 */
|
|
|
6882 filter_msword: function(html) {
|
|
|
6883 if (!this.get('filterWord')) {
|
|
|
6884 return html;
|
|
|
6885 }
|
|
|
6886 //Remove the ms o: tags
|
|
|
6887 html = html.replace(/<o:p>\s*<\/o:p>/g, '');
|
|
|
6888 html = html.replace(/<o:p>[\s\S]*?<\/o:p>/g, ' ');
|
|
|
6889
|
|
|
6890 //Remove the ms w: tags
|
|
|
6891 html = html.replace( /<w:[^>]*>[\s\S]*?<\/w:[^>]*>/gi, '');
|
|
|
6892
|
|
|
6893 //Remove mso-? styles.
|
|
|
6894 html = html.replace( /\s*mso-[^:]+:[^;"]+;?/gi, '');
|
|
|
6895
|
|
|
6896 //Remove more bogus MS styles.
|
|
|
6897 html = html.replace( /\s*MARGIN: 0cm 0cm 0pt\s*;/gi, '');
|
|
|
6898 html = html.replace( /\s*MARGIN: 0cm 0cm 0pt\s*"/gi, "\"");
|
|
|
6899 html = html.replace( /\s*TEXT-INDENT: 0cm\s*;/gi, '');
|
|
|
6900 html = html.replace( /\s*TEXT-INDENT: 0cm\s*"/gi, "\"");
|
|
|
6901 html = html.replace( /\s*PAGE-BREAK-BEFORE: [^\s;]+;?"/gi, "\"");
|
|
|
6902 html = html.replace( /\s*FONT-VARIANT: [^\s;]+;?"/gi, "\"" );
|
|
|
6903 html = html.replace( /\s*tab-stops:[^;"]*;?/gi, '');
|
|
|
6904 html = html.replace( /\s*tab-stops:[^"]*/gi, '');
|
|
|
6905
|
|
|
6906 //Remove XML declarations
|
|
|
6907 html = html.replace(/<\\?\?xml[^>]*>/gi, '');
|
|
|
6908
|
|
|
6909 //Remove lang
|
|
|
6910 html = html.replace(/<(\w[^>]*) lang=([^ |>]*)([^>]*)/gi, "<$1$3");
|
|
|
6911
|
|
|
6912 //Remove language tags
|
|
|
6913 html = html.replace( /<(\w[^>]*) language=([^ |>]*)([^>]*)/gi, "<$1$3");
|
|
|
6914
|
|
|
6915 //Remove onmouseover and onmouseout events (from MS Word comments effect)
|
|
|
6916 html = html.replace( /<(\w[^>]*) onmouseover="([^\"]*)"([^>]*)/gi, "<$1$3");
|
|
|
6917 html = html.replace( /<(\w[^>]*) onmouseout="([^\"]*)"([^>]*)/gi, "<$1$3");
|
|
|
6918
|
|
|
6919 return html;
|
|
|
6920 },
|
|
|
6921 /**
|
|
|
6922 * @method filter_invalid_lists
|
|
|
6923 * @param String html The HTML string to filter
|
|
|
6924 * @description Filters invalid ol and ul list markup, converts this: <li></li><ol>..</ol> to this: <li></li><li><ol>..</ol></li>
|
|
|
6925 */
|
|
|
6926 filter_invalid_lists: function(html) {
|
|
|
6927 html = html.replace(/<\/li>\n/gi, '</li>');
|
|
|
6928
|
|
|
6929 html = html.replace(/<\/li><ol>/gi, '</li><li><ol>');
|
|
|
6930 html = html.replace(/<\/ol>/gi, '</ol></li>');
|
|
|
6931 html = html.replace(/<\/ol><\/li>\n/gi, "</ol>");
|
|
|
6932
|
|
|
6933 html = html.replace(/<\/li><ul>/gi, '</li><li><ul>');
|
|
|
6934 html = html.replace(/<\/ul>/gi, '</ul></li>');
|
|
|
6935 html = html.replace(/<\/ul><\/li>\n?/gi, "</ul>");
|
|
|
6936
|
|
|
6937 html = html.replace(/<\/li>/gi, "</li>");
|
|
|
6938 html = html.replace(/<\/ol>/gi, "</ol>");
|
|
|
6939 html = html.replace(/<ol>/gi, "<ol>");
|
|
|
6940 html = html.replace(/<ul>/gi, "<ul>");
|
|
|
6941 return html;
|
|
|
6942 },
|
|
|
6943 /**
|
|
|
6944 * @method filter_safari
|
|
|
6945 * @param String html The HTML string to filter
|
|
|
6946 * @description Filters strings specific to Safari
|
|
|
6947 * @return String
|
|
|
6948 */
|
|
|
6949 filter_safari: function(html) {
|
|
|
6950 if (this.browser.webkit) {
|
|
|
6951 //<span class="Apple-tab-span" style="white-space:pre"> </span>
|
|
|
6952 html = html.replace(/<span class="Apple-tab-span" style="white-space:pre">([^>])<\/span>/gi, ' ');
|
|
|
6953 html = html.replace(/Apple-style-span/gi, '');
|
|
|
6954 html = html.replace(/style="line-height: normal;"/gi, '');
|
|
|
6955 html = html.replace(/yui-wk-div/gi, '');
|
|
|
6956 html = html.replace(/yui-wk-p/gi, '');
|
|
|
6957
|
|
|
6958
|
|
|
6959 //Remove bogus LI's
|
|
|
6960 html = html.replace(/<li><\/li>/gi, '');
|
|
|
6961 html = html.replace(/<li> <\/li>/gi, '');
|
|
|
6962 html = html.replace(/<li> <\/li>/gi, '');
|
|
|
6963 //Remove bogus DIV's - updated from just removing the div's to replacing /div with a break
|
|
|
6964 if (this.get('ptags')) {
|
|
|
6965 html = html.replace(/<div([^>]*)>/g, '<p$1>');
|
|
|
6966 html = html.replace(/<\/div>/gi, '</p>');
|
|
|
6967 } else {
|
|
|
6968 //html = html.replace(/<div>/gi, '<br>');
|
|
|
6969 html = html.replace(/<div([^>]*)>([ tnr]*)<\/div>/gi, '<br>');
|
|
|
6970 html = html.replace(/<\/div>/gi, '');
|
|
|
6971 }
|
|
|
6972 }
|
|
|
6973 return html;
|
|
|
6974 },
|
|
|
6975 /**
|
|
|
6976 * @method filter_internals
|
|
|
6977 * @param String html The HTML string to filter
|
|
|
6978 * @description Filters internal RTE strings and bogus attrs we don't want
|
|
|
6979 * @return String
|
|
|
6980 */
|
|
|
6981 filter_internals: function(html) {
|
|
|
6982 html = html.replace(/\r/g, '');
|
|
|
6983 //Fix stuff we don't want
|
|
|
6984 html = html.replace(/<\/?(body|head|html)[^>]*>/gi, '');
|
|
|
6985 //Fix last BR in LI
|
|
|
6986 html = html.replace(/<YUI_BR><\/li>/gi, '</li>');
|
|
|
6987
|
|
|
6988 html = html.replace(/yui-tag-span/gi, '');
|
|
|
6989 html = html.replace(/yui-tag/gi, '');
|
|
|
6990 html = html.replace(/yui-non/gi, '');
|
|
|
6991 html = html.replace(/yui-img/gi, '');
|
|
|
6992 html = html.replace(/ tag="span"/gi, '');
|
|
|
6993 html = html.replace(/ class=""/gi, '');
|
|
|
6994 html = html.replace(/ style=""/gi, '');
|
|
|
6995 html = html.replace(/ class=" "/gi, '');
|
|
|
6996 html = html.replace(/ class=" "/gi, '');
|
|
|
6997 html = html.replace(/ target=""/gi, '');
|
|
|
6998 html = html.replace(/ title=""/gi, '');
|
|
|
6999
|
|
|
7000 if (this.browser.ie) {
|
|
|
7001 html = html.replace(/ class= /gi, '');
|
|
|
7002 html = html.replace(/ class= >/gi, '');
|
|
|
7003 }
|
|
|
7004
|
|
|
7005 return html;
|
|
|
7006 },
|
|
|
7007 /**
|
|
|
7008 * @method filter_all_rgb
|
|
|
7009 * @param String str The HTML string to filter
|
|
|
7010 * @description Converts all RGB color strings found in passed string to a hex color, example: style="color: rgb(0, 255, 0)" converts to style="color: #00ff00"
|
|
|
7011 * @return String
|
|
|
7012 */
|
|
|
7013 filter_all_rgb: function(str) {
|
|
|
7014 var exp = new RegExp("rgb\\s*?\\(\\s*?([0-9]+).*?,\\s*?([0-9]+).*?,\\s*?([0-9]+).*?\\)", "gi");
|
|
|
7015 var arr = str.match(exp);
|
|
|
7016 if (Lang.isArray(arr)) {
|
|
|
7017 for (var i = 0; i < arr.length; i++) {
|
|
|
7018 var color = this.filter_rgb(arr[i]);
|
|
|
7019 str = str.replace(arr[i].toString(), color);
|
|
|
7020 }
|
|
|
7021 }
|
|
|
7022
|
|
|
7023 return str;
|
|
|
7024 },
|
|
|
7025 /**
|
|
|
7026 * @method filter_rgb
|
|
|
7027 * @param String css The CSS string containing rgb(#,#,#);
|
|
|
7028 * @description Converts an RGB color string to a hex color, example: rgb(0, 255, 0) converts to #00ff00
|
|
|
7029 * @return String
|
|
|
7030 */
|
|
|
7031 filter_rgb: function(css) {
|
|
|
7032 if (css.toLowerCase().indexOf('rgb') != -1) {
|
|
|
7033 var exp = new RegExp("(.*?)rgb\\s*?\\(\\s*?([0-9]+).*?,\\s*?([0-9]+).*?,\\s*?([0-9]+).*?\\)(.*?)", "gi");
|
|
|
7034 var rgb = css.replace(exp, "$1,$2,$3,$4,$5").split(',');
|
|
|
7035
|
|
|
7036 if (rgb.length == 5) {
|
|
|
7037 var r = parseInt(rgb[1], 10).toString(16);
|
|
|
7038 var g = parseInt(rgb[2], 10).toString(16);
|
|
|
7039 var b = parseInt(rgb[3], 10).toString(16);
|
|
|
7040
|
|
|
7041 r = r.length == 1 ? '0' + r : r;
|
|
|
7042 g = g.length == 1 ? '0' + g : g;
|
|
|
7043 b = b.length == 1 ? '0' + b : b;
|
|
|
7044
|
|
|
7045 css = "#" + r + g + b;
|
|
|
7046 }
|
|
|
7047 }
|
|
|
7048 return css;
|
|
|
7049 },
|
|
|
7050 /**
|
|
|
7051 * @method pre_filter_linebreaks
|
|
|
7052 * @param String html The HTML to filter
|
|
|
7053 * @param String markup The markup type to filter to
|
|
|
7054 * @description HTML Pre Filter
|
|
|
7055 * @return String
|
|
|
7056 */
|
|
|
7057 pre_filter_linebreaks: function(html, markup) {
|
|
|
7058 if (this.browser.webkit) {
|
|
|
7059 html = html.replace(/<br class="khtml-block-placeholder">/gi, '<YUI_BR>');
|
|
|
7060 html = html.replace(/<br class="webkit-block-placeholder">/gi, '<YUI_BR>');
|
|
|
7061 }
|
|
|
7062 html = html.replace(/<br>/gi, '<YUI_BR>');
|
|
|
7063 html = html.replace(/<br (.*?)>/gi, '<YUI_BR>');
|
|
|
7064 html = html.replace(/<br\/>/gi, '<YUI_BR>');
|
|
|
7065 html = html.replace(/<br \/>/gi, '<YUI_BR>');
|
|
|
7066 html = html.replace(/<div><YUI_BR><\/div>/gi, '<YUI_BR>');
|
|
|
7067 html = html.replace(/<p>( | )<\/p>/g, '<YUI_BR>');
|
|
|
7068 html = html.replace(/<p><br> <\/p>/gi, '<YUI_BR>');
|
|
|
7069 html = html.replace(/<p> <\/p>/gi, '<YUI_BR>');
|
|
|
7070 //Fix last BR
|
|
|
7071 html = html.replace(/<YUI_BR>$/, '');
|
|
|
7072 //Fix last BR in P
|
|
|
7073 html = html.replace(/<YUI_BR><\/p>/g, '</p>');
|
|
|
7074 if (this.browser.ie) {
|
|
|
7075 html = html.replace(/ /g, '\t');
|
|
|
7076 }
|
|
|
7077 return html;
|
|
|
7078 },
|
|
|
7079 /**
|
|
|
7080 * @method post_filter_linebreaks
|
|
|
7081 * @param String html The HTML to filter
|
|
|
7082 * @param String markup The markup type to filter to
|
|
|
7083 * @description HTML Pre Filter
|
|
|
7084 * @return String
|
|
|
7085 */
|
|
|
7086 post_filter_linebreaks: function(html, markup) {
|
|
|
7087 if (markup == 'xhtml') {
|
|
|
7088 html = html.replace(/<YUI_BR>/g, '<br />');
|
|
|
7089 } else {
|
|
|
7090 html = html.replace(/<YUI_BR>/g, '<br>');
|
|
|
7091 }
|
|
|
7092 return html;
|
|
|
7093 },
|
|
|
7094 /**
|
|
|
7095 * @method clearEditorDoc
|
|
|
7096 * @description Clear the doc of the Editor
|
|
|
7097 */
|
|
|
7098 clearEditorDoc: function() {
|
|
|
7099 this._getDoc().body.innerHTML = ' ';
|
|
|
7100 },
|
|
|
7101 /**
|
|
|
7102 * @method openWindow
|
|
|
7103 * @description Override Method for Advanced Editor
|
|
|
7104 */
|
|
|
7105 openWindow: function(win) {
|
|
|
7106 },
|
|
|
7107 /**
|
|
|
7108 * @method moveWindow
|
|
|
7109 * @description Override Method for Advanced Editor
|
|
|
7110 */
|
|
|
7111 moveWindow: function() {
|
|
|
7112 },
|
|
|
7113 /**
|
|
|
7114 * @private
|
|
|
7115 * @method _closeWindow
|
|
|
7116 * @description Override Method for Advanced Editor
|
|
|
7117 */
|
|
|
7118 _closeWindow: function() {
|
|
|
7119 },
|
|
|
7120 /**
|
|
|
7121 * @method closeWindow
|
|
|
7122 * @description Override Method for Advanced Editor
|
|
|
7123 */
|
|
|
7124 closeWindow: function() {
|
|
|
7125 //this.unsubscribeAll('afterExecCommand');
|
|
|
7126 this.toolbar.resetAllButtons();
|
|
|
7127 this.focus();
|
|
|
7128 },
|
|
|
7129 /**
|
|
|
7130 * @method destroy
|
|
|
7131 * @description Destroys the editor, all of it's elements and objects.
|
|
|
7132 * @return {Boolean}
|
|
|
7133 */
|
|
|
7134 destroy: function() {
|
|
|
7135 if (this._nodeChangeDelayTimer) {
|
|
|
7136 clearTimeout(this._nodeChangeDelayTimer);
|
|
|
7137 }
|
|
|
7138 this.hide();
|
|
|
7139
|
|
|
7140 if (this.resize) {
|
|
|
7141 this.resize.destroy();
|
|
|
7142 }
|
|
|
7143 if (this.dd) {
|
|
|
7144 this.dd.unreg();
|
|
|
7145 }
|
|
|
7146 if (this.get('panel')) {
|
|
|
7147 this.get('panel').destroy();
|
|
|
7148 }
|
|
|
7149 this.saveHTML();
|
|
|
7150 this.toolbar.destroy();
|
|
|
7151 this.setStyle('visibility', 'visible');
|
|
|
7152 this.setStyle('position', 'static');
|
|
|
7153 this.setStyle('top', '');
|
|
|
7154 this.setStyle('left', '');
|
|
|
7155 var textArea = this.get('element');
|
|
|
7156 this.get('element_cont').get('parentNode').replaceChild(textArea, this.get('element_cont').get('element'));
|
|
|
7157 this.get('element_cont').get('element').innerHTML = '';
|
|
|
7158 this.set('handleSubmit', false); //Remove the submit handler
|
|
|
7159 return true;
|
|
|
7160 },
|
|
|
7161 /**
|
|
|
7162 * @method toString
|
|
|
7163 * @description Returns a string representing the editor.
|
|
|
7164 * @return {String}
|
|
|
7165 */
|
|
|
7166 toString: function() {
|
|
|
7167 var str = 'SimpleEditor';
|
|
|
7168 if (this.get && this.get('element_cont')) {
|
|
|
7169 str = 'SimpleEditor (#' + this.get('element_cont').get('id') + ')' + ((this.get('disabled') ? ' Disabled' : ''));
|
|
|
7170 }
|
|
|
7171 return str;
|
|
|
7172 }
|
|
|
7173 });
|
|
|
7174
|
|
|
7175 /**
|
|
|
7176 * @event toolbarLoaded
|
|
|
7177 * @description Event is fired during the render process directly after the Toolbar is loaded. Allowing you to attach events to the toolbar. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
|
|
|
7178 * @type YAHOO.util.CustomEvent
|
|
|
7179 */
|
|
|
7180 /**
|
|
|
7181 * @event cleanHTML
|
|
|
7182 * @description Event is fired after the cleanHTML method is called.
|
|
|
7183 * @type YAHOO.util.CustomEvent
|
|
|
7184 */
|
|
|
7185 /**
|
|
|
7186 * @event afterRender
|
|
|
7187 * @description Event is fired after the render process finishes. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
|
|
|
7188 * @type YAHOO.util.CustomEvent
|
|
|
7189 */
|
|
|
7190 /**
|
|
|
7191 * @event editorContentLoaded
|
|
|
7192 * @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 <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
|
|
|
7193 * @type YAHOO.util.CustomEvent
|
|
|
7194 */
|
|
|
7195 /**
|
|
|
7196 * @event beforeNodeChange
|
|
|
7197 * @description Event fires at the beginning of the nodeChange process. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
|
|
|
7198 * @type YAHOO.util.CustomEvent
|
|
|
7199 */
|
|
|
7200 /**
|
|
|
7201 * @event afterNodeChange
|
|
|
7202 * @description Event fires at the end of the nodeChange process. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
|
|
|
7203 * @type YAHOO.util.CustomEvent
|
|
|
7204 */
|
|
|
7205 /**
|
|
|
7206 * @event beforeExecCommand
|
|
|
7207 * @description Event fires at the beginning of the execCommand process. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
|
|
|
7208 * @type YAHOO.util.CustomEvent
|
|
|
7209 */
|
|
|
7210 /**
|
|
|
7211 * @event afterExecCommand
|
|
|
7212 * @description Event fires at the end of the execCommand process. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
|
|
|
7213 * @type YAHOO.util.CustomEvent
|
|
|
7214 */
|
|
|
7215 /**
|
|
|
7216 * @event editorMouseUp
|
|
|
7217 * @param {Event} ev The DOM Event that occured
|
|
|
7218 * @description Passed through HTML Event. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
|
|
|
7219 * @type YAHOO.util.CustomEvent
|
|
|
7220 */
|
|
|
7221 /**
|
|
|
7222 * @event editorMouseDown
|
|
|
7223 * @param {Event} ev The DOM Event that occured
|
|
|
7224 * @description Passed through HTML Event. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
|
|
|
7225 * @type YAHOO.util.CustomEvent
|
|
|
7226 */
|
|
|
7227 /**
|
|
|
7228 * @event editorDoubleClick
|
|
|
7229 * @param {Event} ev The DOM Event that occured
|
|
|
7230 * @description Passed through HTML Event. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
|
|
|
7231 * @type YAHOO.util.CustomEvent
|
|
|
7232 */
|
|
|
7233 /**
|
|
|
7234 * @event editorClick
|
|
|
7235 * @param {Event} ev The DOM Event that occured
|
|
|
7236 * @description Passed through HTML Event. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
|
|
|
7237 * @type YAHOO.util.CustomEvent
|
|
|
7238 */
|
|
|
7239 /**
|
|
|
7240 * @event editorKeyUp
|
|
|
7241 * @param {Event} ev The DOM Event that occured
|
|
|
7242 * @description Passed through HTML Event. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
|
|
|
7243 * @type YAHOO.util.CustomEvent
|
|
|
7244 */
|
|
|
7245 /**
|
|
|
7246 * @event editorKeyPress
|
|
|
7247 * @param {Event} ev The DOM Event that occured
|
|
|
7248 * @description Passed through HTML Event. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
|
|
|
7249 * @type YAHOO.util.CustomEvent
|
|
|
7250 */
|
|
|
7251 /**
|
|
|
7252 * @event editorKeyDown
|
|
|
7253 * @param {Event} ev The DOM Event that occured
|
|
|
7254 * @description Passed through HTML Event. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
|
|
|
7255 * @type YAHOO.util.CustomEvent
|
|
|
7256 */
|
|
|
7257 /**
|
|
|
7258 * @event beforeEditorMouseUp
|
|
|
7259 * @param {Event} ev The DOM Event that occured
|
|
|
7260 * @description Fires before editor event, returning false will stop the internal processing.
|
|
|
7261 * @type YAHOO.util.CustomEvent
|
|
|
7262 */
|
|
|
7263 /**
|
|
|
7264 * @event beforeEditorMouseDown
|
|
|
7265 * @param {Event} ev The DOM Event that occured
|
|
|
7266 * @description Fires before editor event, returning false will stop the internal processing.
|
|
|
7267 * @type YAHOO.util.CustomEvent
|
|
|
7268 */
|
|
|
7269 /**
|
|
|
7270 * @event beforeEditorDoubleClick
|
|
|
7271 * @param {Event} ev The DOM Event that occured
|
|
|
7272 * @description Fires before editor event, returning false will stop the internal processing.
|
|
|
7273 * @type YAHOO.util.CustomEvent
|
|
|
7274 */
|
|
|
7275 /**
|
|
|
7276 * @event beforeEditorClick
|
|
|
7277 * @param {Event} ev The DOM Event that occured
|
|
|
7278 * @description Fires before editor event, returning false will stop the internal processing.
|
|
|
7279 * @type YAHOO.util.CustomEvent
|
|
|
7280 */
|
|
|
7281 /**
|
|
|
7282 * @event beforeEditorKeyUp
|
|
|
7283 * @param {Event} ev The DOM Event that occured
|
|
|
7284 * @description Fires before editor event, returning false will stop the internal processing.
|
|
|
7285 * @type YAHOO.util.CustomEvent
|
|
|
7286 */
|
|
|
7287 /**
|
|
|
7288 * @event beforeEditorKeyPress
|
|
|
7289 * @param {Event} ev The DOM Event that occured
|
|
|
7290 * @description Fires before editor event, returning false will stop the internal processing.
|
|
|
7291 * @type YAHOO.util.CustomEvent
|
|
|
7292 */
|
|
|
7293 /**
|
|
|
7294 * @event beforeEditorKeyDown
|
|
|
7295 * @param {Event} ev The DOM Event that occured
|
|
|
7296 * @description Fires before editor event, returning false will stop the internal processing.
|
|
|
7297 * @type YAHOO.util.CustomEvent
|
|
|
7298 */
|
|
|
7299
|
|
|
7300 /**
|
|
|
7301 * @event editorWindowFocus
|
|
|
7302 * @description Fires when the iframe is focused. Note, this is window focus event, not an Editor focus event.
|
|
|
7303 * @type YAHOO.util.CustomEvent
|
|
|
7304 */
|
|
|
7305 /**
|
|
|
7306 * @event editorWindowBlur
|
|
|
7307 * @description Fires when the iframe is blurred. Note, this is window blur event, not an Editor blur event.
|
|
|
7308 * @type YAHOO.util.CustomEvent
|
|
|
7309 */
|
|
|
7310
|
|
|
7311
|
|
|
7312 /**
|
|
|
7313 * @description Singleton object used to track the open window objects and panels across the various open editors
|
|
|
7314 * @class EditorInfo
|
|
|
7315 * @static
|
|
|
7316 */
|
|
|
7317 YAHOO.widget.EditorInfo = {
|
|
|
7318 /**
|
|
|
7319 * @private
|
|
|
7320 * @property _instances
|
|
|
7321 * @description A reference to all editors on the page.
|
|
|
7322 * @type Object
|
|
|
7323 */
|
|
|
7324 _instances: {},
|
|
|
7325 /**
|
|
|
7326 * @private
|
|
|
7327 * @property blankImage
|
|
|
7328 * @description A reference to the blankImage url
|
|
|
7329 * @type String
|
|
|
7330 */
|
|
|
7331 blankImage: '',
|
|
|
7332 /**
|
|
|
7333 * @private
|
|
|
7334 * @property window
|
|
|
7335 * @description A reference to the currently open window object in any editor on the page.
|
|
|
7336 * @type Object <a href="YAHOO.widget.EditorWindow.html">YAHOO.widget.EditorWindow</a>
|
|
|
7337 */
|
|
|
7338 window: {},
|
|
|
7339 /**
|
|
|
7340 * @private
|
|
|
7341 * @property panel
|
|
|
7342 * @description A reference to the currently open panel in any editor on the page.
|
|
|
7343 * @type Object <a href="YAHOO.widget.Overlay.html">YAHOO.widget.Overlay</a>
|
|
|
7344 */
|
|
|
7345 panel: null,
|
|
|
7346 /**
|
|
|
7347 * @method getEditorById
|
|
|
7348 * @description Returns a reference to the Editor object associated with the given textarea
|
|
|
7349 * @param {String/HTMLElement} id The id or reference of the textarea to return the Editor instance of
|
|
|
7350 * @return Object <a href="YAHOO.widget.Editor.html">YAHOO.widget.Editor</a>
|
|
|
7351 */
|
|
|
7352 getEditorById: function(id) {
|
|
|
7353 if (!YAHOO.lang.isString(id)) {
|
|
|
7354 //Not a string, assume a node Reference
|
|
|
7355 id = id.id;
|
|
|
7356 }
|
|
|
7357 if (this._instances[id]) {
|
|
|
7358 return this._instances[id];
|
|
|
7359 }
|
|
|
7360 return false;
|
|
|
7361 },
|
|
|
7362 /**
|
|
|
7363 * @method saveAll
|
|
|
7364 * @description Saves all Editor instances on the page. If a form reference is passed, only Editor's bound to this form will be saved.
|
|
|
7365 * @param {HTMLElement} form The form to check if this Editor instance belongs to
|
|
|
7366 */
|
|
|
7367 saveAll: function(form) {
|
|
|
7368 var i, e, items = YAHOO.widget.EditorInfo._instances;
|
|
|
7369 if (form) {
|
|
|
7370 for (i in items) {
|
|
|
7371 if (Lang.hasOwnProperty(items, i)) {
|
|
|
7372 e = items[i];
|
|
|
7373 if (e.get('element').form && (e.get('element').form == form)) {
|
|
|
7374 e.saveHTML();
|
|
|
7375 }
|
|
|
7376 }
|
|
|
7377 }
|
|
|
7378 } else {
|
|
|
7379 for (i in items) {
|
|
|
7380 if (Lang.hasOwnProperty(items, i)) {
|
|
|
7381 items[i].saveHTML();
|
|
|
7382 }
|
|
|
7383 }
|
|
|
7384 }
|
|
|
7385 },
|
|
|
7386 /**
|
|
|
7387 * @method toString
|
|
|
7388 * @description Returns a string representing the EditorInfo.
|
|
|
7389 * @return {String}
|
|
|
7390 */
|
|
|
7391 toString: function() {
|
|
|
7392 var len = 0;
|
|
|
7393 for (var i in this._instances) {
|
|
|
7394 if (Lang.hasOwnProperty(this._instances, i)) {
|
|
|
7395 len++;
|
|
|
7396 }
|
|
|
7397 }
|
|
|
7398 return 'Editor Info (' + len + ' registered intance' + ((len > 1) ? 's' : '') + ')';
|
|
|
7399 }
|
|
|
7400 };
|
|
|
7401
|
|
|
7402
|
|
|
7403
|
|
|
7404
|
|
|
7405 })();
|
|
|
7406 YAHOO.register("simpleeditor", YAHOO.widget.SimpleEditor, {version: "2.8.0r4", build: "2449"});
|
