This is a first step toward making the window provide
an draw handler interface, so we can hide the details
of pause/unpause, resetting raw mode, and graphics mode,
etc from the individual plugins.
Previously we were setting up the exit handler at the top
of the show vtable function. This meant having to remove
the exit handler if the show fails. It's much easier to
not set up the handler until after we know we're going to
succeed.
There was a sort useless layer of indirection between the
window object and splash plugins. It ended up with
functions like:
void
on_backspace (ply_splash_plugin_t *plugin)
{
plugin->interface->on_backspace (plugin);
}
Since the individual plugins are aware of the window object
anyway, they can register their own on_backspace et al handlers
without going through the ply_splash_plugin_t layer.
Package the individual plugins as subpackages and
get the file lists up to date. Also, drop
plymouth-update-initrd %post call since it's not
meant to be used in packages
Right now we do it in the cheesiest way possible, by
calling the backspace function over and over again on
behalf of the user. It might make more sense to export
another window callback specifically for erase line. It
probably doesn't make sense to do that until we fix the
TODO item:
- have plugins hook into line editing through window
directly, instead of via vtable functions
though.
The previous format was just the ascii value directly
in octal. I'm getting sick of typing 'man ascii' to look
it up though. The new format is just, e.g.,
('\100' ^ 'U')
which not only means I can add new entries without looking
them up, but also has the added advantage that it looks
sort of similiar to, e.g., ^U, which is a common notation
for respresenting control characters.
When debugging it's useful to be able to force text mode so
text messages become visible on screen. ctrl-t and ctrl-v
combined make it a lot easier to see what's going on.
Currently we toggle verbose messges if the user presses ctrl-v.
That's fine, but doesn't help to debug problems that happen before
a splash screen is shown. This provides a mechanism to enable messages
earlier
When I added commit c12164c162
to copy an entire row at a time to the framebuffer, I miscalculated the
offset to copy from/to. Their may be uninitialized data at the
beginning and end of the temporary row buffer, if only part of the row
is getting copied. We need to make sure we jump passed that junk in
memory and copy just the part that got filled in.
This is just a thin wrapper around the buffer object,
that keeps the data in terms of "elements" instead of
bytes, and always null terminates the result.
This function disowns the bytes in the buffer and returns
them to the caller. It's useful for freeing the buffer, but
keeping the bytes around without doing a copy.
The idea is to make a plugin that matches mockups done by
Mike Langlie. The mockups feature a throbber that spins
in the shape of an infinity sign. This is just a placeholder.
Most of the mockup isn't implemented yet.
ply_frame_buffer_add_area_to_flush_area() computes the wrong area
when the new area right of the current area but is wider than the
old area.
The easiest way to get rectangle intersection right is to just do
it on absolute coordinates and then convert back to width and height
afterwards.
Add:
- Add limited text support
- Make --ask-for-password take a prompt message
- consider making details plugin have stdin hooked
up to the pty instead of tty so input works
- consider making details plugin go back to pretty
plugin if user presses escape
The logic for line editing is a little complicated, so it's
best not to duplicate it across all the plugins. Now we
manage it all from the window. The plugins now access the
various editing events via there vtable, but that's an
extra layer of indirection that doesn't matter given that
we pass the window to the plugins anyway. We should drop
that and just have the plugins register for edit events
directly.
This function is like ply_buffer_remove_bytes, but it
truncates away the end of the buffer instead of shifting
the contents over the start of the buffer.
