logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

keyboard.py (12240B)

    

  1. """Functions that help us work with keyboards.
  2. """
  3. from array import array
  4. from functools import lru_cache
  5. from math import ceil
  6. from pathlib import Path
  7. import os
  8. from glob import glob
  10. import qmk.path
  11. from qmk.c_parse import parse_config_h_file
  12. from qmk.json_schema import json_load
  13. from qmk.makefile import parse_rules_mk_file
  15. BOX_DRAWING_CHARACTERS = {
  16.     "unicode": {
  17.         "tl": "┌",
  18.         "tr": "┐",
  19.         "bl": "└",
  20.         "br": "┘",
  21.         "v": "│",
  22.         "h": "─",
  23.     },
  24.     "ascii": {
  25.         "tl": " ",
  26.         "tr": " ",
  27.         "bl": "|",
  28.         "br": "|",
  29.         "v": "|",
  30.         "h": "_",
  31.     },
  32. }
  33. ENC_DRAWING_CHARACTERS = {
  34.     "unicode": {
  35.         "tl": "╭",
  36.         "tr": "╮",
  37.         "bl": "╰",
  38.         "br": "╯",
  39.         "vl": "▲",
  40.         "vr": "▼",
  41.         "v": "│",
  42.         "h": "─",
  43.     },
  44.     "ascii": {
  45.         "tl": " ",
  46.         "tr": " ",
  47.         "bl": "\\",
  48.         "br": "/",
  49.         "v": "|",
  50.         "vl": "/",
  51.         "vr": "\\",
  52.         "h": "_",
  53.     },
  54. }
  57. class AllKeyboards:
  58.     """Represents all keyboards.
  59.     """
  60.     def __str__(self):
  61.         return 'all'
  63.     def __repr__(self):
  64.         return 'all'
  66.     def __eq__(self, other):
  67.         return isinstance(other, AllKeyboards)
  70. base_path = os.path.join(os.getcwd(), "keyboards") + os.path.sep
  73. @lru_cache(maxsize=1)
  74. def keyboard_alias_definitions():
  75.     return json_load(Path('data/mappings/keyboard_aliases.hjson'))
  78. def is_all_keyboards(keyboard):
  79.     """Returns True if the keyboard is an AllKeyboards object.
  80.     """
  81.     if isinstance(keyboard, str):
  82.         return (keyboard == 'all')
  83.     return isinstance(keyboard, AllKeyboards)
  86. def find_keyboard_from_dir():
  87.     """Returns a keyboard name based on the user's current directory.
  88.     """
  89.     relative_cwd = qmk.path.under_qmk_userspace()
  90.     if not relative_cwd:
  91.         relative_cwd = qmk.path.under_qmk_firmware()
  93.     if relative_cwd and len(relative_cwd.parts) > 1 and relative_cwd.parts[0] == 'keyboards':
  94.         # Attempt to extract the keyboard name from the current directory
  95.         current_path = Path('/'.join(relative_cwd.parts[1:]))
  97.         if 'keymaps' in current_path.parts:
  98.             # Strip current_path of anything after `keymaps`
  99.             keymap_index = len(current_path.parts) - current_path.parts.index('keymaps') - 1
  100.             current_path = current_path.parents[keymap_index]
  102.         current_path = resolve_keyboard(current_path)
  104.         if qmk.path.is_keyboard(current_path):
  105.             return str(current_path)
  108. def find_readme(keyboard):
  109.     """Returns the readme for this keyboard.
  110.     """
  111.     cur_dir = qmk.path.keyboard(keyboard)
  112.     keyboards_dir = Path('keyboards')
  113.     while not (cur_dir / 'readme.md').exists():
  114.         if cur_dir == keyboards_dir:
  115.             return None
  116.         cur_dir = cur_dir.parent
  118.     return cur_dir / 'readme.md'
  121. def keyboard_folder(keyboard):
  122.     """Returns the actual keyboard folder.
  124.     This checks aliases and DEFAULT_FOLDER to resolve the actual path for a keyboard.
  125.     """
  126.     aliases = keyboard_alias_definitions()
  128.     while keyboard in aliases:
  129.         last_keyboard = keyboard
  130.         keyboard = aliases[keyboard].get('target', keyboard)
  131.         if keyboard == last_keyboard:
  132.             break
  134.     keyboard = resolve_keyboard(keyboard)
  136.     if not qmk.path.is_keyboard(keyboard):
  137.         raise ValueError(f'Invalid keyboard: {keyboard}')
  139.     return keyboard
  142. def keyboard_aliases(keyboard):
  143.     """Returns the list of aliases for the supplied keyboard.
  145.     Includes the keyboard itself.
  146.     """
  147.     aliases = json_load(Path('data/mappings/keyboard_aliases.hjson'))
  149.     if keyboard in aliases:
  150.         keyboard = aliases[keyboard].get('target', keyboard)
  152.     keyboards = set(filter(lambda k: aliases[k].get('target', '') == keyboard, aliases.keys()))
  153.     keyboards.add(keyboard)
  154.     keyboards = list(sorted(keyboards))
  155.     return keyboards
  158. def keyboard_folder_or_all(keyboard):
  159.     """Returns the actual keyboard folder.
  161.     This checks aliases and DEFAULT_FOLDER to resolve the actual path for a keyboard.
  162.     If the supplied argument is "all", it returns an AllKeyboards object.
  163.     """
  164.     if keyboard == 'all':
  165.         return AllKeyboards()
  167.     return keyboard_folder(keyboard)
  170. def _find_name(path):
  171.     """Determine the keyboard name by stripping off the base_path and filename.
  172.     """
  173.     return path.replace(base_path, "").rsplit(os.path.sep, 1)[0]
  176. def keyboard_completer(prefix, action, parser, parsed_args):
  177.     """Returns a list of keyboards for tab completion.
  178.     """
  179.     return list_keyboards()
  182. def list_keyboards(resolve_defaults=True):
  183.     """Returns a list of all keyboards - optionally processing any DEFAULT_FOLDER.
  184.     """
  185.     # We avoid pathlib here because this is performance critical code.
  186.     paths = []
  187.     for marker in ['rules.mk', 'keyboard.json']:
  188.         kb_wildcard = os.path.join(base_path, "**", marker)
  189.         paths += [path for path in glob(kb_wildcard, recursive=True) if os.path.sep + 'keymaps' + os.path.sep not in path]
  191.     found = map(_find_name, paths)
  192.     if resolve_defaults:
  193.         found = map(resolve_keyboard, found)
  195.     return sorted(set(found))
  198. @lru_cache(maxsize=None)
  199. def resolve_keyboard(keyboard):
  200.     cur_dir = Path('keyboards')
  201.     rules = parse_rules_mk_file(cur_dir / keyboard / 'rules.mk')
  202.     while 'DEFAULT_FOLDER' in rules and keyboard != rules['DEFAULT_FOLDER']:
  203.         keyboard = rules['DEFAULT_FOLDER']
  204.         rules = parse_rules_mk_file(cur_dir / keyboard / 'rules.mk')
  205.     return keyboard
  208. def config_h(keyboard):
  209.     """Parses all the config.h files for a keyboard.
  211.     Args:
  212.         keyboard: name of the keyboard
  214.     Returns:
  215.         a dictionary representing the content of the entire config.h tree for a keyboard
  216.     """
  217.     config = {}
  218.     cur_dir = Path('keyboards')
  219.     keyboard = Path(resolve_keyboard(keyboard))
  221.     for dir in keyboard.parts:
  222.         cur_dir = cur_dir / dir
  223.         config = {**config, **parse_config_h_file(cur_dir / 'config.h')}
  225.     return config
  228. def rules_mk(keyboard):
  229.     """Get a rules.mk for a keyboard
  231.     Args:
  232.         keyboard: name of the keyboard
  234.     Returns:
  235.         a dictionary representing the content of the entire rules.mk tree for a keyboard
  236.     """
  237.     cur_dir = Path('keyboards')
  238.     keyboard = Path(resolve_keyboard(keyboard))
  239.     rules = parse_rules_mk_file(cur_dir / keyboard / 'rules.mk')
  241.     for i, dir in enumerate(keyboard.parts):
  242.         cur_dir = cur_dir / dir
  243.         rules = parse_rules_mk_file(cur_dir / 'rules.mk', rules)
  245.     return rules
  248. def render_layout(layout_data, render_ascii, key_labels=None):
  249.     """Renders a single layout.
  250.     """
  251.     textpad = [array('u', ' ' * 200) for x in range(100)]
  252.     style = 'ascii' if render_ascii else 'unicode'
  254.     for key in layout_data:
  255.         x = key.get('x', 0)
  256.         y = key.get('y', 0)
  257.         w = key.get('w', 1)
  258.         h = key.get('h', 1)
  260.         if key_labels:
  261.             label = key_labels.pop(0)
  262.             if label.startswith('KC_'):
  263.                 label = label[3:]
  264.         else:
  265.             label = key.get('label', '')
  267.         if 'encoder' in key:
  268.             render_encoder(textpad, x, y, w, h, label, style)
  269.         elif x >= 0.25 and w == 1.25 and h == 2:
  270.             render_key_isoenter(textpad, x, y, w, h, label, style)
  271.         elif w == 1.5 and h == 2:
  272.             render_key_baenter(textpad, x, y, w, h, label, style)
  273.         else:
  274.             render_key_rect(textpad, x, y, w, h, label, style)
  276.     lines = []
  277.     for line in textpad:
  278.         if line.tounicode().strip():
  279.             lines.append(line.tounicode().rstrip())
  281.     return '\n'.join(lines)
  284. def render_layouts(info_json, render_ascii):
  285.     """Renders all the layouts from an `info_json` structure.
  286.     """
  287.     layouts = {}
  289.     for layout in info_json['layouts']:
  290.         layout_data = info_json['layouts'][layout]['layout']
  291.         layouts[layout] = render_layout(layout_data, render_ascii)
  293.     return layouts
  296. def render_key_rect(textpad, x, y, w, h, label, style):
  297.     box_chars = BOX_DRAWING_CHARACTERS[style]
  298.     x = ceil(x * 4)
  299.     y = ceil(y * 3)
  300.     w = ceil(w * 4)
  301.     h = ceil(h * 3)
  303.     label_len = w - 2
  304.     label_leftover = label_len - len(label)
  306.     if len(label) > label_len:
  307.         label = label[:label_len]
  309.     label_blank = ' ' * label_len
  310.     label_border = box_chars['h'] * label_len
  311.     label_middle = label + ' ' * label_leftover
  313.     top_line = array('u', box_chars['tl'] + label_border + box_chars['tr'])
  314.     lab_line = array('u', box_chars['v'] + label_middle + box_chars['v'])
  315.     mid_line = array('u', box_chars['v'] + label_blank + box_chars['v'])
  316.     bot_line = array('u', box_chars['bl'] + label_border + box_chars['br'])
  318.     textpad[y][x:x + w] = top_line
  319.     textpad[y + 1][x:x + w] = lab_line
  320.     for i in range(h - 3):
  321.         textpad[y + i + 2][x:x + w] = mid_line
  322.     textpad[y + h - 1][x:x + w] = bot_line
  325. def render_key_isoenter(textpad, x, y, w, h, label, style):
  326.     box_chars = BOX_DRAWING_CHARACTERS[style]
  327.     x = ceil(x * 4)
  328.     y = ceil(y * 3)
  329.     w = ceil(w * 4)
  330.     h = ceil(h * 3)
  332.     label_len = w - 1
  333.     label_leftover = label_len - len(label)
  335.     if len(label) > label_len:
  336.         label = label[:label_len]
  338.     label_blank = ' ' * (label_len - 1)
  339.     label_border_top = box_chars['h'] * label_len
  340.     label_border_bottom = box_chars['h'] * (label_len - 1)
  341.     label_middle = label + ' ' * label_leftover
  343.     top_line = array('u', box_chars['tl'] + label_border_top + box_chars['tr'])
  344.     lab_line = array('u', box_chars['v'] + label_middle + box_chars['v'])
  345.     crn_line = array('u', box_chars['bl'] + box_chars['tr'] + label_blank + box_chars['v'])
  346.     mid_line = array('u', box_chars['v'] + label_blank + box_chars['v'])
  347.     bot_line = array('u', box_chars['bl'] + label_border_bottom + box_chars['br'])
  349.     textpad[y][x - 1:x + w] = top_line
  350.     textpad[y + 1][x - 1:x + w] = lab_line
  351.     textpad[y + 2][x - 1:x + w] = crn_line
  352.     textpad[y + 3][x:x + w] = mid_line
  353.     textpad[y + 4][x:x + w] = mid_line
  354.     textpad[y + 5][x:x + w] = bot_line
  357. def render_key_baenter(textpad, x, y, w, h, label, style):
  358.     box_chars = BOX_DRAWING_CHARACTERS[style]
  359.     x = ceil(x * 4)
  360.     y = ceil(y * 3)
  361.     w = ceil(w * 4)
  362.     h = ceil(h * 3)
  364.     label_len = w + 1
  365.     label_leftover = label_len - len(label)
  367.     if len(label) > label_len:
  368.         label = label[:label_len]
  370.     label_blank = ' ' * (label_len - 3)
  371.     label_border_top = box_chars['h'] * (label_len - 3)
  372.     label_border_bottom = box_chars['h'] * label_len
  373.     label_middle = label + ' ' * label_leftover
  375.     top_line = array('u', box_chars['tl'] + label_border_top + box_chars['tr'])
  376.     mid_line = array('u', box_chars['v'] + label_blank + box_chars['v'])
  377.     crn_line = array('u', box_chars['tl'] + box_chars['h'] + box_chars['h'] + box_chars['br'] + label_blank + box_chars['v'])
  378.     lab_line = array('u', box_chars['v'] + label_middle + box_chars['v'])
  379.     bot_line = array('u', box_chars['bl'] + label_border_bottom + box_chars['br'])
  381.     textpad[y][x:x + w] = top_line
  382.     textpad[y + 1][x:x + w] = mid_line
  383.     textpad[y + 2][x:x + w] = mid_line
  384.     textpad[y + 3][x - 3:x + w] = crn_line
  385.     textpad[y + 4][x - 3:x + w] = lab_line
  386.     textpad[y + 5][x - 3:x + w] = bot_line
  389. def render_encoder(textpad, x, y, w, h, label, style):
  390.     box_chars = ENC_DRAWING_CHARACTERS[style]
  391.     x = ceil(x * 4)
  392.     y = ceil(y * 3)
  393.     w = ceil(w * 4)
  394.     h = ceil(h * 3)
  396.     label_len = w - 2
  397.     label_leftover = label_len - len(label)
  399.     if len(label) > label_len:
  400.         label = label[:label_len]
  402.     label_blank = ' ' * label_len
  403.     label_border = box_chars['h'] * label_len
  404.     label_middle = label + ' ' * label_leftover
  406.     top_line = array('u', box_chars['tl'] + label_border + box_chars['tr'])
  407.     lab_line = array('u', box_chars['vl'] + label_middle + box_chars['vr'])
  408.     mid_line = array('u', box_chars['v'] + label_blank + box_chars['v'])
  409.     bot_line = array('u', box_chars['bl'] + label_border + box_chars['br'])
  411.     textpad[y][x:x + w] = top_line
  412.     textpad[y + 1][x:x + w] = lab_line
  413.     for i in range(h - 3):
  414.         textpad[y + i + 2][x:x + w] = mid_line
  415.     textpad[y + h - 1][x:x + w] = bot_line