Changeset 1394 for trunk

Timestamp:

02/10/18 06:36:44 (18 months ago)

Author:

gogo

Message:

Rewrite and standardise key events (see #1393), add onKeyDown, onKeyUp and also onShortCut

This commit rewrites much of the keyboard event handling, but it is (hopefully, in theory, as far as I can test) backwards compatible, in fact, it's so compatible it is used in the exact same way so far as plugins are concerned.

It adds events for plugins of onKeyDown, onKeyUp and also onShortCut

The existing onKeyPress is still fired - however with some caveat, namely the intention is that onKeyPress is only fired for the following classifications of key pressing...

"Adding Characters"

letters, numbers, space, punctuation, symbols, tab, enter

"Deleting Characters"

delete, backspace

"Shortcuts and Other Useful Things"

esc, ctrl-a, ctrl-b...

where previously under some browsers (WebKit?, IE) it would be fired for all keydown events, now it will only fire for "normally useful" events, and the event noise is reduced.

Also considerable work to make sure that the browsers are consistent, to ensure this some "keydown" events in some browsers also produce a "fake" keypress event, where in other browsers they would get a real keypress event (and we want them to).

getKey() hs been improved in Gecko and WebKit? and should be about the same for most uses (certainly all uses in the Xinha distribution), as it now uses the DOM3 keyboard event codes, special keys are now returned by name (where possible), eg tab is reported by getKey as "Tab", where previously, it would have been probably an actual tab character (but other special keys would have been pretty random incorrect characters).

Whew. This was a lot more work than I had anticipated. KeyboardEvent? across browsers is a mess.

Location:

trunk

Files:

• XinhaCore.js (modified) (4 diffs)
• modules/Gecko/Gecko.js (modified) (6 diffs)
• modules/InternetExplorer/InternetExplorer.js (modified) (4 diffs)
• modules/Opera/Opera.js (modified) (3 diffs)
• modules/WebKit/WebKit.js (modified) (6 diffs)
• plugins/Equation/ASCIIMathML.js (modified) (1 diff)
• plugins/GenericPlugin/GenericPlugin.js (modified) (1 diff)
• plugins/InsertNote/InsertNote.js (modified) (1 diff)
• plugins/ListOperations/ListOperations.js (modified) (1 diff)
• plugins/TableOperations/TableOperations.js (modified) (2 diffs)

trunk/XinhaCore.js

@@ -4832 +4832 @@
     {
       this.setHTML(txt);
+      
     }
     else
@@ -5788 +5789 @@
   }
   
-  if ( this.isKeyEvent(ev) )
-  {
-    // Run the ordinary plugins first
+
+  var isShortCut = this.isShortCut(ev);
+  
+  // Order of priority is something like...
+  // Keydown Cancels
+  //   KeyPress Cancels
+  //      ShortCut Cancels 
+  //         (built in shortcuts)
+  //         KeyUp
+  
+  if(ev.type == 'keydown')
+  {
+    if(editor.firePluginEvent('onKeyDown', ev))
+    {
+      return false;
+    }
+    
+    // If this is a shortcut, fire it as a keypress but when the key down
+    //  happens, this is because some browsers (various versions and platform combinations even!) 
+    //  fire press and some do not, so we can only rely on keydown here
+    //  we will suppress an actual shortcut press a bit further down to avoid duplicates
+    if(isShortCut)
+    {
+      if(editor.firePluginEvent('onKeyPress', ev))
+      {
+        return false;
+      }
+      
+      // Also we have a special onShortCut which only fires for them
+      if(editor.firePluginEvent('onShortCut', ev, isShortCut))
+      {
+        return false;
+      }
+      
+      this._shortCuts(ev);
+    }
+  }
+  
+  // Shortcuts were fired as a keydown masquerading as a keypress already
+  // so don't fire them again on an actual keypress.  Additionally
+  // browsers differ slightly in what they call a keypress, to be sure we 
+  // issue keyress on a standard set of things we pass off to isKeyPressEvent
+  // to do some more indepth checking, it will a boolean, some keypress will
+  // be invalid and skiped, some keydown will be repeated as a keypress because
+  // that browser wouldn't normally issue a keypress.  Sigh.
+  if(!isShortCut && this.isKeyPressEvent(ev))
+  {
     if(editor.firePluginEvent('onKeyPress', ev))
     {
       return false;
     }
-    
-    // Handle the core shortcuts
-    if ( this.isShortCut( ev ) )
-    {
-      this._shortCuts(ev);
+  }
+  
+  // At last, something we can rely on!
+  if(ev.type == 'keyup')
+  {
+    if(editor.firePluginEvent('onKeyUp', ev))
+    {
+      return false;
     }
   }
@@ -8634 +8682 @@
 Xinha.prototype.createRange           = function(sel) { Xinha.notImplemented("createRange"); };
 
-/** Determine if the given event object is a keydown/press event.
+/** Different browsers have subtle differences in what they call a "keypress", we try and
+ *  standardise them here.  For example, Firefox calls Tab a keypress (with keyCode 9)
+ *  while WebKit does not record a keypress for the Tab key.
+ * 
+ *  Webkit does record a keydown for tab, but typically not a keyup as it's caused a 
+ *  defocus by then, and there is no keypress.
+ *  
+ *  For the sake of Xinha, we will define keyPress something like...
+ * 
+ *   "Adding Characters"
+ *      letters, numbers, space, punctuation, symbols, tab, enter
+ * 
+ *   "Deleting Characters"
+ *      delete, backspace
+ * 
+ *   "Shortcuts and Other Useful Things"
+ *      esc, ctrl-a, ctrl-b...
+ * 
+ * Note that in the interests of performance, we are not too strict about removing things
+ *   that should not be keypresses if they don't happen frequently, like for example,
+ *   Function Keys **might** get passed as onKeyPress, depending on browser, since it's
+ *   rare and plugins probably won't be looking for them anyway, there's no sense
+ *   wasting cycles looking for them.
+ * 
+ * If you are looking for something that is not "officially" a keypress as defined above
+ *   use onKeyDown and you will get notifications for EVERY key down, even if it's for
+ *   example a modifier like shift (eg ctrl-shift-a would give three keydowns), which is 
+ *   why keypress is a better idea if you can do that.
+ * 
+ * Note also that you can listen to onShortCut to only hear about those if you want, 
+ *   it gets a second argument of the shortcut key already decoded for you.
+ * 
+ * A useful key Tester is here:
+ *    https://dvcs.w3.org/hg/d4e/raw-file/tip/key-event-test.html
+ * 
+ * A useful reference of DOM3 key names is here:
+ *    https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values
+ * 
+ * @param KeyboardEvent
+ * @return boolean
+ */
+
+Xinha.prototype.isKeyPressEvent = function(keyEvent)
+{
+  if(typeof Xinha.DOM3NotAKeyPress == 'undefined')
+  {
+    // The following regular expressions match KeyboardEvent.key for keys which should NOT be 
+    //  regarded as a keypress
+    //
+    // Note that we don't actually test them all, currently only modifier, navigation and editing
+    // are actually tested and excluded, the others wont' happen frequently enough to bother
+    // with testing.  It's not typically a big deal if keys slip-through the net and issue 
+    // a keypress as plugins will likely just skip it as an unknown key.
+    //
+    // See:   https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values
+    
+    Xinha.DOM3NotAKeyPress = {
+      'modifier'    : /^(Alt|CapsLock|Control|F[0-9]+|FnLock|Hyper|Meta|NumLock|ScrollLock|Shift|Super|Symbol|OS|Scroll)/,
+      'navigation'  : /^(Arrow|Page|End|Home|Left|Right|Up|Down)/,
+      'editing'     : /^(Insert)/,
+      'ui'          : /^(Accept|Again|Attn|Cancel|ContextMenu|Execute|Find|Finish|Help|Pause|Play|Props|Select|Zoom|Pause|Apps)/,
+      'device'      : /^(Brightness|Eject|LoghOff|Power|Print|Hibernate|Standby|WakeUp)/,
+      'ime'         : /^(AllCandidates|Alphanumeric|CodeInput|Compose|Convert|Dead|FinalMode|Group|ModeChange|NextCandidate|NonConvert|PreviousCandidate|Process|SingleCandidate|Multi|Nonconvert|AltGraph)/,
+      'korean'      : /^(Hangul|Hanja|Junja)/,
+      'japanese'    : /^(Eisu|Hanakaku|Hirigana|Kana|Kanji|Katakana|Romanji|Zenkaku|RomanCharacters|HalfWidth|FullWidth)/,
+      'function'    : /^(F[0-9]+|Soft[0-9]+)/,
+      'phone'       : /^(AppSwitch|Call|Camera|EndCall|GoBack|GoHome|HeadsetHook|LastNumber|Notification|Manner|Voice|Exit|MozHomeScreen)/,
+      'multimedia'  : /^(Channel|Media|FastFwd)/,
+      'audio'       : /^(Audio|Microphone|Volume)/,
+      'tv'          : /^(TV|Live)/,
+      'media'       : /^(AVR|Color|ClosedCaption|Dummer|DisplaySwap|DVR|Exit|Favorite|Guide|Info|InstantReplay|Link|List|Live|Lock|Media|Navigate|Next|OnDemand|Pairing|PinP|Play|Random|RcLow|Record|RfBypass|ScanChannels|ScreenMode|Settings|SplitScreen|STBInput|Subtitle|Teletext|VideoMode|Wink|ZoomToggle|Zoom)/,
+      'speech'      : /^(Speech)/,
+      'document'    : /^(Close|New|Open|Print|Save|Spellcheck|Mail)/,
+      'application' : /^(Launch|MediaSelect|SelectMedia)/
+    };
+  }
+
+  if(keyEvent.type == 'keypress')
+  {
+    // Detect some things that might come in as a press and should not be a press
+    
+    //  DOM3 Keys
+    
+    if(typeof keyEvent.key != 'undefined')
+    {
+      if(keyEvent.key == 'Unidentified')
+      {
+        // Some old Gecko versions called Shift-tab Unidentified !
+        if(typeof keyEvent.keyCode != 'undefined' && keyEvent.keyCode == 9) return true;
+        return false;
+      }
+
+      // Modifier keys
+      if(Xinha.DOM3NotAKeyPress.modifier.test(keyEvent.key))   return false;
+         
+      // Navigation Keys
+      if(Xinha.DOM3NotAKeyPress.navigation.test(keyEvent.key)) return false;
+                
+      // Editing Keys
+      if(Xinha.DOM3NotAKeyPress.editing.test(keyEvent.key))    return false;
+           
+    }
+    // Old DOM3 (only Safari and old Chrome)
+    /* I could not find anything reported as a press that should not be in Safari 9.1 and that 
+     * is as far back as I can easily test, my thought is that dropping straight through to the 
+     * legacy keys should work fine so I have disabled this
+     */ 
+    else if( 0 && typeof keyEvent.keyIdentifier != 'undefined' && keyEvent.keyIdentifier.length)
+    {
+      var kI = parseInt(keyEvent.keyIdentifier.replace(/^U\+/,''),16);
+      
+    }
+    // Legacy Keys
+    else 
+    {
+      if(keyEvent.charCode == 0)
+      {
+        if((keyEvent.keyCode >= 37 && keyEvent.keyCode <= 40)) return false; // Arrows
+           
+        if(   keyEvent.keyCode == 45 // Insert
+          ||  keyEvent.keyCode == 36 // Home
+          ||  keyEvent.keyCode == 35 // End
+          ||  keyEvent.keyCode == 33 // Page Up
+          ||  keyEvent.keyCode == 34 // Page Dn
+          ||  keyEvent.keyCode == 19 // Pause/Break
+          ||  keyEvent.keyCode == 17 // Control
+          ||  keyEvent.keyCode == 18 // Alt
+          ||  keyEvent.keyCode == 20 // CapsLock
+          ||  keyEvent.keyCode == 91 // OS
+          ||  keyEvent.keyCode == 93 // ContextMenu          
+        ) return false;
+        
+        if( keyEvent.keyCode >= 112 && keyEvent <= 123 ) return false; // F1 through F12
+        if( keyEvent.keyCode == 0) return false; // Other things (like "LaunchApp1")
+      }
+    }
+   
+    // If it wasn't a bad thing we skiped, then a keypress is a keypress
+    return true;
+  }
+  else if(keyEvent.type == 'keydown')
+  {
+    // Now we get into browser specifics, we want to return true 
+    //  if the keydown event is for a key which should be reported as a press
+    //  and is NOT reported as  a press (otherwise press would fire twice for it)
+    return this.isKeyDownThatShouldGetButDoesNotGetAKeyPressEvent(keyEvent);
+  }
+};
+
+/** Due to browser differences, some keys which Xinha prefers to call a keyPress
+ *   do not get an actual keypress event.  This browser specific function 
+ *   overridden in the browser's engine (eg modules/WebKit/WebKit.js) as required
+ *   takes a keydown event type and tells us if we should treat it as a 
+ *   keypress event type.
  *
- *  @param {Event} event 
- *  @returns {Boolean}
- */
- 
-Xinha.prototype.isKeyEvent            = function(event) { Xinha.notImplemented("isKeyEvent"); };
+ *  To be clear, the keys we are interested here are
+ *        Escape, Tab, Backspace, Delete, Enter
+ *   these are "non printable" characters which we still want to regard generally
+ *   as a keypress.  
+ * 
+ *  If the browser does not report these as a keypress
+ *   ( https://dvcs.w3.org/hg/d4e/raw-file/tip/key-event-test.html )
+ *   then this function must return true for such keydown events as it is
+ *   given.
+ * 
+ * @param KeyboardEvent
+ * @return boolean
+ */
+
+Xinha.prototype.isKeyDownThatShouldGetButDoesNotGetAKeyPressEvent = function(keyEvent)
+{
+  return false;
+};
 
 /** Determines if the given key event object represents a combination of CTRL-<key>,
@@ -8646 +8860 @@
  *
  *  @param    {Event} keyEvent
- *  @returns  {Boolean}
+ *  @returns  {mixed} Either the key representing the short cut (eg ctrl-b gives 'b'), or false
  */
  
 Xinha.prototype.isShortCut = function(keyEvent)
 {
-  if(keyEvent.ctrlKey && !keyEvent.altKey)
-  {
-    return true;
+  if(keyEvent.ctrlKey && !keyEvent.altKey && this.getKey(keyEvent).length == 1)
+  {
+    return this.getKey(keyEvent);
   }
   

trunk/modules/Gecko/Gecko.js

@@ -50 +50 @@
 /** Allow Gecko to handle some key events in a special way.
  */
-  
 Gecko.prototype.onKeyPress = function(ev)
 {
   var editor = this.editor;
   var s = editor.getSelection();
-  
   // Handle shortcuts
   if(editor.isShortCut(ev))
@@ -133 +131 @@
         return a;
       };
-  
+
       if ( editor.config.convertUrlsToLinks && s && s.isCollapsed && s.anchorNode.nodeType == 3 && s.anchorNode.data.length > 3 && s.anchorNode.data.indexOf('.') >= 0 )
       {
@@ -157 +155 @@
 
           autoWrap(midTextEmail, 'a').href = 'mailto:' + mEmail[0];
-          break;
+          return true;
         }
 
@@ -177 +175 @@
           var midTextUrl   = leftTextUrl.splitText(midStart);
           autoWrap(midTextUrl, 'a').href = (mUrl[1] ? mUrl[1] : 'http://') + mUrl[2];
-          break;
+          return true;
         }
       }
@@ -734 +732 @@
 };
 
-/** Determine if the given event object is a keydown/press event.
+/** Due to browser differences, some keys which Xinha prefers to call a keyPress
+ *   do not get an actual keypress event.  This browser specific function 
+ *   overridden in the browser's engine (eg modules/WebKit/WebKit.js) as required
+ *   takes a keydown event type and tells us if we should treat it as a 
+ *   keypress event type.
  *
- *  @param event Event 
- *  @returns true|false
- */
- 
-Xinha.prototype.isKeyEvent = function(event)
-{
-  return event.type == "keypress";
-}
+ *  To be clear, the keys we are interested here are
+ *        Escape, Tab, Backspace, Delete, Enter
+ *   these are "non printable" characters which we still want to regard generally
+ *   as a keypress.  
+ * 
+ *  If the browser does not report these as a keypress
+ *   ( https://dvcs.w3.org/hg/d4e/raw-file/tip/key-event-test.html )
+ *   then this function must return true for such keydown events as it is
+ *   given.
+ * 
+ * @param KeyboardEvent with keyEvent.type == keydown
+ * @return boolean
+ */
+
+Xinha.prototype.isKeyDownThatShouldGetButDoesNotGetAKeyPressEvent = function(keyEvent)
+{
+  // Dom 3
+  if(typeof keyEvent.key != 'undefined')
+  {
+    // Found using IE11 (which uses Gecko)
+    //   this seems to be a reasonable way to distinguish
+    //   between IE11 and other Gecko browsers which do 
+    //   not provide the "Old DOM3" .char property
+    if(typeof keyEvent.char != 'undefined')
+    {
+      if(typeof Xinha.DOM3_IE11_KeyDownKeyPress_RE == 'undefined')
+      {
+        // I don't know if pre-defining this is really faster in the modern world of
+        //  Javascript JIT compiling, but it does no harm
+        Xinha.DOM3_IE11_KeyDownKeyPress_RE = /^(Tab|Backspace|Del)/;
+      }
+      
+      if(Xinha.DOM3_IE11_KeyDownKeyPress_RE.test(keyEvent.key))
+      {
+        return true;
+      }
+    }
+    
+    // Firefox reports everything we need as a keypress
+    // correctly (in terms of Xinha)
+  }
+  // Legacy
+  else
+  {
+    // Even very old firefox reports everything we need as a keypress
+    // correctly (in terms of Xinha)
+  }
+};
 
 /** Return the character (as a string) of a keyEvent  - ie, press the 'a' key and
@@ -751 +793 @@
  *  @returns string
  */
-                                   
+
 Xinha.prototype.getKey = function(keyEvent)
-{
-  return String.fromCharCode(keyEvent.charCode);
+{ 
+  // DOM3 Key is easy (ish)
+  if(typeof keyEvent.key != 'undefined' && keyEvent.key.length > 0)
+  {
+    switch(keyEvent.key)
+    {
+      case 'Unidentified':
+        // Some old Gecko version reports Shift-Tab as Unidentified
+        if(typeof keyEvent.keyCode != 'undefined' && keyEvent.keyCode == 9) return 'Tab';
+        
+        // Otherwise not know
+        return '';
+        
+      case 'Spacebar': // FF<37
+        return ' '; 
+    }
+    
+    return keyEvent.key;
+  }
+  // If charCode is specified, that's what we want
+  else if(keyEvent.charCode)
+  {
+    return String.fromCharCode(keyEvent.charCode);
+  }
+  // Safari does not set charCode if CTRL is pressed
+  //  but does set keyCode to the key, it also sets keyCode
+  //  for the actual pressing of ctrl, skip that
+  //  the keyCode in Safari si the uppercase character's code 
+  //  for that key, so if shift is not pressed, lowercase it
+  else if(keyEvent.ctrlKey && keyEvent.keyCode != 17)
+  {
+    if(keyEvent.shiftKey)
+    {
+      return String.fromCharCode(keyEvent.keyCode);
+    }
+    else
+    {
+      return String.fromCharCode(keyEvent.keyCode).toLowerCase();
+    }
+  }
+  
+  // Ok, give up, no idea!
+  return '';
 }
 

trunk/modules/InternetExplorer/InternetExplorer.js

@@ -1 +1 @@
 
   /*--------------------------------------:noTabs=true:tabSize=2:indentSize=2:--
+    --
+    --  NOTICE Modern IE does not use this engine any more
+    --
+    --          IE 11 identifies as Gecko
+    --          Edge  identifies as WebKit
+    --
+    --  The last IE version to use this engine is probably IE10, people should
+    --   not use such an old version of IE and should upgrade or use a WebKit
+    --   or Gecko based browser.
+    --
+    --  This engine is no longer officially supported or tested.
+    --
+    -----------------------------------------------------------------------------
+    --
     --  Xinha (is not htmlArea) - http://xinha.gogo.co.nz/
     --
@@ -50 +64 @@
 /** Allow Internet Explorer to handle some key events in a special way.
  */
-  
 InternetExplorer.prototype.onKeyPress = function(ev)
 {
+  var editor = this.editor;
+  
   // Shortcuts
   if(this.editor.isShortCut(ev))
@@ -94 +109 @@
     break;
     
-    case 9: // KEY tab, see ticket #1121
-    {
+    case 9: // KEY tab
+    {
+      // Note that the ListOperations plugin will handle tabs in list items and indent/outdent those
+      // at some point TableOperations might do also
+      // so this only has to handle a tab/untab in text
+      if(editor.config.tabSpanClass)
+      {
+        if(!ev.shiftKey)
+        {
+          editor.insertHTML('<span class="'+editor.config.tabSpanClass+'">'+editor.config.tabSpanContents+'</span>');
+          var s = editor.getSelection();
+          var r = editor.createRange(s);                   
+          r.collapse(true);
+          r.select();
+        }
+        else
+        {
+          // Shift tab is not trivial to fix in old IE
+          // and I don't care enough about it to try hard
+        }
+      }
+      
       Xinha._stopEvent(ev);
       return true;
     }
+    break;
 
   }
@@ -825 +861 @@
 };
 
-/** Determine if the given event object is a keydown/press event.
+/** Due to browser differences, some keys which Xinha prefers to call a keyPress
+ *   do not get an actual keypress event.  This browser specific function 
+ *   overridden in the browser's engine (eg modules/WebKit/WebKit.js) as required
+ *   takes a keydown event type and tells us if we should treat it as a 
+ *   keypress event type.
  *
- *  @param event Event 
- *  @returns true|false
- */
- 
-Xinha.prototype.isKeyEvent = function(event)
-{
-  return event.type == "keydown";
-}
+ *  To be clear, the keys we are interested here are
+ *        Escape, Tab, Backspace, Delete, Enter
+ *   these are "non printable" characters which we still want to regard generally
+ *   as a keypress.  
+ * 
+ *  If the browser does not report these as a keypress
+ *   ( https://dvcs.w3.org/hg/d4e/raw-file/tip/key-event-test.html )
+ *   then this function must return true for such keydown events as it is
+ *   given.
+ * 
+ * @param KeyboardEvent with keyEvent.type == keydown
+ * @return boolean
+ */
+
+Xinha.prototype.isKeyDownThatShouldGetButDoesNotGetAKeyPressEvent = function(keyEvent)
+{
+  // Dom 3
+  if(typeof keyEvent.key != 'undefined')
+  {
+    // Found using IE11 in 9-10 modes
+    if(keyEvent.key.match(/^(Tab|Backspace|Del)/))
+    {
+      return true;
+    }
+  }
+  // Legacy
+  else
+  {
+    // Found using IE11 in 5-8 modes
+    if(keyEvent.keyCode == 9   // Tab
+    || keyEvent.keyCode == 8   // Backspace
+    || keyEvent.keyCode == 46  // Del
+    ) return true;
+  }
+};
 
 /** Return the character (as a string) of a keyEvent  - ie, press the 'a' key and

trunk/modules/Opera/Opera.js

@@ -1 +1 @@
 
   /*--------------------------------------:noTabs=true:tabSize=2:indentSize=2:--
+    --
+    --
+    --  NOTICE Modern Opera does not use this engine any more, it identifies as
+    --           and uses WebKit (Opera is these days based on Blink).
+    --
+    --   People using older versions of Opera that need this engine should
+    --   upgrade to a WebKit or Gecko based browser.
+    --
+    --  This engine is no longer officially supported or tested.
+    --
+    -----------------------------------------------------------------------------
     --  Xinha (is not htmlArea) - http://xinha.gogo.co.nz/
     --
@@ -50 +61 @@
 /** Allow Opera to handle some key events in a special way.
  */
-  
 Opera.prototype.onKeyPress = function(ev)
 {
@@ -693 +703 @@
 };
 
-/** Determine if the given event object is a keydown/press event.
+/** 
+ * @NOTE I don't have a way to test this any more (don't have old opera version
+ *   and don't care enough to find one), I'm assuming it will probably be close
+ *   to Gecko so I have just copied it directly.
+ * 
+ * Due to browser differences, some keys which Xinha prefers to call a keyPress
+ *   do not get an actual keypress event.  This browser specific function 
+ *   overridden in the browser's engine (eg modules/WebKit/WebKit.js) as required
+ *   takes a keydown event type and tells us if we should treat it as a 
+ *   keypress event type.
  *
- *  @param event Event 
- *  @returns true|false
- */
- 
-Xinha.prototype.isKeyEvent = function(event)
-{
-  return event.type == "keypress";
-}
+ *  To be clear, the keys we are interested here are
+ *        Escape, Tab, Backspace, Delete, Enter
+ *   these are "non printable" characters which we still want to regard generally
+ *   as a keypress.  
+ * 
+ *  If the browser does not report these as a keypress
+ *   ( https://dvcs.w3.org/hg/d4e/raw-file/tip/key-event-test.html )
+ *   then this function must return true for such keydown events as it is
+ *   given.
+ * 
+ * @param KeyboardEvent with keyEvent.type == keydown
+ * @return boolean
+ */
+
+Xinha.prototype.isKeyDownThatShouldGetButDoesNotGetAKeyPressEvent = function(keyEvent)
+{
+  // Dom 3
+  if(typeof keyEvent.key != 'undefined')
+  {
+    // Found using IE11 (which uses Gecko)
+    //   this seems to be a reasonable way to distinguish
+    //   between IE11 and other Gecko browsers which do 
+    //   not provide the "Old DOM3" .char property
+    if(typeof keyEvent.char != 'undefined')
+    {
+      if(keyEvent.key.match(/^(Tab|Backspace|Del)/))
+      {
+        return true;
+      }
+    }
+    
+    // Firefox reports everything we need as a keypress
+    // correctly (in terms of Xinha)
+  }
+  // Legacy
+  else
+  {
+    // Even very old firefox reports everything we need as a keypress
+    // correctly (in terms of Xinha)
+  }
+};
 
 /** Return the character (as a string) of a keyEvent  - ie, press the 'a' key and

trunk/modules/WebKit/WebKit.js

@@ -57 +57 @@
   // Handle shortcuts
   if(editor.isShortCut(ev))
-  {
+  {    
     switch(editor.getKey(ev).toLowerCase())
     {
@@ -115 +115 @@
         };
         editor._unlinkOnUndo = true;
-    
         return a;
       };
@@ -142 +141 @@
 
           autoWrap(midTextEmail, 'a').href = 'mailto:' + mEmail[0];
-          break;
+          return true;
         }
 
@@ -162 +161 @@
           var midTextUrl   = leftTextUrl.splitText(midStart);
           autoWrap(midTextUrl, 'a').href = (mUrl[1] ? mUrl[1] : 'http://') + mUrl[2];
-          break;
+          return true;
         }
       }
@@ -718 +717 @@
 };
 
-/** Determine if the given event object is a keydown/press event.
+
+/** Due to browser differences, some keys which Xinha prefers to call a keyPress
+ *   do not get an actual keypress event.  This browser specific function 
+ *   overridden in the browser's engine (eg modules/WebKit/WebKit.js) as required
+ *   takes a keydown event type and tells us if we should treat it as a 
+ *   keypress event type.
  *
- *  @param event Event 
- *  @returns true|false
- */
- 
-Xinha.prototype.isKeyEvent = function(event)
-{
-  return event.type == "keydown";
-}
+ *  To be clear, the keys we are interested here are
+ *        Escape, Tab, Backspace, Delete, Enter
+ *   these are "non printable" characters which we still want to regard generally
+ *   as a keypress.  
+ * 
+ *  If the browser does not report these as a keypress
+ *   ( https://dvcs.w3.org/hg/d4e/raw-file/tip/key-event-test.html )
+ *   then this function must return true for such keydown events as it is
+ *   given.
+ * 
+ * @param KeyboardEvent with keyEvent.type == keydown
+ * @return boolean
+ */
+
+Xinha.prototype.isKeyDownThatShouldGetButDoesNotGetAKeyPressEvent = function(keyEvent)
+{
+  // Dom 3
+  if(typeof keyEvent.key != 'undefined')
+  {
+    if(typeof Xinha.DOM3_WebKit_KeyDownKeyPress_RE == 'undefined')
+    {
+      // I don't know if pre-defining this is really faster in the modern world of
+      //  Javascript JIT compiling, but it does no harm
+      Xinha.DOM3_WebKit_KeyDownKeyPress_RE = /^(Escape|Esc|Tab|Backspace|Delete|Del)/;
+    }
+    
+    // Found using Chrome 65 and Opera 50, Edge
+    //  Note that Edge calls Escape Esc, and Delete Del
+    if(Xinha.DOM3_WebKit_KeyDownKeyPress_RE.test(keyEvent.key))
+    {
+      return true;
+    }
+  }
+  // Old Safari and Chrome
+  else if(typeof keyEvent.keyIdentifier != 'undefined' && keyEvent.keyIdentifier.length)
+  {
+    var kI = parseInt(keyEvent.keyIdentifier.replace(/^U\+/,''),16);
+    // Found using Safari 9.1.1 - safari seems to pass ESC ok as a keyPress
+    if(kI == 9 /* Tab */ || kI == 8 /* Backspace */ || kI == 127 /* Delete */ ) return true;
+  }
+  // Legacy
+  else
+  {
+    // Also Chrome 65, I'm assuming perhaps dangerously, that it's about the same as 
+    // older pre-KeyboardEvent.key but that's been around a few years now so
+    // people will mostly be on supporting browsers anyway so this probably
+    // won't be hit by that many people
+    if(keyEvent.charCode == 0)
+    {
+      if( keyEvent.keyCode == 27  // ESC
+       || keyEvent.keyCode == 9   // Tab
+       || keyEvent.keyCode == 8   // Backspace
+       || keyEvent.keyCode == 46  // Del
+      ) return true;
+    }
+  }
+};
 
 /** Return the character (as a string) of a keyEvent  - ie, press the 'a' key and
@@ -738 +791 @@
 Xinha.prototype.getKey = function(keyEvent)
 { 
- // with ctrl pressed Safari does not give the charCode, unfortunately this (shortcuts) is about the only thing this function is for
-  if(typeof keyEvent.keyIdentifier == 'undefined')
-  {
-    if(typeof keyEvent.key != 'undefined')
-    {
-      return keyEvent.key;
-    }
-  }
-  
-  var key = String.fromCharCode(parseInt(keyEvent.keyIdentifier.replace(/^U\+/,''),16));
-  if (keyEvent.shiftKey) return key;
-  else return key.toLowerCase();
+  // DOM3 Key is easy (ish)
+  if(typeof keyEvent.key != 'undefined' && keyEvent.key.length > 0)
+  {
+    return keyEvent.key;
+  }
+  // Old DOM3 used by (Old?) Safari SOMETIMES (but not ALWAYS!) and old Chrome
+  else if(typeof keyEvent.keyIdentifier != 'undefined' && keyEvent.keyIdentifier.length > 0 && keyEvent.keyIdentifier.match(/^U\+/))
+  {
+      var key = String.fromCharCode(parseInt(keyEvent.keyIdentifier.replace(/^U\+/,''),16));
+      if (keyEvent.shiftKey) return key;
+      else return key.toLowerCase();
+  }
+  // If charCode is specified, that's what we want
+  else if(keyEvent.charCode)
+  {
+    return String.fromCharCode(keyEvent.charCode);
+  }
+  // Safari does not set charCode if CTRL is pressed
+  //  but does set keyCode to the key, it also sets keyCode
+  //  for the actual pressing of ctrl, skip that
+  //  the keyCode in Safari si the uppercase character's code 
+  //  for that key, so if shift is not pressed, lowercase it
+  else if(keyEvent.ctrlKey && keyEvent.keyCode != 17)
+  {
+    if(keyEvent.shiftKey)
+    {
+      return String.fromCharCode(keyEvent.keyCode);
+    }
+    else
+    {
+      return String.fromCharCode(keyEvent.keyCode).toLowerCase();
+    }
+  }
+  
+  // Ok, give up, no idea!
+  return '';
 }
 

trunk/plugins/Equation/ASCIIMathML.js

@@ -2389 +2389 @@
   src = src.replace(/height\s*=\s*\d+/,"height="+(factor*(pic.getAttribute("height")-0)));
   document.getElementById(name+"input").value = src;
-//alert(getKey(evt.keycode))
   updatePicture(name);
 }

trunk/plugins/GenericPlugin/GenericPlugin.js

@@ -46 +46 @@
 }
 
+GenericPlugin.prototype.onKeyDown = function ( event )
+{
+  return false;
+}
+
 GenericPlugin.prototype.onKeyPress = function ( event )
 {
         return false;
+}
+
+GenericPlugin.prototype.onOnShortCut = function ( event , shortCut )
+{
+  // Where shortCut is a single character, eg if you press ctrl-a, then
+  //  shortCut == 'a'
+  return false;
+}
+
+GenericPlugin.prototype.onKeyUp = function ( event )
+{
+  return false;
 }
 

trunk/plugins/InsertNote/InsertNote.js

@@ -568 +568 @@
   // This seems a bit hacky, but I don't presently see
   // a better way.
+  //@NOTE: 8 = Backspace, 46 = Delete; this undocumented
+  //  function apears to be for handling delete note references
+  //  to have the note automatically deleted also
   if (event.keyCode == 8 || event.keyCode == 46)
   {

trunk/plugins/ListOperations/ListOperations.js

@@ -77 +77 @@
   }
 
-  ev.preventDefault();
+  Xinha._stopEvent(ev);
 
   if( ev.shiftKey ) {

trunk/plugins/TableOperations/TableOperations.js

@@ -717 +717 @@
         Styler.applyStyleIfMatch(params, /border($|Color|Width|Style)/);
       }
+      
+      // It is also friendly to remove table borders as it tends to override
+      // and this could be confusing when styling borders (user thinks it didn't work)
+      Xinha._removeClass(table, 'htmtableborders');
     }
     
@@ -883 +887 @@
   }
 
-  ev.preventDefault();
+  Xinha._stopEvent(ev);
     
   // find the next cell, get all the cells (td/th) which are in this table