esp-ckeditor 0.1.0

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

@@ -0,0 +1,253 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @file Justify commands.
+ */
+
+(function()
+{
+  function getState( editor, path )
+  {
+    var firstBlock = path.block || path.blockLimit;
+
+    if ( !firstBlock || firstBlock.getName() == 'body' )
+      return CKEDITOR.TRISTATE_OFF;
+
+    return ( getAlignment( firstBlock, editor.config.useComputedState ) == this.value ) ?
+      CKEDITOR.TRISTATE_ON :
+      CKEDITOR.TRISTATE_OFF;
+  }
+
+  function getAlignment( element, useComputedState )
+  {
+    useComputedState = useComputedState === undefined || useComputedState;
+
+    var align;
+    if ( useComputedState )
+      align = element.getComputedStyle( 'text-align' );
+    else
+    {
+      while ( !element.hasAttribute || !( element.hasAttribute( 'align' ) || element.getStyle( 'text-align' ) ) )
+      {
+        var parent = element.getParent();
+        if ( !parent )
+          break;
+        element = parent;
+      }
+      align = element.getStyle( 'text-align' ) || element.getAttribute( 'align' ) || '';
+    }
+
+    align && ( align = align.replace( /-moz-|-webkit-|start|auto/i, '' ) );
+
+    !align && useComputedState && ( align = element.getComputedStyle( 'direction' ) == 'rtl' ? 'right' : 'left' );
+
+    return align;
+  }
+
+  function onSelectionChange( evt )
+  {
+    if ( evt.editor.readOnly )
+      return;
+
+    var command = evt.editor.getCommand( this.name );
+    command.state = getState.call( this, evt.editor, evt.data.path );
+    command.fire( 'state' );
+  }
+
+  function justifyCommand( editor, name, value )
+  {
+    this.name = name;
+    this.value = value;
+
+    var classes = editor.config.justifyClasses;
+    if ( classes )
+    {
+      switch ( value )
+      {
+        case 'left' :
+          this.cssClassName = classes[0];
+          break;
+        case 'center' :
+          this.cssClassName = classes[1];
+          break;
+        case 'right' :
+          this.cssClassName = classes[2];
+          break;
+        case 'justify' :
+          this.cssClassName = classes[3];
+          break;
+      }
+
+      this.cssClassRegex = new RegExp( '(?:^|\\s+)(?:' + classes.join( '|' ) + ')(?=$|\\s)' );
+    }
+  }
+
+  function onDirChanged( e )
+  {
+    var editor = e.editor;
+
+    var range = new CKEDITOR.dom.range( editor.document );
+    range.setStartBefore( e.data.node );
+    range.setEndAfter( e.data.node );
+
+    var walker = new CKEDITOR.dom.walker( range ),
+      node;
+
+    while ( ( node = walker.next() ) )
+    {
+      if ( node.type == CKEDITOR.NODE_ELEMENT )
+      {
+        // A child with the defined dir is to be ignored.
+        if ( !node.equals( e.data.node ) && node.getDirection() )
+        {
+          range.setStartAfter( node );
+          walker = new CKEDITOR.dom.walker( range );
+          continue;
+        }
+
+        // Switch the alignment.
+        var classes = editor.config.justifyClasses;
+        if ( classes )
+        {
+          // The left align class.
+          if ( node.hasClass( classes[ 0 ] ) )
+          {
+            node.removeClass( classes[ 0 ] );
+            node.addClass( classes[ 2 ] );
+          }
+          // The right align class.
+          else if ( node.hasClass( classes[ 2 ] ) )
+          {
+            node.removeClass( classes[ 2 ] );
+            node.addClass( classes[ 0 ] );
+          }
+        }
+
+        // Always switch CSS margins.
+        var style = 'text-align';
+        var align = node.getStyle( style );
+
+        if ( align == 'left' )
+          node.setStyle( style, 'right' );
+        else if ( align == 'right' )
+          node.setStyle( style, 'left' );
+      }
+    }
+  }
+
+  justifyCommand.prototype = {
+    exec : function( editor )
+    {
+      var selection = editor.getSelection(),
+        enterMode = editor.config.enterMode;
+
+      if ( !selection )
+        return;
+
+      var bookmarks = selection.createBookmarks(),
+        ranges = selection.getRanges( true );
+
+      var cssClassName = this.cssClassName,
+        iterator,
+        block;
+
+      var useComputedState = editor.config.useComputedState;
+      useComputedState = useComputedState === undefined || useComputedState;
+
+      for ( var i = ranges.length - 1 ; i >= 0 ; i-- )
+      {
+        iterator = ranges[ i ].createIterator();
+        iterator.enlargeBr = enterMode != CKEDITOR.ENTER_BR;
+
+        while ( ( block = iterator.getNextParagraph( enterMode == CKEDITOR.ENTER_P ? 'p' : 'div' ) ) )
+        {
+          block.removeAttribute( 'align' );
+          block.removeStyle( 'text-align' );
+
+          // Remove any of the alignment classes from the className.
+          var className = cssClassName && ( block.$.className =
+            CKEDITOR.tools.ltrim( block.$.className.replace( this.cssClassRegex, '' ) ) );
+
+          var apply =
+            ( this.state == CKEDITOR.TRISTATE_OFF ) &&
+            ( !useComputedState || ( getAlignment( block, true ) != this.value ) );
+
+          if ( cssClassName )
+          {
+            // Append the desired class name.
+            if ( apply )
+              block.addClass( cssClassName );
+            else if ( !className )
+              block.removeAttribute( 'class' );
+          }
+          else if ( apply )
+            block.setStyle( 'text-align', this.value );
+        }
+
+      }
+
+      editor.focus();
+      editor.forceNextSelectionCheck();
+      selection.selectBookmarks( bookmarks );
+    }
+  };
+
+  CKEDITOR.plugins.add( 'justify',
+  {
+    init : function( editor )
+    {
+      var left = new justifyCommand( editor, 'justifyleft', 'left' ),
+        center = new justifyCommand( editor, 'justifycenter', 'center' ),
+        right = new justifyCommand( editor, 'justifyright', 'right' ),
+        justify = new justifyCommand( editor, 'justifyblock', 'justify' );
+
+      editor.addCommand( 'justifyleft', left );
+      editor.addCommand( 'justifycenter', center );
+      editor.addCommand( 'justifyright', right );
+      editor.addCommand( 'justifyblock', justify );
+
+      editor.ui.addButton( 'JustifyLeft',
+        {
+          label : editor.lang.justify.left,
+          command : 'justifyleft'
+        } );
+      editor.ui.addButton( 'JustifyCenter',
+        {
+          label : editor.lang.justify.center,
+          command : 'justifycenter'
+        } );
+      editor.ui.addButton( 'JustifyRight',
+        {
+          label : editor.lang.justify.right,
+          command : 'justifyright'
+        } );
+      editor.ui.addButton( 'JustifyBlock',
+        {
+          label : editor.lang.justify.block,
+          command : 'justifyblock'
+        } );
+
+      editor.on( 'selectionChange', CKEDITOR.tools.bind( onSelectionChange, left ) );
+      editor.on( 'selectionChange', CKEDITOR.tools.bind( onSelectionChange, right ) );
+      editor.on( 'selectionChange', CKEDITOR.tools.bind( onSelectionChange, center ) );
+      editor.on( 'selectionChange', CKEDITOR.tools.bind( onSelectionChange, justify ) );
+      editor.on( 'dirChanged', onDirChanged );
+    },
+
+    requires : [ 'domiterator' ]
+  });
+})();
+
+ /**
+ * List of classes to use for aligning the contents. If it's null, no classes will be used
+ * and instead the corresponding CSS values will be used. The array should contain 4 members, in the following order: left, center, right, justify.
+ * @name CKEDITOR.config.justifyClasses
+ * @type Array
+ * @default null
+ * @example
+ * // Use the classes 'AlignLeft', 'AlignCenter', 'AlignRight', 'AlignJustify'
+ * config.justifyClasses = [ 'AlignLeft', 'AlignCenter', 'AlignRight', 'AlignJustify' ];
+ */

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

@@ -0,0 +1,225 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+// Register a plugin named "sample".
+CKEDITOR.plugins.add( 'keystrokes',
+{
+  beforeInit : function( editor )
+  {
+    /**
+     * Controls keystrokes typing in this editor instance.
+     * @name CKEDITOR.editor.prototype.keystrokeHandler
+     * @type CKEDITOR.keystrokeHandler
+     * @example
+     */
+    editor.keystrokeHandler = new CKEDITOR.keystrokeHandler( editor );
+
+    editor.specialKeys = {};
+  },
+
+  init : function( editor )
+  {
+    var keystrokesConfig  = editor.config.keystrokes,
+      blockedConfig    = editor.config.blockedKeystrokes;
+
+    var keystrokes      = editor.keystrokeHandler.keystrokes,
+      blockedKeystrokes  = editor.keystrokeHandler.blockedKeystrokes;
+
+    for ( var i = 0 ; i < keystrokesConfig.length ; i++ )
+      keystrokes[ keystrokesConfig[i][0] ] = keystrokesConfig[i][1];
+
+    for ( i = 0 ; i < blockedConfig.length ; i++ )
+      blockedKeystrokes[ blockedConfig[i] ] = 1;
+  }
+});
+
+/**
+ * Controls keystrokes typing in an editor instance.
+ * @constructor
+ * @param {CKEDITOR.editor} editor The editor instance.
+ * @example
+ */
+CKEDITOR.keystrokeHandler = function( editor )
+{
+  if ( editor.keystrokeHandler )
+    return editor.keystrokeHandler;
+
+  /**
+   * List of keystrokes associated to commands. Each entry points to the
+   * command to be executed.
+   * @type Object
+   * @example
+   */
+  this.keystrokes = {};
+
+  /**
+   * List of keystrokes that should be blocked if not defined at
+   * {@link keystrokes}. In this way it is possible to block the default
+   * browser behavior for those keystrokes.
+   * @type Object
+   * @example
+   */
+  this.blockedKeystrokes = {};
+
+  this._ =
+  {
+    editor : editor
+  };
+
+  return this;
+};
+
+(function()
+{
+  var cancel;
+
+  var onKeyDown = function( event )
+  {
+    // The DOM event object is passed by the "data" property.
+    event = event.data;
+
+    var keyCombination = event.getKeystroke();
+    var command = this.keystrokes[ keyCombination ];
+    var editor = this._.editor;
+
+    cancel = ( editor.fire( 'key', { keyCode : keyCombination } ) === true );
+
+    if ( !cancel )
+    {
+      if ( command )
+      {
+        var data = { from : 'keystrokeHandler' };
+        cancel = ( editor.execCommand( command, data ) !== false );
+      }
+
+      if  ( !cancel )
+      {
+        var handler = editor.specialKeys[ keyCombination ];
+        cancel = ( handler && handler( editor ) === true );
+
+        if ( !cancel )
+          cancel = !!this.blockedKeystrokes[ keyCombination ];
+      }
+    }
+
+    if ( cancel )
+      event.preventDefault( true );
+
+    return !cancel;
+  };
+
+  var onKeyPress = function( event )
+  {
+    if ( cancel )
+    {
+      cancel = false;
+      event.data.preventDefault( true );
+    }
+  };
+
+  CKEDITOR.keystrokeHandler.prototype =
+  {
+    /**
+     * Attaches this keystroke handle to a DOM object. Keystrokes typed
+     ** over this object will get handled by this keystrokeHandler.
+     * @param {CKEDITOR.dom.domObject} domObject The DOM object to attach
+     *    to.
+     * @example
+     */
+    attach : function( domObject )
+    {
+      // For most browsers, it is enough to listen to the keydown event
+      // only.
+      domObject.on( 'keydown', onKeyDown, this );
+
+      // Some browsers instead, don't cancel key events in the keydown, but in the
+      // keypress. So we must do a longer trip in those cases.
+      if ( CKEDITOR.env.opera || ( CKEDITOR.env.gecko && CKEDITOR.env.mac ) )
+        domObject.on( 'keypress', onKeyPress, this );
+    }
+  };
+})();
+
+/**
+ * A list of keystrokes to be blocked if not defined in the {@link CKEDITOR.config.keystrokes}
+ * setting. In this way it is possible to block the default browser behavior
+ * for those keystrokes.
+ * @type Array
+ * @default (see example)
+ * @example
+ * // This is actually the default value.
+ * config.blockedKeystrokes =
+ * [
+ *     CKEDITOR.CTRL + 66 &#47;*B*&#47;,
+ *     CKEDITOR.CTRL + 73 &#47;*I*&#47;,
+ *     CKEDITOR.CTRL + 85 &#47;*U*&#47;
+ * ];
+ */
+CKEDITOR.config.blockedKeystrokes =
+[
+  CKEDITOR.CTRL + 66 /*B*/,
+  CKEDITOR.CTRL + 73 /*I*/,
+  CKEDITOR.CTRL + 85 /*U*/
+];
+
+/**
+ * A list associating keystrokes to editor commands. Each element in the list
+ * is an array where the first item is the keystroke, and the second is the
+ * name of the command to be executed.
+ * @type Array
+ * @default (see example)
+ * @example
+ * // This is actually the default value.
+ * config.keystrokes =
+ * [
+ *     [ CKEDITOR.ALT + 121 &#47;*F10*&#47;, 'toolbarFocus' ],
+ *     [ CKEDITOR.ALT + 122 &#47;*F11*&#47;, 'elementsPathFocus' ],
+ *
+ *     [ CKEDITOR.SHIFT + 121 &#47;*F10*&#47;, 'contextMenu' ],
+ *
+ *     [ CKEDITOR.CTRL + 90 &#47;*Z*&#47;, 'undo' ],
+ *     [ CKEDITOR.CTRL + 89 &#47;*Y*&#47;, 'redo' ],
+ *     [ CKEDITOR.CTRL + CKEDITOR.SHIFT + 90 &#47;*Z*&#47;, 'redo' ],
+ *
+ *     [ CKEDITOR.CTRL + 76 &#47;*L*&#47;, 'link' ],
+ *
+ *     [ CKEDITOR.CTRL + 66 &#47;*B*&#47;, 'bold' ],
+ *     [ CKEDITOR.CTRL + 73 &#47;*I*&#47;, 'italic' ],
+ *     [ CKEDITOR.CTRL + 85 &#47;*U*&#47;, 'underline' ],
+ *
+ *     [ CKEDITOR.ALT + 109 &#47;*-*&#47;, 'toolbarCollapse' ]
+ * ];
+ */
+CKEDITOR.config.keystrokes =
+[
+  [ CKEDITOR.ALT + 121 /*F10*/, 'toolbarFocus' ],
+  [ CKEDITOR.ALT + 122 /*F11*/, 'elementsPathFocus' ],
+
+  [ CKEDITOR.SHIFT + 121 /*F10*/, 'contextMenu' ],
+  [ CKEDITOR.CTRL + CKEDITOR.SHIFT + 121 /*F10*/, 'contextMenu' ],
+
+  [ CKEDITOR.CTRL + 90 /*Z*/, 'undo' ],
+  [ CKEDITOR.CTRL + 89 /*Y*/, 'redo' ],
+  [ CKEDITOR.CTRL + CKEDITOR.SHIFT + 90 /*Z*/, 'redo' ],
+
+  [ CKEDITOR.CTRL + 76 /*L*/, 'link' ],
+
+  [ CKEDITOR.CTRL + 66 /*B*/, 'bold' ],
+  [ CKEDITOR.CTRL + 73 /*I*/, 'italic' ],
+  [ CKEDITOR.CTRL + 85 /*U*/, 'underline' ],
+
+  [ CKEDITOR.ALT + ( CKEDITOR.env.ie || CKEDITOR.env.webkit ? 189 : 109 ) /*-*/, 'toolbarCollapse' ],
+  [ CKEDITOR.ALT + 48 /*0*/, 'a11yHelp' ]
+];
+
+/**
+ * Fired when any keyboard key (or combination) is pressed into the editing area.
+ * @name CKEDITOR.editor#key
+ * @event
+ * @param {Number} data.keyCode A number representing the key code (or
+ *    combination). It is the sum of the current key code and the
+ *    {@link CKEDITOR.CTRL}, {@link CKEDITOR.SHIFT} and {@link CKEDITOR.ALT}
+ *    constants, if those are pressed.
+ */