Before the 0.5.0 release, we had a very small number of remotes and receivers combination declared, and unless you owned a receiver and remote that the developers did, you had to select your receiver/remote combination by hand.
Johannes Schmid fixed half of that problem by creating a script that'll go through the lirc sources to add all those remotes to our remotes list. I fixed up a number of bugs, added quirks, and support for parsing user-space drivers.
With that, we went from around 10 remotes/receivers combinations to just short of a hundred.
ir-core work is ongoing in the kernel, and will provide drivers for a number of receivers with a default keymap. That means that things will work as soon as you plug them in.
A number of receivers also already have input drivers, one level down from ir-core, and work out of the box, such as the ati_remote and appleir drivers.
As we can receive events from the remotes, we just need to funnel them to the desktop. That'll be the work of lircd in the short-term, until XKB2 shows up.
Can I help?
Sure you can. Plug in your receiver, launch gnome-lirc-properties and report whether the receiver is not auto-detected, or whether no remote is selected by default. You can also get me one of the listed remotes on this Amazon wishlist :)
If your application matches the type of applications that would benefit from having a dark theme, please try it out. The 3 lines patch is easy to add to existing applications.
You'll most likely want to switch to using symbolic icons as well, for most of your UI, so that the icons show in the expected colour when a dark theme is not available.
What does it mean for me, GTK+ theme designer?
Either you keep your theme as-is. Then all applications will use that theme. This is most likely what should happen for Accessibility-related themes.
Or you create a "gtkrc-dark" file in your theme, at the same level as your gtkrc, and make it dark (not a bit darker like the bad example above, but real dark). Test it out with gtk-demo's “Application Window” demo.
This morning, my RSS reader was full of news with links to Mark Shuttleworth's blog about Canonical's idea for windicators.
The problem now is people conflating Canonical's own design decisions (most of which I don't agree with, except for the case of netbook UIs, but that's not the point here) and Client-Side Window Decorations support.
Martin Gräßlin's blog lists a few things that you would lose if we were to use client-side window decorations. Most of them are just wrong:
Consistent behavior between all applications no matter if it is a Qt or a GTK or $Toolkit application: How can you say that when there's no agreements on the implementation yet? Of course Athena widget apps will look different, they already do. As long as the theming and behaviour is known and agreed upon, there's no reasons why it should happen. It's just a bit more complicated because you would have cases where the Window Manager would behave differently from the toolkit. All those are solvable, and old, unmaintained toolkits will not integrate.
Window Tabbing (KWin specific): Why would that be impossible to implement? You'd just need help from the toolkit to do that.
Window rules like always show a close button even if the window is not closeable: Working around broken apps? Fix your apps...
Accessibility features like big border and button sizes for all windows: Certainly not. It would even mean that you wouldn't get a disconnect between application and window manager implementing accessibility features.
Easily changeable window themes: Why wouldn't they be easily changeable? That's highly dependent on how the theming is implemented in toolkits. I guess it would be the case if you had a half-hearted implementation.
Shadows which are part of the theme (KWin would not paint shadows for a client-side window-decorated window): Why not? If KWin knows that the application is drawing its own decorations, it could draw the shadows, or you could make the application's toolkit be aware that it needs to draw the shadows. Either way, it's not impossible to implement.
There also doesn't seem to be a list of thing you'd end up winning:
Tear-free window resizing (when the client is doing the resizing, with a proper resize grip for example)
Better integration of resizing within applications (say "zooming" when going to fullscreen
Proper way to do tabs in titlebar, a-la Google Chrome