3 |
2 |
3 |
](https://youtu.be/hVVDJ-jgU80)
12 |
13 | Some features of pointer-cc:
14 |
15 | - Detects the geometry of the software instruments, i.e. you can resize and move the instruments window around
16 | - Supports software instruments that react to "mouse wheel" AND to "dragging up and down"
17 | - Allows controlling many software instruments at the same time: pointer-cc detects the instrument window the pointer is inside and switches configurations dynamically
18 | - No setup in the DAW / Host-application required: pointer-cc only talks to the OS
19 | - Currently only supports software instruments with control elements at static positions, i.e. doesn't support menus or paged/tabbed interfaces
20 |
21 | ## Installation / Download
22 |
23 | You can download pointer-cc for both Mac and Windows from the [releases page](https://github.com/smatting/pointer-cc/releases). If you have a newer Mac with an M? chip, download the `.dmg` file that ends with `-arm64`. Otherwise, download the `.dmg` file that ends with `-x86_x64`. You can verify your Mac type under `About This Mac` in the Apple menu.
24 |
25 |
26 | When running the Windows installer, you may encounter a warning about the installer coming from an "Unknown Publisher." This is because I (the author) have not bought a verified certificate, which requires an annual fee of 300 EUR. Optionally, you can add the [StefanMattingCA.cer](https://raw.githubusercontent.com/smatting/pointer-cc/main/certs/StefanMattingCA.cer) certificate to your trusted root certificates to remove this warning.
27 |
28 | ## Using pointer-cc
29 |
30 | Upon first launch on a Mac, pointer-cc will request permissions for both "Screen Recording" and "Accessibility" to function properly. Navigate to "Security & Privacy" in your system settings and ensure permissions are enabled. Please restart the app afterward; sometimes, pointer-cc may not request all necessary permissions on the first attempt, requiring a second restart.
31 |
32 | 
33 |
34 | 
35 |
36 | At the bottom of the main window, you can select your MIDI device and channel. If everything is set up correctly, MIDI messages should appear at the bottom as you interact.
37 |
38 | To begin using pointer-cc, you'll need to configure instrument settings. Follow these steps:
39 |
40 | 1. Capture a screenshot of your instrument. Make sure you crop to the exact contents of the window, omit the window bar or borders.
41 | 2. Use a paint program (e.g. online [jspaint.app](https://jspaint.app), MS Paint or [GIMP](https://www.gimp.org/)) to mark all controls with points or rectangles in a distinct color not found in the screenshot. Note the exact RGB color code (e.g., `#ff00ff` or `R = 255, G = 0, B = 255`). You can omit controls you're not interested in. Here's an example:
42 |
43 | 
44 |
45 | Save the marked screenshot as a PNG file.
46 |
47 | 3. In pointer-cc, select `Add Instrument` from the menu and follow the prompts.
48 |
49 | After adding the instruments choose `Open Config Dir`. The configuration directory of pointer-cc contains two types of files:
50 |
51 | - `config.txt`: The main configuration file.
52 |
53 | - `inst-{some name}.txt`: Instrument configuration files (must start with `inst-` and end with `.txt`).
54 |
55 | The config files use the [TOML](https://toml.io/en/) format.
56 |
57 | The **main confguration** file `config.txt` looks like this
58 |
59 | ```toml
60 | [bindings]
61 | [bindings.1]
62 | command = "pan-x"
63 | cc = 77
64 |
65 | [bindings.2]
66 | command = "pan-y"
67 | cc = 78
68 |
69 | [bindings.3]
70 | command = "adjust-control"
71 | cc = 79
72 |
73 | [bindings.4]
74 | command = "freewheel"
75 | cc = 80
76 |
77 | [midi]
78 | port = "Launch Control XL 0"
79 | channel = 0
80 |
81 | ```
82 |
83 | In the `[bindings]` section, you map MIDI control knobs to pointer-cc commands. To determine the correct `cc` field value, note the control number displayed in the MIDI status bar at the bottom of the pointer-cc window.
84 |
85 | The `command` field specifies the action performed when adjusting the MIDI controller.
86 |
87 | - `pan-x`: pan the cursor horizontally. A CC value `0` pans the pointer all the way left
88 |
89 | - `pan-x-inv` pan the cursor horizonally. A CC value of `127` pans the pointer all the way left
90 |
91 | - `pan-y` pan the cursor vertically. A CC value `0` pans the pointer all the way up
92 |
93 | - `pan-y-inv` pan the cursor vertically. A CC value `127` pans the pointer all the way up
94 |
95 | - `adjust-control` adjust the current control. What mouse pointer action is simulated depends on the configuration of current control element (See instrument configuration below)
96 |
97 | - `freewheel` start freewheeling. While freewheeling you can turn the adjustment knob (knob mapped to `adjust-control`) in one direction without it having any effect. When you turn the adjustment knob in the other direction freewheeling stops and the adjustment knob has its effect again. Freewheeling is useful if you don't have an endless rotary knob on your midi controller.
98 |
99 | The `[midi]` section updates automatically based on your MIDI settings within the application.
100 |
101 | The instrument file that is generated in the "Add Instrument" window is meant to be edited manually after creating it. A typical **instrument configuration** file, e.g. `inst-jupiter8.txt` looks like this
102 |
103 | ```toml
104 | [window]
105 | contains = "TAL-J-8"
106 |
107 | [default]
108 | type = "wheel"
109 |
110 | [default.drag]
111 | speed = 1.0
112 |
113 | [default.wheel]
114 | speed = 0.3
115 | time_resolution = 50
116 |
117 | [dimensions]
118 | width = 1439
119 | height = 736
120 |
121 | [controls]
122 | [controls.c1]
123 | x = 1074
124 | y = 172
125 | m = 1.0
126 |
127 | [controls.c2]
128 | type = "click"
129 | x = 1033
130 | y = 177
131 | m = 1.0
132 | ```
133 |
134 | - `window.contains` is used by pointer-cc to find the instrument window. Pick a string here that is contained in the window title of the instrument. It's usually the name of the instrument. Note that the case has to also match (comparison is case-sensitive).
135 |
136 | - `controls` The `controls.c1`, `controls.c2`, ... sections correspond to the control elements that you marked in the screenshots. You can see the `c?` number that belongs to acontrol element in the pointer-cc window when you select it via the panning knobs.
137 |
138 | - `controls.c1.x`: x coordinate of the control element (was extracted from screenshot)
139 |
140 | - `controls.c1.y`: y coordinate of the control element (was extracted from screenshot)
141 |
142 | - `controls.c1.type` (optional): Specifies the type of mouse pointer action simulated by pointer-cc when adjusting the knob associated with control `c1`. Available values include:
143 |
144 | - `drag`: Simulates dragging the mouse pointer up or down.
145 |
146 | - `wheel`: Simulates scrolling the mouse wheel up or down.
147 |
148 | - `click`: Simulates a mouse click. To trigger a click, quickly turn the adjustment knob down and then up again.
149 |
150 | If no `type` is specified for a control element (`c1`), the default type specified by `default.type` will be used.
151 |
152 | - `control.c1.m` (optional): This parameter acts as a speed multiplier specifically applicable to `wheel` and `drag` control types. When set to values smaller than `1.0`, it reduces the sensitivity of dragging or wheeling actions, resulting in slower movements. Conversely, values greater than `1.0` increase sensitivity, causing faster dragging or wheeling. Adjust this parameter to fine-tune the responsiveness of the control relative to others. The resulting speed of the controller is calculated as `speed * m`. If `m` is not specified, a default value of `1.0` is used.
153 |
154 | - `control.c1.speed` (optional): This parameter defines the speed specifically for the control element. It is recommended not to set this parameter unless you have a specific reason to do so. Instead, it is preferable to establish consistent base speeds for all knobs by setting `default.drag.speed` and `default.wheel.speed`. Use `control.c1.m` to adjust the relative speed of individual controls based on this standardized base speed. This approach ensures uniform behavior across controls and simplifies configuration management.
155 |
156 | - `default.type` the default type of pointer control used by all controls if not explicitely `type` is defined. Valid values are `drag`, `wheel`, `click` (see above)
157 |
158 | - `default.drag.speed` default setting for`speed` for controls that are of type `drag`
159 |
160 | - `default.wheel.speed` default setting for`speed` for controls that are of type `wheel`
161 |
162 | - `default.wheel.time_resolution`: This setting determines the maximum frequency (in times per second) at which wheel events are sent to the instrument window. If set too high, particularly on Windows systems, rapid adjustment knob turns may cause the operating system to drop wheel events. Conversely, setting it too low can result in overly choppy updates. I recommend experimenting with this value to find an optimal balance. A starting point of `50` times per second often works well to achieve smooth and responsive control.
163 |
164 | - `dimensions.width` and `dimensions.height`. Defines the dimensions of the whole instruments. All `x` and `y` coordinates of control elements relative to it. This is the resolution of the screenshot image.
165 |
166 | ## Acknowledgements
167 | The original idea for this project came from a video by [@WoodyPianoShack](https://www.youtube.com/@WoodyPianoShack) titled [I Fixed The Major Problem With All Software Synths](https://www.youtube.com/watch?v=BPoutltNV_E).
168 |
--------------------------------------------------------------------------------
/main.py:
--------------------------------------------------------------------------------
1 | from PIL import Image
2 | import wx
3 | import wx.lib.delayedresult
4 | import requests
5 | import time
6 | import importlib.resources
7 | import datetime
8 | import http.client
9 | import urllib
10 | import semver
11 | import textwrap
12 | import pyperclip
13 | import traceback
14 | import os
15 | import time
16 | import webbrowser
17 | import subprocess
18 | import platform
19 | import glob
20 | import rtmidi
21 | import math
22 | import traceback
23 | import mouse
24 | from rtmidi.midiutil import open_midiport
25 | import threading
26 | import queue
27 | import tomlkit
28 | import copy
29 | import sys
30 | import re
31 | import appdirs
32 | from enum import Enum
33 | from pointercc.core import Window, Box, make_box
34 | from pointercc.version import version
35 | if sys.platform == "win32":
36 | import pointercc.win32 as core_platform
37 | elif sys.platform == "darwin":
38 | import pointercc.darwin as core_platform
39 | else:
40 | raise NotImplemnted(f'Platform {sys.platform} not supported')
41 |
42 | app_name = "pointer-cc"
43 | app_author = "smatting"
44 | app_url = "https://github.com/smatting/pointer-cc/"
45 | app_email = "pointer-cc@posteo.com"
46 | url_latest = "https://raw.githubusercontent.com/smatting/pointer-cc/main/latest_release.txt"
47 |
48 | InternalCommand = Enum('InternalCommand', ['QUIT', 'CHANGE_MIDI_PORT', 'CHANGE_MIDI_CHANNEL', 'UPDATE_WINDOW', 'RELOAD_ALL_CONFIGS'])
49 |
50 | class Bijection:
51 | def __init__(self, a_name, b_name, atob_pairs):
52 | self._d_atob = dict(atob_pairs)
53 | self._d_btoa = dict([(b, a) for (a, b) in atob_pairs])
54 |
55 | setattr(self, a_name, self._a)
56 | setattr(self, b_name, self._b)
57 |
58 | def _a(self, b):
59 | return self._d_btoa.get(b)
60 |
61 | def _b(self, a):
62 | return self._d_atob.get(a)
63 |
64 | def datadir():
65 | return appdirs.user_data_dir(app_name, app_author)
66 |
67 | def userfile(p):
68 | return os.path.join(datadir(), p)
69 |
70 | def configfile():
71 | return userfile('config.txt')
72 |
73 | def initialize_config():
74 | os.makedirs(datadir(), exist_ok=True)
75 | cf = configfile()
76 | if not os.path.exists(cf):
77 | with open(cf, 'w') as f:
78 | conf = default_config_toml()
79 | f.write(conf.as_string())
80 |
81 | ControlType = Enum('ControlType', ['WHEEL', 'DRAG','CLICK'])
82 |
83 | class ConfigError(Exception):
84 | def __init__(self, msg):
85 | self.msg = msg
86 | super(ConfigError, self).__init__(self.msg)
87 |
88 | def in_context(f, context):
89 | try:
90 | return f()
91 | except ConfigError as ce:
92 | ce.msg = ce.msg + f", {context}"
93 | raise ce
94 |
95 | control_type_bij = Bijection('str', 'enum', [('wheel', ControlType.WHEEL), ('drag', ControlType.DRAG), ('click', ControlType.CLICK)])
96 |
97 | def squared_dist(p1, p2):
98 | x1, y1 = p1
99 | x2, y2 = p2
100 | return (x1 - x2)**2 + (y1 - y2)**2
101 |
102 | class Control:
103 | def __init__(self, type_, i, x, y, speed, m, time_resolution):
104 | self.type_ = type_
105 | self.i = i
106 | self.x = x
107 | self.y = y
108 | self.speed = speed
109 | self.m = m
110 | self.time_resolution = time_resolution
111 |
112 | def __eq__(self, other):
113 | return self.i == other.i
114 |
115 | def __str__(self):
116 | type_str = control_type_bij.str(self.type_)
117 | return f'{self.i}({type_str})'
118 |
119 | @staticmethod
120 | def parse(d, i, default, context):
121 | try:
122 | x_s = expect_value(d, "x")
123 | x = expect_int(x_s, "x")
124 |
125 | y_s = expect_value(d, "y")
126 | y = expect_int(y_s, "y")
127 |
128 | default_type = control_type_bij.enum(default['type'])
129 | type_= maybe(d.get('type'), control_type_bij.enum, default_type)
130 |
131 | m = maybe(d.get('m'), lambda s: expect_float(s, 'm'), 1.0)
132 |
133 | if type_ == ControlType.WHEEL:
134 | d = default['wheel']
135 | default_speed = d['speed']
136 | default_time_resolution = d['time_resolution']
137 | else:
138 | d = default['drag']
139 | default_speed = d['speed']
140 | default_time_resolution = 100
141 |
142 | time_resolution = maybe(d.get('time_resolution'), lambda s: expect_int(s, 'time_resolution'), default_time_resolution)
143 | speed = maybe(d.get('speed'), lambda s: expect_float(s, 'speed'), default_speed)
144 |
145 | return Control(type_, i, x, y, speed, m, time_resolution)
146 |
147 | except ConfigError as ce:
148 | ce.msg = ce.msg + f", {context}"
149 | raise ce
150 |
151 | def maybe(mv, f, default):
152 | if mv is None:
153 | return default
154 | else:
155 | return f(mv)
156 |
157 | class Instrument:
158 | def __init__(self, pattern, box, controls):
159 | self.pattern = pattern
160 | self.box = box
161 | self.controls = controls
162 |
163 | @staticmethod
164 | def load(path, instrument_context):
165 | try:
166 | controls = []
167 |
168 | with open(path, 'r') as f:
169 | d = tomlkit.load(f)
170 |
171 | dimensions = expect_value(d, 'dimensions')
172 | width_s = expect_value(dimensions, 'width', 'dimensions')
173 | width = expect_int(width_s, 'dimensions.width')
174 | height_s = expect_value(dimensions, 'height', 'dimensions')
175 | height = expect_int(height_s, 'dimensions.height')
176 |
177 | box = Box(0, width, 0, height)
178 |
179 | default = expect_value(d, 'default')
180 | type_s = expect_value(default, 'type', 'default')
181 |
182 | default_wheel = expect_value(default, 'wheel', 'default')
183 | expect_value(default_wheel, 'speed', 'default.wheel')
184 | expect_value(default_wheel, 'time_resolution', 'default.wheel')
185 |
186 | default_drag = expect_value(default, 'drag', 'default')
187 | expect_value(default_drag, 'speed', 'default.drag')
188 |
189 | controls_unparsed = expect_value(d, 'controls')
190 | for control_id, v in controls_unparsed.items():
191 | context = f"in control \"{control_id}\""
192 | c = Control.parse(v, control_id, default, context)
193 | controls.append(c)
194 |
195 | window = expect_value(d, 'window')
196 | pattern = expect_value(window, 'contains', 'window')
197 |
198 | return Instrument(pattern, box, controls)
199 |
200 | except tomlkit.exceptions.TOMLKitError as tk:
201 | msg = f'Not a valid TOML file: {tk}'
202 | raise ConfigError(msg + f" in \"{instrument_context}\"")
203 |
204 | except ConfigError as ce:
205 | raise ConfigError(ce.msg + f" in \"{instrument_context}\"")
206 |
207 |
208 | def find_closest_control(self, mx, my):
209 | c_best = None
210 | d_best = math.inf
211 | for c in self.controls:
212 | d = math.pow(c.x - mx, 2.0) + math.pow(c.y - my, 2.0)
213 | if d < d_best:
214 | c_best = c
215 | d_best = d
216 | return c_best
217 |
218 | def overlaps(p1, p2):
219 | if p1[0] > p2[0]:
220 | p1, p2 = p2, p1
221 | return p2[0] <= p1[1]
222 |
223 | def find_overlapping(spans, p):
224 | for p_span in spans:
225 | if overlaps(p_span, p):
226 | return spans[p_span]
227 | return None
228 |
229 | def color_diff(c1, c2):
230 | return max(abs(c1[0] - c2[0]), abs(c1[1] - c2[1]), abs(c1[2] - c2[2]))
231 |
232 | def find_markings(im, marker_color, threshold, update_percent):
233 | boxes = []
234 | spans_last = {}
235 | for y in range(0, im.height):
236 | update_percent(int(100*y//im.height))
237 | xmin = None
238 | xmax = None
239 | spans = {}
240 | for x in range(0, im.width):
241 | color = im.getpixel((x, y))
242 | diff = color_diff(marker_color, color)
243 | in_marker = diff <= threshold
244 | if in_marker:
245 | if xmin is None:
246 | xmin = x
247 | xmax = x
248 |
249 | if (not in_marker and xmax is not None) or (in_marker and x == im.width - 1):
250 | b = find_overlapping(spans_last, (xmin, xmax))
251 | if b is not None:
252 | b.ymax = y
253 | b.xmin = min(b.xmin, xmin)
254 | b.xmax = max(b.xmax, xmax)
255 | else:
256 | b = Box(xmin, xmax, y, y)
257 | boxes.append(b)
258 | spans[(xmin, xmax)] = b
259 | xmin = None
260 | xmax = None
261 | spans_last = spans
262 | return boxes
263 |
264 | def analyze(self, filename, marker_color, threshold):
265 | d = {}
266 | im = Image.open(filename)
267 |
268 | dimensions = {}
269 | d['dimensions'] = dimensions
270 | dimensions['width'] = im.width
271 | dimensions['height'] = im.height
272 |
273 | def update_percent(i):
274 | wx.CallAfter(self.update_progress, i)
275 |
276 | controls = {}
277 | d['controls'] = controls
278 | markings = find_markings(im, marker_color, threshold, update_percent)
279 | for i, box in enumerate(markings):
280 | c = {}
281 | x, y = box.center()
282 | c['x'] = x
283 | c['y'] = y
284 | controls[f'c{i+1}'] = c
285 | return d
286 |
287 | def toml_instrument_config(extract_result, window_contains, control_type):
288 | doc = tomlkit.document()
289 | doc.add(tomlkit.comment(f'The is pointer-cc instrument configuration file. Please edit it to change it, then pick "Reload Config" from the menu for your changes to take effect. See the pointer-cc documentation for details: {app_url}.'))
290 |
291 | window = tomlkit.table()
292 | window.add('contains', window_contains)
293 | doc.add('window', window)
294 |
295 | dimensions = tomlkit.table()
296 | dimensions.add('width', extract_result['dimensions']['width'])
297 | dimensions.add('height', extract_result['dimensions']['height'])
298 | doc.add('dimensions', dimensions)
299 |
300 | default_control = tomlkit.table()
301 | default_control.add('type', control_type)
302 |
303 | default_drag = tomlkit.table()
304 | default_drag.add('speed', 1.0)
305 | default_control.add('drag', default_drag)
306 |
307 | default_wheel = tomlkit.table()
308 | default_wheel.add('speed', 1.0)
309 | default_wheel.add('time_resolution', 100)
310 | default_control.add('wheel', default_wheel)
311 |
312 | doc.add('default', default_control)
313 |
314 | controls = tomlkit.table()
315 | for cid, c in extract_result['controls'].items():
316 | control = tomlkit.table()
317 | control.add('x', c['x'])
318 | control.add('y', c['y'])
319 | control.add('m', 1.0)
320 | controls.add(cid, control)
321 | doc.add('controls', controls)
322 | return doc
323 |
324 | midi_type_bij = Bijection('midi', 'display', [(0x80, "NOTEOFF"), (0x90, "NOTEON"), (0xA0, "KPRESS"), (0xB0, "CC"), (0xC0, "PROG"), (0xC0, "PROG"), (0xD0, "CHPRESS"), (0xE0, "PBEND"), (0xF0, "SYSEX")])
325 |
326 | def fmt_hex(i):
327 | s = hex(i)[2:].upper()
328 | prefix = "".join(((2 - len(s)) * ["0"]))
329 | return prefix + s
330 |
331 | def fmt_midi(msg):
332 | if len(msg) == 0:
333 | return None
334 | else:
335 | parts = []
336 | t = midi_type_bij.display(msg[0] & 0xf0)
337 | if t is not None:
338 | chan = (msg[0] & 0x0f) + 1
339 | parts.append(f'Ch.{chan}')
340 | parts.append(t)
341 | else:
342 | parts.append(fmt_hex(msg[0]))
343 | parts = parts + [str(i) for i in msg[1:]]
344 | return ' '.join(parts)
345 |
346 | class Dispatcher(threading.Thread):
347 | def __init__(self, midiin, queue, frame):
348 | super(Dispatcher, self).__init__()
349 | self.midiin = midiin
350 | self.queue = queue
351 | self.frame = frame
352 | self.port_name = None
353 | self.midi_channel= 0
354 | self.controllers = {}
355 | self.polling = None
356 | self.config = default_config()
357 | self.instruments = {}
358 | self.reload_all_configs()
359 |
360 | def reload_all_configs(self):
361 | try:
362 | config = load_config()
363 | except ConfigError as e:
364 | msg = f'Configuration error: {e}'
365 | wx.CallAfter(self.frame.show_error, msg)
366 | else:
367 | instruments, inst_exceptions = load_instruments()
368 |
369 | self.config = config
370 | self.set_instruments(instruments)
371 |
372 | if config.preferred_midi_port is not None:
373 | self.queue.put((InternalCommand.CHANGE_MIDI_PORT, config.preferred_midi_port, False))
374 |
375 | if config.preferred_midi_channel is not None:
376 | self.queue.put((InternalCommand.CHANGE_MIDI_CHANNEL, config.preferred_midi_channel))
377 |
378 | self.stop_window_polling()
379 | self.start_window_polling()
380 |
381 | if len(inst_exceptions) > 0:
382 | msgs = []
383 | for e in inst_exceptions:
384 | msgs.append(str(e))
385 | msg = 'Configuration error: ' + ' '.join(msgs)
386 | wx.CallAfter(self.frame.show_error, msg)
387 |
388 | def get_active_controller(self):
389 | if len(self.controllers) == 0:
390 | return None
391 |
392 | elif len(self.controllers) == 1:
393 | return list(self.controllers.values())[0]
394 |
395 | else:
396 |
397 | x, y = mouse.get_position()
398 |
399 | def sort_key(controller):
400 | box = controller.window.box
401 | key_contains = 0 if box.contains_point(x, y) else 1
402 | key_distance = squared_dist(box.center(), (x, y))
403 | tpl = (key_contains, key_distance)
404 | return tpl
405 |
406 | controllers = list(self.controllers.values())
407 | controllers.sort(key=sort_key)
408 | if len(controllers) > 0:
409 | return controllers[0]
410 |
411 | def __call__(self, event, data=None):
412 | try:
413 | message, deltatime = event
414 |
415 | ch = message[0] & 0x0f
416 | ignore = False
417 | if self.midi_channel != 0:
418 | if ch != self.midi_channel - 1:
419 | return
420 |
421 | controller = self.get_active_controller()
422 |
423 | midi_msg_text_parts = []
424 | m = fmt_midi(message)
425 | if m is not None:
426 | midi_msg_text_parts.append(m)
427 |
428 | # note off(?)
429 | if message[0] & 0xf0 == 0x80:
430 | pass
431 |
432 | ctrl_info_parts = []
433 | if controller:
434 | if controller.current_control is not None:
435 | ctrl_info_parts.append(str(controller.current_control))
436 |
437 | if controller.freewheeling:
438 | ctrl_info_parts.append('(freewheeling)')
439 |
440 | if message[0] & 0xf0 == 0xb0:
441 | for binding in self.config.bindings:
442 | if binding.cc == message[1]:
443 |
444 | c = cmd_str.str(binding.command)
445 | midi_msg_text_parts.append(f'({c})')
446 |
447 | if binding.command == Command.PAN_X:
448 | x_normed = message[2] / 127.0
449 | controller.pan_x(x_normed)
450 |
451 | elif binding.command == Command.PAN_X_INV:
452 | x_normed = message[2] / 127.0
453 | controller.pan_x(1.0 - x_normed)
454 |
455 | elif binding.command == Command.PAN_Y:
456 | y_normed = message[2] / 127.0
457 | controller.pan_y(y_normed)
458 |
459 | elif binding.command == Command.PAN_Y_INV:
460 | y_normed = message[2] / 127.0
461 | controller.pan_y(1.0 - y_normed)
462 |
463 | elif binding.command == Command.ADJUST_CONTROL:
464 | cc = message[2]
465 | status = controller.turn(cc)
466 | if status is not None:
467 | ctrl_info_parts.append(status)
468 |
469 | elif binding.command == Command.FREEWHEEL:
470 | controller.freewheel()
471 |
472 | ctrl_info = ' '.join(ctrl_info_parts)
473 | midi_msg_text = ' '.join(midi_msg_text_parts)
474 | wx.CallAfter(self.frame.update_view, midi_msg_text, ctrl_info)
475 |
476 | except Exception as e:
477 | traceback.print_exception(e)
478 |
479 | def set_instruments(self, instruments):
480 | if len(instruments) == 0:
481 | msg = "No instruments configured, please read the docs"
482 | else:
483 | msg = f'{len(instruments)} instruments configured'
484 |
485 | self.instruments = instruments
486 | wx.CallAfter(self.frame.set_window_text, msg)
487 |
488 | def start_window_polling(self):
489 | self.polling = WindowPolling(self.queue, list(self.instruments.keys()))
490 | self.polling.start()
491 |
492 | def stop_window_polling(self):
493 | if self.polling:
494 | self.polling.event.set()
495 | self.polling.join()
496 |
497 | def run(self):
498 | self.midiin.set_callback(self)
499 |
500 | running = True
501 | while running:
502 | item = self.queue.get()
503 | cmd = item[0]
504 | if cmd == InternalCommand.QUIT:
505 | running = False
506 | self.stop_window_polling()
507 |
508 | elif cmd == InternalCommand.CHANGE_MIDI_CHANNEL:
509 | self.midi_channel = item[1]
510 | if self.midiin.is_port_open() and self.port_name is not None:
511 | self.config.set_preferred_midi(self.port_name, self.midi_channel)
512 |
513 | elif cmd == InternalCommand.CHANGE_MIDI_PORT:
514 | port_name = item[1]
515 | triggered_by_user = item[2]
516 | (success, exc) = open_midi_port(self.midiin, port_name)
517 | if success:
518 | self.port_name = port_name
519 | self.config.set_preferred_midi(port_name, self.midi_channel)
520 | self.midiin.set_callback(self)
521 | wx.CallAfter(self.frame.set_midi_selection, self.port_name, self.midi_channel)
522 | else:
523 | if triggered_by_user:
524 | msg = f"Could not open MIDI port \"{port_name}\""
525 | wx.CallAfter(self.frame.show_error, msg)
526 | # TODO:
527 | # wx.CallAfter(self.frame.set_midi_selection, None, None)
528 |
529 | elif cmd == InternalCommand.UPDATE_WINDOW:
530 | name = item[1]
531 | window = item[2]
532 | if window is None:
533 | if name in self.controllers:
534 | del self.controllers[name]
535 | else:
536 | self.controllers[name] = InstrumentController(self.instruments[window.pattern], window)
537 |
538 | c = self.get_active_controller()
539 | if c is None:
540 | self.frame.set_window_text('No window found')
541 | else:
542 | self.frame.set_window_text(c.window.name)
543 |
544 | elif cmd == InternalCommand.RELOAD_ALL_CONFIGS:
545 | self.reload_all_configs()
546 |
547 | def unit_affine():
548 | return Affine(1.0, 1.0, 0.0, 0.0)
549 |
550 | # affine transform that can be scaling and translation
551 | class Affine:
552 | def __init__(self, sx, sy, dx, dy):
553 | self.sx = sx
554 | self.sy = sy
555 | self.dx = dx
556 | self.dy = dy
557 |
558 | def inverse(self):
559 | small = 1e-2
560 | if abs(self.sx) < small or abs(self.sy) < small:
561 | return unit_affine()
562 | sx_inv = 1.0 / self.sx
563 | sy_inv = 1.0 / self.sy
564 | return Affine(sx_inv, sy_inv, - sx_inv * self.dx, - sy_inv * self.dy)
565 |
566 | def multiply_right(self, other):
567 | sx = self.sx * other.sx
568 | sy = self.sy * other.sy
569 | dx = sx * other.dx + self.dx
570 | dy = sy * other.dy + self.dy
571 | self.sx = sx
572 | self.sy = sy
573 | self.dx = dx
574 | self.dy = dy
575 |
576 | def apply(self, x, y):
577 | x_ = self.sx * x + self.dx
578 | y_ = self.sy * y + self.dy
579 | return (x_, y_)
580 |
581 | def screen_to_window(window_box):
582 | b = window_box
583 | return Affine(1.0, 1.0, -b.xmin, -b.ymin)
584 |
585 | def window_to_screen(window_box):
586 | return screen_to_window(window_box).inverse()
587 |
588 | def model_to_window(window_box, model_box):
589 | if model_box.width == 0 or model_box.height == 0:
590 | return unit_affine()
591 | sx = window_box.width / model_box.width
592 | sy = window_box.height / model_box.height
593 | s = min(sx, sy)
594 | excess_x = window_box.width - s * model_box.width
595 | excess_y = window_box.height - s * model_box.height
596 | return Affine(s, s, excess_x / 2.0, excess_y)
597 |
598 | def window_to_model(window_box, model_box):
599 | return model_to_window(window_box, model_box).inverse()
600 |
601 | class InstrumentController:
602 | def __init__(self, instrument, window):
603 | self.instrument = instrument
604 | self.set_window(window)
605 |
606 | self.mx = 0.0
607 | self.my = 0.0
608 | self.current_control = None
609 |
610 | self.freewheeling = False
611 | self.freewheeling_direction = None
612 |
613 | self.last_cc = None
614 | self.last_control = None
615 | self.last_control_accum = 0.0
616 | self.last_t = None
617 | self.dragging = False
618 |
619 | self.click_sm = ClickStateMachine(1.0, 2)
620 |
621 | def set_window(self, window):
622 | window_box = window.box
623 | t = window_to_model(window_box, self.instrument.box)
624 | s2w = screen_to_window(window_box)
625 | t.multiply_right(s2w)
626 | self.screen_to_instrument = t
627 | self.instrument_to_screen = self.screen_to_instrument.inverse()
628 | self.window = window
629 |
630 | def pan_x(self, x_normed):
631 | self.mx = self.instrument.box.width * x_normed
632 | self.current_control = self.move_pointer_to_closest()
633 |
634 | def pan_y(self, y_normed):
635 | self.my = self.instrument.box.height * y_normed
636 | self.current_control = self.move_pointer_to_closest()
637 |
638 | def turn(self, cc):
639 | status = None
640 |
641 | screen_x, screen_y = mouse.get_position()
642 | if not self.dragging:
643 | self.mx, self.my = self.screen_to_instrument.apply(screen_x, screen_y)
644 |
645 | self.current_control = self.instrument.find_closest_control(self.mx, self.my)
646 |
647 | if self.last_control is not None:
648 | if self.current_control != self.last_control:
649 | self.click_sm.reset()
650 | self.last_cc = cc
651 | self.last_control_accum = 0.0
652 | self.last_t = None
653 |
654 | if self.last_cc is None:
655 | self.last_cc = cc
656 |
657 | delta = cc - self.last_cc
658 | t = time.time()
659 |
660 | if self.freewheeling:
661 | if self.freewheeling_direction is None:
662 | self.freewheeling_direction = delta > 0
663 | elif self.freewheeling_direction != (delta > 0):
664 | self.freewheeling = False
665 | self.freewheeling_direction = None
666 |
667 | else:
668 | if self.current_control is not None:
669 | m = self.current_control.m
670 | speed = self.current_control.speed * self.current_control.m
671 |
672 | self.last_control_accum += delta * speed
673 |
674 | if self.current_control.type_ == ControlType.WHEEL:
675 | if self.last_t is None:
676 | self.last_t = t
677 | else:
678 | time_delta = t - self.last_t
679 | time_delta_res = 1.0 / self.current_control.time_resolution
680 | if time_delta > time_delta_res:
681 | if time_delta < 5 * time_delta_res:
682 | mouse.wheel(self.last_control_accum)
683 | status = f'wheel! {"+" if self.last_control_accum > 0 else ""}{self.last_control_accum:.2f} (x{speed:.2f})'
684 | self.last_control_accum = 0
685 | self.last_t = t
686 | elif self.current_control.type_ == ControlType.DRAG:
687 | if self.dragging:
688 | pass
689 | else:
690 | mouse.press()
691 | self.dragging = True
692 | k_whole = int(self.last_control_accum)
693 | mouse.move(screen_x, screen_y - k_whole)
694 | status = f'drag! {"+" if k_whole > 0 else ""}{k_whole} (x{speed:.2f})'
695 | self.last_control_accum -= k_whole
696 | elif self.current_control.type_ == ControlType.CLICK:
697 | is_click = self.click_sm.on_cc(cc, time.time())
698 | if is_click:
699 | mouse.click()
700 | status = f'click! (x{speed:.2f})'
701 |
702 | self.last_control = self.current_control
703 | self.last_cc = cc
704 | return status
705 |
706 | def freewheel(self):
707 | self.freewheeling = True
708 | self.freewheeling_direction = None
709 |
710 | def move_pointer_to_closest(self):
711 | c = self.instrument.find_closest_control(self.mx, self.my)
712 | if self.dragging:
713 | mouse.release()
714 | self.dragging = False
715 | x, y = self.instrument_to_screen.apply(c.x, c.y)
716 | mouse.move(int(x), int(y))
717 | return c
718 |
719 | class AddInstrumentDialog(wx.Dialog):
720 | def __init__(self, parent, title, queue):
721 | wx.Frame.__init__(self, parent, title=title)
722 | self.queue = queue
723 |
724 | self.extract_result = None
725 | topbottommargin = 25
726 | intermargin = 25
727 | smallmargin = 4
728 | horizontal_margin = 20
729 |
730 | sizer = wx.BoxSizer(wx.VERTICAL)
731 | sizer.AddSpacer(topbottommargin)
732 |
733 | introText = wx.StaticText(self)
734 | t = textwrap.dedent('''\
735 | Here you can create a instrument configuration .txt file for your VST / Software Instrument.
736 | After you've created it you need to edit the .txt file with a text editor to change the details
737 | of each control, e.g. speed multiplier etc. Please read the pointer documentation on how to do this.
738 | ''')
739 | introText.SetLabelMarkup(t)
740 | sizer.Add(introText, 0, wx.EXPAND | wx.LEFT | wx.RIGHT, border=horizontal_margin)
741 |
742 | controlPosLabel = wx.StaticText(self)
743 | controlPosLabel.SetLabelMarkup('Control positions')
744 | controlPosDescr = wx.StaticText(self)
745 | controlPosDescr.SetLabelMarkup('Take a screenshot of the instrument window. Crop the screen to contents, but\nexclude all window decoration, e.g. the window title bar or borders.\nThen mark the controls by drawing rectangles in the marker color with any image app (e.g. GIMP).')
746 | # cpLabel = wx.StaticText(self, label="Marker color #FF00FF, rgb(255,0,255)")
747 | self.cpLabel = wx.StaticText(self)
748 | self.colorPickerCtrl = wx.ColourPickerCtrl(self)
749 | self.colorPickerCtrl.SetColour(wx.Colour(255, 0, 255))
750 | self.colorPickerCtrl.Bind(wx.EVT_COLOURPICKER_CHANGED, self.on_color_changed)
751 |
752 | self.set_color_text()
753 | cpSizer = wx.BoxSizer(wx.HORIZONTAL)
754 | cpSizer.Add(self.colorPickerCtrl, 0)
755 | cpSizer.Add(self.cpLabel, wx.SizerFlags().Bottom().Border(wx.LEFT, borderinpixels=smallmargin))
756 | sizer.Add(controlPosLabel, 0, wx.EXPAND | wx.LEFT | wx.RIGHT, border=horizontal_margin)
757 | sizer.AddSpacer(smallmargin)
758 | sizer.Add(controlPosDescr, 0, wx.EXPAND | wx.LEFT | wx.RIGHT, border=horizontal_margin)
759 | sizer.AddSpacer(smallmargin)
760 | sizer.Add(cpSizer, 0, wx.LEFT | wx.RIGHT, border=horizontal_margin)
761 | sizer.AddSpacer(smallmargin)
762 |
763 |
764 | self.colorThreshold = wx.TextCtrl(self, value="30")
765 | colorThresholdSizer = wx.BoxSizer(wx.HORIZONTAL)
766 | colorThresholdSizer.Add(self.colorThreshold)
767 |
768 | thresholdLabel = wx.StaticText(self, label="Marker color threshold (0-255)")
769 | colorThresholdSizer.Add(thresholdLabel, 0, wx.LEFT, border=smallmargin)
770 | sizer.Add(colorThresholdSizer, 0, wx.EXPAND | wx.LEFT | wx.RIGHT, border=horizontal_margin)
771 |
772 | self.selectScreenshot = wx.FilePickerCtrl(self, style=wx.FLP_OPEN, message="Select a cropped screenshot of instrument", wildcard="*.png")
773 | self.selectScreenshot.Bind(wx.EVT_FILEPICKER_CHANGED, self.on_screenshot_selected)
774 | filepicker_set_button_label(self.selectScreenshot, 'Analyze Screenshot')
775 |
776 |
777 | self.analyzeText = wx.StaticText(self, label="(no positions extracted yet)")
778 | analyzeSizer = wx.BoxSizer(wx.HORIZONTAL)
779 | analyzeSizer.Add(self.selectScreenshot)
780 | analyzeSizer.Add(self.analyzeText, 0, wx.LEFT, border=smallmargin)
781 | sizer.Add(analyzeSizer, 0, wx.EXPAND | wx.LEFT | wx.RIGHT, border=horizontal_margin)
782 |
783 | sizer.AddSpacer(intermargin)
784 |
785 | windowPatternLabel = wx.StaticText(self)
786 | windowPatternLabel.SetLabelMarkup('Window Pattern')
787 | windowPatternDescr = wx.StaticText(self, style=wx.LB_MULTIPLE)
788 | windowPatternDescr.SetLabelMarkup('What string is always contained in the instrument\'s window title (usually the name)? This is needed to detect its window.')
789 | self.window_pattern_ctrl = wx.TextCtrl(self)
790 | sizer.Add(windowPatternLabel, 0, wx.EXPAND | wx.LEFT | wx.RIGHT, border=horizontal_margin)
791 | sizer.AddSpacer(smallmargin)
792 | sizer.Add(windowPatternDescr, 0, wx.EXPAND | wx.LEFT | wx.RIGHT, border=horizontal_margin)
793 | sizer.AddSpacer(smallmargin)
794 | sizer.Add(self.window_pattern_ctrl, 0, wx.EXPAND | wx.LEFT | wx.RIGHT, border=horizontal_margin)
795 |
796 | sizer.AddSpacer(intermargin)
797 |
798 | mouseControlLabel = wx.StaticText(self)
799 | mouseControlLabel.SetLabelMarkup('Mouse control')
800 | mouseControlDescr = wx.StaticText(self)
801 | mouseControlDescr.SetLabelMarkup('How does the mouse adjust controls?')
802 | sizer.Add(mouseControlLabel, 0, wx.EXPAND | wx.LEFT | wx.RIGHT, border=horizontal_margin)
803 | sizer.AddSpacer(smallmargin)
804 | sizer.Add(mouseControlDescr, 0, wx.EXPAND | wx.LEFT | wx.RIGHT, border=horizontal_margin)
805 | sizer.AddSpacer(smallmargin)
806 | choices = [
807 | "mouse drag up and down",
808 | "mouse wheel"
809 | ]
810 | self.mousectrl_combo = wx.ComboBox(self, id=wx.ID_ANY, value="mouse wheel", choices=choices, style=wx.CB_READONLY)
811 | sizer.Add(self.mousectrl_combo, 0, wx.EXPAND | wx.LEFT | wx.RIGHT, border=horizontal_margin)
812 |
813 | sizer.AddSpacer(intermargin)
814 |
815 | filenameDescr = wx.StaticText(self)
816 | filenameDescr.SetLabelMarkup('Choose instrument configuration save file. The filename must start with "inst-" and end with ".txt".')
817 | self.chooseSaveFile = wx.FilePickerCtrl(self, style=wx.FLP_SAVE, message="Save instrument text file")
818 | filepicker_set_button_label(self.chooseSaveFile, 'Save Instrument')
819 | self.chooseSaveFile.SetInitialDirectory(datadir())
820 | self.chooseSaveFile.SetPath(userfile('inst-renameme.txt'))
821 | self.chooseSaveFile.Bind(wx.EVT_FILEPICKER_CHANGED, self.on_save_file_picked)
822 |
823 | sizer.Add(filenameDescr, 0, wx.EXPAND | wx.LEFT | wx.RIGHT, border=horizontal_margin)
824 | sizer.AddSpacer(smallmargin)
825 | sizer.Add(self.chooseSaveFile, 0, wx.CENTER | wx.LEFT | wx.RIGHT, border=horizontal_margin)
826 | sizer.AddSpacer(topbottommargin)
827 |
828 | self.progress = None
829 |
830 | self.SetSizer(sizer)
831 | self.Fit()
832 |
833 | def on_color_changed(self, _):
834 | self.set_color_text()
835 |
836 | def set_color_text(self):
837 | c = self.colorPickerCtrl.GetColour()
838 | r, g, b, _ = c.Get()
839 | msg = 'Marker color: #' + fmt_hex(r) + fmt_hex(g) + fmt_hex(b) + ", " + f'rgb({r},{g},{b})'
840 | self.cpLabel.SetLabel(msg)
841 |
842 | def on_extract_done(self, delayed_result, **kwargs):
843 | if self.progress:
844 | self.progress.Destroy()
845 | self.progress = None
846 | self.set_extract_result(delayed_result.get(), kwargs['path'])
847 |
848 | def update_progress(self, i):
849 | if self.progress:
850 | self.progress.Update(i)
851 |
852 | def on_screenshot_selected(self, event):
853 | v = self.colorThreshold.GetValue()
854 | msg = None
855 | try:
856 | v_int = int(v)
857 | except Exception as e:
858 | msg = f'Color threshold {v} is not an integer'
859 | if not (0 <= v_int and v_int <= 255):
860 | msg = f'Color threshold {v} is not in range 0-255'
861 | if msg:
862 | wx.CallAfter(self.frame.show_error, msg)
863 | return
864 |
865 | path = self.selectScreenshot.GetPath()
866 | marker_color = self.colorPickerCtrl.GetColour().Get()
867 | self.progress = wx.ProgressDialog("In Progress", message="Analyzing screenshot...")
868 | wx.lib.delayedresult.startWorker(self.on_extract_done, workerFn=analyze, ckwargs=dict(path=path), wargs=[self, path, marker_color, v_int])
869 |
870 | def set_extract_result(self, extract_result, path):
871 | self.extract_result = extract_result
872 | dim = extract_result['dimensions']
873 | width = dim['width']
874 | height = dim['height']
875 | n = len(extract_result['controls'])
876 | filename = os.path.basename(path)
877 | msg = f'{n} controls found in {filename}, {width}x{height}.'
878 | self.analyzeText.SetLabel(msg)
879 |
880 | def on_save_file_picked(self, event):
881 | path = self.chooseSaveFile.GetPath()
882 |
883 | problems = []
884 | if os.path.dirname(path) != datadir():
885 | problems.append('Instrument file is not chosen in the configuration directory')
886 |
887 | if not re.match('^inst-(.*)\.txt$', os.path.basename(path)):
888 | problems.append('Instrument file is not named in format inst-{name}.txt . It must start with "inst-" and end in ".txt".')
889 |
890 | if self.extract_result is None:
891 | problems.append('Screenshot analysis is missing')
892 |
893 | window_contains = self.window_pattern_ctrl.GetValue()
894 | if len(window_contains) == 0:
895 | problems.append('Window title pattern is missing')
896 |
897 | if len(problems) > 0:
898 | message = "Did not save the instrument because:\n"
899 | message += '\n'.join([f"{i+1}: {p}" for i, p in enumerate(problems)])
900 | dlg = wx.MessageDialog(None, message, 'Instrument not saved', wx.OK | wx.ICON_ERROR)
901 | dlg.ShowModal()
902 | dlg.Destroy()
903 | return
904 |
905 | mouse_control = control_type_bij.str([ControlType.DRAG, ControlType.WHEEL][self.mousectrl_combo.GetCurrentSelection()])
906 | doc = toml_instrument_config(self.extract_result, window_contains, mouse_control)
907 | with open(path, 'w') as f:
908 | f.write(doc.as_string())
909 |
910 | self.queue.put((InternalCommand.RELOAD_ALL_CONFIGS, None))
911 |
912 | message = f'"{os.path.basename(path)}" was successfully saved to the configuration directory.\nTo further adjust it you need to open it with a text editor.\nPlease read the documentation on the details of the instrument configuration file. Please "Reload Config" in the menu after you\'ve changed config files to take effect.'
913 | dlg = wx.MessageDialog(None, message, f'Instrument successfully saved', wx.OK | wx.CANCEL)
914 | dlg.SetOKLabel("Open configuration directory")
915 | response = dlg.ShowModal()
916 | dlg.Destroy()
917 |
918 | if response == wx.ID_OK:
919 | open_directory(datadir())
920 |
921 | self.EndModal(0)
922 |
923 | class AboutWindow(wx.Frame):
924 | def __init__(self, parent):
925 | super(AboutWindow, self).__init__(parent)
926 | msg = f'pointer-cc, Version {version}\nby Stefan Matting\nPlease send feedback to pointer-cc@posteo.com or the github site.'
927 |
928 | sizer = wx.BoxSizer(wx.VERTICAL)
929 |
930 | margin_outside = 20
931 |
932 | sizer.AddSpacer(40)
933 |
934 | self.version_label = wx.StaticText(self, label=msg, style=wx.ALIGN_CENTRE_HORIZONTAL)
935 | sizer.Add(self.version_label, 0, wx.LEFT | wx.RIGHT, margin_outside)
936 |
937 | sizer.AddSpacer(10)
938 |
939 | self.go_website = wx.Button(self, label='Go to website')
940 | self.go_website.Bind(wx.EVT_BUTTON, self.on_go_website)
941 | sizer.Add(self.go_website, 0, wx.LEFT | wx.RIGHT, margin_outside)
942 |
943 | sizer.AddSpacer(10)
944 |
945 | self.copy_email = wx.Button(self, label='Copy email address to clipboard')
946 | self.copy_email.Bind(wx.EVT_BUTTON, self.on_copy_email)
947 | sizer.Add(self.copy_email, 0, wx.LEFT | wx.RIGHT, margin_outside)
948 |
949 | sizer.AddSpacer(10)
950 |
951 | self.close_button = wx.Button(self, label='Close window')
952 | self.close_button.Bind(wx.EVT_BUTTON, self.on_close)
953 | sizer.Add(self.close_button, 0, wx.LEFT | wx.RIGHT, margin_outside)
954 |
955 | sizer.AddSpacer(40)
956 |
957 | self.SetSizer(sizer)
958 | sizer.SetMinSize((300, 0))
959 | sizer.Fit(self)
960 |
961 | def on_go_website(self, event):
962 | webbrowser.open(app_url)
963 |
964 | def on_copy_email(self, event):
965 | pyperclip.copy(app_email)
966 |
967 | def on_close(self, event):
968 | self.Destroy()
969 |
970 |
971 | class MainWindow(wx.Frame):
972 | def __init__(self, parent, title, q, ports):
973 | wx.Frame.__init__(self, parent, title=title)
974 |
975 | self.panel = wx.Panel(self, wx.ID_ANY)
976 |
977 | self.Bind(wx.EVT_CLOSE, self.on_close)
978 |
979 | self.queue = q
980 |
981 | self.ports = ports
982 |
983 | files = importlib.resources.files('pointercc')
984 | with files.joinpath('resources/logo-small.png').open('rb') as f:
985 | png = wx.Image(f, wx.BITMAP_TYPE_ANY).ConvertToBitmap()
986 | logo = wx.StaticBitmap(self.panel, -1, png, (10, 10), (png.GetWidth(), png.GetHeight()))
987 |
988 | self.version_label = wx.StaticText(self.panel, label=f'', style=wx.ALIGN_CENTRE_HORIZONTAL)
989 |
990 | value = ""
991 | self.port_dropdown = wx.ComboBox(self.panel, id=wx.ID_ANY, value=value, choices=self.ports, style=wx.CB_READONLY)
992 | self.Bind(wx.EVT_COMBOBOX, self.handle_midi_port_choice, self.port_dropdown)
993 |
994 | channel_choices = ["All"] + [f"Ch. {i}" for i in range(1, 17)]
995 | value = ""
996 | # value = channel_choices[config.preferred_midi_channel]
997 | self.channel_dropdown = wx.ComboBox(self.panel, id=wx.ID_ANY, value=value, choices=channel_choices, style=wx.CB_READONLY)
998 | self.Bind(wx.EVT_COMBOBOX, self.handle_midi_channel_choice, self.channel_dropdown)
999 |
1000 | self.window_text_ctrl = wx.TextCtrl(self.panel, style=wx.TE_READONLY)
1001 |
1002 | self.ctrlinfo_text_ctrl = wx.TextCtrl(self.panel, style=wx.TE_READONLY)
1003 |
1004 | # self.midi_msg_text = wx.StaticText(self.panel, label="