command: Add exec()
ct-perms: Fix some issues re: colored perms & filtering
Refactor filter API

No more get_ct_data_fn and all that crap: no more donna_app_get_ct_data()
and no donna_tree_view_filter_nodes() either.

Now there's a single donna_app_filter_nodes() that takes an optional
treeview argument, to filter through it, else it's dona via app. (Much
like the command already did.)

Similarly, {,color_}filter_is_match() simply takes an (optional, for
filter) treeview argument.
filter: Fix refresh on option change

That is, the callback in case a column was set to a different type was
still watching at the wrong/old location.
filter/app: Fix how getting ct_data works

app now keeps the column's ct_data with a ref_count, and when a filter
needs one it takes a ref on it. Once done, it unrefs it.

Also, app now watches config and refreshes the ct_data if needed. If it
has been ref-ed (i.e. in use by a filter) it just creates a new one, and
the old one will be free-d on last unref.

This makes sure that if the ct_data is invalidated/refreshed while a
filter uses it, it keeps its (valid) ct_data all along.

Noting that when using filter with/through a treeview, it must be in
thread UI and goes through its ct_datas. But when via app, it works on
any thread.
config: Fix get_*_column missing mode when no treeview name

When no treeview name was specified (e.g. from a filter via app), the
path at mode would be skipped, even though it shouldn't.

This would lead to always setting it to the given default, ignoring
(possibly overwriting) the current value.
provider-exec: Parse environment variables

Now when creating a node, location is processed and environment
variables are resolved. $FOOBAR will be replaced with its value (if any),
quoted (to make things easier). $"FOOBAR can be used for as-is value.
Use $$ to include a literal dollar sign.

This is all done on node creation, so the node's location will then be
the resolved string (i.e. this isn't a shell-like parsing or anything.)

Done this way cause it should work for most things, without the need to
handle the entire shell-compatible command line parsing.
app: Add get_environ()

Now app will create a copy of the environment on start, that can be used
anytime (from any thread).
conf: Make use of environment variables support in exec
node: Remove new_from_node()

This was a bad idea (also, not (yet) used).

Bad idea because to make e.g. a node based on one from "fs" for listing
the same file more than once as search results, you should create a node
on your own (refing the node from fs and "replicating" its properties).

This was bad because the original refresher/setter would be called on nodes
that don't belong to the original provider, which could lead to trouble.
Because a node_peek_provider() wouldn't return the expected provider, or
because the node's location wasn't actually owned by the provider (but the
"new" one). All things that would badly fail.

Besides, the coming addition of user_data to refresher/setter for
extra properties wouldn't help things either.
node: add_property(): Add data for refresher/setter
node: Fix refresh_task(SET_VALUES) refreshing all basic properties

All basic properties were always include in the refresh, even with
SET_VALUES.

(In fact, even non-existing ones were always added.)
node: refresh{,_arr}_task(): Check properties exist

When given a list/an array of properties to refresh, we first ensure
they exist on the node (Also ignore dupes, if given the same property more than
once). If not, throw a warning and ignore them.

Will fail only if there are no properties left to refresh.
node: Add visibility for refreshers

When creating a node, a visibility is given for the refresher; One is
also given when adding properties.

When the node creates a task to refresh properties, it'll use those to
determine the best/appropriate visibility for the task.

E.g. refeshing nodes in mark or config is in-memory, so FAST: no need to
create/use threads. Same goes for all properties with gtk_true as
refresher.
node: Minor refactoring

Not sure why this was done that way, but refreshed doesn't have a function
to free its elements set (unlike names), so there's no point in doing
that.
node: Minor refactoring/optimization
app: Minor refactoring handling of providers

In prevision of custom properties.
app: Fix memory leak

ls->item will ref_sink menu, no need for us to ref it.
app: Fix handling menu destruction (re: memory leak)

We used to ref_sink/unref the menu, to work around the forced floating
ref on menu and a GTK bug that would leak on destroy.
But, with out patch this isn't needed anymore, and in fact since we didn't
call destroy on the menu, there now was a leak (since GTK still has its
strong ref on the menu).

This handles things properly in all cases, using new help popup_and_destroy()
when patched, or doing the old ref_sink/unref when not to avoid the leak.
imagemenuitem: Fix reference handling

We need to ref the parent shell/main menu before calling popdown(), as that
will hide the menu, which is when GTK will destroy the menu when using
popup_and_destroy()