This exposes the profile list, currently selected profile, and the ability to
set the selected profile via the AppletManager's D-Bus interface. This isn't
really the ideal place for it, but Gtk Actions aren't really suited for this,
either. Additionally, it creates the profile switcher applet as an external
applet to better exercise the Applet interface.
- Manager passes in the preferences object to the AppletManager, so that these
variables can be exposed over D-Bus.
- Exposed the list of profiles, get/set of active profile via D-Bus.
- Created the Profiles applet.
- Exposed a onRegistered / onUnregistered hook for Applets to make use of.
- Removed the onUpdateScreen hook from KeyPressed/KeyReleased, since the
onKeyPressed/onKeyReleased hooks handle this nicely already.
- Fixed the AppletManager's method authorization checks.
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
