From 8cd673d16a823e18e867c1c0d167a40bfbdda250 Mon Sep 17 00:00:00 2001
From: Jan Miksovsky <jan@quickui.org>
Date: Fri, 9 Sep 2016 16:44:30 -0700
Subject: [PATCH 1/3] Detect when element focus is obtained as a result of
 focus being restored to the window.

---
 iron-button-state.html  |  5 ++++-
 iron-control-state.html | 29 ++++++++++++++++++++++++++++-
 2 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/iron-button-state.html b/iron-button-state.html
index 8114e2d..10d3e6e 100644
--- a/iron-button-state.html
+++ b/iron-button-state.html
@@ -113,7 +113,10 @@
     },
 
     _detectKeyboardFocus: function(focused) {
-      this._setReceivedFocusFromKeyboard(!this.pointerDown && focused);
+      console.log(this.textContent.trim() + ' detectKeyboardFocus: ' + focused + ' ' + this.pointerDown + ' ' + this.receivedFocusViaWindowRestore);
+      if (focused && !this.receivedFocusViaWindowRestore) {
+        this._setReceivedFocusFromKeyboard(!this.pointerDown);
+      }
     },
 
     // to emulate native checkbox, (de-)activations from a user interaction fire
diff --git a/iron-control-state.html b/iron-control-state.html
index f34d057..2bb4629 100644
--- a/iron-control-state.html
+++ b/iron-control-state.html
@@ -11,6 +11,21 @@
 <link rel="import" href="../polymer/polymer.html">
 
 <script>
+function documentFocusListener(event) {
+  console.log('element focus');
+  event._focusRestoredToWindow = true;
+  document.removeEventListener('focus', documentFocusListener);
+}
+window.addEventListener('focus', function(event) {
+  console.log('window focus');
+  setTimeout(function() {
+    console.log('window focus timeout');
+  });
+});
+window.addEventListener('blur', function(event) {
+  console.log('window blur');
+  document.addEventListener('focus', documentFocusListener, true);
+});
 
   /**
    * @demo demo/index.html
@@ -42,6 +57,15 @@
         reflectToAttribute: true
       },
 
+      /**
+       * True if the action that caused the element to receive focus was the
+       * top-level tab/window having focused restored to it.
+       */
+      receivedFocusViaWindowRestore: {
+        type: Boolean,
+        readOnly: true
+      },
+
       _oldTabIndex: {
         type: Number
       },
@@ -72,7 +96,10 @@
       // handled). In either case, we can disregard `event.path`.
 
       if (event.target === this) {
-        this._setFocused(event.type === 'focus');
+        console.log(this.textContent.trim() + ' ' + event.type + ' ' + event._focusRestoredToWindow);
+        var focused = (event.type === 'focus');
+        this._setReceivedFocusViaWindowRestore(event._focusRestoredToWindow || false);
+        this._setFocused(focused);
       } else if (!this.shadowRoot) {
         var target = /** @type {Node} */(Polymer.dom(event).localTarget);
         if (!this.isLightDescendant(target)) {

From 74f548596ef542476a01185c1a62dd3cde6d87af Mon Sep 17 00:00:00 2001
From: Jan Miksovsky <jan@quickui.org>
Date: Fri, 9 Sep 2016 18:04:57 -0700
Subject: [PATCH 2/3] Revert changes to iron-control-state, moving new
 focus-tracking logic to iron-button-state. The latter can now detect when a
 previously-focused element is receiving a focus event as a result of the
 window regaining focus, and update the element's keyboard-focus state
 appropriately.

---
 iron-button-state.html  | 48 ++++++++++++++++++++++++++++++++++++++---
 iron-control-state.html | 29 +------------------------
 2 files changed, 46 insertions(+), 31 deletions(-)

diff --git a/iron-button-state.html b/iron-button-state.html
index 10d3e6e..f25ae1c 100644
--- a/iron-button-state.html
+++ b/iron-button-state.html
@@ -13,6 +13,10 @@
 <link rel="import" href="iron-control-state.html">
 
 <script>
+(function () {
+
+  var processingWindowFocusEvent = false;
+  var lastKeyboardFocusedElement;
 
   /**
    * @demo demo/index.html
@@ -112,10 +116,31 @@
       }
     },
 
+    // Heuristically determine whether this element received the focus via
+    // the keyboard. In most situations, we infer that, if the pointer isn't
+    // currently down, then the user must have moved the focus with the
+    // keyboard.
     _detectKeyboardFocus: function(focused) {
-      console.log(this.textContent.trim() + ' detectKeyboardFocus: ' + focused + ' ' + this.pointerDown + ' ' + this.receivedFocusViaWindowRestore);
-      if (focused && !this.receivedFocusViaWindowRestore) {
-        this._setReceivedFocusFromKeyboard(!this.pointerDown);
+      if (focused) {
+        // One special case is when the user is moving focus back to the current
+        // window. When a window blurs, the active element will blur too. If the
+        // user later restores focus to the window, the element will get a focus
+        // event again. If that element had previously been focused with the
+        // keyboard, we want to reestablish its receivedFocusFromKeyboard flag.
+        // This allows a keyboard user to once again see where the focus is
+        // without having to begin tabbing around.
+        var keyboard = processingWindowFocusEvent ?
+          (this === lastKeyboardFocusedElement) : // Keyboard used originally
+          !this.pointerDown;                      // Keyboard in use right now
+
+        this._setReceivedFocusFromKeyboard(keyboard);
+
+        // If the keyboard was used, remember this element so that, if the
+        // window suddenly loses and then regains focus, we can tell whether to
+        // reestablish the keyboard flag (above).
+        lastKeyboardFocusedElement = keyboard ? this : null;
+      } else {
+        this._setReceivedFocusFromKeyboard(false);
       }
     },
 
@@ -132,6 +157,7 @@
       this._setPointerDown(true);
       this._setPressed(true);
       this._setReceivedFocusFromKeyboard(false);
+      lastKeyboardFocusedElement = null;
     },
 
     _upHandler: function() {
@@ -228,4 +254,20 @@
     Polymer.IronButtonStateImpl
   ];
 
+  /*
+   * Set a flag we can use to detect when an element is receiving a focus event
+   * because the window has been refocused.
+   */
+  window.addEventListener('focus', function(event) {
+    // This point is reached before the element that will regain the focus will
+    // receive its focus event.
+    processingWindowFocusEvent = true;
+    setTimeout(function() {
+      // If an element has regained the focus, this point will be reached after
+      // that element's focus event.
+      processingWindowFocusEvent = false;
+    });
+  });
+
+})();
 </script>
diff --git a/iron-control-state.html b/iron-control-state.html
index 2bb4629..f34d057 100644
--- a/iron-control-state.html
+++ b/iron-control-state.html
@@ -11,21 +11,6 @@
 <link rel="import" href="../polymer/polymer.html">
 
 <script>
-function documentFocusListener(event) {
-  console.log('element focus');
-  event._focusRestoredToWindow = true;
-  document.removeEventListener('focus', documentFocusListener);
-}
-window.addEventListener('focus', function(event) {
-  console.log('window focus');
-  setTimeout(function() {
-    console.log('window focus timeout');
-  });
-});
-window.addEventListener('blur', function(event) {
-  console.log('window blur');
-  document.addEventListener('focus', documentFocusListener, true);
-});
 
   /**
    * @demo demo/index.html
@@ -57,15 +42,6 @@
         reflectToAttribute: true
       },
 
-      /**
-       * True if the action that caused the element to receive focus was the
-       * top-level tab/window having focused restored to it.
-       */
-      receivedFocusViaWindowRestore: {
-        type: Boolean,
-        readOnly: true
-      },
-
       _oldTabIndex: {
         type: Number
       },
@@ -96,10 +72,7 @@
       // handled). In either case, we can disregard `event.path`.
 
       if (event.target === this) {
-        console.log(this.textContent.trim() + ' ' + event.type + ' ' + event._focusRestoredToWindow);
-        var focused = (event.type === 'focus');
-        this._setReceivedFocusViaWindowRestore(event._focusRestoredToWindow || false);
-        this._setFocused(focused);
+        this._setFocused(event.type === 'focus');
       } else if (!this.shadowRoot) {
         var target = /** @type {Node} */(Polymer.dom(event).localTarget);
         if (!this.isLightDescendant(target)) {

From e4b9d45145098e0f51602ecc185288c0b2283dd3 Mon Sep 17 00:00:00 2001
From: Jan Miksovsky <jan@quickui.org>
Date: Mon, 12 Sep 2016 09:37:06 -0700
Subject: [PATCH 3/3] Handle cases where use sets focus with one mode
 (keyboard/mouse), then switches to another mode (mouse/keyboard).

---
 iron-button-state.html | 34 ++++++++++++++++++++++++----------
 1 file changed, 24 insertions(+), 10 deletions(-)

diff --git a/iron-button-state.html b/iron-button-state.html
index f25ae1c..35b8941 100644
--- a/iron-button-state.html
+++ b/iron-button-state.html
@@ -100,7 +100,7 @@
     ],
 
     keyBindings: {
-      'enter:keydown': '_asyncClick',
+      'enter:keydown': '_enterKeyDownHandler',
       'space:keydown': '_spaceKeyDownHandler',
       'space:keyup': '_spaceKeyUpHandler',
     },
@@ -132,14 +132,11 @@
         var keyboard = processingWindowFocusEvent ?
           (this === lastKeyboardFocusedElement) : // Keyboard used originally
           !this.pointerDown;                      // Keyboard in use right now
-
-        this._setReceivedFocusFromKeyboard(keyboard);
-
-        // If the keyboard was used, remember this element so that, if the
-        // window suddenly loses and then regains focus, we can tell whether to
-        // reestablish the keyboard flag (above).
-        lastKeyboardFocusedElement = keyboard ? this : null;
+        this._trackKeyboardFocusedElement(keyboard);
       } else {
+        // Update this element's keyboard focus state. Since the element's
+        // losing focus, not gaining it, we don't update our notion of which
+        // element last received focus via the keyboard.
         this._setReceivedFocusFromKeyboard(false);
       }
     },
@@ -156,8 +153,7 @@
     _downHandler: function(event) {
       this._setPointerDown(true);
       this._setPressed(true);
-      this._setReceivedFocusFromKeyboard(false);
-      lastKeyboardFocusedElement = null;
+      this._trackKeyboardFocusedElement(false);
     },
 
     _upHandler: function() {
@@ -165,6 +161,23 @@
       this._setPressed(false);
     },
 
+    _trackKeyboardFocusedElement: function(receivedFocusFromKeyboard) {
+      this._setReceivedFocusFromKeyboard(receivedFocusFromKeyboard);
+
+      // If the keyboard was used, remember this element so that, if the
+      // window suddenly loses and then regains focus, we can tell whether to
+      // reestablish the keyboard flag in _detectKeyboardFocus.
+      lastKeyboardFocusedElement = receivedFocusFromKeyboard ? this : null;
+    },
+
+    /**
+     * @param {!KeyboardEvent} event .
+     */
+    _enterKeyDownHandler: function(event) {
+      this._trackKeyboardFocusedElement(true);
+      this._asyncClick();
+    },
+
     /**
      * @param {!KeyboardEvent} event .
      */
@@ -179,6 +192,7 @@
 
       keyboardEvent.preventDefault();
       keyboardEvent.stopImmediatePropagation();
+      this._trackKeyboardFocusedElement(true);
       this._setPressed(true);
     },