[controls] Add new bitmap label plugin

This is like the existing label plugin, but it has a small
ascii fixed builtin fontset and doesn't pull in any pango, cairo,
fontconfig, or freetype dependencies.

[frame-buffer] initialize head on query not map

That's the "right" thing to do and now that we
map lazily, doing it the old way is broken.

[renderer] map buffer lazily

This is to prevent screen clears on plugins that don't
use the renderers (text plugins)

[renderer] make map and unmap idempotent

[keyboard] make stop_watching_for_terminal_input idempotent

[renderer] make input_source_close idempotent

[main] remove displays before closing renderer

[terminal] Only close terminal on free when open

We were closing the terminal twice, causing assertions
to blow.

[main] Disconnect from tty when hiding splash

We were still processing keystrokes when the splash screen was
hidden. This caused problems because the tty is used by other
programs at that time.

[drm] Destroy console buffer object on error path

We were leaking the object if it couldn't be mapped.

[drm] Destroy console buffer object when done with it

[main] clean up terminal when done with it

Before we were relying on the renderer to clean
up the terminal, which was wrong.

[renderer] close device on failures

Before we were just unloading the module without
closing it.

[drm] don't close terminal

It belongs to the core daemon, not the plugin.

[drm] Drop master on VT switches

This improves plymouth's interaction with X.

[text] Don't crash after password prompt

We were treating the passed in view to the
draw handler as if it was the plugin itself.

[main] Properly reinitialize environment on show splash

Before we were tearing down the displays and keyboard on hide
splash but not bringing them back on subsequent show splashes.

This fixes that.  We can probably throw less stuff away on
hide splash, but this is a more conservative fix for now.

[script] Give sensible unique-ish strings for all objects.

All objects can now be transformed into strings which allows them to be used as
hash indexes. Some rules do still apply. If an object is lost (freed....)
another object may take on the name of the lost one. The object address is used
to create a string in the form "#(0x123abc45)". NULL has the string "#NULL".
So arr[NULL] is the same as arr["#NULL"], and similar for the objects.

[script] Do not segfault if accessing array with no key

Things like "array[] = 7" would cause a crash.
This is now caught and warned about during the parse.

[script] Allow inline array definitions

This can be used to initialise an array:
arr = [12, 43];    // arr[0] = 12; arr[1] = 43;

Or create an empty object:
obj = [];

[script] Add do-while loops

Format is:
    do {operations} while (condition);
or
    do operation; while (condition);

Like in C, the semicolon at the end is necessary.

[branch-merge] Add x11 renderer plugin

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.

[x11] Throttle plymouth to X server

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.

[x11] Tile windows initially

[x11] Move windows when dragged

Since they don't have title bars now, we need to
provide and easy way for them to be moved around.

[x11] Hide title bar

It's not useful.

[x11] Ignore ply_console_set_mode calls

Since X is rendering to the console, we don't need
(or want) to move the console between KD_GRAPHICS
and KD_TEXT mode.

[console] Generalize mode override api

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.

[x11] Don't allow windows to be resized

We don't handle the display resizing, so disallow it.

[x11] Draw to back pixmap instead of on exposes

It's a little more efficient.

[x11] Process events only as they come in

Previously, we were waking up an processing events
in a loop.  Now we only do it when there are events.

[renderer] Add start of X11 plugin

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.

[renderer] Move VT switching to renderer plugins

Since not all renderer plugins should switch VTs we
do it from the individual plugins now.

[event-loop] ignore EAGAIN

Sometimes when debugging under gdb, epoll_wait spuriously
returns EAGAIN.

We treat it like EINTR now.

[text-progress-bar] Don't segfault if no os string

Some distributions won't have a release file that
we know about.  In those cases, we shouldn't crash.

[drm] Force raw mode on each draw cycle

This is just

602d9972002cb5fd7fd946f1af930c4b00017f30

all over again.

[terminal] Force raw mode when reopening terminal

If we need to reopen the terminal for whatever reason,
we'll also need to reset its attributes for input to work.

Bump to 0.8.0

Next release will be 0.8.0 (it's a bit off though)

[branch-merge] Support multi-head renderering

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.

[throbber] Properly finish animation before stopping

I can't say I have any idea what I was trying to do before
but it's clearly bogus.

[animation] Make ply_animation_start idempotent

[animation] Use default event loop

[drm] Force fb backend if 1 head and ttm driver

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.

[drm] Add initial support for nvidia cards

[drm] Add initial support for radeon cards

[drm] Add initial support for intel cards

[drm] Add start of a drm plugin

This commit adds most of the non-driver specific bits
necessary for backing a renderer plugin.

Subsequent commits will add the driver specific bits.

[utils] Add ply_round_to_multiple macro

We'll need something like this for rowstride calculation

[libplybootsplash] Drop window class

It's been obsoleted by the display, keyboard, console and terminal
classes.

[libply] Drop frame-buffer class

We no longer use it now that we have the pixel-display class,
pixel buffers, etc.

[image] Drop test code

It won't work when frame buffer is removed.

I really want to redo how tests are done anyway, to be
more automated.

[utils] drop ply_switch_to_vt

It's been replaced by ply_console_set_active_vt, and won't
work right because of ply-console anyway.

[main] switch to vt that plymouth is running on at startup

[main] Update to use new multihead interface

[two-step] Update to use new multihead interface

[trigger] add new ignore_next_pull method

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.

[throbgress] Update to use new multihead interface

[text] Update to use new multihead interface

[space-flares] Update to use new multihead interface

[script] Update to use new multihead interface

[fade-throbber] Update to use new multihead interface

[details] Update to use new multihead interface

[text-progress-bar] Use text display instead of window

[progress-bar] Use pixel display instead of window

[progress-animation] Use pixel display instead of window

[throbber] Use pixel display instead of window

[animation] Use pixel display instead of window

[entry] Use pixel display instead of window

[label] Use pixel display instead of window

[boot-splash] Update to use new multihead interface

The boot splash plugin now takes in a keyboard, text
displays, pixel displays, and the console.

I passes those along to the plugins, and listens for
key strokes to handle CTRL-L refresh and other keybindings.

So now it's assuming some of the role of ply-window.

[renderer] Add start of frame-buffer plugin

Much of this code comes directly from ply-frame-buffer in libply,
but shoehorned to fit into the renderer plugin interface.

One improvement over the old code is it tracks VT changes, and
stops drawing when the wrong VT is active.

[libplybootsplash] Add pixel-display class

This is the graphical output portion of the window class.  This
commit and the previous few commits lay the foundation needed
for dropping the window class and getting  multi-head rendering support.

[libplybootsplash] Add text-display class

This is the text output portion of the window class.  With this commit
and a subsequent commit to split out the graphical output portion,
we should be able to drop the window class.

As mentioned earlier, this will give us the flexibility we
need for multi-head rendering.

[libplybootsplash] Add renderer class

In order to support multiple rendering backends, and multi-head
monitor layouts, I'm moving the actually rendering to render
plugins.

Examples of plugins could be frame-buffer, drm fb, and x11
(for debugging).

The renderer class is responsible for loading the appropriate rendering
backend, and providing an interface for the rendering backend to
advertise multiple displays.

Right now we only check for a frame-buffer plugin, although, it isn't
implemented yet.

[libplybootsplash] Add terminal class

This is the terminal settings portion of the window class.  With this
commit and subsequent commits to split out the higher level text output,
and graphical output portions, we should be able to drop window
in favor of the new display classes.

[libplybootsplash] Add console class

This serves a few purposes:

1) To watch for VT changes
2) To make VT changes
3) To put the console in KD_GRAPHICS mode

The latter is handled by the window class right now, but I want to
drop the window class.

[libplybootsplash] Add keyboard class

This is the input portion of the window class.  With this commit
and subsequent commits to split out the output portions, we should
be able to drop the window class.

This will give us the flexibility we need for multi-head rendering.

[libplybootsplash] Add new pixel buffer class

Right now a lot of pixel manipulation functions are in the frame buffer
code.  This means it's hard to do these types of things without the
results showing up on the display.

Furthermore, we want to get away from one frame buffer anyway for
multihead support.  I can imagine each display in a multihead
configuration with its own pixel buffer, so splash plugins can draw to
the independently.

This commit adds the start of a pixel buffer class, which just copies
and pastes most of pixel-twiddling frame buffer code.  There are some
changes to deal with pixel buffers not always having a final alpha of
1.0, and some changes to provide a more flexible interface for masking
fill operations.

At some point it will probably gain copy-and-pastes of the resize an
rotate code from the image class as well, and provide a mechansim for
have subpixbufs where rowstride != width.

[libply] Add new region class

Sometimes it's necessary to deal with a disjoint
set of rectangles together.

One big example is when keeping track of which parts of
the screen have changed.

Another example would be for non-rectangular clip masks.

This commit adds a new region class to simplify the handling
of these types of cases.

[libply] Add new rectangle type

Previously we were using ply_frame_buffer_area_t even
when not dealing with a frame buffer area.

This commit adds a new general purpose rectangle type
to replace ply_frame_buffer_area_t.  It has some
convenience functions for operating on rectangles as well.

[event-loop] Add ply_event_loop_get_default ()

The event loop is used all through out the code
for many different things.  In order to use it
in all those various bits of code, it's getting
passed around a lot.  This adds a lot of complexity
to the code.

The event loop should probably be a standard
resource that all parts of the code have free access
to in the same vein as the logging apis.

This commit adds a new function
ply_event_loop_get_default () and makes main use it
and pass it along.

Subsequent commits may clean up all the places that
take an event loop to just use this instead.

[libply] Drop terminal class

It was a really lame small wrapper around creating pseudoterminals.
The wrapper didn't buy anything and the name ply-terminal would be
better used for managing tty settings, etc.

[configure] Bump to 0.7.2

[libplybootsplash] Order header list one-per line

It's a lot easier to add and remove entries from the Makefile
this way.

[libplybootsplash] Drop text-pulser

It hasn't been used since we dropped the pulser plugin

[entry] Fix up max bullet calculation

Before we were counting space that could only fit a partial bullet as room
for a whole bullet.  Now we look and see if there is enough extra space for
at least half a bullet (since the code will draw half a bullet in the case
of more bullets than can fit)

[main] rename state->console to state->kernel_console_tty

The name "console" is sort of ambiguous.  It could mean:

1) the keyboard and mouse together (also known as "seat")
2) the VT console
3) /dev/console
4) where /dev/console messages should go

In this case we mean 4, so we rename it to kernel_console_tty
for clarity.

[main] Make some callback functions static

[main] Flip debug buffer conditional check

It was inverted so we were never creating a debug buffer
when plymouth:debug was put on the kernel command line.

[progress] Stop progress at 25% if progress file is not loaded

In cases where, before the file system is mounted, there is a very long pause,
the progress would continue all the way to 100% assuming a 60 second boot time.

It now stops at 25% to signal that something is wrong and moves to crawl mode
(nudging forward very very slowly).

[daemon] fix detection of single on kernel cmdline

[daemon] recognize s, S, -s as single for kernel cmdline

[populate-initrd] Don't require set_verbose function

If it's not around, define it, so we can use it without error

[script] Example script rewritten to use the object system

[script] Add inheritance to the language

The inheritance works primarily on objects and functions.
Object example:
 A.v1 = 1;
 A.v2 = 2;
 B.v2 = 7;
 B.v3 = 3;
 C = A | B;

C is now equal to A with B as a base (C.v1 = 1, C.v2 = 2, C.v3 = 3).
A and B remain unchanged.

Function example:
 fib = fun (a) if (a < 2) 1; else fail;
     | fun (a) if (fibcache[a]) fibcache[a] ; else fail;
     | fun (a) fib (a - 1) + fib (a - 2); ;

Fail means a function is aborted and a more base function is attempted.

[script] Create new objects when incrementing/decrementing

It is dangerous to directly edit a number as it may be referenced from multiple
places.

[script] Make "this" (the current object) a part of the status

This is now also looked up when evaluating vars. Vars are looked for in the
local context, then within this (current object) and finally within the
global context;

[script] Correct some header files

Missing includes and incorrect recursion protection names

[script] Reference actual object and do not create an indirect reference

[script] Free the scan only after adding the last debug symbol

Was causing valgrind errors of access to freed locations as the scan name was
freed.