GitLab

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.

We need to rewrite this to avoid using threads. This just stubs out the
same API for where we will start with.

This removes the "threaded" usage of IdeCodeIndexer and moves to
our new async/finish API.

It also creates a new CXIndex for each file, so we can more
reliably release memory after each parse. It probably means we
have to index some data more, but since this is a background
operation, I'd prefer to keep the memory usage lower at any
given time.

We don't want "threaded plugin API". Instead, we want objects that live in
the main thread, and have async/finish API (for which plugins can choose to
use threads if they like).