Since the migration to the G13 Configurator for everything, most of these files
have literally no use anymore. We can safely remove them from the project at
this point.
This allows us to have separate applications from the G13 Configurator render to
the G13's display, just like the way Logitech's design worked. It even includes
an applet switcher, and an example clock applet.
There's quite a few deficiencies in this model, not the least of which is the
fact that we're using dbus-python as the main communications channel. Things
that are broken include:
- We can't tell when an applet dies except when we fail a call.
- Applets have to be running at the same time G13 Configurator is to handle
the initial register call.
We can likely deal with these somehow using DBus signals.
This adds a whole new ListView widget (and associated ListItem widget) so that
we can handle selecting items from a list. Additionally, it brings in rectangle
tests, and sadly removes the nice rounded rectangle from its design.
- The button module gained a Glyph widget, and Buttons are now composites
containing both a Rectangle and a Glyph.
- ButtonBar has been fixed to match the above Button change, which produces a
much more correct layout of glyphs and their drawing inside of each
ButtonBar slot.
- Added a Button test for Glyphs.
- Made X11DisplayDevice update its output window name when it's assigned to,
making it possible for each test to indicate which test it belongs to.
- Created ListView and ListItem.
- Made Widget not use its accessors for its constructor, which would create a
ton of erronous observer events down the chain.
- Made some of Widget's setters ValueErrors more specific.
At this point, functionality is nearly the same as what we had before I started
the migration away from g13d. We can now save prefs to disk! The next trick is
to make sure that the backlighting works, and I think we can call that the next
version, and maybe tag it for a alpha release.
This reorganizes the ownership of the main window under the control of the
appindicator. It also adds some additional flags in prefs to allow for disabling
the opening of the main window on startup, and removes a bunch of cruft from
main.
It would make sense that when the profile changes that the manager should
automatically reconfigure for the new profile. This changes the Manager into an
Observer and registers for profile and LCD color changes.
Since GDK/GTK filter events through Xorg, libinput, and everything else in
between, we can't use their keypress detection code to actually figure out what
the linux key codes are, instead we read directly from all keyboard-like evdev
devices on the system.
This is less than ideal, but directly due to Linux/Xorg/libinput/XKB/GDK/GTK/GNOME's
completely batshit insane input model. On Wayland it gets better, but not by
much since most compositors still use XKB and libinput.
*sigh*
Unfortunately, strings are iterable in python, so without this a call with a
single string, or a construct of "('foo')" would result in creating keys for
each letter of the string 'foo'. "('foo',)" works, because , creates the tuple,
not the parens...
This isn't ideal, since opening all of the devices in /dev/input is slow, and
this runs on the UI thread, but it works for now. Ultimately, InputReader should
probably be restructured as a threading.Thread and use GLib.idle_add to send the
signals out.
This allows us to be a bit more flexible in the way we define bindings. We still
have to use the scancodes for the actual bindings (since we're outputting to
uinput), but this should be a little easier to digest.
...also it fixed a bug... =op
This adds a whole bunch of tests and additional widgets we can use to draw up
interfaces on the g13's LCD. It also abstracts the backend a bit so we can draw
to X11 rather than a g13.
- Added a Button and ButtonBar class so we can start making use of those great
L* buttons
- Added a Label class so we can stick text all over the screen
- Added a Screen class to abstract away common display elements such as the
button bar, as well as send along the next frame to the display.
- Created the Widget class to make a lot of common boilerplate code live
somewhere useful.
- Added X11DisplayDevice so we can test on desktops without needing a G13.
This is based upon most of the code written in g13d's device and manager classes
as a means to actually "manage" the g13 itself from the GUI. This eliminates the
silly daemon, fifos, bad protocol design, and overall a whole slew of security
issues.
Our key binds will now use actual key codes from evdev instead of using made up
key symbol names from G13D. This results in a *major* change, of which this is
just the start. Effectively, we're going to move away from using the old and
crufty g13d for everything, and just write our own g13 manager instead.
