esp-ckeditor 0.1.0

data/app/assets/javascripts/esp-ckeditor/_source/plugins/styles/styles/default.js

@@ -0,0 +1,88 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+CKEDITOR.stylesSet.add( 'default',
+[
+  /* Block Styles */
+
+  // These styles are already available in the "Format" combo, so they are
+  // not needed here by default. You may enable them to avoid placing the
+  // "Format" combo in the toolbar, maintaining the same features.
+  /*
+  { name : 'Paragraph'    , element : 'p' },
+  { name : 'Heading 1'    , element : 'h1' },
+  { name : 'Heading 2'    , element : 'h2' },
+  { name : 'Heading 3'    , element : 'h3' },
+  { name : 'Heading 4'    , element : 'h4' },
+  { name : 'Heading 5'    , element : 'h5' },
+  { name : 'Heading 6'    , element : 'h6' },
+  { name : 'Preformatted Text', element : 'pre' },
+  { name : 'Address'      , element : 'address' },
+  */
+
+  { name : 'Blue Title'    , element : 'h3', styles : { 'color' : 'Blue' } },
+  { name : 'Red Title'    , element : 'h3', styles : { 'color' : 'Red' } },
+
+  /* Inline Styles */
+
+  // These are core styles available as toolbar buttons. You may opt enabling
+  // some of them in the Styles combo, removing them from the toolbar.
+  /*
+  { name : 'Strong'      , element : 'strong', overrides : 'b' },
+  { name : 'Emphasis'      , element : 'em'  , overrides : 'i' },
+  { name : 'Underline'    , element : 'u' },
+  { name : 'Strikethrough'  , element : 'strike' },
+  { name : 'Subscript'    , element : 'sub' },
+  { name : 'Superscript'    , element : 'sup' },
+  */
+
+  { name : 'Marker: Yellow'  , element : 'span', styles : { 'background-color' : 'Yellow' } },
+  { name : 'Marker: Green'  , element : 'span', styles : { 'background-color' : 'Lime' } },
+
+  { name : 'Big'        , element : 'big' },
+  { name : 'Small'      , element : 'small' },
+  { name : 'Typewriter'    , element : 'tt' },
+
+  { name : 'Computer Code'  , element : 'code' },
+  { name : 'Keyboard Phrase'  , element : 'kbd' },
+  { name : 'Sample Text'    , element : 'samp' },
+  { name : 'Variable'      , element : 'var' },
+
+  { name : 'Deleted Text'    , element : 'del' },
+  { name : 'Inserted Text'  , element : 'ins' },
+
+  { name : 'Cited Work'    , element : 'cite' },
+  { name : 'Inline Quotation'  , element : 'q' },
+
+  { name : 'Language: RTL'  , element : 'span', attributes : { 'dir' : 'rtl' } },
+  { name : 'Language: LTR'  , element : 'span', attributes : { 'dir' : 'ltr' } },
+
+  /* Object Styles */
+
+  {
+    name : 'Image on Left',
+    element : 'img',
+    attributes :
+    {
+      'style' : 'padding: 5px; margin-right: 5px',
+      'border' : '2',
+      'align' : 'left'
+    }
+  },
+
+  {
+    name : 'Image on Right',
+    element : 'img',
+    attributes :
+    {
+      'style' : 'padding: 5px; margin-left: 5px',
+      'border' : '2',
+      'align' : 'right'
+    }
+  },
+
+  { name : 'Borderless Table', element : 'table', styles: { 'border-style': 'hidden', 'background-color' : '#E6E6FA' } },
+  { name : 'Square Bulleted List', element : 'ul', styles : { 'list-style-type' : 'square' } }
+]);

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

@@ -0,0 +1,218 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+(function()
+{
+  CKEDITOR.plugins.add( 'stylescombo',
+  {
+    requires : [ 'richcombo', 'styles' ],
+
+    init : function( editor )
+    {
+      var config = editor.config,
+        lang = editor.lang.stylesCombo,
+        styles = {},
+        stylesList = [],
+        combo;
+
+      function loadStylesSet( callback )
+      {
+        editor.getStylesSet( function( stylesDefinitions )
+        {
+          if ( !stylesList.length )
+          {
+            var style,
+              styleName;
+
+            // Put all styles into an Array.
+            for ( var i = 0, count = stylesDefinitions.length ; i < count ; i++ )
+            {
+              var styleDefinition = stylesDefinitions[ i ];
+
+              styleName = styleDefinition.name;
+
+              style = styles[ styleName ] = new CKEDITOR.style( styleDefinition );
+              style._name = styleName;
+              style._.enterMode = config.enterMode;
+
+              stylesList.push( style );
+            }
+
+            // Sorts the Array, so the styles get grouped by type.
+            stylesList.sort( sortStyles );
+          }
+
+          callback && callback();
+        });
+      }
+
+      editor.ui.addRichCombo( 'Styles',
+        {
+          label : lang.label,
+          title : lang.panelTitle,
+          className : 'cke_styles',
+
+          panel :
+          {
+            css : editor.skin.editor.css.concat( config.contentsCss ),
+            multiSelect : true,
+            attributes : { 'aria-label' : lang.panelTitle }
+          },
+
+          init : function()
+          {
+            combo = this;
+
+            loadStylesSet( function()
+              {
+                var style,
+                  styleName,
+                  lastType,
+                  type,
+                  i,
+                  count;
+
+                // Loop over the Array, adding all items to the
+                // combo.
+                for ( i = 0, count = stylesList.length ; i < count ; i++ )
+                {
+                  style = stylesList[ i ];
+                  styleName = style._name;
+                  type = style.type;
+
+                  if ( type != lastType )
+                  {
+                    combo.startGroup( lang[ 'panelTitle' + String( type ) ] );
+                    lastType = type;
+                  }
+
+                  combo.add(
+                    styleName,
+                    style.type == CKEDITOR.STYLE_OBJECT ? styleName : style.buildPreview(),
+                    styleName );
+                }
+
+                combo.commit();
+
+              });
+          },
+
+          onClick : function( value )
+          {
+            editor.focus();
+            editor.fire( 'saveSnapshot' );
+
+            var style = styles[ value ],
+              selection = editor.getSelection(),
+              elementPath = new CKEDITOR.dom.elementPath( selection.getStartElement() );
+
+            style[ style.checkActive( elementPath ) ? 'remove' : 'apply' ]( editor.document );
+
+            editor.fire( 'saveSnapshot' );
+          },
+
+          onRender : function()
+          {
+            editor.on( 'selectionChange', function( ev )
+              {
+                var currentValue = this.getValue(),
+                  elementPath = ev.data.path,
+                  elements = elementPath.elements;
+
+                // For each element into the elements path.
+                for ( var i = 0, count = elements.length, element ; i < count ; i++ )
+                {
+                  element = elements[i];
+
+                  // Check if the element is removable by any of
+                  // the styles.
+                  for ( var value in styles )
+                  {
+                    if ( styles[ value ].checkElementRemovable( element, true ) )
+                    {
+                      if ( value != currentValue )
+                        this.setValue( value );
+                      return;
+                    }
+                  }
+                }
+
+                // If no styles match, just empty it.
+                this.setValue( '' );
+              },
+              this);
+          },
+
+          onOpen : function()
+          {
+            if ( CKEDITOR.env.ie || CKEDITOR.env.webkit )
+              editor.focus();
+
+            var selection = editor.getSelection(),
+              element = selection.getSelectedElement(),
+              elementPath = new CKEDITOR.dom.elementPath( element || selection.getStartElement() ),
+              counter = [ 0, 0, 0, 0 ];
+
+            this.showAll();
+            this.unmarkAll();
+            for ( var name in styles )
+            {
+              var style = styles[ name ],
+                type = style.type;
+
+              if ( style.checkActive( elementPath ) )
+                this.mark( name );
+              else if ( type == CKEDITOR.STYLE_OBJECT && !style.checkApplicable( elementPath ) )
+              {
+                this.hideItem( name );
+                counter[ type ]--;
+              }
+
+              counter[ type ]++;
+            }
+
+            if ( !counter[ CKEDITOR.STYLE_BLOCK ] )
+              this.hideGroup( lang[ 'panelTitle' + String( CKEDITOR.STYLE_BLOCK ) ] );
+
+            if ( !counter[ CKEDITOR.STYLE_INLINE ] )
+              this.hideGroup( lang[ 'panelTitle' + String( CKEDITOR.STYLE_INLINE ) ] );
+
+            if ( !counter[ CKEDITOR.STYLE_OBJECT ] )
+              this.hideGroup( lang[ 'panelTitle' + String( CKEDITOR.STYLE_OBJECT ) ] );
+          },
+
+          // Force a reload of the data
+          reset: function()
+          {
+            if ( combo )
+            {
+              delete combo._.panel;
+              delete combo._.list;
+              combo._.committed = 0;
+              combo._.items = {};
+              combo._.state = CKEDITOR.TRISTATE_OFF;
+            }
+            styles = {};
+            stylesList = [];
+            loadStylesSet();
+          }
+        });
+
+      editor.on( 'instanceReady', function() { loadStylesSet(); } );
+    }
+  });
+
+  function sortStyles( styleA, styleB )
+  {
+    var typeA = styleA.type,
+      typeB = styleB.type;
+
+    return typeA == typeB ? 0 :
+      typeA == CKEDITOR.STYLE_OBJECT ? -1 :
+      typeB == CKEDITOR.STYLE_OBJECT ? 1 :
+      typeB == CKEDITOR.STYLE_BLOCK ? 1 :
+      -1;
+  }
+})();

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

@@ -0,0 +1,367 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+(function()
+{
+  var meta =
+  {
+    editorFocus : false,
+    modes : { wysiwyg:1, source:1 }
+  };
+
+  var blurCommand =
+    {
+      exec : function( editor )
+      {
+        editor.container.focusNext( true, editor.tabIndex );
+      }
+    };
+
+  var blurBackCommand =
+    {
+      exec : function( editor )
+      {
+        editor.container.focusPrevious( true, editor.tabIndex );
+      }
+    };
+
+  function selectNextCellCommand( backward )
+  {
+    return {
+      editorFocus : false,
+      canUndo : false,
+      modes : { wysiwyg : 1 },
+      exec : function( editor )
+      {
+        if ( editor.focusManager.hasFocus )
+        {
+          var sel = editor.getSelection(),
+            ancestor = sel.getCommonAncestor(),
+            cell;
+
+          if ( ( cell = ( ancestor.getAscendant( 'td', true ) || ancestor.getAscendant( 'th', true ) ) ) )
+          {
+            var resultRange = new CKEDITOR.dom.range( editor.document ),
+                next = CKEDITOR.tools.tryThese( function()
+                {
+                  var row = cell.getParent(),
+                      next = row.$.cells[ cell.$.cellIndex + ( backward ? - 1 : 1 ) ];
+
+                  // Invalid any empty value.
+                  next.parentNode.parentNode;
+                  return next;
+                },
+                function()
+                {
+                  var row = cell.getParent(),
+                      table = row.getAscendant( 'table' ),
+                      nextRow = table.$.rows[ row.$.rowIndex + ( backward ? - 1 : 1 ) ];
+
+                  return nextRow.cells[ backward? nextRow.cells.length -1 : 0 ];
+                });
+
+            // Clone one more row at the end of table and select the first newly established cell.
+            if ( ! ( next || backward ) )
+            {
+              var table = cell.getAscendant( 'table' ).$,
+                  cells = cell.getParent().$.cells;
+
+              var newRow = new CKEDITOR.dom.element( table.insertRow( -1 ), editor.document );
+
+              for ( var i = 0, count = cells.length ; i < count; i++ )
+              {
+                var newCell = newRow.append( new CKEDITOR.dom.element(
+                    cells[ i ], editor.document ).clone( false, false ) );
+                !CKEDITOR.env.ie && newCell.appendBogus();
+              }
+
+              resultRange.moveToElementEditStart( newRow );
+            }
+            else if ( next )
+            {
+              next = new CKEDITOR.dom.element( next );
+              resultRange.moveToElementEditStart( next );
+              // Avoid selecting empty block makes the cursor blind.
+              if ( !( resultRange.checkStartOfBlock() && resultRange.checkEndOfBlock() ) )
+                resultRange.selectNodeContents( next );
+            }
+            else
+              return true;
+
+            resultRange.select( true );
+            return true;
+          }
+        }
+        return false;
+      }
+    };
+  }
+
+  CKEDITOR.plugins.add( 'tab',
+  {
+    requires : [ 'keystrokes' ],
+
+    init : function( editor )
+    {
+      var tabTools = editor.config.enableTabKeyTools !== false,
+        tabSpaces = editor.config.tabSpaces || 0,
+        tabText = '';
+
+      while ( tabSpaces-- )
+        tabText += '\xa0';
+
+      if ( tabText )
+      {
+        editor.on( 'key', function( ev )
+          {
+            if ( ev.data.keyCode == 9 )  // TAB
+            {
+              editor.insertHtml( tabText );
+              ev.cancel();
+            }
+          });
+      }
+
+      if ( tabTools )
+      {
+        editor.on( 'key', function( ev )
+        {
+          if ( ev.data.keyCode == 9 && editor.execCommand( 'selectNextCell' ) ||  // TAB
+              ev.data.keyCode == ( CKEDITOR.SHIFT + 9 ) && editor.execCommand( 'selectPreviousCell' ) )  // SHIFT+TAB
+            ev.cancel();
+        });
+      }
+
+      if ( CKEDITOR.env.webkit || CKEDITOR.env.gecko )
+      {
+        editor.on( 'key', function( ev )
+          {
+            var keyCode = ev.data.keyCode;
+
+            if ( keyCode == 9 && !tabText )        // TAB
+            {
+              ev.cancel();
+              editor.execCommand( 'blur' );
+            }
+
+            if ( keyCode == ( CKEDITOR.SHIFT + 9 ) )  // SHIFT+TAB
+            {
+              editor.execCommand( 'blurBack' );
+              ev.cancel();
+            }
+          });
+      }
+
+      editor.addCommand( 'blur', CKEDITOR.tools.extend( blurCommand, meta ) );
+      editor.addCommand( 'blurBack', CKEDITOR.tools.extend( blurBackCommand, meta ) );
+      editor.addCommand( 'selectNextCell', selectNextCellCommand() );
+      editor.addCommand( 'selectPreviousCell', selectNextCellCommand( true ) );
+    }
+  });
+})();
+
+/**
+ * Moves the UI focus to the element following this element in the tabindex
+ * order.
+ * @example
+ * var element = CKEDITOR.document.getById( 'example' );
+ * element.focusNext();
+ */
+CKEDITOR.dom.element.prototype.focusNext = function( ignoreChildren, indexToUse )
+{
+  var $ = this.$,
+    curTabIndex = ( indexToUse === undefined ? this.getTabIndex() : indexToUse ),
+    passedCurrent, enteredCurrent,
+    elected, electedTabIndex,
+    element, elementTabIndex;
+
+  if ( curTabIndex <= 0 )
+  {
+    // If this element has tabindex <= 0 then we must simply look for any
+    // element following it containing tabindex=0.
+
+    element = this.getNextSourceNode( ignoreChildren, CKEDITOR.NODE_ELEMENT );
+
+    while ( element )
+    {
+      if ( element.isVisible() && element.getTabIndex() === 0 )
+      {
+        elected = element;
+        break;
+      }
+
+      element = element.getNextSourceNode( false, CKEDITOR.NODE_ELEMENT );
+    }
+  }
+  else
+  {
+    // If this element has tabindex > 0 then we must look for:
+    //    1. An element following this element with the same tabindex.
+    //    2. The first element in source other with the lowest tabindex
+    //       that is higher than this element tabindex.
+    //    3. The first element with tabindex=0.
+
+    element = this.getDocument().getBody().getFirst();
+
+    while ( ( element = element.getNextSourceNode( false, CKEDITOR.NODE_ELEMENT ) ) )
+    {
+      if ( !passedCurrent )
+      {
+        if ( !enteredCurrent && element.equals( this ) )
+        {
+          enteredCurrent = true;
+
+          // Ignore this element, if required.
+          if ( ignoreChildren )
+          {
+            if ( !( element = element.getNextSourceNode( true, CKEDITOR.NODE_ELEMENT ) ) )
+              break;
+            passedCurrent = 1;
+          }
+        }
+        else if ( enteredCurrent && !this.contains( element ) )
+          passedCurrent = 1;
+      }
+
+      if ( !element.isVisible() || ( elementTabIndex = element.getTabIndex() ) < 0 )
+        continue;
+
+      if ( passedCurrent && elementTabIndex == curTabIndex )
+      {
+        elected = element;
+        break;
+      }
+
+      if ( elementTabIndex > curTabIndex && ( !elected || !electedTabIndex || elementTabIndex < electedTabIndex ) )
+      {
+        elected = element;
+        electedTabIndex = elementTabIndex;
+      }
+      else if ( !elected && elementTabIndex === 0 )
+      {
+        elected = element;
+        electedTabIndex = elementTabIndex;
+      }
+    }
+  }
+
+  if ( elected )
+    elected.focus();
+};
+
+/**
+ * Moves the UI focus to the element before this element in the tabindex order.
+ * @example
+ * var element = CKEDITOR.document.getById( 'example' );
+ * element.focusPrevious();
+ */
+CKEDITOR.dom.element.prototype.focusPrevious = function( ignoreChildren, indexToUse )
+{
+  var $ = this.$,
+    curTabIndex = ( indexToUse === undefined ? this.getTabIndex() : indexToUse ),
+    passedCurrent, enteredCurrent,
+    elected,
+    electedTabIndex = 0,
+    elementTabIndex;
+
+  var element = this.getDocument().getBody().getLast();
+
+  while ( ( element = element.getPreviousSourceNode( false, CKEDITOR.NODE_ELEMENT ) ) )
+  {
+    if ( !passedCurrent )
+    {
+      if ( !enteredCurrent && element.equals( this ) )
+      {
+        enteredCurrent = true;
+
+        // Ignore this element, if required.
+        if ( ignoreChildren )
+        {
+          if ( !( element = element.getPreviousSourceNode( true, CKEDITOR.NODE_ELEMENT ) ) )
+            break;
+          passedCurrent = 1;
+        }
+      }
+      else if ( enteredCurrent && !this.contains( element ) )
+        passedCurrent = 1;
+    }
+
+    if ( !element.isVisible() || ( elementTabIndex = element.getTabIndex() ) < 0 )
+      continue;
+
+    if ( curTabIndex <= 0 )
+    {
+      // If this element has tabindex <= 0 then we must look for:
+      //    1. An element before this one containing tabindex=0.
+      //    2. The last element with the highest tabindex.
+
+      if ( passedCurrent && elementTabIndex === 0 )
+      {
+        elected = element;
+        break;
+      }
+
+      if ( elementTabIndex > electedTabIndex )
+      {
+        elected = element;
+        electedTabIndex = elementTabIndex;
+      }
+    }
+    else
+    {
+      // If this element has tabindex > 0 we must look for:
+      //    1. An element preceeding this one, with the same tabindex.
+      //    2. The last element in source other with the highest tabindex
+      //       that is lower than this element tabindex.
+
+      if ( passedCurrent && elementTabIndex == curTabIndex )
+      {
+        elected = element;
+        break;
+      }
+
+      if ( elementTabIndex < curTabIndex && ( !elected || elementTabIndex > electedTabIndex ) )
+      {
+        elected = element;
+        electedTabIndex = elementTabIndex;
+      }
+    }
+  }
+
+  if ( elected )
+    elected.focus();
+};
+
+/**
+ * Intructs the editor to add a number of spaces (&amp;nbsp;) to the text when
+ * hitting the TAB key. If set to zero, the TAB key will be used to move the
+ * cursor focus to the next element in the page, out of the editor focus.
+ * @name CKEDITOR.config.tabSpaces
+ * @type Number
+ * @default 0
+ * @example
+ * config.tabSpaces = 4;
+ */
+
+/**
+ * Allow context-sensitive tab key behaviors, including the following scenarios:
+ * <h5>When selection is anchored inside <b>table cells</b>:</h5>
+ * <ul>
+ *     <li>If TAB is pressed, select the contents of the "next" cell. If in the last cell in the table, add a new row to it and focus its first cell.</li>
+ *     <li>If SHIFT+TAB is pressed, select the contents of the "previous" cell. Do nothing when it's in the first cell.</li>
+ * </ul>
+ * @name CKEDITOR.config.enableTabKeyTools
+ * @type Boolean
+ * @default true
+ * @example
+ * config.enableTabKeyTools = false;
+ */
+
+// If the TAB key is not supposed to be enabled for navigation, the following
+// settings could be used alternatively:
+// config.keystrokes.push(
+//  [ CKEDITOR.ALT + 38 /*Arrow Up*/, 'selectPreviousCell' ],
+//  [ CKEDITOR.ALT + 40 /*Arrow Down*/, 'selectNextCell' ]
+// );