wxPython 4: detection of double keystroke

Question

Is there a way with wxPython 4 to recognize double pressing the same key? Especially in my case, I would like to recognize when the SHIFT key is pressed twice in quick succession.

Answer 1

This by no means as obvious as it first looks.

The code below, uses a "one-shot" wx.Timer to re-set the previous key after 250 milliseconds, to resolve the issue of "in quick succession". You can of course set it to whatever is appropriate. For older versions of wxPython the timer does not have the StartOnce option, you would have to use Start(250, oneShot=True)

I have slight complicated it by allowing for keys other than Shift and the dictionary of names is just for test purposes.

I should point out that, because this has to check every key depression, it isn't very efficient but I suppose that you are aware of that and are willing to pay the price.

I do have one caveat, I do not know how holding a key down, such as the shift key, will react on a non Linux machine. If it proves not to be like Linux, then you should change the Bind from wx.EVT_KEY_DOWN to wx.EVT_KEY_UP.

import wx
import time
class Frame(wx.Frame):

    def __init__(self, parent):
        wx.Frame.__init__ (self, parent, -1, title = "Test Frame", size = (500,360))

        self.text_window = wx.TextCtrl(self, wx.ID_ANY, "", size = (450,250), style = wx.TE_MULTILINE)
        self.text_window.Bind(wx.EVT_KEY_DOWN, self.key_info)

        #Define a timer to reset the key values
        self.key_timer = wx.Timer(self)
        self.Bind(wx.EVT_TIMER, self.Ontimer, self.key_timer)

        #Define storage for the previous key
        self.prev_key = 0

        #Define the set of double keys we are looking for and a dict  of their names
        # Shift is 306 (on my keyboard), Alt is 307 and Ctrl is 308
        self.double_keys = (306,307,308)
        self.names = {'306':'Shift','307':'Alt','308':'Ctrl'}

        sizer1= wx.BoxSizer(wx.VERTICAL)
        sizer1.Add(self.text_window, 0, wx.ALL, 5)
        self.SetSizer(sizer1)
        self.Show()

    def key_info(self, event):
        self.key = event.GetKeyCode()
        if self.key in self.double_keys and self.prev_key == self.key:
            self.text_window.AppendText("Double key "+self.names[str(self.key)]+" used within a quarter second\n")
        self.prev_key = self.key
        #fire up the timer to execute once to reset the previous key
        if self.key in self.double_keys:
            self.key_timer.StartOnce(250)
        # Skip so this doesn't consume the key event itself
        event.Skip()

    def Ontimer(self,event):
        # Re-set the previous key after 250 milliseconds
        self.prev_key = 0

app = wx.App()
frame = Frame(None)
app.MainLoop()

Answer 2

I think the problem is, that he does not want to get informed, when several keys are triggered at once, but shorty after one another. I did not find a native way to do it, so I tried it myself. My solution results in ugly state within the TestFrame, so I would be interested as well, if a native approach exists within wxPython.

import wx
import time

class TestFrame(wx.Frame):
    def __init__(self, parent):
        wx.Frame.__init__(self, parent)

        self._keyCounter = 0
        self._lastKeyTs = -1

        sizer = wx.BoxSizer(wx.VERTICAL)
        self.Bind(wx.EVT_KEY_DOWN, self._OnKeyDown)
        self.SetSizer(sizer)

    def _OnKeyDown(self, event):
        self._keyCounter += 1
        if self._keyCounter % 2 == 0 and time.time() - self._lastKeyTs < 0.3:
            print "Trigger"
        self._lastKeyTs = time.time()

class App(wx.App):
    def OnInit(self):
        frmMain = TestFrame(None)
        frmMain.SetSize(wx.Size(800, 600))

        frmMain.Show()

        return True


if __name__ == '__main__':
    application = App(False)
    application.MainLoop()

Answer 3

Here is a more general solution

The event EVT_CHAR_HOOK is used instead of EVT_KEY_UP. The problem with EVT_KEY_UP is that it is swallowed when the event is bound to a frame that contains a panel.

The challenge with EVT_CHAR_HOOK is to determine whether the key is actually pressed twice or only held. Therefore the RawKeyFlags are read out. The bit at position 30 indicates whether the key was held or not.

Please note, however, that this solution only works on Windows systems!

import wx

class DoubleKeyStrokeListener(object):
    def __init__(self, parent, keyCode, callback, timeout=500):
        self._monitoredKey = keyCode
        self._callback = callback
        self._timeout = timeout

        self._firstPressRecognized = False
        self._keyTimer = wx.Timer(parent)

        parent.Bind(wx.EVT_CHAR_HOOK, self._OnKeyPressed)
        parent.Bind(wx.EVT_TIMER, self._OnTimer, self._keyTimer)

    def _OnKeyPressed(self, event):
        event.Skip()

        pressedKey = event.GetKeyCode()

        if pressedKey == self._monitoredKey:
            rawFlags = event.GetRawKeyFlags()

            # bit at position 30 is "previous key state" flag
            prevStateBit = rawFlags >> 30 & 1

            if prevStateBit == 1:  # -> key is held
                return

            if self._firstPressRecognized:
                self._firstPressRecognized = False
                self._callback(event)
            else:
                self._firstPressRecognized = True
                self._keyTimer.StartOnce(self._timeout)
        else:
            self._firstPressRecognized = False

    def _OnTimer(self, event):
        self._firstPressRecognized = False
        event.Skip()