repport new changes from layouts

Author: Neradoc

adafruit_hid/keyboard_layout_base.py

@@ -7,8 +7,8 @@
 """
 
 
-__version__ = "2.0.0-auto.0"
-__repo__ = "https://github.com/Neradoc/Circuitpython_Keyboard_Layouts.git"
+__version__ = "0.0.0-auto.0"
+__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_HID.git"
 
 
 class KeyboardLayoutBase:
@@ -35,15 +35,14 @@ def __init__(self, keyboard):
         """
         self.keyboard = keyboard
 
-    def _write(self, char, keycode, altgr=False):
-        if keycode == 0:
-            raise ValueError(
-                "No keycode available for character {letter} ({num}/0x{num:02x}).".format(
-                    letter=repr(char), num=ord(char)
-                )
-            )
+    def _write(self, keycode, altgr=False):
+        """Type a key combination based on shift bit and altgr bool
+        
+        :param keycode: int value of the keycode, with the shift bit.
+        :param altgr: bool indicating if the altgr key should be pressed too.
+        """
+        # Add altgr modifier if needed
         if altgr:
-            # Add altgr modifier
             self.keyboard.press(self.RIGHT_ALT_CODE)
         # If this is a shifted char, clear the SHIFT flag and press the SHIFT key.
         if keycode & self.SHIFT_FLAG:
@@ -56,22 +55,24 @@ def write(self, string):
         """Type the string by pressing and releasing keys on my keyboard.
 
         :param string: A string of ASCII characters.
-        :raises ValueError: if any of the characters are not ASCII or have no keycode
+        :raises ValueError: if any of the characters has no keycode
             (such as some control characters).
         """
         for char in string:
             # find easy ones first
             keycode = self._char_to_keycode(char)
             if keycode > 0:
-                self._write(char, keycode, char in self.NEED_ALTGR)
+                self._write(keycode, char in self.NEED_ALTGR)
             # find combined keys
-            elif char in self.COMBINED_KEYS:
-                cchar = self.COMBINED_KEYS[char]
-                self._write(char, (cchar >> 8), (cchar & 0xFF & self.ALTGR_FLAG))
+            elif ord(char) in self.COMBINED_KEYS:
+                # first key (including shift bit)
+                cchar = self.COMBINED_KEYS[ord(char)]
+                self._write(cchar >> 8, cchar & self.ALTGR_FLAG)
+                # second key (removing the altgr bit)
                 char = chr(cchar & 0xFF & (~self.ALTGR_FLAG))
                 keycode = self._char_to_keycode(char)
                 # assume no altgr needed for second key
-                self._write(char, keycode, False)
+                self._write(keycode, False)
             else:
                 raise ValueError(
                     "No keycode available for character {letter} ({num}/0x{num:02x}).".format(
@@ -82,10 +83,9 @@ def write(self, string):
     def keycodes(self, char):
         """Return a tuple of keycodes needed to type the given character.
 
-        :param char: A single ASCII character in a string.
+        :param char: A single UTF8 character in a string.
         :type char: str of length one.
         :returns: tuple of Keycode keycodes.
-        :raises ValueError: if ``char`` is not ASCII or there is no keycode for it.
         """
         keycode = self._char_to_keycode(char)
         if keycode == 0:
@@ -104,16 +104,15 @@ def keycodes(self, char):
     def _above128char_to_keycode(self, char):
         """Return keycode for above 128 ascii codes.
 
-        Since the values are sparse, this may be more space efficient than bloating the table above
-        or adding a dict.
+        A character can be indexed by the char itself or its int ord() value.
 
         :param char_val: ascii char value
         :return: keycode, with modifiers if needed
         """
-        if char in self.HIGHER_ASCII:
-            return self.HIGHER_ASCII[char]
         if ord(char) in self.HIGHER_ASCII:
             return self.HIGHER_ASCII[ord(char)]
+        if char in self.HIGHER_ASCII:
+            return self.HIGHER_ASCII[char]
         return 0
 
     def _char_to_keycode(self, char):