source: trunk/admin/inc/ckeditor/_source/plugins/bbcode/plugin.js

Last change on this file was 239, checked in by luc, 9 years ago

Admin: correzione visulaizzazione immissione dati spoglio per Chrome e Safari - Aggiornamento dell'editor da FCKeditor a CKeditor , accessibili anche a Chrome e Safari.
  • Property svn:executable set to *
File size: 25.8 KB
Line 
1/*
2Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
3For licensing, see LICENSE.html or http://ckeditor.com/license
4*/
5
6(function()
7{
8 CKEDITOR.on( 'dialogDefinition', function( ev )
9 {
10 var tab, name = ev.data.name,
11 definition = ev.data.definition;
12
13 if ( name == 'link' )
14 {
15 definition.removeContents( 'target' );
16 definition.removeContents( 'upload' );
17 definition.removeContents( 'advanced' );
18 tab = definition.getContents( 'info' );
19 tab.remove( 'emailSubject' );
20 tab.remove( 'emailBody' );
21 }
22 else if ( name == 'image' )
23 {
24 definition.removeContents( 'advanced' );
25 tab = definition.getContents( 'Link' );
26 tab.remove( 'cmbTarget' );
27 tab = definition.getContents( 'info' );
28 tab.remove( 'txtAlt' );
29 tab.remove( 'basic' );
30 }
31 });
32
33 var bbcodeMap = { 'b' : 'strong', 'u': 'u', 'i' : 'em', 'color' : 'span', 'size' : 'span', 'quote' : 'blockquote', 'code' : 'code', 'url' : 'a', 'email' : 'span', 'img' : 'span', '*' : 'li', 'list' : 'ol' },
34 convertMap = { 'strong' : 'b' , 'b' : 'b', 'u': 'u', 'em' : 'i', 'i': 'i', 'code' : 'code', 'li' : '*' },
35 tagnameMap = { 'strong' : 'b', 'em' : 'i', 'u' : 'u', 'li' : '*', 'ul' : 'list', 'ol' : 'list', 'code' : 'code', 'a' : 'link', 'img' : 'img', 'blockquote' : 'quote' },
36 stylesMap = { 'color' : 'color', 'size' : 'font-size' },
37 attributesMap = { 'url' : 'href', 'email' : 'mailhref', 'quote': 'cite', 'list' : 'listType' };
38
39 // List of block-like tags.
40 var dtd = CKEDITOR.dtd,
41 blockLikeTags = CKEDITOR.tools.extend( { table:1 }, dtd.$block, dtd.$listItem, dtd.$tableContent, dtd.$list );
42
43 var semicolonFixRegex = /\s*(?:;\s*|$)/;
44 function serializeStyleText( stylesObject )
45 {
46 var styleText = '';
47 for ( var style in stylesObject )
48 {
49 var styleVal = stylesObject[ style ],
50 text = ( style + ':' + styleVal ).replace( semicolonFixRegex, ';' );
51
52 styleText += text;
53 }
54 return styleText;
55 }
56
57 function parseStyleText( styleText )
58 {
59 var retval = {};
60 ( styleText || '' )
61 .replace( /"/g, '"' )
62 .replace( /\s*([^ :;]+)\s*:\s*([^;]+)\s*(?=;|$)/g, function( match, name, value )
63 {
64 retval[ name.toLowerCase() ] = value;
65 } );
66 return retval;
67 }
68
69 function RGBToHex( cssStyle )
70 {
71 return cssStyle.replace( /(?:rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\))/gi, function( match, red, green, blue )
72 {
73 red = parseInt( red, 10 ).toString( 16 );
74 green = parseInt( green, 10 ).toString( 16 );
75 blue = parseInt( blue, 10 ).toString( 16 );
76 var color = [red, green, blue] ;
77
78 // Add padding zeros if the hex value is less than 0x10.
79 for ( var i = 0 ; i < color.length ; i++ )
80 color[i] = String( '0' + color[i] ).slice( -2 ) ;
81
82 return '#' + color.join( '' ) ;
83 });
84 }
85
86 // Maintain the map of smiley-to-description.
87 var smileyMap = {"smiley":":)","sad":":(","wink":";)","laugh":":D","cheeky":":P","blush":":*)","surprise":":-o","indecision":":|","angry":">:(","angel":"o:)","cool":"8-)","devil":">:-)","crying":";(","kiss":":-*" },
88 smileyReverseMap = {},
89 smileyRegExp = [];
90
91 // Build regexp for the list of smiley text.
92 for ( var i in smileyMap )
93 {
94 smileyReverseMap[ smileyMap[ i ] ] = i;
95 smileyRegExp.push( smileyMap[ i ].replace( /\(|\)|\:|\/|\*|\-|\|/g, function( match ) { return '\\' + match; } ) );
96 }
97
98 smileyRegExp = new RegExp( smileyRegExp.join( '|' ), 'g' );
99
100 var decodeHtml = ( function ()
101 {
102 var regex = [],
103 entities =
104 {
105 nbsp : '\u00A0', // IE | FF
106 shy : '\u00AD', // IE
107 gt : '\u003E', // IE | FF | -- | Opera
108 lt : '\u003C' // IE | FF | Safari | Opera
109 };
110
111 for ( var entity in entities )
112 regex.push( entity );
113
114 regex = new RegExp( '&(' + regex.join( '|' ) + ');', 'g' );
115
116 return function( html )
117 {
118 return html.replace( regex, function( match, entity )
119 {
120 return entities[ entity ];
121 });
122 };
123 })();
124
125 CKEDITOR.BBCodeParser = function()
126 {
127 this._ =
128 {
129 bbcPartsRegex : /(?:\[([^\/\]=]*?)(?:=([^\]]*?))?\])|(?:\[\/([a-z]{1,16})\])/ig
130 };
131 };
132
133 CKEDITOR.BBCodeParser.prototype =
134 {
135 parse : function( bbcode )
136 {
137 var parts,
138 part,
139 lastIndex = 0;
140
141 while ( ( parts = this._.bbcPartsRegex.exec( bbcode ) ) )
142 {
143 var tagIndex = parts.index;
144 if ( tagIndex > lastIndex )
145 {
146 var text = bbcode.substring( lastIndex, tagIndex );
147 this.onText( text, 1 );
148 }
149
150 lastIndex = this._.bbcPartsRegex.lastIndex;
151
152 /*
153 "parts" is an array with the following items:
154 0 : The entire match for opening/closing tags and line-break;
155 1 : line-break;
156 2 : open of tag excludes option;
157 3 : tag option;
158 4 : close of tag;
159 */
160
161 part = ( parts[ 1 ] || parts[ 3 ] || '' ).toLowerCase();
162 // Unrecognized tags should be delivered as a simple text (#7860).
163 if ( part && !bbcodeMap[ part ] )
164 {
165 this.onText( parts[ 0 ] );
166 continue;
167 }
168
169 // Opening tag
170 if ( parts[ 1 ] )
171 {
172 var tagName = bbcodeMap[ part ],
173 attribs = {},
174 styles = {},
175 optionPart = parts[ 2 ];
176
177 if ( optionPart )
178 {
179 if ( part == 'list' )
180 {
181 if ( !isNaN( optionPart ) )
182 optionPart = 'decimal';
183 else if ( /^[a-z]+$/.test( optionPart ) )
184 optionPart = 'lower-alpha';
185 else if ( /^[A-Z]+$/.test( optionPart ) )
186 optionPart = 'upper-alpha';
187 }
188
189 if ( stylesMap[ part ] )
190 {
191 // Font size represents percentage.
192 if ( part == 'size' )
193 optionPart += '%';
194
195 styles[ stylesMap[ part ] ] = optionPart;
196 attribs.style = serializeStyleText( styles );
197 }
198 else if ( attributesMap[ part ] )
199 attribs[ attributesMap[ part ] ] = optionPart;
200 }
201
202 // Two special handling - image and email, protect them
203 // as "span" with an attribute marker.
204 if ( part == 'email' || part == 'img' )
205 attribs[ 'bbcode' ] = part;
206
207 this.onTagOpen( tagName, attribs, CKEDITOR.dtd.$empty[ tagName ] );
208 }
209 // Closing tag
210 else if ( parts[ 3 ] )
211 this.onTagClose( bbcodeMap[ part ] );
212 }
213
214 if ( bbcode.length > lastIndex )
215 this.onText( bbcode.substring( lastIndex, bbcode.length ), 1 );
216 }
217 };
218
219 /**
220 * Creates a {@link CKEDITOR.htmlParser.fragment} from an HTML string.
221 * @param {String} source The HTML to be parsed, filling the fragment.
222 * @param {Number} [fixForBody=false] Wrap body with specified element if needed.
223 * @returns CKEDITOR.htmlParser.fragment The fragment created.
224 * @example
225 * var fragment = CKEDITOR.htmlParser.fragment.fromHtml( '<b>Sample</b> Text' );
226 * alert( fragment.children[0].name ); "b"
227 * alert( fragment.children[1].value ); " Text"
228 */
229 CKEDITOR.htmlParser.fragment.fromBBCode = function( source )
230 {
231 var parser = new CKEDITOR.BBCodeParser(),
232 fragment = new CKEDITOR.htmlParser.fragment(),
233 pendingInline = [],
234 pendingBrs = 0,
235 currentNode = fragment,
236 returnPoint;
237
238 function checkPending( newTagName )
239 {
240 if ( pendingInline.length > 0 )
241 {
242 for ( var i = 0 ; i < pendingInline.length ; i++ )
243 {
244 var pendingElement = pendingInline[ i ],
245 pendingName = pendingElement.name,
246 pendingDtd = CKEDITOR.dtd[ pendingName ],
247 currentDtd = currentNode.name && CKEDITOR.dtd[ currentNode.name ];
248
249 if ( ( !currentDtd || currentDtd[ pendingName ] ) && ( !newTagName || !pendingDtd || pendingDtd[ newTagName ] || !CKEDITOR.dtd[ newTagName ] ) )
250 {
251 // Get a clone for the pending element.
252 pendingElement = pendingElement.clone();
253
254 // Add it to the current node and make it the current,
255 // so the new element will be added inside of it.
256 pendingElement.parent = currentNode;
257 currentNode = pendingElement;
258
259 // Remove the pending element (back the index by one
260 // to properly process the next entry).
261 pendingInline.splice( i, 1 );
262 i--;
263 }
264 }
265 }
266 }
267
268 function checkPendingBrs( tagName, closing )
269 {
270 var len = currentNode.children.length,
271 previous = len > 0 && currentNode.children[ len - 1 ],
272 lineBreakParent = !previous && BBCodeWriter.getRule( tagnameMap[ currentNode.name ], 'breakAfterOpen' ),
273 lineBreakPrevious = previous && previous.type == CKEDITOR.NODE_ELEMENT && BBCodeWriter.getRule( tagnameMap[ previous.name ], 'breakAfterClose' ),
274 lineBreakCurrent = tagName && BBCodeWriter.getRule( tagnameMap[ tagName ], closing ? 'breakBeforeClose' : 'breakBeforeOpen' );
275
276 if ( pendingBrs && ( lineBreakParent || lineBreakPrevious || lineBreakCurrent ) )
277 pendingBrs--;
278
279 // 1. Either we're at the end of block, where it requires us to compensate the br filler
280 // removing logic (from htmldataprocessor).
281 // 2. Or we're at the end of pseudo block, where it requires us to compensate
282 // the bogus br effect.
283 if ( pendingBrs && tagName in blockLikeTags )
284 pendingBrs++;
285
286 while ( pendingBrs && pendingBrs-- )
287 currentNode.children.push( previous = new CKEDITOR.htmlParser.element( 'br' ) );
288 }
289
290 function addElement( node, target )
291 {
292 checkPendingBrs( node.name, 1 );
293
294 target = target || currentNode || fragment;
295
296 var len = target.children.length,
297 previous = len > 0 && target.children[ len - 1 ] || null;
298
299 node.previous = previous;
300 node.parent = target;
301
302 target.children.push( node );
303
304 if ( node.returnPoint )
305 {
306 currentNode = node.returnPoint;
307 delete node.returnPoint;
308 }
309 }
310
311 parser.onTagOpen = function( tagName, attributes, selfClosing )
312 {
313 var element = new CKEDITOR.htmlParser.element( tagName, attributes );
314
315 // This is a tag to be removed if empty, so do not add it immediately.
316 if ( CKEDITOR.dtd.$removeEmpty[ tagName ] )
317 {
318 pendingInline.push( element );
319 return;
320 }
321
322 var currentName = currentNode.name;
323
324 var currentDtd = currentName
325 && ( CKEDITOR.dtd[ currentName ]
326 || ( currentNode._.isBlockLike ? CKEDITOR.dtd.div : CKEDITOR.dtd.span ) );
327
328 // If the element cannot be child of the current element.
329 if ( currentDtd && !currentDtd[ tagName ] )
330 {
331 var reApply = false,
332 addPoint; // New position to start adding nodes.
333
334 // If the element name is the same as the current element name,
335 // then just close the current one and append the new one to the
336 // parent. This situation usually happens with <p>, <li>, <dt> and
337 // <dd>, specially in IE. Do not enter in this if block in this case.
338 if ( tagName == currentName )
339 addElement( currentNode, currentNode.parent );
340 else if ( tagName in CKEDITOR.dtd.$listItem )
341 {
342 parser.onTagOpen( 'ul', {} );
343 addPoint = currentNode;
344 reApply = true;
345 }
346 else
347 {
348 addElement( currentNode, currentNode.parent );
349
350 // The current element is an inline element, which
351 // cannot hold the new one. Put it in the pending list,
352 // and try adding the new one after it.
353 pendingInline.unshift( currentNode );
354 reApply = true;
355 }
356
357 if ( addPoint )
358 currentNode = addPoint;
359 // Try adding it to the return point, or the parent element.
360 else
361 currentNode = currentNode.returnPoint || currentNode.parent;
362
363 if ( reApply )
364 {
365 parser.onTagOpen.apply( this, arguments );
366 return;
367 }
368 }
369
370 checkPending( tagName );
371 checkPendingBrs( tagName );
372
373 element.parent = currentNode;
374 element.returnPoint = returnPoint;
375 returnPoint = 0;
376
377 if ( element.isEmpty )
378 addElement( element );
379 else
380 currentNode = element;
381 };
382
383 parser.onTagClose = function( tagName )
384 {
385 // Check if there is any pending tag to be closed.
386 for ( var i = pendingInline.length - 1 ; i >= 0 ; i-- )
387 {
388 // If found, just remove it from the list.
389 if ( tagName == pendingInline[ i ].name )
390 {
391 pendingInline.splice( i, 1 );
392 return;
393 }
394 }
395
396 var pendingAdd = [],
397 newPendingInline = [],
398 candidate = currentNode;
399
400 while ( candidate.type && candidate.name != tagName )
401 {
402 // If this is an inline element, add it to the pending list, if we're
403 // really closing one of the parents element later, they will continue
404 // after it.
405 if ( !candidate._.isBlockLike )
406 newPendingInline.unshift( candidate );
407
408 // This node should be added to it's parent at this point. But,
409 // it should happen only if the closing tag is really closing
410 // one of the nodes. So, for now, we just cache it.
411 pendingAdd.push( candidate );
412
413 candidate = candidate.parent;
414 }
415
416 if ( candidate.type )
417 {
418 // Add all elements that have been found in the above loop.
419 for ( i = 0 ; i < pendingAdd.length ; i++ )
420 {
421 var node = pendingAdd[ i ];
422 addElement( node, node.parent );
423 }
424
425 currentNode = candidate;
426
427
428 addElement( candidate, candidate.parent );
429
430 // The parent should start receiving new nodes now, except if
431 // addElement changed the currentNode.
432 if ( candidate == currentNode )
433 currentNode = currentNode.parent;
434
435 pendingInline = pendingInline.concat( newPendingInline );
436 }
437 };
438
439 parser.onText = function( text )
440 {
441 var currentDtd = CKEDITOR.dtd[ currentNode.name ];
442 if ( !currentDtd || currentDtd[ '#' ] )
443 {
444 checkPendingBrs();
445 checkPending();
446
447 text.replace(/([\r\n])|[^\r\n]*/g, function( piece, lineBreak )
448 {
449 if ( lineBreak !== undefined && lineBreak.length )
450 pendingBrs++;
451 else if ( piece.length )
452 {
453 var lastIndex = 0;
454
455 // Create smiley from text emotion.
456 piece.replace( smileyRegExp, function( match, index )
457 {
458 addElement( new CKEDITOR.htmlParser.text( piece.substring( lastIndex, index ) ), currentNode );
459 addElement( new CKEDITOR.htmlParser.element( 'smiley', { 'desc': smileyReverseMap[ match ] } ), currentNode );
460 lastIndex = index + match.length;
461 });
462
463 if ( lastIndex != piece.length )
464 addElement( new CKEDITOR.htmlParser.text( piece.substring( lastIndex, piece.length ) ), currentNode );
465 }
466 });
467 }
468 };
469
470 // Parse it.
471 parser.parse( CKEDITOR.tools.htmlEncode( source ) );
472
473 // Close all hanging nodes.
474 while ( currentNode.type )
475 {
476 var parent = currentNode.parent,
477 node = currentNode;
478
479 addElement( node, parent );
480 currentNode = parent;
481 }
482
483 return fragment;
484 };
485
486 CKEDITOR.htmlParser.BBCodeWriter = CKEDITOR.tools.createClass(
487 {
488 $ : function()
489 {
490 this._ =
491 {
492 output : [],
493 rules : []
494 };
495
496 // List and list item.
497 this.setRules( 'list',
498 {
499 breakBeforeOpen : 1,
500 breakAfterOpen : 1,
501 breakBeforeClose : 1,
502 breakAfterClose : 1
503 } );
504
505 this.setRules( '*',
506 {
507 breakBeforeOpen : 1,
508 breakAfterOpen : 0,
509 breakBeforeClose : 1,
510 breakAfterClose : 0
511 } );
512
513 this.setRules( 'quote',
514 {
515 breakBeforeOpen : 1,
516 breakAfterOpen : 0,
517 breakBeforeClose : 0,
518 breakAfterClose : 1
519 } );
520 },
521
522 proto :
523 {
524 /**
525 * Sets formatting rules for a given tag. The possible rules are:
526 * <ul>
527 * <li><b>breakBeforeOpen</b>: break line before the opener tag for this element.</li>
528 * <li><b>breakAfterOpen</b>: break line after the opener tag for this element.</li>
529 * <li><b>breakBeforeClose</b>: break line before the closer tag for this element.</li>
530 * <li><b>breakAfterClose</b>: break line after the closer tag for this element.</li>
531 * </ul>
532 *
533 * All rules default to "false". Each call to the function overrides
534 * already present rules, leaving the undefined untouched.
535 *
536 * @param {String} tagName The tag name to which set the rules.
537 * @param {Object} rules An object containing the element rules.
538 * @example
539 * // Break line before and after "img" tags.
540 * writer.setRules( 'list',
541 * {
542 * breakBeforeOpen : true
543 * breakAfterOpen : true
544 * });
545 */
546 setRules : function( tagName, rules )
547 {
548 var currentRules = this._.rules[ tagName ];
549
550 if ( currentRules )
551 CKEDITOR.tools.extend( currentRules, rules, true );
552 else
553 this._.rules[ tagName ] = rules;
554 },
555
556 getRule : function( tagName, ruleName )
557 {
558 return this._.rules[ tagName ] && this._.rules[ tagName ][ ruleName ];
559 },
560
561 openTag : function( tag, attributes )
562 {
563 if ( tag in bbcodeMap )
564 {
565 if ( this.getRule( tag, 'breakBeforeOpen' ) )
566 this.lineBreak( 1 );
567
568 this.write( '[', tag );
569 var option = attributes.option;
570 option && this.write( '=', option );
571 this.write( ']' );
572
573 if ( this.getRule( tag, 'breakAfterOpen' ) )
574 this.lineBreak( 1 );
575 }
576 else if ( tag == 'br' )
577 this._.output.push( '\n' );
578 },
579
580 openTagClose : function() { },
581 attribute : function() { },
582
583 closeTag : function( tag )
584 {
585 if ( tag in bbcodeMap )
586 {
587 if ( this.getRule( tag, 'breakBeforeClose' ) )
588 this.lineBreak( 1 );
589
590 tag != '*' && this.write( '[/', tag, ']' );
591
592 if ( this.getRule( tag, 'breakAfterClose' ) )
593 this.lineBreak( 1 );
594 }
595 },
596
597 text : function( text )
598 {
599 this.write( text );
600 },
601
602 /**
603 * Writes a comment.
604 * @param {String} comment The comment text.
605 * @example
606 * // Writes "&lt;!-- My comment --&gt;".
607 * writer.comment( ' My comment ' );
608 */
609 comment : function() {},
610
611 /*
612 * Output line-break for formatting.
613 */
614 lineBreak : function()
615 {
616 // Avoid line break when:
617 // 1) Previous tag already put one.
618 // 2) We're at output start.
619 if ( !this._.hasLineBreak && this._.output.length )
620 {
621 this.write( '\n' );
622 this._.hasLineBreak = 1;
623 }
624 },
625
626 write : function()
627 {
628 this._.hasLineBreak = 0;
629 var data = Array.prototype.join.call( arguments, '' );
630 this._.output.push( data );
631 },
632
633 reset : function()
634 {
635 this._.output = [];
636 this._.hasLineBreak = 0;
637 },
638
639 getHtml : function( reset )
640 {
641 var bbcode = this._.output.join( '' );
642
643 if ( reset )
644 this.reset();
645
646 return decodeHtml ( bbcode );
647 }
648 }
649 });
650
651 var BBCodeWriter = new CKEDITOR.htmlParser.BBCodeWriter();
652
653 CKEDITOR.plugins.add( 'bbcode',
654 {
655 requires : [ 'htmldataprocessor', 'entities' ],
656 beforeInit : function( editor )
657 {
658 // Adapt some critical editor configuration for better support
659 // of BBCode environment.
660 var config = editor.config;
661 CKEDITOR.tools.extend( config,
662 {
663 enterMode : CKEDITOR.ENTER_BR,
664 basicEntities: false,
665 entities : false,
666 fillEmptyBlocks : false
667 }, true );
668 },
669 init : function( editor )
670 {
671 var config = editor.config;
672
673 function BBCodeToHtml( code )
674 {
675 var fragment = CKEDITOR.htmlParser.fragment.fromBBCode( code ),
676 writer = new CKEDITOR.htmlParser.basicWriter();
677
678 fragment.writeHtml( writer, dataFilter );
679 return writer.getHtml( true );
680 }
681
682 var dataFilter = new CKEDITOR.htmlParser.filter();
683 dataFilter.addRules(
684 {
685 elements :
686 {
687 'blockquote' : function( element )
688 {
689 var quoted = new CKEDITOR.htmlParser.element( 'div' );
690 quoted.children = element.children;
691 element.children = [ quoted ];
692 var citeText = element.attributes.cite;
693 if ( citeText )
694 {
695 var cite = new CKEDITOR.htmlParser.element( 'cite' );
696 cite.add( new CKEDITOR.htmlParser.text( citeText.replace( /^"|"$/g, '' ) ) );
697 delete element.attributes.cite;
698 element.children.unshift( cite );
699 }
700 },
701 'span' : function( element )
702 {
703 var bbcode;
704 if ( ( bbcode = element.attributes.bbcode ) )
705 {
706 if ( bbcode == 'img' )
707 {
708 element.name = 'img';
709 element.attributes.src = element.children[ 0 ].value;
710 element.children = [];
711 }
712 else if ( bbcode == 'email' )
713 {
714 element.name = 'a';
715 element.attributes.href = 'mailto:' + element.children[ 0 ].value;
716 }
717
718 delete element.attributes.bbcode;
719 }
720 },
721 'ol' : function ( element )
722 {
723 if ( element.attributes.listType )
724 {
725 if ( element.attributes.listType != 'decimal' )
726 element.attributes.style = 'list-style-type:' + element.attributes.listType;
727 }
728 else
729 element.name = 'ul';
730
731 delete element.attributes.listType;
732 },
733 a : function( element )
734 {
735 if ( !element.attributes.href )
736 element.attributes.href = element.children[ 0 ].value;
737 },
738 'smiley' : function( element )
739 {
740 element.name = 'img';
741
742 var description = element.attributes.desc,
743 image = config.smiley_images[ CKEDITOR.tools.indexOf( config.smiley_descriptions, description ) ],
744 src = CKEDITOR.tools.htmlEncode( config.smiley_path + image );
745
746 element.attributes =
747 {
748 src : src,
749 'data-cke-saved-src' : src,
750 title : description,
751 alt : description
752 };
753 }
754 }
755 } );
756
757 editor.dataProcessor.htmlFilter.addRules(
758 {
759 elements :
760 {
761 $ : function( element )
762 {
763 var attributes = element.attributes,
764 style = parseStyleText( attributes.style ),
765 value;
766
767 var tagName = element.name;
768 if ( tagName in convertMap )
769 tagName = convertMap[ tagName ];
770 else if ( tagName == 'span' )
771 {
772 if ( ( value = style.color ) )
773 {
774 tagName = 'color';
775 value = RGBToHex( value );
776 }
777 else if ( ( value = style[ 'font-size' ] ) )
778 {
779 var percentValue = value.match( /(\d+)%$/ );
780 if ( percentValue )
781 {
782 value = percentValue[ 1 ];
783 tagName = 'size';
784 }
785 }
786 }
787 else if ( tagName == 'ol' || tagName == 'ul' )
788 {
789 if ( ( value = style[ 'list-style-type'] ) )
790 {
791 switch ( value )
792 {
793 case 'lower-alpha':
794 value = 'a';
795 break;
796 case 'upper-alpha':
797 value = 'A';
798 break;
799 }
800 }
801 else if ( tagName == 'ol' )
802 value = 1;
803
804 tagName = 'list';
805 }
806 else if ( tagName == 'blockquote' )
807 {
808 try
809 {
810 var cite = element.children[ 0 ],
811 quoted = element.children[ 1 ],
812 citeText = cite.name == 'cite' && cite.children[ 0 ].value;
813
814 if ( citeText )
815 {
816 value = '"' + citeText + '"';
817 element.children = quoted.children;
818 }
819
820 }
821 catch( er )
822 {
823 }
824
825 tagName = 'quote';
826 }
827 else if ( tagName == 'a' )
828 {
829 if ( ( value = attributes.href ) )
830 {
831 if ( value.indexOf( 'mailto:' ) !== -1 )
832 {
833 tagName = 'email';
834 // [email] should have a single text child with email address.
835 element.children = [ new CKEDITOR.htmlParser.text( value.replace( 'mailto:', '' ) ) ];
836 value = '';
837 }
838 else
839 {
840 var singleton = element.children.length == 1 && element.children[ 0 ];
841 if ( singleton
842 && singleton.type == CKEDITOR.NODE_TEXT
843 && singleton.value == value )
844 value = '';
845
846 tagName = 'url';
847 }
848 }
849 }
850 else if ( tagName == 'img' )
851 {
852 element.isEmpty = 0;
853
854 // Translate smiley (image) to text emotion.
855 var src = attributes[ 'data-cke-saved-src' ];
856 if ( src && src.indexOf( editor.config.smiley_path ) != -1 )
857 return new CKEDITOR.htmlParser.text( smileyMap[ attributes.alt ] );
858 else
859 element.children = [ new CKEDITOR.htmlParser.text( src ) ];
860 }
861
862 element.name = tagName;
863 value && ( element.attributes.option = value );
864
865 return null;
866 },
867
868 // Remove any bogus br from the end of a pseudo block,
869 // e.g. <div>some text<br /><p>paragraph</p></div>
870 br : function( element )
871 {
872 var next = element.next;
873 if ( next && next.name in blockLikeTags )
874 return false;
875 }
876 }
877 }, 1 );
878
879 editor.dataProcessor.writer = BBCodeWriter;
880
881 editor.on( 'beforeSetMode', function( evt )
882 {
883 evt.removeListener();
884 var wysiwyg = editor._.modes[ 'wysiwyg' ];
885 wysiwyg.loadData = CKEDITOR.tools.override( wysiwyg.loadData, function( org )
886 {
887 return function( data )
888 {
889 return ( org.call( this, BBCodeToHtml( data ) ) );
890 };
891 } );
892 } );
893 },
894
895 afterInit : function( editor )
896 {
897 var filters;
898 if ( editor._.elementsPath )
899 {
900 // Eliminate irrelevant elements from displaying, e.g body and p.
901 if ( ( filters = editor._.elementsPath.filters ) )
902 filters.push( function( element )
903 {
904 var htmlName = element.getName(),
905 name = tagnameMap[ htmlName ] || false;
906
907 // Specialized anchor presents as email.
908 if ( name == 'link' && element.getAttribute( 'href' ).indexOf( 'mailto:' ) === 0 )
909 name = 'email';
910 // Styled span could be either size or color.
911 else if ( htmlName == 'span' )
912 {
913 if ( element.getStyle( 'font-size' ) )
914 name = 'size';
915 else if ( element.getStyle( 'color' ) )
916 name = 'color';
917 }
918 else if ( name == 'img' )
919 {
920 var src = element.data( 'cke-saved-src' );
921 if ( src && src.indexOf( editor.config.smiley_path ) === 0 )
922 name = 'smiley';
923 }
924
925 return name;
926 });
927 }
928 }
929 } );
930
931})();
Note: See TracBrowser for help on using the repository browser.