GitLab

If the extension is updated in a delayed fashion, we still want to ensure
that the resolvers are loaded/unloaded as necessary. So separate the
load/unload from the signal we use to track loading has completed.

This allows us to be symmetrical, with load/unload.

If we know the command from the manifest, we should pass that to the
flatpak build-finish command. Otherwise, we risk build-finish choosing the
first binary it finds in /app/bin.

Fixes #353

We can get into some weird positions with GTask and async completion, so
try harder to ensure we don't already have various configurations. Just
gracefully ignore them.

This broke during various updates to the style scheme for 3.28.

Now that pipeline is a GListModel, we can simplify our list of connected
build stages. This also ensures that things are updated after the pipeline
is initialized. Otherwise, we would show an empty list in the case that
the pipeline was not immediately setup fully. Such can happen when
installing dependent runtimes.

This ensures that we connect/disconnect propertly rather than relying on
the finalization of dependent objects.

When the PTY changes, we need to connect it to the terminal. This fixes an
issue where the pipeline is not ready on startup so that the user wont
see the PTY at all, even when the runtime installation succeeds.

#354

This pairs with the proper call. They should be the same, but that is not
going to be guaranteed.

It is convenient ot be able to track the pipeline stages using the
GListModel interface on the pipeline.

We can't really handle a single pipeline tracking load/unload/load, so
just disconnect our unload tracking after we have connected.

Instead, we rely on the build manager to reset the pipeline when the
configuration changes.

Creating a PTY with a cancellable will fail due to lower levels complaining
about socket initialization with cancellables. This works around it by
ensuring we don't propagate the cancellable to vte_pty_new_sync().

This is useful so that we can track when it changes and update the binding
in various UI components.

No need to imply the sink to the transfer of the call, so hoist this out.

Just to simplify the process of locating what indexers are at play.

Vala currently doesn't handle the null-terminated array of strings
being passed down correctly (const gchar * const *). This is a workaround
for it temporarily.

Not sure the exact version for these, but lets start with this.

We wanted to remove the use of indexers called from threads and
instead keep the communication between objects on the main
thread (and let indexers do their own off-thread work if they
so decide).

This isn't being used yet, but will allow us in the future to
potentially drop the full paths used in the index files and
instead use basenames for a healthy file size slimming.

We can change these a bit now that we know how they're getting
used in the new version of the code.

This is convenient for the code indexer, so lets require it of
the code entries to save us some pain.

This simplies the process of getting all the children in a directory and
the build flags for each file. It will not return ignored files as those
ignored by the VCS.

This is a convenience function to simplify the number of async callbacks
necessary to work through the data set.