esp-ckeditor 0.1.0

data/app/assets/javascripts/esp-ckeditor/_source/plugins/pastefromword/plugin.js

@@ -0,0 +1,141 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+(function()
+{
+  function forceHtmlMode( evt ) { evt.data.mode = 'html'; }
+
+  CKEDITOR.plugins.add( 'pastefromword',
+  {
+    init : function( editor )
+    {
+
+      // Flag indicate this command is actually been asked instead of a generic
+      // pasting.
+      var forceFromWord = 0;
+      var resetFromWord = function( evt )
+        {
+          evt && evt.removeListener();
+          editor.removeListener( 'beforePaste', forceHtmlMode );
+          forceFromWord && setTimeout( function() { forceFromWord = 0; }, 0 );
+        };
+
+      // Features bring by this command beside the normal process:
+      // 1. No more bothering of user about the clean-up.
+      // 2. Perform the clean-up even if content is not from MS-Word.
+      // (e.g. from a MS-Word similar application.)
+      editor.addCommand( 'pastefromword',
+      {
+        canUndo : false,
+        exec : function()
+        {
+          // Ensure the received data format is HTML and apply content filtering. (#6718)
+          forceFromWord = 1;
+          editor.on( 'beforePaste', forceHtmlMode );
+
+          if ( editor.execCommand( 'paste', 'html' ) === false )
+          {
+            editor.on( 'dialogShow', function ( evt )
+            {
+              evt.removeListener();
+              evt.data.on( 'cancel', resetFromWord );
+            });
+
+            editor.on( 'dialogHide', function( evt )
+            {
+              evt.data.removeListener( 'cancel', resetFromWord );
+            } );
+          }
+
+          editor.on( 'afterPaste', resetFromWord );
+        }
+      });
+
+      // Register the toolbar button.
+      editor.ui.addButton( 'PasteFromWord',
+        {
+          label : editor.lang.pastefromword.toolbar,
+          command : 'pastefromword'
+        });
+
+      editor.on( 'pasteState', function( evt )
+        {
+          editor.getCommand( 'pastefromword' ).setState( evt.data );
+        });
+
+      editor.on( 'paste', function( evt )
+      {
+        var data = evt.data,
+          mswordHtml;
+
+        // MS-WORD format sniffing.
+        if ( ( mswordHtml = data[ 'html' ] )
+           && ( forceFromWord || ( /(class=\"?Mso|style=\"[^\"]*\bmso\-|w:WordDocument)/ ).test( mswordHtml ) ) )
+        {
+          var isLazyLoad = this.loadFilterRules( function()
+            {
+              // Event continuation with the original data.
+              if ( isLazyLoad )
+                editor.fire( 'paste', data );
+              else if ( !editor.config.pasteFromWordPromptCleanup
+                || ( forceFromWord || confirm( editor.lang.pastefromword.confirmCleanup ) ) )
+               {
+                data[ 'html' ] = CKEDITOR.cleanWord( mswordHtml, editor );
+              }
+            });
+
+          // The cleanup rules are to be loaded, we should just cancel
+          // this event.
+          isLazyLoad && evt.cancel();
+        }
+      }, this );
+    },
+
+    loadFilterRules : function( callback )
+    {
+
+      var isLoaded = CKEDITOR.cleanWord;
+
+      if ( isLoaded )
+        callback();
+      else
+      {
+        var filterFilePath = CKEDITOR.getUrl(
+            CKEDITOR.config.pasteFromWordCleanupFile
+            || ( this.path + 'filter/default.js' ) );
+
+        // Load with busy indicator.
+        CKEDITOR.scriptLoader.load( filterFilePath, callback, null, true );
+      }
+
+      return !isLoaded;
+    },
+
+    requires : [ 'clipboard' ]
+  });
+})();
+
+/**
+ * Whether to prompt the user about the clean up of content being pasted from
+ * MS Word.
+ * @name CKEDITOR.config.pasteFromWordPromptCleanup
+ * @since 3.1
+ * @type Boolean
+ * @default undefined
+ * @example
+ * config.pasteFromWordPromptCleanup = true;
+ */
+
+/**
+ * The file that provides the MS Word cleanup function for pasting operations.
+ * Note: This is a global configuration shared by all editor instances present
+ * in the page.
+ * @name CKEDITOR.config.pasteFromWordCleanupFile
+ * @since 3.1
+ * @type String
+ * @default 'default'
+ * @example
+ * // Load from 'pastefromword' plugin 'filter' sub folder (custom.js file).
+ * CKEDITOR.config.pasteFromWordCleanupFile = 'custom';
+ */

data/app/assets/javascripts/esp-ckeditor/_source/plugins/pastetext/dialogs/pastetext.js

@@ -0,0 +1,67 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+(function()
+{
+  CKEDITOR.dialog.add( 'pastetext', function( editor )
+    {
+      return {
+        title : editor.lang.pasteText.title,
+
+        minWidth : CKEDITOR.env.ie && CKEDITOR.env.quirks ? 368 : 350,
+        minHeight : 240,
+
+        onShow : function(){ this.setupContent(); },
+        onOk : function(){ this.commitContent(); },
+
+        contents :
+        [
+          {
+            label : editor.lang.common.generalTab,
+            id : 'general',
+            elements :
+            [
+              {
+                type : 'html',
+                id : 'pasteMsg',
+                html : '<div style="white-space:normal;width:340px;">' + editor.lang.clipboard.pasteMsg + '</div>'
+              },
+              {
+                type : 'textarea',
+                id : 'content',
+                className : 'cke_pastetext',
+
+                onLoad : function()
+                {
+                  var label = this.getDialog().getContentElement( 'general', 'pasteMsg' ).getElement(),
+                    input = this.getElement().getElementsByTag( 'textarea' ).getItem( 0 );
+
+                  input.setAttribute( 'aria-labelledby', label.$.id );
+                  input.setStyle( 'direction', editor.config.contentsLangDirection );
+                },
+
+                focus : function()
+                {
+                  this.getElement().focus();
+                },
+                setup : function()
+                {
+                  this.setValue( '' );
+                },
+                commit : function()
+                {
+                  var value = this.getValue();
+                  setTimeout( function()
+                  {
+                    editor.fire( 'paste', { 'text' : value } );
+                  }, 0 );
+                }
+              }
+            ]
+          }
+        ]
+      };
+    });
+})();

data/app/assets/javascripts/esp-ckeditor/_source/plugins/pastetext/plugin.js

@@ -0,0 +1,98 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @file Paste as plain text plugin
+ */
+
+(function()
+{
+  // The pastetext command definition.
+  var pasteTextCmd =
+  {
+    exec : function( editor )
+    {
+      var clipboardText = CKEDITOR.tools.tryThese(
+        function()
+        {
+          var clipboardText = window.clipboardData.getData( 'Text' );
+          if ( !clipboardText )
+            throw 0;
+          return clipboardText;
+        }
+        // Any other approach that's working...
+        );
+
+      if ( !clipboardText )   // Clipboard access privilege is not granted.
+      {
+        editor.openDialog( 'pastetext' );
+        return false;
+      }
+      else
+        editor.fire( 'paste', { 'text' : clipboardText } );
+
+      return true;
+    }
+  };
+
+  // Register the plugin.
+  CKEDITOR.plugins.add( 'pastetext',
+  {
+    init : function( editor )
+    {
+      var commandName = 'pastetext',
+        command = editor.addCommand( commandName, pasteTextCmd );
+
+      editor.ui.addButton( 'PasteText',
+        {
+          label : editor.lang.pasteText.button,
+          command : commandName
+        });
+
+      CKEDITOR.dialog.add( commandName, CKEDITOR.getUrl( this.path + 'dialogs/pastetext.js' ) );
+
+      if ( editor.config.forcePasteAsPlainText )
+      {
+        // Intercept the default pasting process.
+        editor.on( 'beforeCommandExec', function ( evt )
+        {
+          var mode = evt.data.commandData;
+          // Do NOT overwrite if HTML format is explicitly requested.
+          if ( evt.data.name == 'paste' && mode != 'html' )
+          {
+            editor.execCommand( 'pastetext' );
+            evt.cancel();
+          }
+        }, null, null, 0 );
+
+        editor.on( 'beforePaste', function( evt )
+        {
+          evt.data.mode = 'text';
+        });
+      }
+
+      editor.on( 'pasteState', function( evt )
+        {
+          editor.getCommand( 'pastetext' ).setState( evt.data );
+        });
+    },
+
+    requires : [ 'clipboard' ]
+  });
+
+})();
+
+
+/**
+ * Whether to force all pasting operations to insert on plain text into the
+ * editor, loosing any formatting information possibly available in the source
+ * text.
+ * <strong>Note:</strong> paste from word is not affected by this configuration.
+ * @name CKEDITOR.config.forcePasteAsPlainText
+ * @type Boolean
+ * @default false
+ * @example
+ * config.forcePasteAsPlainText = true;
+ */

data/app/assets/javascripts/esp-ckeditor/_source/plugins/popup/plugin.js

@@ -0,0 +1,64 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+CKEDITOR.plugins.add( 'popup' );
+
+CKEDITOR.tools.extend( CKEDITOR.editor.prototype,
+{
+  /**
+   * Opens Browser in a popup. The "width" and "height" parameters accept
+   * numbers (pixels) or percent (of screen size) values.
+   * @param {String} url The url of the external file browser.
+   * @param {String} width Popup window width.
+   * @param {String} height Popup window height.
+   * @param {String} options Popup window features.
+   */
+  popup : function( url, width, height, options )
+  {
+    width = width || '80%';
+    height = height || '70%';
+
+    if ( typeof width == 'string' && width.length > 1 && width.substr( width.length - 1, 1 ) == '%' )
+      width = parseInt( window.screen.width * parseInt( width, 10 ) / 100, 10 );
+
+    if ( typeof height == 'string' && height.length > 1 && height.substr( height.length - 1, 1 ) == '%' )
+      height = parseInt( window.screen.height * parseInt( height, 10 ) / 100, 10 );
+
+    if ( width < 640 )
+      width = 640;
+
+    if ( height < 420 )
+      height = 420;
+
+    var top = parseInt( ( window.screen.height - height ) / 2, 10 ),
+      left = parseInt( ( window.screen.width  - width ) / 2, 10 );
+
+    options = ( options || 'location=no,menubar=no,toolbar=no,dependent=yes,minimizable=no,modal=yes,alwaysRaised=yes,resizable=yes,scrollbars=yes' ) +
+      ',width='  + width +
+      ',height=' + height +
+      ',top='  + top +
+      ',left=' + left;
+
+    var popupWindow = window.open( '', null, options, true );
+
+    // Blocked by a popup blocker.
+    if ( !popupWindow )
+      return false;
+
+    try
+    {
+      popupWindow.moveTo( left, top );
+      popupWindow.resizeTo( width, height );
+      popupWindow.focus();
+      popupWindow.location.href = url;
+    }
+    catch ( e )
+    {
+      popupWindow = window.open( url, null, options, true );
+    }
+
+    return true;
+  }
+});

data/app/assets/javascripts/esp-ckeditor/_source/plugins/removeformat/plugin.js

@@ -0,0 +1,185 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+CKEDITOR.plugins.add( 'removeformat',
+{
+  requires : [ 'selection' ],
+
+  init : function( editor )
+  {
+    editor.addCommand( 'removeFormat', CKEDITOR.plugins.removeformat.commands.removeformat );
+    editor.ui.addButton( 'RemoveFormat',
+      {
+        label : editor.lang.removeFormat,
+        command : 'removeFormat'
+      });
+
+    editor._.removeFormat = { filters: [] };
+  }
+});
+
+CKEDITOR.plugins.removeformat =
+{
+  commands :
+  {
+    removeformat :
+    {
+      exec : function( editor )
+      {
+        var tagsRegex = editor._.removeFormatRegex ||
+          ( editor._.removeFormatRegex = new RegExp( '^(?:' + editor.config.removeFormatTags.replace( /,/g,'|' ) + ')$', 'i' ) );
+
+        var removeAttributes = editor._.removeAttributes ||
+          ( editor._.removeAttributes = editor.config.removeFormatAttributes.split( ',' ) );
+
+        var filter = CKEDITOR.plugins.removeformat.filter;
+        var ranges = editor.getSelection().getRanges( 1 ),
+          iterator = ranges.createIterator(),
+          range;
+
+        while ( ( range = iterator.getNextRange() ) )
+        {
+          if ( ! range.collapsed )
+            range.enlarge( CKEDITOR.ENLARGE_ELEMENT );
+
+          // Bookmark the range so we can re-select it after processing.
+          var bookmark = range.createBookmark(),
+            // The style will be applied within the bookmark boundaries.
+            startNode  = bookmark.startNode,
+            endNode    = bookmark.endNode,
+            currentNode;
+
+          // We need to check the selection boundaries (bookmark spans) to break
+          // the code in a way that we can properly remove partially selected nodes.
+          // For example, removing a <b> style from
+          //    <b>This is [some text</b> to show <b>the] problem</b>
+          // ... where [ and ] represent the selection, must result:
+          //    <b>This is </b>[some text to show the]<b> problem</b>
+          // The strategy is simple, we just break the partial nodes before the
+          // removal logic, having something that could be represented this way:
+          //    <b>This is </b>[<b>some text</b> to show <b>the</b>]<b> problem</b>
+
+          var breakParent = function( node )
+          {
+            // Let's start checking the start boundary.
+            var path = new CKEDITOR.dom.elementPath( node ),
+              pathElements = path.elements;
+
+            for ( var i = 1, pathElement ; pathElement = pathElements[ i ] ; i++ )
+            {
+              if ( pathElement.equals( path.block ) || pathElement.equals( path.blockLimit ) )
+                break;
+
+              // If this element can be removed (even partially).
+              if ( tagsRegex.test( pathElement.getName() ) && filter( editor, pathElement ) )
+                node.breakParent( pathElement );
+            }
+          };
+
+          breakParent( startNode );
+          if ( endNode )
+          {
+            breakParent( endNode );
+
+            // Navigate through all nodes between the bookmarks.
+            currentNode = startNode.getNextSourceNode( true, CKEDITOR.NODE_ELEMENT );
+
+            while ( currentNode )
+            {
+              // If we have reached the end of the selection, stop looping.
+              if ( currentNode.equals( endNode ) )
+                break;
+
+              // Cache the next node to be processed. Do it now, because
+              // currentNode may be removed.
+              var nextNode = currentNode.getNextSourceNode( false, CKEDITOR.NODE_ELEMENT );
+
+              // This node must not be a fake element.
+              if ( !( currentNode.getName() == 'img'
+                && currentNode.data( 'cke-realelement' ) )
+                && filter( editor, currentNode ) )
+              {
+                // Remove elements nodes that match with this style rules.
+                if ( tagsRegex.test( currentNode.getName() ) )
+                  currentNode.remove( 1 );
+                else
+                {
+                  currentNode.removeAttributes( removeAttributes );
+                  editor.fire( 'removeFormatCleanup', currentNode );
+                }
+              }
+
+              currentNode = nextNode;
+            }
+          }
+
+          range.moveToBookmark( bookmark );
+        }
+
+        editor.getSelection().selectRanges( ranges );
+      }
+    }
+  },
+
+  /**
+   * Perform the remove format filters on the passed element.
+   * @param {CKEDITOR.editor} editor
+   * @param {CKEDITOR.dom.element} element
+   */
+  filter : function ( editor, element )
+  {
+    var filters = editor._.removeFormat.filters;
+    for ( var i = 0; i < filters.length; i++ )
+    {
+      if ( filters[ i ]( element ) === false )
+        return false;
+    }
+    return true;
+  }
+};
+
+/**
+ * Add to a collection of functions to decide whether a specific
+ * element should be considered as formatting element and thus
+ * could be removed during <b>removeFormat</b> command,
+ * Note: Only available with the existence of 'removeformat' plugin.
+ * @since 3.3
+ * @param {Function} func The function to be called, which will be passed a {CKEDITOR.dom.element} element to test.
+ * @example
+ *  // Don't remove empty span
+ *  editor.addRemoveFormatFilter.push( function( element )
+ *    {
+ *      return !( element.is( 'span' ) && CKEDITOR.tools.isEmpty( element.getAttributes() ) );
+ *    });
+ */
+CKEDITOR.editor.prototype.addRemoveFormatFilter = function( func )
+{
+  this._.removeFormat.filters.push( func );
+};
+
+/**
+ * A comma separated list of elements to be removed when executing the "remove
+ " format" command. Note that only inline elements are allowed.
+ * @type String
+ * @default 'b,big,code,del,dfn,em,font,i,ins,kbd,q,samp,small,span,strike,strong,sub,sup,tt,u,var'
+ * @example
+ */
+CKEDITOR.config.removeFormatTags = 'b,big,code,del,dfn,em,font,i,ins,kbd,q,samp,small,span,strike,strong,sub,sup,tt,u,var';
+
+/**
+ * A comma separated list of elements attributes to be removed when executing
+ * the "remove format" command.
+ * @type String
+ * @default 'class,style,lang,width,height,align,hspace,valign'
+ * @example
+ */
+CKEDITOR.config.removeFormatAttributes = 'class,style,lang,width,height,align,hspace,valign';
+
+/**
+ * Fired after an element was cleaned by the removeFormat plugin.
+ * @name CKEDITOR.editor#removeFormatCleanup
+ * @event
+ * @param {Object} data.element The element that was cleaned up.
+ */