[javascript] How to prevent sticky hover effects for buttons on touch devices

I have created a carousel with a previous and a next button that are always visible. These buttons have a hover state, they turn blue. On touch devices, like iPad, the hover state is sticky, so the button stays blue after tapping it. I don't want that.

  • I could add a no-hover class ontouchend for each button, and make my CSS like this: button:not(.no-hover):hover { background-color: blue; } but that's probably quite bad for performance, and doesn't handle devices like the Chromebook Pixel (which has both a touchscreen and a mouse) correctly.

  • I could add a touch class to the documentElement and make my CSS like this: html:not(.touch) button:hover { background-color: blue; } But that also doesn't work right on devices with both touch and a mouse.

What I would prefer is removing the hover state ontouchend. But it doesn't seem like that is possible. Focusing another element doesn't remove the hover state. Tapping another element manually does, but I can't seem to trigger that in JavaScript.

All the solutions I have found seem imperfect. Is there a perfect solution?

This question is related to javascript css hover touch

The answer is


I was going to post my own solution, but checking if someone already posted it, I found that @Rodney almost did it. However, he missed it one last crucial that made it uniseful, at least in my case. I mean, I too took the same .fakeHover class addition / removing via mouseenter and mouseleave event detection, but that alone, per se, acts almost exactly like "genuine" :hover. I mean: when you tap on a element in your table, it won't detect that you have "leaved" it - thus keeping the "fakehover" state.

What I did was simply to listen on click, too, so when I "tap" the button, I manually fire a mouseleave.

Si this is my final code:

.fakeHover {
    background-color: blue;
}


$(document).on('mouseenter', 'button.myButton',function(){
    $(this).addClass('fakeHover');
});

$(document).on('mouseleave', 'button.myButton',function(){
    $(this).removeClass('fakeHover');
});

$(document).on('button.myButton, 'click', function(){
    $(this).mouseleave();
});

This way you keep your usual hover functionality when using a mouse when simply "hovering" on your buttons. Well, almost all of it: the only drawback somehow is that, after clicking on the button with the mouse, it wont be in hover state. Much like if you clicked and quickly took the pointer out of the button. But in my case I can live with that.


What I did so far in my projects was was to revert the :hover changes on touch devices:

.myhoveredclass {
    background-color:green;
}
.myhoveredclass:hover {
    background-color:red;
}
@media screen and (-webkit-min-device-pixel-ratio:0) {
    .myhoveredclass:hover, .myhoveredclass:active, .myhoveredclass:focus {
        background-color:green;
    }
}

All class names and named colors just for demonstration purposes ;-)


Add this JS code to your page:

document.body.className = 'ontouchstart' in document.documentElement ? '' : 'hover';

now in your CSS before every hover add the hover class like this:

.hover .foo:hover {}

If the device is touch, the body class will be empty, otherwise its class will be hover and the rules are applied!


You could set background-color on :active state and give :focus the defaut background.

if you set background-color via onfocus/ontouch, color style remains once :focus state has gone.
You need a reset on onblur as well to restore defaut bg when focus is lost.


With Modernizr you can target your hovers specifically for no-touch devices:

(Note: this doesn't run on StackOverflow's snippet system, check the jsfiddle instead)

/* this one is sticky */
#regular:hover, #regular:active {
  opacity: 0.5;
}

/* this one isn't */
html.no-touch #no-touch:hover, #no-touch:active {
  opacity: 0.5;
}

Note that :active doesn't need to be targeted with .no-touch because it works as expected on both mobile and desktop.


This works perfectly in 2 steps.

  1. Set your body tag to be like this <body ontouchstart="">. I'm not a fan of this "hack", but it allows Safari on iOS to react to touches instantly. Not sure how, but it works.

  2. Set up your touchable class like this:

    // I did this in SASS, but this should work with normal CSS as well
    
    // Touchable class
    .example {
    
        // Default styles
        background: green;
    
        // Default hover styles 
        // (Think of this as Desktop and larger)
        &:hover {
            background: yellow;
        }
    
        // Default active styles
        &:active {
            background: red;
        }
    
        // Setup breakpoint for smaller device widths
        @media only screen and (max-width: 1048px) {
    
            // Important!
            // Reset touchable hover styles
            // You may want to use the same exact styles as the Default styles
            &:hover {
                background: green;
            }
    
            // Important!
            // Touchable active styles
            &:active {
                background: red;
            }
        }
    }
    

You may want to remove any animation on your touchable class as well. Android Chrome seems to be a little slower than iOS.

This will also result in the active state being applied if the user scrolls the page while touching your class.


From 4 ways to deal with sticky hover on mobile: Here's a way to dynamically add or remove a "can touch" class to the document based on the current input type of the user. It works with hybrid devices as well where the user may be switching between touch and a mouse/trackpad:

<script>

;(function(){
    var isTouch = false //var to indicate current input type (is touch versus no touch) 
    var isTouchTimer 
    var curRootClass = '' //var indicating current document root class ("can-touch" or "")

    function addtouchclass(e){
        clearTimeout(isTouchTimer)
        isTouch = true
        if (curRootClass != 'can-touch'){ //add "can-touch' class if it's not already present
            curRootClass = 'can-touch'
            document.documentElement.classList.add(curRootClass)
        }
        isTouchTimer = setTimeout(function(){isTouch = false}, 500) //maintain "istouch" state for 500ms so removetouchclass doesn't get fired immediately following a touch event
    }

    function removetouchclass(e){
        if (!isTouch && curRootClass == 'can-touch'){ //remove 'can-touch' class if not triggered by a touch event and class is present
            isTouch = false
            curRootClass = ''
            document.documentElement.classList.remove('can-touch')
        }
    }

    document.addEventListener('touchstart', addtouchclass, false) //this event only gets called when input type is touch
    document.addEventListener('mouseover', removetouchclass, false) //this event gets called when input type is everything from touch to mouse/ trackpad
})();

</script>

I think I've found an elegant (minimum js) solution for a similar problem:

Using jQuery, you can trigger hover on body (or any other element), using .mouseover()

So I simply attach a this handler to the element's ontouchend event like so:

_x000D_
_x000D_
var unhover = function() {_x000D_
  $("body").mousover();  _x000D_
};
_x000D_
.hoverable {_x000D_
  width: 100px;_x000D_
  height: 100px;_x000D_
  background: teal;_x000D_
  cursor: pointer;_x000D_
}_x000D_
_x000D_
.hoverable:hover {_x000D_
  background: pink;_x000D_
}
_x000D_
<div class="hoverable" ontouchend={unhover}></div>
_x000D_
_x000D_
_x000D_

This, however, only removes :hover pseudoclass from the element after some other touch event has been triggered, like swipe or another touch


This is what I have come up with so far after studying the rest of the answers. It should be able to support touch-only, mouse-only or hybrid users.

Create a separate hover class for the hover effect. By default, add this hover class to our button.

We do not want to detect the presence of touch support and disable all hover effects from the very beginning. As mentioned by others, hybrid devices are gaining popularity; people may have touch support but want to use a mouse and vice versa. Therefore, only remove the hover class when the user actually touches the button.

The next problem is, what if the user wants to go back to using a mouse after touching the button? To solve that, we need to find an opportune moment to add back the hover class which we have removed.

However, we cannot add it back immediately after removing it, because the hover state is still active. We may not want to destroy and recreate the entire button as well.

So, I thought of using a busy-waiting algorithm (using setInterval) to check the hover state. Once the hover state is deactivated, we can then add back the hover class and stop the busy-waiting, bringing us back to the original state where the user can use either mouse or touch.

I know busy-waiting isn't that great but I'm not sure if there is an appropriate event. I've considered to add it back in the mouseleave event, but it was not very robust. For example, when an alert pops up after the button is touched, the mouse position shifts but the mouseleave event is not triggered.

_x000D_
_x000D_
var button = document.getElementById('myButton');_x000D_
_x000D_
button.ontouchstart = function(e) {_x000D_
  console.log('ontouchstart');_x000D_
  $('.button').removeClass('button-hover');_x000D_
  startIntervalToResetHover();_x000D_
};_x000D_
_x000D_
button.onclick = function(e) {_x000D_
  console.log('onclick');_x000D_
}_x000D_
_x000D_
var intervalId;_x000D_
_x000D_
function startIntervalToResetHover() {_x000D_
  // Clear the previous one, if any._x000D_
  if (intervalId) {_x000D_
    clearInterval(intervalId);_x000D_
  }_x000D_
  _x000D_
  intervalId = setInterval(function() {_x000D_
    // Stop if the hover class already exists._x000D_
    if ($('.button').hasClass('button-hover')) {_x000D_
      clearInterval(intervalId);_x000D_
      intervalId = null;_x000D_
      return;_x000D_
    }_x000D_
    _x000D_
    // Checking of hover state from _x000D_
    // http://stackoverflow.com/a/8981521/2669960._x000D_
    var isHovered = !!$('.button').filter(function() {_x000D_
      return $(this).is(":hover");_x000D_
    }).length;_x000D_
    _x000D_
    if (isHovered) {_x000D_
      console.log('Hover state is active');_x000D_
    } else {_x000D_
      console.log('Hover state is inactive');_x000D_
      $('.button').addClass('button-hover');_x000D_
      console.log('Added back the button-hover class');_x000D_
      _x000D_
      clearInterval(intervalId);_x000D_
      intervalId = null;_x000D_
    }_x000D_
  }, 1000);_x000D_
}
_x000D_
.button {_x000D_
  color: green;_x000D_
  border: none;_x000D_
}_x000D_
_x000D_
.button-hover:hover {_x000D_
  background: yellow;_x000D_
  border: none;_x000D_
}_x000D_
_x000D_
.button:active {_x000D_
  border: none;_x000D_
}
_x000D_
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>_x000D_
<button id='myButton' class='button button-hover'>Hello</button>
_x000D_
_x000D_
_x000D_

Edit: Another approach I tried is to call e.preventDefault() within ontouchstart or ontouchend. It appears to stop the hover effect when the button is touched, but it also stops the button click animation and prevents the onclick function from being called when the button is touched, so you have to call those manually in the ontouchstart or ontouchend handler. Not a very clean solution.


A solution that has worked for me:

html {
   -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
}

Add this code to your stylesheet.

I wanted to get rid of the grey background that appears on iOS Safari when a link is clicked. But it appears to do more. Now clicking a button (with a :hover pseudoclass!) gets opened right away! I only tested it on an iPad, I don't know if it'll work on other devices.


Once CSS Media Queries Level 4 is implemented, you'll be able to do this:

@media (hover: hover) {
    button:hover {
        background-color: blue;
    }
}

Or in English: "If the browser supports proper/true/real/non-emulated hovering (e.g. has a mouse-like primary input device), then apply this style when buttons are hovered over."

Since this part of Media Queries Level 4 has so far only been implemented in bleeding-edge Chrome, I wrote a polyfill to deal with this. Using it, you can transform the above futuristic CSS into:

html.my-true-hover button:hover {
    background-color: blue;
}

(A variation on the .no-touch technique) And then using some client-side JavaScript from the same polyfill that detects support for hovering, you can toggle the presence of the my-true-hover class accordingly:

$(document).on('mq4hsChange', function (e) {
    $(document.documentElement).toggleClass('my-true-hover', e.trueHover);
});

You can override the hover effect for devices that don't support hover. Like:

.my-thing {
    color: #BADA55;
}

.my-thing:hover {
    color: hotpink;
}

@media (hover: none) {
    .my-thing {
        color: #BADA55;
    }
}

Tested and verified on iOS 12

Hat tip to https://stackoverflow.com/a/50285058/178959 for pointing this out.


This worked for me: put the hover styling in a new class

.fakehover {background: red}

Then add / remove the class as and when required

$(".someclass > li").on("mouseenter", function(e) {
  $(this).addClass("fakehover");
});
$(".someclass > li").on("mouseleave", function(e) {
  $(this).removeClass("fakehover");
});

Repeat for touchstart and touchend events. Or whatever events you like to get the desired result, for example I wanted the hover effect to be toggled on a touch screen.


Thats too easy to use javascrpt. thats not hover problem thats focus problem. set outline to none when focus using css.

.button:focus {
outline: none;
}    

$("#elementwithhover").click(function() { 
  // code that makes element or parent slide or otherwise move out from under mouse. 

  $(this).clone(true).insertAfter($(this));
  $(this).remove();
});

I could add a no-hover class ontouchend for each button, and make my CSS like >this: button:not(.no-hover):hover { background-color: blue; } but that's probably quite bad for performance, and doesn't handle >devices like the Chromebook Pixel (which has both a touchscreen and a mouse) >correctly.

This is the right starting point. Next step: apply/remove nohover class on following events (demo with jQuery)

buttonelement
 .on("touchend touchcancel",function(){$(this).addClass("nohover")})
 .on("touchstart mouseover",function({$(this).removeClass("nohover")});   

Notice: If You wish to apply other classes to the buttonelement, the :not(.nohover) in the CSS won't work anymore as expected. Than You have to add instead a separate definition with default value and !important tag to overwrite hover style: .nohover{ background-color: white !important}

This should even handle devices like the Chromebook Pixel (which has both a touchscreen and a mouse) correctly! And I don't think, that this a major performance killer...


I went through the similar problem, my application was compatible for all screen sizes had a hell lot of hover effects in the desktop-screen-size / mouse based devices , and later on I realised that touch based devices were causing a condition known as sticky-hover and it was an hurdle for the app to work properly for touch based device users.

We were making use of SCSS in our app. and I defined a mixin to take care of touch based device.

@mixin hover-support {
  @media not all and (pointer: coarse) {
    &:hover {
      @content;
    }
  }
}

and then I placed all my css classes under the below-mentioned snippet.

   @include hover-support() {
    // Your css-classes or css that you want to apply on those devices that support hover.
   }

For instance we had a class for animating an icon, and which used to trigger once we hover over icon as you can see it from css, but in touch based device it was getting affected by sticky hover-effect and then I placed it inside @include hover-support() in order to ensure that hover only applies to those devices that support hover.

@include hover-support() {
  .animate-icon {
    -webkit-transition: all 0.2s;
    transition: all 0.2s;
    &:hover {
      transform: scale(1.3);
      filter: brightness(85%);
      cursor: pointer;
    }
  }
}

I have nice solution that i would like to share. First you need to detect if user is on mobile like this:

var touchDevice = /ipad|iphone|android|windows phone|blackberry/i.test(navigator.userAgent.toLowerCase());

Then just add:

if (!touchDevice) {
    $(".navbar-ul").addClass("hoverable");
}

And in CSS:

.navbar-ul.hoverable li a:hover {
    color: #fff;
}

This is a common problem with no perfect solution. Hover behavior is useful with a mouse and mostly detrimental with touch. Compounding the problem are devices which support touch and mouse (simultaneously, no less!) like the Chromebook Pixel and Surface.

The cleanest solution I've found is to only enable hover behavior if the device isn't deemed to support touch input.

var isTouch =  !!("ontouchstart" in window) || window.navigator.msMaxTouchPoints > 0;

if( !isTouch ){
    // add class which defines hover behavior
}

Granted, you lose hover on devices which may support it. However, sometimes hover impacts more than the link itself, e.g. perhaps you want to show a menu when an element is hovered. This approach allows you to test for the existence of touch and perhaps conditionally attach a different event.

I've tested this on the iPhone, iPad, Chromebook Pixel, Surface, and a variety of Android devices. I can't guarantee that it will work when a generic USB touch input (such as a stylus) is added to the mix.


It was helpful for me: link

function hoverTouchUnstick() {
    // Check if the device supports touch events
    if('ontouchstart' in document.documentElement) {
        // Loop through each stylesheet
        for(var sheetI = document.styleSheets.length - 1; sheetI >= 0; sheetI--) {
            var sheet = document.styleSheets[sheetI];
            // Verify if cssRules exists in sheet
            if(sheet.cssRules) {
                // Loop through each rule in sheet
                for(var ruleI = sheet.cssRules.length - 1; ruleI >= 0; ruleI--) {
                    var rule = sheet.cssRules[ruleI];
                    // Verify rule has selector text
                    if(rule.selectorText) {
                        // Replace hover psuedo-class with active psuedo-class
                        rule.selectorText = rule.selectorText.replace(":hover", ":active");
                    }
                }
            }
        }
    }
}

From 2020 You can add hover styles inside media query

@media (hover: hover) and (pointer: fine) {
    /* css hover class/style */
}

This media query indicates that styles will work on browsers that not emulate :hover so it will NOT work on touch browsers.


Based on Darren Cooks answer which also works if you moved your finger over another element.

See Find element finger is on during a touchend event

jQuery(function() {
    FastClick.attach(document.body);
});
// Prevent sticky hover effects for buttons on touch devices
// From https://stackoverflow.com/a/17234319
//
//
// Usage:
// <a href="..." touch-focus-fix>..</a>
//
// Refactored from a directive for better performance and compability
jQuery(document.documentElement).on('touchend', function(event) {
  'use strict';

  function fix(sourceElement) {
    var el = $(sourceElement).closest('[touch-focus-fix]')[0];
    if (!el) {
      return;
    }
    var par = el.parentNode;
    var next = el.nextSibling;
    par.removeChild(el);
    par.insertBefore(el, next);
  }

  fix(event.target);
  var changedTouch = event.originalEvent.changedTouches[0];
  // http://www.w3.org/TR/2011/WD-touch-events-20110505/#the-touchend-event
  if (!changedTouch) {
    return;
  }
  var touchTarget = document.elementFromPoint(changedTouch.clientX, changedTouch.clientY);
  if (touchTarget && touchTarget !== event.target) {
    fix(touchTarget);
  }
});

Codepen Demo


The solution for me was after touchend was to clone and replace the node... i hate doing this but even trying to repaint the element with offsetHeight wasn't working

    let cloneNode = originNode.cloneNode( true );
    originNode.parentNode.replaceChild( cloneNode, originNode );

It can be accomplished by swapping an HTML class. It should be less prone to glitches than removing the whole element, especially with large, image links etc.

We can also decide whether we want hover states to be triggered when scrolling with touch (touchmove) or even add a timeout to delay them.

The only significant change in our code will be using additional HTML class such as <a class='hover'></a> on elements that implement the new behaviour.

HTML

<a class='my-link hover' href='#'>
    Test
</a>

CSS

.my-link:active, // :active can be turned off to disable hover state on 'touchmove'
.my-link.hover:hover {

    border: 2px dotted grey;
}

JS (with jQuery)

$('.hover').bind('touchstart', function () {

   var $el;
   $el = $(this);
   $el.removeClass('hover'); 

   $el.hover(null, function () {
      $el.addClass('hover');
   });
});

Example

https://codepen.io/mattrcouk/pen/VweajZv

-

I don’t have any device with both mouse and touch to test it properly, though.


You can try this way.

javascript:

var isEventSupported = function (eventName, elementName) {
    var el = elementName ? document.createElement(elementName) : window;
    eventName = 'on' + eventName;
    var isSupported = (eventName in el);
    if (!isSupported && el.setAttribute) {
        el.setAttribute(eventName, 'return;');
        isSupported = typeof el[eventName] == 'function';
    }
    el = null;
    return isSupported;
};

if (!isEventSupported('touchstart')) {
    $('a').addClass('with-hover');
}

css:

a.with-hover:hover {
  color: #fafafa;
}

Some of the sticky or stuck :hover :focus :active problems on mobile devices may be caused by missing <meta name="viewport" content="width=device-width"> as the browsers try to manipulate the screen.


Here's some simple JavaScript code that doesn't require the developer to edit CSS or write any new CSS rules. I wrote this for Bootstrap buttons with class="btn", but it will work with any button that has a specific class name.

The steps are:

  1. determine if this is a touch device
  2. if it is, iterate over every CSS rule in document.styleSheets
  3. delete any rule containing both .btn and :hover

The elimination of all .btn :hover CSS rules ensures that there will be no visual hover effect on a button.

Step 1: Detect Touch Device

Check media query for presence of (hover: none):

    const hasMatchMedia = typeof window.matchMedia !== 'undefined';
    /**
     * determine if device is touch-capable
     * true - device is touch-capable
     * false - device is not touch-capable
     * null - unable to determine touch capability
     * @return {null|boolean}
     */
    const hasTouch = () => {
      if (hasMatchMedia) {
        return window.matchMedia('(hover: none)').matches;
      }
      return null;
    };

Step 2: Delete CSS Rules Containing `btn` and `:hover`

    /**
     * remove all CSS rules contaning both '.btn' and ':hover'
     * @return {number} count of rules deleted
     */
    function removeBtnHovers () {

      let rulesDeleted = 0;

      // recursively delete '.btn:hover' rules
      function recursiveDelete (rules, styleSheet) {

        if (typeof rules === 'undefined' ||
          typeof rules.length === 'undefined' ||
          rules.length <= 0) {
          return;
        }

        // iterate in reverse order,
        // deleting any rule containing both '.btn' and ':hover'
        const ruleLen = rules.length;
        for (let i = ruleLen - 1; i >= 0; i--) {
          const rule = rules[i];
          if (typeof rule.cssRules === 'undefined') {
            // a standard rule, evaluate it
            const cssText = rule.cssText;
            if (typeof cssText === 'string' &&
              cssText.includes('.btn') &&
              cssText.includes(':hover')) {
              styleSheet.deleteRule(i);
              rulesDeleted++;
            }
          } else {
            // rule contains cssRules, iterate over them
            recursiveDelete(rule.cssRules, rule);
          }
        }
      }

      // iterate over all style sheets in document
      for (const styleSheet of document.styleSheets) {
        let rules = styleSheet.cssRules;
        if (!rules) { continue; }
        recursiveDelete(rules, styleSheet);
      }
      return rulesDeleted;
    }

Complete code is on GitHub and npm.

Live demo at terrymorse.com.


Examples related to javascript

need to add a class to an element How to make a variable accessible outside a function? Hide Signs that Meteor.js was Used How to create a showdown.js markdown extension Please help me convert this script to a simple image slider Highlight Anchor Links when user manually scrolls? Summing radio input values How to execute an action before close metro app WinJS javascript, for loop defines a dynamic variable name Getting all files in directory with ajax

Examples related to css

need to add a class to an element Using Lato fonts in my css (@font-face) Please help me convert this script to a simple image slider Why there is this "clear" class before footer? How to set width of mat-table column in angular? Center content vertically on Vuetify bootstrap 4 file input doesn't show the file name Bootstrap 4: responsive sidebar menu to top navbar Stylesheet not loaded because of MIME-type Force flex item to span full row width

Examples related to hover

Angular 2 Hover event How can I access a hover state in reactjs? CSS disable hover effect How to remove/ignore :hover css style on touch devices Spin or rotate an image on hover How to make in CSS an overlay over an image? How to display and hide a div with CSS? simple Jquery hover enlarge Changing image on hover with CSS/HTML CSS On hover show another element

Examples related to touch

Consider marking event handler as 'passive' to make the page more responsive Touch move getting stuck Ignored attempt to cancel a touchmove How to remove/ignore :hover css style on touch devices Fix CSS hover on iPhone/iPad/iPod How to prevent sticky hover effects for buttons on touch devices Draw in Canvas by finger, Android Disable scrolling when touch moving certain element How to implement swipe gestures for mobile devices? Prevent Android activity dialog from closing on outside touch Media query to detect if device is touchscreen