This merges the "x11-renderer" branch to master.
In order to make debugging splash plugins easier,
and in order to make debugging multi-head renderering
possible on single head displays, Charlie wrote an
X11 rendering plugin.
This plugin displays plymouth in a running X session,
instead of on the console.
It currently only supports graphical plugins. At some
point it may grow support for text plugins, too, using
vte. That will take some reworking of the plymouth
daemon core.
This could some day serve as a basis for providing a
graphical theme chooser application (like
gnome-screensaver-preferences), although it's not clear
yet that's a good idea.
Right now, it's a great debugging and development tool,
though.
Some drivers completely choke with the amount of data plymouth is
sending over the wire. This makes sure that plymouth doesn't
keep assaulting the X server when it's already overworked by asking
the server to return back a pixel before continuing.
Previously it was force_text_mode ().
Now, we do ignore_mode_changes (). The
force_text_mode() behavior can be emulated by
setting the console mode to text mode and then
calling the new API.
This will be useful because we can make
ply_console_set_mode a NOOP for renderers that
don't render directly to the console.
This renderer is useful for testing plymouth splash
plugins without leaving X. It simulates a multi-head
display by creating two X windows each representing
one monitor.
This merges the "seat-rework" branch to master.
Instead of talking to /dev/fb, we now use libdrm
to set up the drawing area. This gives us the
functionality we need for querying the user's
monitor layout.
There are cases where /dev/fb works when the new
interfaces don't. For those cases we fall back
to /dev/fb.
Drivers backed by TTM memory manager don't support mapping the
kernel backed framebuffer console, so can't be used for doing
a smooth transition (unless you use /dev/fb). In single head
configurations, there isn't a big advantage to using libdrm
anyway, so we bail for TTM drivers.
It can be cumbersome to wait for multiple operations to finish before
pulling a trigger. In those cases, one option would be to have a
separate trigger for each operation, and then wait until every trigger
is pulled before pulling the main trigger.
This commit instead allows a trigger to get pulled more
than once before it actually fires. By calling ignore_next_pull
once for each suboperaton, and immediately pulling the trigger,
it won't fire until the last operation finishes.
